{"version":3,"sources":["webpack:///./src/components/integration-builder/hooks/use-isomorphic-layout-effect/index.tsx","webpack:///./src/utils/auto-id/index.tsx","webpack:///./src/utils/withAnalytics.tsx","webpack:///./src/react-utils/context/index.ts","webpack:///./src/react-utils/form-control-utils/index.tsx","webpack:///./src/react-utils/function/index.tsx","webpack:///./src/components/integration-builder/hooks/use-boolean/index.ts","webpack:///./src/components/integration-builder/hooks/use-ids/index.tsx","webpack:///./src/components/integration-builder/utils/misc.ts","webpack:///./node_modules/lodash.mergewith/index.js","webpack:///./src/components/integration-builder/hooks/use-safe-layout-effect/index.tsx","webpack:///./src/components/integration-builder/hooks/use-force-update/index.tsx","webpack:///./src/components/integration-builder/hooks/use-unmount-effect/index.tsx"],"names":["useIsomorphicLayoutEffect","window","React","serverHandoffComplete","id","genId","useId","idFromProps","initialId","setId","useLayoutEffect","String","undefined","withAnalytics","Component","props","createElement","Object","assign","fpti","record","recordImpression","createContext","options","strict","errorMessage","name","Context","displayName","Provider","useContext","context","_Error$captureStackTr","error","Error","captureStackTrace","call","FormControlProvider","useFormControlContext","runIfFn","valueOrFn","_len3","arguments","length","args","Array","_key3","_isFunction","apply","useBoolean","initialState","value","setValue","useState","on","useCallback","off","toggle","prev","useIds","idProp","_len","prefixes","_key","map","prefix","callAllHandlers","fns","event","some","fn","defaultPrevented","assignRef","ref","isFunction","current","mergeRefs","_len2","refs","_key2","node","forEach","isBrowser","document","reIsHostCtor","reIsUint","typedArrayTags","freeGlobal","global","freeSelf","self","root","Function","freeExports","exports","nodeType","freeModule","module","moduleExports","freeProcess","process","nodeUtil","types","require","binding","e","nodeIsTypedArray","isTypedArray","func","thisArg","uid","transform","arrayProto","prototype","funcProto","objectProto","coreJsData","funcToString","toString","hasOwnProperty","maskSrcKey","exec","keys","IE_PROTO","nativeObjectToString","objectCtorString","reIsNative","RegExp","replace","Buffer","Symbol","Uint8Array","allocUnsafe","getPrototype","getPrototypeOf","arg","objectCreate","create","propertyIsEnumerable","splice","symToStringTag","toStringTag","defineProperty","getNative","nativeIsBuffer","isBuffer","nativeMax","Math","max","nativeNow","Date","now","Map","nativeCreate","baseCreate","object","proto","isObject","result","Hash","entries","index","this","clear","entry","set","ListCache","MapCache","Stack","data","__data__","size","arrayLikeKeys","inherited","isArr","isArray","isArg","isArguments","isBuff","isType","skipIndexes","n","iteratee","baseTimes","key","isIndex","push","assignMergeValue","eq","baseAssignValue","assignValue","objValue","assocIndexOf","array","has","get","pop","getMapData","pairs","LARGE_ARRAY_SIZE","fromRight","baseFor","keysFunc","iterable","baseGetTag","isOwn","tag","unmasked","getRawTag","objectToString","baseIsArguments","isObjectLike","baseIsNative","isMasked","test","toSource","baseKeysIn","nativeKeysIn","isProto","isPrototype","baseMerge","source","srcIndex","customizer","stack","srcValue","mergeFunc","safeGet","stacked","newValue","isCommon","isTyped","isArrayLike","copyArray","buffer","isDeep","slice","constructor","copy","cloneBuffer","typedArray","arrayBuffer","byteLength","byteOffset","Ctor","isPlainObject","isNew","copyObject","keysIn","toPlainObject","initCloneObject","baseMergeDeep","baseRest","start","setToString","otherArgs","overRest","identity","type","getValue","count","lastCalled","stamp","remaining","shortOut","string","other","isLength","baseUnary","assigner","mergeWith","sources","guard","isIterateeCall","useSafeLayoutEffect","useForceUpdate","unloadingRef","setCount","useUnmountEffect","deps"],"mappings":"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","file":"152025db965c661bb24971169d0795fbb208a411-7cd1e3464c069969dada.js","sourcesContent":["import * as React from 'react'\n\nexport const useIsomorphicLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n","/* eslint-disable */\nimport * as React from 'react'\nimport { useIsomorphicLayoutEffect as useLayoutEffect } from '../../components/integration-builder/hooks/use-isomorphic-layout-effect'\n\n// NOTE: this guy belongs to dx-ui-react, but we can export the component later\n// on the library.\n\nlet serverHandoffComplete = false\nlet id = 0\nconst genId = () => ++id\n\n/**\n * useId\n *\n * Autogenerate IDs to facilitate WAI-ARIA and server rendering.\n *\n * Note: The returned ID will initially be `null` and will update after a\n * component mounts. Users may need to supply their own ID if they need\n * consistent values for SSR.\n *\n */\nfunction useId(idFromProps: string): string\nfunction useId(idFromProps: string | undefined): string | undefined\nfunction useId(idFromProps?: null): string | undefined\nfunction useId(idFromProps?: string | null) {\n  /*\n   * If this instance isn't part of the initial render, we don't have to do the\n   * double render/patch-up dance. We can just generate the ID and return it.\n   */\n  const initialId = idFromProps || (serverHandoffComplete ? genId() : null)\n\n  const [id, setId] = React.useState(initialId)\n\n  useLayoutEffect(() => {\n    if (id === null) {\n      /*\n       * Patch the ID after render. We do this in `useLayoutEffect` to avoid any\n       * rendering flicker, though it'll make the first render slower (unlikely\n       * to matter, but you're welcome to measure your app and let us know if\n       * it's a problem).\n       */\n      setId(genId())\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [])\n\n  React.useEffect(() => {\n    if (serverHandoffComplete === false) {\n      /*\n       * Flag all future uses of `useId` to skip the update dance. This is in\n       * `useEffect` because it goes after `useLayoutEffect`, ensuring we don't\n       * accidentally bail out of the patch-up dance prematurely.\n       */\n      serverHandoffComplete = true\n    }\n  }, [])\n  return id != null ? String(id) : undefined\n}\n\nexport { useId }\n","import React from 'react'\nimport { record, recordImpression } from '@paypalcorp/fpti'\n\nconst withAnalytics = (Component: any) => {\n  return (props: any) => (\n    <Component {...props} fpti={{ record, recordImpression }} />\n  )\n}\n\nexport default withAnalytics\n","/* eslint-disable */\nimport * as React from 'react'\n\nexport interface CreateContextOptions {\n  /**\n   * If `true`, React will throw if context is `null` or `undefined`\n   * In some cases, you might want to support nested context, so you can set it to `false`\n   */\n  strict?: boolean\n  /**\n   * Error message to throw if the context is `undefined`\n   */\n  errorMessage?: string\n  /**\n   * The display name of the context\n   */\n  name?: string\n}\n\ntype CreateContextReturn<T> = [React.Provider<T>, () => T, React.Context<T>]\n\n/**\n * Creates a named context, provider, and hook.\n *\n * @param options create context options\n */\nexport function createContext<ContextType>(options: CreateContextOptions = {}) {\n  const {\n    strict = true,\n    errorMessage = 'useContext: `context` is undefined. Seems you forgot to wrap component within the Provider',\n    name,\n  } = options\n\n  const Context = React.createContext<ContextType | undefined>(undefined)\n\n  Context.displayName = name\n\n  function useContext() {\n    const context = React.useContext(Context)\n\n    if (!context && strict) {\n      const error = new Error(errorMessage)\n      error.name = 'ContextError'\n      Error.captureStackTrace?.(error, useContext)\n      throw error\n    }\n\n    return context\n  }\n\n  return [\n    Context.Provider,\n    useContext,\n    Context,\n  ] as CreateContextReturn<ContextType>\n}\n\nexport function createNamedContext<ContextValueType>(\n  //@ts-ignore\n  name: string,\n  defaultValue: ContextValueType,\n): React.Context<ContextValueType> {\n  const Ctx = React.createContext<ContextValueType>(defaultValue)\n\n  return Ctx\n}\n","import { createContext } from '../context'\nimport * as React from 'react'\nimport { PropGetter, PropGetterAlt } from '../types'\nimport { mergeRefs } from '../ref'\nimport { dataAttr } from '../dom'\nimport { useId } from '../../utils/auto-id'\nimport { useBoolean } from '../../components/integration-builder/hooks/use-boolean'\n\nexport interface FormControlOptions {\n  /**\n   * If `true`, the form control will be required. This has 2 side effects:\n   * - The `FormLabel` will show a required indicator\n   * - The form element (e.g, Input) will have `aria-required` set to `true`\n   */\n  isRequired?: boolean\n  /**\n   * If `true`, the form control will be disabled. This has 2 side effects:\n   * - The `FormLabel` will have `data-disabled` attribute\n   * - The form element (e.g, Input) will be disabled\n   */\n  isDisabled?: boolean\n  /**\n   * If `true`, the form control will be invalid. This has 2 side effects:\n   * - The `FormLabel` and `FormErrorIcon` will have `data-invalid` set to `true`\n   * - The form element (e.g, Input) will have `aria-invalid` set to `true`\n   */\n  isInvalid?: boolean\n  /**\n   * If `true`, the form control will be readonly\n   */\n  isReadOnly?: boolean\n}\n\nexport interface FormControlContext extends FormControlOptions {\n  /**\n   * The label text used to inform users as to what information is\n   * requested for a text field.\n   */\n  label?: string\n  /**\n   * The custom `id` to use for the form control. This is passed directly to the form element (e.g, Input).\n   * - The form element (e.g Input) gets the `id`\n   * - The form label id: `form-label-${id}`\n   * - The form error text id: `form-error-text-${id}`\n   * - The form helper text id: `form-helper-text-${id}`\n   */\n  id?: string\n}\n\ntype FormControlProviderContext = Omit<\n  ReturnType<typeof useFormControlProvider>,\n  'getRootProps' | 'htmlProps'\n>\n\nconst [FormControlProvider, useFormControlContext] =\n  createContext<FormControlProviderContext>({\n    strict: false,\n    name: 'FormControlContext',\n  })\n\nexport { useFormControlContext }\n\nfunction useFormControlProvider(props: FormControlContext) {\n  const {\n    id: idProp,\n    isRequired,\n    isInvalid,\n    isDisabled,\n    isReadOnly,\n    ...htmlProps\n  } = props\n\n  // Generate all the required ids\n  const uuid = useId()\n  const id = idProp || `field-${uuid}`\n\n  const labelId = `${id}-label`\n  const feedbackId = `${id}-feedback`\n  const helpTextId = `${id}-helptext`\n\n  /**\n   * Track whether the `FormErrorMessage` has been rendered.\n   * We use this to append its id the the `aria-describedby` of the `input`.\n   */\n  const [hasFeedbackText, setHasFeedbackText] = React.useState(false)\n\n  /**\n   * Track whether the `FormHelperText` has been rendered.\n   * We use this to append its id the the `aria-describedby` of the `input`.\n   */\n  const [hasHelpText, setHasHelpText] = React.useState(false)\n\n  // Track whether the form element (e.g, `input`) has focus.\n  const [isFocused, setFocus] = useBoolean()\n\n  const getHelpTextProps = React.useCallback<PropGetter>(\n    (props = {}, forwardedRef = null) => ({\n      id: helpTextId,\n      ...props,\n      /**\n       * Notify the field context when the help text is rendered on screen,\n       * so we can apply the correct `aria-describedby` to the field (e.g. input, textarea).\n       */\n      ref: mergeRefs(forwardedRef, (node) => {\n        if (!node) return\n        setHasHelpText(true)\n      }),\n    }),\n    [helpTextId],\n  )\n\n  const getLabelProps = React.useCallback<PropGetterAlt<'label'>>(\n    (props = {}, forwardedRef = null) => ({\n      ...props,\n      ref: forwardedRef,\n      'data-focus': dataAttr(isFocused),\n      'data-disabled': dataAttr(isDisabled),\n      'data-invalid': dataAttr(isInvalid),\n      'data-readonly': dataAttr(isReadOnly),\n      id: props.id ?? labelId,\n      htmlFor: props.htmlFor ?? id,\n    }),\n    [id, isDisabled, isFocused, isInvalid, isReadOnly, labelId],\n  )\n\n  const getErrorMessageProps = React.useCallback<PropGetter>(\n    (props = {}, forwardedRef = null) => ({\n      id: feedbackId,\n      ...props,\n      /**\n       * Notify the field context when the error message is rendered on screen,\n       * so we can apply the correct `aria-describedby` to the field (e.g. input, textarea).\n       */\n      ref: mergeRefs(forwardedRef, (node) => {\n        if (!node) return\n        setHasFeedbackText(true)\n      }),\n      'aria-live': 'polite',\n    }),\n    [feedbackId],\n  )\n\n  const getRootProps = React.useCallback<PropGetterAlt<'div'>>(\n    (props = {}, forwardedRef = null) => ({\n      ...props,\n      ...htmlProps,\n      ref: forwardedRef,\n      role: 'group',\n    }),\n    [htmlProps],\n  )\n\n  const getRequiredIndicatorProps = React.useCallback<PropGetter>(\n    (props = {}, forwardedRef = null) => ({\n      ...props,\n      ref: forwardedRef,\n      role: 'presentation',\n      'aria-hidden': true,\n      children: props.children || '*',\n    }),\n    [],\n  )\n\n  return {\n    isRequired: !!isRequired,\n    isInvalid: !!isInvalid,\n    isReadOnly: !!isReadOnly,\n    isDisabled: !!isDisabled,\n    isFocused: !!isFocused,\n    onFocus: setFocus.on,\n    onBlur: setFocus.off,\n    hasFeedbackText,\n    setHasFeedbackText,\n    hasHelpText,\n    setHasHelpText,\n    id,\n    labelId,\n    feedbackId,\n    helpTextId,\n    htmlProps,\n    getHelpTextProps,\n    getErrorMessageProps,\n    getRootProps,\n    getLabelProps,\n    getRequiredIndicatorProps,\n  }\n}\n","import { isFunction } from 'lodash'\nimport { AnyFunction, FunctionArguments } from '../types'\n\nexport function callAllHandlers<T extends (event: any) => void>(\n  ...fns: (T | undefined)[]\n) {\n  return function func(event: FunctionArguments<T>[0]) {\n    fns.some((fn) => {\n      fn?.(event)\n      return event?.defaultPrevented\n    })\n  }\n}\n\nexport const noop = () => {}\n\nexport function callAll<T extends AnyFunction>(...fns: (T | undefined)[]) {\n  return function mergedFn(arg: FunctionArguments<T>[0]) {\n    fns.forEach((fn) => {\n      fn?.(arg)\n    })\n  }\n}\n\nexport function runIfFn<T, U>(\n  valueOrFn: T | ((...fnArgs: U[]) => T),\n  ...args: U[]\n): T {\n  return isFunction(valueOrFn) ? valueOrFn(...args) : valueOrFn\n}\n","import { useCallback, useState } from 'react'\n\ntype InitialState = boolean | (() => boolean)\n\n/**\n * React hook to manage boolean (on - off) states\n *\n * @param initialState the initial boolean state value\n */\nexport function useBoolean(initialState: InitialState = false) {\n  const [value, setValue] = useState(initialState)\n\n  const on = useCallback(() => {\n    setValue(true)\n  }, [])\n\n  const off = useCallback(() => {\n    setValue(false)\n  }, [])\n\n  const toggle = useCallback(() => {\n    setValue((prev) => !prev)\n  }, [])\n\n  return [value, { on, off, toggle }] as const\n}\n","import * as React from 'react'\nimport { useId } from '../../../../utils/auto-id'\n\n/**\n * Reack hook to generate ids for use in compound components\n *\n * @param idProp the external id passed from the user\n * @param prefixes array of prefixes to use\n *\n * @example\n *\n * ```js\n * const [buttonId, menuId] = useIds(\"52\", \"button\", \"menu\")\n *\n * // buttonId will be `button-52`\n * // menuId will be `menu-52`\n * ```\n */\nexport function useIds(idProp?: string, ...prefixes: string[]) {\n  const id = useId(idProp)\n  return React.useMemo(() => {\n    return prefixes.map((prefix) => `${prefix}-${id}`)\n  }, [id, prefixes])\n}\n","/* eslint-disable */\nimport * as React from 'react'\n\n/**\n * Well basically these utils are based on\n * typescript generics, generics are great\n * for reusable functions and cool utils.\n */\n\ntype FunctionArguments<T extends Function> = T extends (...args: infer R) => any\n  ? R\n  : never\n\nfunction callAllHandlers<T extends (event: any) => void>(\n  ...fns: (T | undefined)[]\n) {\n  return function func(event: FunctionArguments<T>[0]) {\n    fns.some((fn) => {\n      fn?.(event)\n      return event?.defaultPrevented\n    })\n  }\n}\n\nconst isFunction = (value: any): value is Function =>\n  typeof value === 'function'\n\ntype ReactRef<T> = React.Ref<T> | React.RefObject<T> | React.MutableRefObject<T>\n\nfunction assignRef<T = any>(ref: ReactRef<T> | undefined, value: T) {\n  if (ref == null) return\n\n  if (isFunction(ref)) {\n    ref(value)\n    return\n  }\n\n  try {\n    // @ts-ignore\n    ref.current = value\n  } catch (error) {\n    throw new Error(`Cannot assign value '${value}' to ref '${ref}'`)\n  }\n}\n\n/**\n * Combine multiple React refs into a single ref function.\n * This is used mostly when you need to allow consumers forward refs to\n * internal components\n *\n * @param refs refs to assign to value to\n */\nfunction mergeRefs<T>(...refs: (ReactRef<T> | undefined)[]) {\n  return (node: T | null) => {\n    refs.forEach((ref) => assignRef(ref, node))\n  }\n}\n\ntype Merge<T, P> = P & Omit<T, keyof P>\n\ntype PropGetter<T extends HTMLElement = any, P = {}> = (\n  props?: Merge<React.HTMLProps<T>, P>,\n  ref?: React.Ref<any> | React.RefObject<any>,\n) => Merge<React.HTMLProps<T>, P>\n\nfunction canUseDOM(): boolean {\n  return !!(\n    typeof window !== 'undefined' &&\n    window.document &&\n    window.document.createElement\n  )\n}\n\nconst isBrowser = canUseDOM()\n\nexport type { PropGetter, Merge, ReactRef, FunctionArguments }\n\nexport {\n  mergeRefs,\n  assignRef,\n  isFunction,\n  callAllHandlers,\n  canUseDOM,\n  isBrowser,\n}\n","/**\n * Lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n  HOT_SPAN = 16;\n\n/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n  arrayTag = '[object Array]',\n  asyncTag = '[object AsyncFunction]',\n  boolTag = '[object Boolean]',\n  dateTag = '[object Date]',\n  errorTag = '[object Error]',\n  funcTag = '[object Function]',\n  genTag = '[object GeneratorFunction]',\n  mapTag = '[object Map]',\n  numberTag = '[object Number]',\n  nullTag = '[object Null]',\n  objectTag = '[object Object]',\n  proxyTag = '[object Proxy]',\n  regexpTag = '[object RegExp]',\n  setTag = '[object Set]',\n  stringTag = '[object String]',\n  undefinedTag = '[object Undefined]',\n  weakMapTag = '[object WeakMap]';\nvar arrayBufferTag = '[object ArrayBuffer]',\n  dataViewTag = '[object DataView]',\n  float32Tag = '[object Float32Array]',\n  float64Tag = '[object Float64Array]',\n  int8Tag = '[object Int8Array]',\n  int16Tag = '[object Int16Array]',\n  int32Tag = '[object Int32Array]',\n  uint8Tag = '[object Uint8Array]',\n  uint8ClampedTag = '[object Uint8ClampedArray]',\n  uint16Tag = '[object Uint16Array]',\n  uint32Tag = '[object Uint32Array]';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = function () {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}();\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0:\n      return func.call(thisArg);\n    case 1:\n      return func.call(thisArg, args[0]);\n    case 2:\n      return func.call(thisArg, args[0], args[1]);\n    case 3:\n      return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\n/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n    result = Array(n);\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function (value) {\n    return func(value);\n  };\n}\n\n/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n  return object == null ? undefined : object[key];\n}\n\n/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function (arg) {\n    return func(transform(arg));\n  };\n}\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype,\n  funcProto = Function.prototype,\n  objectProto = Object.prototype;\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = function () {\n  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n  return uid ? 'Symbol(src)_1.' + uid : '';\n}();\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&').replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$');\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n  Symbol = root.Symbol,\n  Uint8Array = root.Uint8Array,\n  allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n  getPrototype = overArg(Object.getPrototypeOf, Object),\n  objectCreate = Object.create,\n  propertyIsEnumerable = objectProto.propertyIsEnumerable,\n  splice = arrayProto.splice,\n  symToStringTag = Symbol ? Symbol.toStringTag : undefined;\nvar defineProperty = function () {\n  try {\n    var func = getNative(Object, 'defineProperty');\n    func({}, '', {});\n    return func;\n  } catch (e) {}\n}();\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n  nativeMax = Math.max,\n  nativeNow = Date.now;\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map'),\n  nativeCreate = getNative(Object, 'create');\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = function () {\n  function object() {}\n  return function (proto) {\n    if (!isObject(proto)) {\n      return {};\n    }\n    if (objectCreate) {\n      return objectCreate(proto);\n    }\n    object.prototype = proto;\n    var result = new object();\n    object.prototype = undefined;\n    return result;\n  };\n}();\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n  var index = -1,\n    length = entries == null ? 0 : entries.length;\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n  this.__data__ = nativeCreate ? nativeCreate(null) : {};\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n  var result = this.has(key) && delete this.__data__[key];\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n  var data = this.__data__;\n  if (nativeCreate) {\n    var result = data[key];\n    return result === HASH_UNDEFINED ? undefined : result;\n  }\n  return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n  var data = this.__data__;\n  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);\n}\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n  var data = this.__data__;\n  this.size += this.has(key) ? 0 : 1;\n  data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;\n  return this;\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n  var index = -1,\n    length = entries == null ? 0 : entries.length;\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n  this.__data__ = [];\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n  var data = this.__data__,\n    index = assocIndexOf(data, key);\n  if (index < 0) {\n    return false;\n  }\n  var lastIndex = data.length - 1;\n  if (index == lastIndex) {\n    data.pop();\n  } else {\n    splice.call(data, index, 1);\n  }\n  --this.size;\n  return true;\n}\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n  var data = this.__data__,\n    index = assocIndexOf(data, key);\n  return index < 0 ? undefined : data[index][1];\n}\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n  return assocIndexOf(this.__data__, key) > -1;\n}\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n  var data = this.__data__,\n    index = assocIndexOf(data, key);\n  if (index < 0) {\n    ++this.size;\n    data.push([key, value]);\n  } else {\n    data[index][1] = value;\n  }\n  return this;\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n  var index = -1,\n    length = entries == null ? 0 : entries.length;\n  this.clear();\n  while (++index < length) {\n    var entry = entries[index];\n    this.set(entry[0], entry[1]);\n  }\n}\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n  this.size = 0;\n  this.__data__ = {\n    'hash': new Hash(),\n    'map': new (Map || ListCache)(),\n    'string': new Hash()\n  };\n}\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n  var result = getMapData(this, key)['delete'](key);\n  this.size -= result ? 1 : 0;\n  return result;\n}\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n  return getMapData(this, key).get(key);\n}\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n  return getMapData(this, key).has(key);\n}\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n  var data = getMapData(this, key),\n    size = data.size;\n  data.set(key, value);\n  this.size += data.size == size ? 0 : 1;\n  return this;\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache();\n  this.size = 0;\n}\n\n/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n    result = data['delete'](key);\n  this.size = data.size;\n  return result;\n}\n\n/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\n/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n    isArg = !isArr && isArguments(value),\n    isBuff = !isArr && !isArg && isBuffer(value),\n    isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n    skipIndexes = isArr || isArg || isBuff || isType,\n    result = skipIndexes ? baseTimes(value.length, String) : [],\n    length = result.length;\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (\n    // Safari 9 has enumerable `arguments.length` in strict mode.\n    key == 'length' ||\n    // Node.js 0.10 has enumerable non-index properties on buffers.\n    isBuff && (key == 'offset' || key == 'parent') ||\n    // PhantomJS 2 has enumerable non-index properties on typed arrays.\n    isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') ||\n    // Skip index properties.\n    isIndex(key, length)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n  if (value !== undefined && !eq(object[key], value) || value === undefined && !(key in object)) {\n    baseAssignValue(object, key, value);\n  }\n}\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n  var objValue = object[key];\n  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined && !(key in object)) {\n    baseAssignValue(object, key, value);\n  }\n}\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n  var length = array.length;\n  while (length--) {\n    if (eq(array[length][0], key)) {\n      return length;\n    }\n  }\n  return -1;\n}\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n  if (key == '__proto__' && defineProperty) {\n    defineProperty(object, key, {\n      'configurable': true,\n      'enumerable': true,\n      'value': value,\n      'writable': true\n    });\n  } else {\n    object[key] = value;\n  }\n}\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);\n}\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n *  else `false`.\n */\nfunction baseIsNative(value) {\n  if (!isObject(value) || isMasked(value)) {\n    return false;\n  }\n  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n  return pattern.test(toSource(value));\n}\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n  if (!isObject(object)) {\n    return nativeKeysIn(object);\n  }\n  var isProto = isPrototype(object),\n    result = [];\n  for (var key in object) {\n    if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n  if (object === source) {\n    return;\n  }\n  baseFor(source, function (srcValue, key) {\n    stack || (stack = new Stack());\n    if (isObject(srcValue)) {\n      baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n    } else {\n      var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + '', object, source, stack) : undefined;\n      if (newValue === undefined) {\n        newValue = srcValue;\n      }\n      assignMergeValue(object, key, newValue);\n    }\n  }, keysIn);\n}\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n *  counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n  var objValue = safeGet(object, key),\n    srcValue = safeGet(source, key),\n    stacked = stack.get(srcValue);\n  if (stacked) {\n    assignMergeValue(object, key, stacked);\n    return;\n  }\n  var newValue = customizer ? customizer(objValue, srcValue, key + '', object, source, stack) : undefined;\n  var isCommon = newValue === undefined;\n  if (isCommon) {\n    var isArr = isArray(srcValue),\n      isBuff = !isArr && isBuffer(srcValue),\n      isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n    newValue = srcValue;\n    if (isArr || isBuff || isTyped) {\n      if (isArray(objValue)) {\n        newValue = objValue;\n      } else if (isArrayLikeObject(objValue)) {\n        newValue = copyArray(objValue);\n      } else if (isBuff) {\n        isCommon = false;\n        newValue = cloneBuffer(srcValue, true);\n      } else if (isTyped) {\n        isCommon = false;\n        newValue = cloneTypedArray(srcValue, true);\n      } else {\n        newValue = [];\n      }\n    } else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n      newValue = objValue;\n      if (isArguments(objValue)) {\n        newValue = toPlainObject(objValue);\n      } else if (!isObject(objValue) || isFunction(objValue)) {\n        newValue = initCloneObject(srcValue);\n      }\n    } else {\n      isCommon = false;\n    }\n  }\n  if (isCommon) {\n    // Recursively merge objects and arrays (susceptible to call stack limits).\n    stack.set(srcValue, newValue);\n    mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n    stack['delete'](srcValue);\n  }\n  assignMergeValue(object, key, newValue);\n}\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n  return setToString(overRest(func, start, identity), func + '');\n}\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function (func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\n/**\n * Creates a clone of  `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n  if (isDeep) {\n    return buffer.slice();\n  }\n  var length = buffer.length,\n    result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n  buffer.copy(result);\n  return result;\n}\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n  new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n  return result;\n}\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n  var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\n/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n  var index = -1,\n    length = source.length;\n  array || (array = Array(length));\n  while (++index < length) {\n    array[index] = source[index];\n  }\n  return array;\n}\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n  var isNew = !object;\n  object || (object = {});\n  var index = -1,\n    length = props.length;\n  while (++index < length) {\n    var key = props[index];\n    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined;\n    if (newValue === undefined) {\n      newValue = source[key];\n    }\n    if (isNew) {\n      baseAssignValue(object, key, newValue);\n    } else {\n      assignValue(object, key, newValue);\n    }\n  }\n  return object;\n}\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n  return baseRest(function (object, sources) {\n    var index = -1,\n      length = sources.length,\n      customizer = length > 1 ? sources[length - 1] : undefined,\n      guard = length > 2 ? sources[2] : undefined;\n    customizer = assigner.length > 3 && typeof customizer == 'function' ? (length--, customizer) : undefined;\n    if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n      customizer = length < 3 ? undefined : customizer;\n      length = 1;\n    }\n    object = Object(object);\n    while (++index < length) {\n      var source = sources[index];\n      if (source) {\n        assigner(object, source, index, customizer);\n      }\n    }\n    return object;\n  });\n}\n\n/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n  return function (object, iteratee, keysFunc) {\n    var index = -1,\n      iterable = Object(object),\n      props = keysFunc(object),\n      length = props.length;\n    while (length--) {\n      var key = props[fromRight ? length : ++index];\n      if (iteratee(iterable[key], key, iterable) === false) {\n        break;\n      }\n    }\n    return object;\n  };\n}\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n  var data = map.__data__;\n  return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;\n}\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n  var value = getValue(object, key);\n  return baseIsNative(value) ? value : undefined;\n}\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n    tag = value[symToStringTag];\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n  return typeof object.constructor == 'function' && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};\n}\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n  var type = typeof value;\n  length = length == null ? MAX_SAFE_INTEGER : length;\n  return !!length && (type == 'number' || type != 'symbol' && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;\n}\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n *  else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n  if (!isObject(object)) {\n    return false;\n  }\n  var type = typeof index;\n  if (type == 'number' ? isArrayLike(object) && isIndex(index, object.length) : type == 'string' && index in object) {\n    return eq(object[index], value);\n  }\n  return false;\n}\n\n/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n  var type = typeof value;\n  return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;\n}\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n  return !!maskSrcKey && maskSrcKey in func;\n}\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n    proto = typeof Ctor == 'function' && Ctor.prototype || objectProto;\n  return value === proto;\n}\n\n/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n  var result = [];\n  if (object != null) {\n    for (var key in Object(object)) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? func.length - 1 : start, 0);\n  return function () {\n    var args = arguments,\n      index = -1,\n      length = nativeMax(args.length - start, 0),\n      array = Array(length);\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\n/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n  if (key === 'constructor' && typeof object[key] === 'function') {\n    return;\n  }\n  if (key == '__proto__') {\n    return;\n  }\n  return object[key];\n}\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n    lastCalled = 0;\n  return function () {\n    var stamp = nativeNow(),\n      remaining = HOT_SPAN - (stamp - lastCalled);\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n  if (func != null) {\n    try {\n      return funcToString.call(func);\n    } catch (e) {}\n    try {\n      return func + '';\n    } catch (e) {}\n  }\n  return '';\n}\n\n/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n  return value === other || value !== value && other !== other;\n}\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function () {\n  return arguments;\n}()) ? baseIsArguments : function (value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');\n};\n\n/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n *  else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n  return isObjectLike(value) && isArrayLike(value);\n}\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n  if (!isObject(value)) {\n    return false;\n  }\n  // The use of `Object#toString` avoids issues with the `typeof` operator\n  // in Safari 9 which returns 'object' for typed arrays and other constructors.\n  var tag = baseGetTag(value);\n  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;\n}\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n  return copyObject(value, keysIn(value));\n}\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\n/**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n *   if (_.isArray(objValue)) {\n *     return objValue.concat(srcValue);\n *   }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\nvar mergeWith = createAssigner(function (object, source, srcIndex, customizer) {\n  baseMerge(object, source, srcIndex, customizer);\n});\n\n/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function () {\n    return value;\n  };\n}\n\n/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\n/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\nmodule.exports = mergeWith;","import * as React from 'react'\nimport { isBrowser } from '../../utils/misc'\n\n/**\n * useSafeLayoutEffect enables us to safely call `useLayoutEffect` on the browser\n * (for SSR reasons)\n *\n * React currently throws a warning when using useLayoutEffect on the server.\n * To get around it, we can conditionally useEffect on the server (no-op) and\n * useLayoutEffect in the browser.\n *\n * @see https://gist.github.com/gaearon/e7d97cdf38a2907924ea12e4ebdf3c85\n */\nexport const useSafeLayoutEffect = isBrowser\n  ? React.useLayoutEffect\n  : React.useEffect\n","import * as React from 'react'\nimport { useUnmountEffect } from '..'\n\nexport function useForceUpdate() {\n  const unloadingRef = React.useRef(false)\n  const [count, setCount] = React.useState(0)\n\n  useUnmountEffect(() => {\n    unloadingRef.current = true\n  })\n\n  return React.useCallback(() => {\n    if (!unloadingRef.current) {\n      setCount(count + 1)\n    }\n  }, [count])\n}\n","import * as React from 'react'\n\nexport function useUnmountEffect(fn: () => void, deps: any[] = []) {\n  return React.useEffect(\n    () => () => fn(),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    deps,\n  )\n}\n"],"sourceRoot":""}