{"version":3,"sources":["webpack:///./node_modules/@paypalcorp/fpti/dist/fpti.js","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":["getNearestInt","num","Math","round","parseFloat","uuid","cryptoObj","window","crypto","msCrypto","random32ByteNumber","randomNumber","rnds32","Uint32Array","getRandomValues","e","random","toString","storages","s","l","getStorage","store","get3pStorage","fpti_3p","key","value","getItem","_getItem","vid","vid_exp","fpti","fpti_exp","now","Date","JSON","parse","item","storage","setItem","_setItem","setLocalItem","stringify","appendDataToURL","url","data","appendQueryStringData","indexOf","charAt","length","encodeURIComponent","fireImagePixel","src","Image","t","ua","navigator","userAgent","isIE","test","isIOSSafari","shouldUpdateReferrerPolicy","referrerPolicy","impressionKeys","normalizeData","dataObject","generateBeaconUrl","options","fptiserverurl","parts","split","match","location","protocol","version","basePayLoad","getTime","g","getTimezoneOffset","start","end","view","t11","undefined","createTrackingPayload","beaconURL","onBeaconCreate","_tenantName","tenant_name","hostname","fpti3pIds","base","obj","shouldOverride","extend","record","inputData","beaconUrl","exports","recordImpression","preRecordCallback","document","title","referrer","screen","colorDepth","screenDimensions","width","height","deviceDimensions","ratio","devicePixelRatio","w","h","abs","orientation","temp","getDeviceDimensions","elem","a","browserDimensions","documentElement","body","cookieEnabled","res","recordWithFetch","result","fetch","useIsomorphicLayoutEffect","React","serverHandoffComplete","id","genId","useId","idFromProps","initialId","setId","useLayoutEffect","String","withAnalytics","Component","props","createElement","Object","assign","createContext","strict","errorMessage","name","Context","displayName","Provider","useContext","context","_Error$captureStackTr","error","Error","captureStackTrace","call","FormControlProvider","useFormControlContext","runIfFn","valueOrFn","_len3","arguments","args","Array","_key3","_isFunction","apply","useBoolean","initialState","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","reIsHostCtor","reIsUint","typedArrayTags","freeGlobal","global","freeSelf","self","root","Function","freeExports","nodeType","freeModule","module","moduleExports","freeProcess","process","nodeUtil","types","require","binding","nodeIsTypedArray","isTypedArray","func","thisArg","uid","transform","arrayProto","prototype","funcProto","objectProto","coreJsData","funcToString","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","max","nativeNow","Map","nativeCreate","baseCreate","object","proto","isObject","Hash","entries","index","this","clear","entry","set","ListCache","MapCache","Stack","__data__","size","arrayLikeKeys","inherited","isArr","isArray","isArg","isArguments","isBuff","isType","skipIndexes","n","iteratee","baseTimes","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","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","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":"068de6f06151eeb4d545e13865e6b6ef0514e03e-580245f2e3c124fd2621.js","sourcesContent":["'use strict';\n\n/**\n * gets current timestamp in epoch seconds\n * @returns {Number} times in epoch seconds\n */\nrequire(\"core-js/modules/es.typed-array.set.js\");\nrequire(\"core-js/modules/es.typed-array.sort.js\");\nfunction getTimestamp() {\n  return new Date().getTime();\n}\n/**\n * gets current GMT offset\n * @returns {Number} offset is mins\n */\n\nfunction getGmtOffset() {\n  return new Date().getTimezoneOffset();\n}\n/**\n * Round off numbers(int/string/float) to int\n * Invalid input returns 0\n *\n * @example\n * getNearestInt(100)  // 100\n * getNearestInt(100.49)  // 100\n * getNearestInt(100.50)  // 101\n * getNearestInt('100.50')  // 101\n * getNearestInt('test')  // 0\n *\n *\n * @param {Number|String} num number or number in string\n * @returns {Number} rounded integer\n */\n\nfunction getNearestInt(num) {\n  return Math.round(parseFloat(num)) || 0;\n}\n/**\n * Extend base object with key-vals from other object with optional override.\n *\n * @example\n * extend({}, { a: 1 });                      // { a: 1 }\n * extend({ a: 1 }, { b: 1 });                // { a: 1, b: 1 }\n * extend({ a: 1 }, { a: 2, b: 2 });          // { a: 2, b: 2 }\n * extend({ a: 1 }, { a: 2, b: 2 }, false);   // { a: 1, b: 2 }\n *\n * @param {Object} base Base source object, which will be updated\n * @param {Object} obj Source object\n * @param {Boolean} shouldOverride default is true\n * @returns {Object} Returns updated base object\n */\n\nfunction extend(base, obj, shouldOverride) {\n  if (typeof shouldOverride === 'undefined') {\n    shouldOverride = true;\n  }\n  base = base || {};\n  obj = obj || {};\n  for (var key in obj) {\n    if (typeof obj[key] !== 'undefined' && (shouldOverride || !shouldOverride && typeof base[key] === 'undefined')) {\n      base[key] = obj[key];\n    }\n  }\n  return base;\n}\n/**\n * uuid generator. Generates a unique ID\n */\n\nfunction uuid() {\n  var cryptoObj = window.crypto || window.msCrypto; // for IE 11\n\n  var random32ByteNumber = function random32ByteNumber() {\n    var randomNumber;\n    var max32ByteNumber = 0x7fffffff;\n    try {\n      var rnds32 = new Uint32Array(1);\n      cryptoObj.getRandomValues(rnds32);\n      randomNumber = rnds32[0] & max32ByteNumber;\n    } catch (e) {\n      randomNumber = Math.round(max32ByteNumber * Math.random());\n    }\n    return randomNumber.toString(16);\n  };\n  return random32ByteNumber() + random32ByteNumber();\n}\n\n/**\n * sets client only cookie key/value pair\n * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies\n *\n * @example\n * setCookie ('key', 'value')\n *\n * @param {String} key cookie key\n * @param {String|Integer} value cookie value\n * @param {Object} options optional cookie options\n */\n\nvar storages = {\n  s: 'sessionStorage',\n  l: 'localStorage'\n};\n/***\n * localStorage: data stored has no expiration time\n * sessionStorage: data stored gets cleared when the page session ends(page is closed)\n **/\n\nfunction getStorage(s) {\n  var store;\n  try {\n    store = window[storages[s]];\n  } catch (e) {\n    store = null;\n  }\n  return store;\n}\nfunction _getItem(store, key) {\n  var value;\n  if (store) {\n    value = store.getItem(key);\n  }\n  return value;\n}\nfunction _setItem(storage, key, item) {\n  if (!storage || !item) {\n    return;\n  }\n  try {\n    storage.setItem(key, item);\n  } catch (e) {// Do Nothing\n  }\n}\n/**\n * Fetch an item from the local Store, given its key\n *\n * @param key Key of the item to be fetched\n * @returns {*} Item from the local Store\n */\n\nfunction getLocalItem(key) {\n  return _getItem(getStorage('l'), key);\n}\n/**\n * Store an item, given its key to local Store\n *\n * @param key Key used to uniquely identify item in the local Store\n * @param item Item to be stored\n */\n\nfunction setLocalItem(key, item) {\n  _setItem(getStorage('l'), key, item);\n}\n/**\n * checks if localStorage is available\n * @return {Boolean}\n */\n\nfunction hasLocalStorage() {\n  return !!getStorage('l');\n}\nvar visitorIdExpiry = 30 * 60 * 1000;\nvar fptiExpiry = 3 * 365 * 24 * 60 * 60 * 1000;\nvar fpti3pKey = 'fpti_3p';\n/**\n * Get/Create 3rd party FPTI Ids. Uses Local Storage for persistence.\n * Addresses some concerns of identity with ITP 2.2\n * @see used by {@link recordImpression}\n */\n\nfunction get3pStorage() {\n  var fpti_3p = null;\n  if (!hasLocalStorage()) {\n    return;\n  }\n  try {\n    fpti_3p = getLocalItem(fpti3pKey);\n    var vid = null;\n    var vid_exp = null;\n    var fpti = null;\n    var fpti_exp = null;\n    var now = Date.now();\n    if (fpti_3p) {\n      // We have data in LS, we need to update the expiry & generate new Ids if expired\n      fpti_3p = JSON.parse(fpti_3p); // check if visitor Id has expired\n\n      if (fpti_3p.vid && fpti_3p.vid_exp > now) {\n        vid = fpti_3p.vid;\n      } else {\n        vid = uuid();\n      } // check if fpti Id has expired\n\n      if (fpti_3p.fpti && fpti_3p.fpti_exp > now) {\n        fpti = fpti_3p.fpti;\n      } else {\n        fpti = uuid();\n      } // Updating expiries\n\n      vid_exp = now + visitorIdExpiry;\n      fpti_exp = now + fptiExpiry;\n    } else {\n      // We dont have data in LS, we need to generate Ids & place them in LS\n      vid = uuid();\n      vid_exp = now + visitorIdExpiry;\n      fpti = uuid();\n      fpti_exp = now + fptiExpiry;\n    } // Set updated data back to LS\n\n    fpti_3p = {\n      vid: vid,\n      vid_exp: vid_exp,\n      fpti: fpti,\n      fpti_exp: fpti_exp\n    };\n    setLocalItem(fpti3pKey, JSON.stringify(fpti_3p));\n  } catch (e) {// Do nothing\n  }\n  return fpti_3p;\n}\n\n/**\n * adds a new data to the query string of a url\n *\n * @example\n * appendDataToURL('https://www.example.com', {x: 'y'});      // https://www.example.com?x=y\n * appendDataToURL('https://www.example.com?a=b', {x: 'y'});  // https://www.example.com?a=b&x=y\n *\n * @param {String} url\n * @param {Object} data JSON Object\n * @returns {String} Updated url\n */\n\nfunction appendDataToURL(url, data) {\n  for (var key in data) {\n    if (key && typeof data[key] !== 'undefined' && data[key] !== '') {\n      url = appendQueryStringData(url, key, data[key]);\n    }\n  }\n  return url;\n}\n/**\n * adds a new piece of data to the query string of a url\n *\n * @example\n * appendQueryStringData('https://www.example.com', 'x', 'y');      // https://www.example.com?x=y\n * appendQueryStringData('https://www.example.com?a=b', 'x', 'y');  // https://www.example.com?a=b&x=y\n *\n * @param {String} url\n * @param {String} key\n * @param {String|Number} value\n * @returns {String} Updated url\n */\n\nfunction appendQueryStringData(url, key, value) {\n  if (key && (value || value === 0 || value === false)) {\n    if (typeof value === 'object') {\n      try {\n        value = JSON.stringify(value);\n      } catch (e) {\n        value = '_err_'; // Log error value to track\n      }\n    }\n    if (url.indexOf('?') === -1) {\n      url += '?';\n    }\n    if (url.charAt(url.length - 1) !== '?') {\n      url += '&';\n    }\n    url += key + '=' + encodeURIComponent(value);\n  }\n  return url;\n}\n/**\n * gets browser dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\nfunction getBrowserDimensions() {\n  var elem = window;\n  var a = 'inner';\n  if (!('innerWidth' in window)) {\n    a = 'client';\n    elem = document.documentElement || document.body;\n  }\n  return {\n    width: elem[a + 'Width'],\n    height: elem[a + 'Height']\n  };\n}\n/**\n * gets device dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\nfunction getDeviceDimensions() {\n  var screen = window.screen || {};\n  var ratio = window.devicePixelRatio || 1;\n  var w = getNearestInt(screen.width * ratio);\n  var h = getNearestInt(screen.height * ratio);\n  if (Math.abs(window.orientation) === 90) {\n    // landscape mode w/h are exchanged\n    var temp = w;\n    w = h;\n    h = temp;\n  }\n  return {\n    width: w,\n    height: h\n  };\n}\n/**\n * gets screen dimensions\n * @returns {Object} {width: Value, height: Value}\n */\n\nfunction getScreenDimensions() {\n  var screen = window.screen || {};\n  return {\n    width: screen.width,\n    height: screen.height\n  };\n}\n/**\n * gets screen color depth\n * @returns {Number}\n */\n\nfunction getScreenColorDepth() {\n  return window.screen.colorDepth;\n} // gets boolean for cookies enabled\n\nfunction isCookiesEnabled() {\n  var enabled = navigator.cookieEnabled ? 1 : 0;\n  return enabled;\n}\n/**\n * Creates an image pixel\n * @param {String} src\n */\n\nfunction fireImagePixel(src) {\n  if (!src || !(typeof window !== 'undefined' && window.Image)) {\n    return;\n  }\n  var t = new window.Image(0, 0);\n  t.src = src;\n  if (shouldUpdateReferrerPolicy()) {\n    t.referrerPolicy = 'no-referrer-when-downgrade';\n  }\n}\nfunction shouldUpdateReferrerPolicy() {\n  var navigator = window.navigator;\n  var ua = navigator.userAgent;\n  var isIE = /MSIE|Trident/i.test(ua);\n  var isIOSSafari = (/iPad/i.test(ua) || /iPhone/i.test(ua)) && /WebKit/i.test(ua) && /CriOS/i.test(ua);\n  if (isIE || isIOSSafari) {\n    return false;\n  }\n  return true;\n}\nvar HOST_PP = 'paypal.com';\nvar VERSION = '1.0.0';\nvar FPTI_BASE_URL = 'https://t.paypal.com/ts';\nvar impressionKeys = {\n  cookiesEnabled: 'ce',\n  pageTitle: 'pt',\n  referrer: 'ru',\n  screenColorDepth: 'cd',\n  screenWidth: 'sw',\n  screenHeight: 'sh',\n  deviceWidth: 'dw',\n  deviceHeight: 'dh',\n  browserWidth: 'bw',\n  browserHeight: 'bh'\n};\n/**\n * Normalize the 2 flavors of options to record API\n * option: { data: {} } and data: {}\n * to option: { data: {} }\n * @param {*} dataObject\n */\n\nfunction normalizeData(dataObject) {\n  var opts;\n  if (dataObject && dataObject.data) {\n    opts = dataObject;\n  } else {\n    opts = {\n      data: dataObject || {}\n    };\n  }\n  return opts;\n} // generates a beacon url given request options\n\nfunction generateBeaconUrl(options, data) {\n  var url = options.url || typeof window !== 'undefined' && window.fptiserverurl || FPTI_BASE_URL;\n  var parts = url.split('?');\n  url = parts[0]; // remove existing query string\n  // if url begins with '//' then we automatically add the current protocol\n\n  if (url.match(/^\\/\\//)) {\n    url = (typeof location !== 'undefined' && location.protocol || '') + url;\n  } // add query string delimiter\n\n  url += '?'; // re-append existing query string\n\n  if (parts[1]) {\n    url += parts[1] + '&';\n  }\n  url += 'v=' + encodeURIComponent(options.version || VERSION); // version\n\n  var basePayLoad = {\n    t: getTimestamp(),\n    // timestamp\n    g: getGmtOffset() // gmt offset\n  }; // if starts time exists provide delta\n\n  if (data.start) {\n    var end = data.end || basePayLoad.t;\n    data.view = data.view || {};\n    data.view.t11 = end - data.start;\n    data.start = data.end = undefined;\n  }\n  url = appendDataToURL(url, basePayLoad);\n  url = appendDataToURL(url, data);\n  return url;\n}\nfunction createTrackingPayload(options, data) {\n  var beaconURL;\n  var onBeaconCreate = options.onBeaconCreate;\n  var _tenantName = window.fpti && window.fpti.tenant_name || HOST_PP; // Use 3p_ variables from local storage only when it is 3rd party\n\n  if (typeof window.location !== 'undefined' && window.location.hostname.indexOf('.' + _tenantName) === -1) {\n    var fpti3pIds = get3pStorage();\n    if (fpti3pIds) {\n      extend(data, {\n        '3p_vid': fpti3pIds.vid,\n        '3p_fpti': fpti3pIds.fpti\n      });\n    }\n  }\n  if (!onBeaconCreate || typeof onBeaconCreate === 'function' && onBeaconCreate() !== false) {\n    // beacon.src throw an exception you access it in IE if url is bigger than 4k\n    beaconURL = generateBeaconUrl(options, data);\n  }\n  fireImagePixel(beaconURL);\n  return beaconURL;\n}\n/**\n * Record any payload as FPTI event\n *\n * @example\n * record({page: 'test', pgrp: 'test', e: 'im'});\n * record({ data: {page: 'test', pgrp: 'test', e: 'im'}, url: '//t.paypal.com/ts' });\n *\n * @param {Object} inputData\n * @returns {Object} {data: {...}, url: '<beacon_URL>'}\n */\n\nfunction record(inputData) {\n  var options = normalizeData(inputData);\n  var beaconUrl = createTrackingPayload(options, options.data);\n  return {\n    data: options.data,\n    url: beaconUrl\n  };\n}\n/**\n * Record a FPTI impression.\n * Adds default browser aware impression key/values automatically like referrer, page title, browser width-height...\n *\n * @example\n * recordImpression({page: 'test', pgrp: 'test'});\n *\n * @param {Object} inputData\n * @param {Function} preRecordCallback\n */\n\nfunction recordImpression(inputData, preRecordCallback) {\n  var options = normalizeData(inputData);\n  var data = options.data; // page title\n\n  data[impressionKeys.pageTitle] = document.title; // referrer url\n\n  data[impressionKeys.referrer] = document.referrer; // screen color depth\n\n  data[impressionKeys.screenColorDepth] = getScreenColorDepth(); // screen dimensions\n\n  var screenDimensions = getScreenDimensions();\n  data[impressionKeys.screenWidth] = screenDimensions.width;\n  data[impressionKeys.screenHeight] = screenDimensions.height; // device dimensions\n\n  var deviceDimensions = getDeviceDimensions();\n  data[impressionKeys.deviceWidth] = deviceDimensions.width;\n  data[impressionKeys.deviceHeight] = deviceDimensions.height; // browser dimensions\n\n  var browserDimensions = getBrowserDimensions();\n  data[impressionKeys.browserWidth] = browserDimensions.width;\n  data[impressionKeys.browserHeight] = browserDimensions.height; // cookies enabled\n\n  data[impressionKeys.cookiesEnabled] = isCookiesEnabled();\n  var res = {\n    data: options.data,\n    url: ''\n  };\n  if (typeof preRecordCallback === 'function') {\n    preRecordCallback(function () {\n      res.url = createTrackingPayload(options, data);\n      return res;\n    });\n  } else {\n    res.url = createTrackingPayload(options, data);\n  }\n  return res;\n}\n/**\n * Record any payload as FPTI event in React-native.\n * Instead of Image pixel using fetch (AJAX) call.\n *\n * @example\n * recordWithFetch({page: 'test', pgrp: 'test', e: 'im'});\n * recordWithFetch({ data: {page: 'test', pgrp: 'test', e: 'im'}, url: 'https://t.paypal.com/ts' });\n *\n * @param {Object} inputData\n * @returns {Object} {data: {...}, url: '<beacon_URL>'}\n */\n\nfunction recordWithFetch(inputData) {\n  var result = record(inputData);\n  if (typeof fetch !== 'undefined') {\n    fetch(result.url);\n  }\n  return result;\n}\nexports.createTrackingPayload = createTrackingPayload;\nexports.generateBeaconUrl = generateBeaconUrl;\nexports.normalizeData = normalizeData;\nexports.record = record;\nexports.recordImpression = recordImpression;\nexports.recordWithFetch = recordWithFetch;","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":""}