{"version":3,"file":"static/chunks/156.593c94048368c97b.js","mappings":"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","sources":["webpack://_N_E/../../node_modules/@coingecko/cryptoformat/lib/cryptoformat.umd.js","webpack://_N_E/../../node_modules/ahooks/es/useInterval/index.js","webpack://_N_E/../../node_modules/lodash-es/noop.js","webpack://_N_E/../../node_modules/lodash-es/_baseIsMatch.js","webpack://_N_E/../../node_modules/lodash-es/_isStrictComparable.js","webpack://_N_E/../../node_modules/lodash-es/_getMatchData.js","webpack://_N_E/../../node_modules/lodash-es/_matchesStrictComparable.js","webpack://_N_E/../../node_modules/lodash-es/_baseMatches.js","webpack://_N_E/../../node_modules/lodash-es/_isKey.js","webpack://_N_E/../../node_modules/lodash-es/memoize.js","webpack://_N_E/../../node_modules/lodash-es/_memoizeCapped.js","webpack://_N_E/../../node_modules/lodash-es/_stringToPath.js","webpack://_N_E/../../node_modules/lodash-es/_castPath.js","webpack://_N_E/../../node_modules/lodash-es/_toKey.js","webpack://_N_E/../../node_modules/lodash-es/_baseGet.js","webpack://_N_E/../../node_modules/lodash-es/get.js","webpack://_N_E/../../node_modules/lodash-es/_baseHasIn.js","webpack://_N_E/../../node_modules/lodash-es/_hasPath.js","webpack://_N_E/../../node_modules/lodash-es/hasIn.js","webpack://_N_E/../../node_modules/lodash-es/_baseMatchesProperty.js","webpack://_N_E/../../node_modules/lodash-es/_baseProperty.js","webpack://_N_E/../../node_modules/lodash-es/_basePropertyDeep.js","webpack://_N_E/../../node_modules/lodash-es/property.js","webpack://_N_E/../../node_modules/lodash-es/_baseIteratee.js","webpack://_N_E/../../node_modules/lodash-es/_arrayIncludes.js","webpack://_N_E/../../node_modules/lodash-es/_arrayIncludesWith.js","webpack://_N_E/../../node_modules/lodash-es/_createSet.js","webpack://_N_E/../../node_modules/lodash-es/_baseUniq.js","webpack://_N_E/../../node_modules/lodash-es/uniqBy.js","webpack://_N_E/<anon>"],"sourcesContent":["(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (global = global || self, factory(global.cryptoformat = {}));\n}(this, function (exports) { 'use strict';\n\n  // A map of supported currency codes to currency symbols.\n  const supportedCurrencySymbols = {\n    BTC: \"₿\",\n    ETH: \"Ξ\",\n    USD: \"$\",\n    CAD: \"C$\",\n    GBP: \"£\",\n    EUR: \"€\",\n    CHF: \"Fr.\",\n    SEK: \"kr\",\n    JPY: \"¥\",\n    CNY: \"¥\",\n    INR: \"₹\",\n    RUB: \"₽\",\n    AUD: \"A$\",\n    HKD: \"HK$\",\n    SGD: \"S$\",\n    TWD: \"NT$\",\n    BRL: \"R$\",\n    KRW: \"₩\",\n    ZAR: \"R\",\n    MYR: \"RM\",\n    IDR: \"Rp\",\n    NZD: \"NZ$\",\n    MXN: \"MX$\",\n    PHP: \"₱\",\n    DKK: \"kr.\",\n    PLN: \"zł\",\n    AED: \"DH\",\n    ARS: \"$\",\n    CLP: \"CLP\",\n    CZK: \"Kč\",\n    HUF: \"Ft\",\n    ILS: \"₪\",\n    KWD: \"KD\",\n    LKR: \"Rs\",\n    NOK: \"kr\",\n    PKR: \"₨\",\n    SAR: \"SR\",\n    THB: \"฿\",\n    TRY: \"₺\",\n    XAU: \"XAU\",\n    XAG: \"XAG\",\n    XDR: \"XDR\",\n  };\n\n  // A map of override objects to apply.\n  // Format:\n  // { location: { start: Boolean, end: Boolean }, forLocales: { <locale>: Boolean } }\n  const symbolOverrides = {\n    MYR: { location: { start: true }, forLocales: { en: true } },\n    SGD: { location: { start: true }, forLocales: { en: true } },\n    PHP: { location: { start: true }, forLocales: { en: true } },\n    BTC: { location: { start: true }, forLocales: { en: true } },\n    ETH: { location: { start: true }, forLocales: { en: true } },\n  };\n\n  // Feature detection for Intl.NumberFormat\n  function IntlNumberFormatSupported() {\n    return !!(\n      typeof Intl == \"object\" &&\n      Intl &&\n      typeof Intl.NumberFormat == \"function\"\n    );\n  }\n\n  function isBTCETH(isoCode) {\n    return isoCode === \"BTC\" || isoCode === \"ETH\";\n  }\n\n  function isCrypto(isoCode) {\n    return isBTCETH(isoCode) || supportedCurrencySymbols[isoCode] == null;\n  }\n\n  // Function to transform decimal trailing zeroes to exponent\n  function decimalTrailingZeroesToExponent(formattedCurrency, maximumDecimalTrailingZeroes) {\n    const decimalTrailingZeroesPattern = new RegExp(`(\\\\.|,)(0{${maximumDecimalTrailingZeroes + 1},})(?=[1-9]?)`);\n\n    return formattedCurrency.replace(\n        decimalTrailingZeroesPattern,\n        (_match, separator, decimalTrailingZeroes) => `${separator}0<sub title=\\\"${formattedCurrency}\\\">${decimalTrailingZeroes.length}</sub>`,\n    )\n  }\n\n  // Function to transform the output from Intl.NumberFormat#format\n  function formatCurrencyOverride(formattedCurrency, locale = \"en\", maximumDecimalTrailingZeroes) {\n    if (typeof maximumDecimalTrailingZeroes !== \"undefined\") {\n      formattedCurrency = decimalTrailingZeroesToExponent(formattedCurrency, maximumDecimalTrailingZeroes);\n    }\n\n    // If currency code remains in front\n    const currencyCodeFrontMatch = formattedCurrency.match(/^[A-Z]{3}\\s?/);\n    if (currencyCodeFrontMatch != null) {\n      const code = currencyCodeFrontMatch[0].trim(); // trim possible trailing space\n\n      // Replace currency code with symbol if whitelisted.\n      const overrideObj = symbolOverrides[code];\n      if (\n        overrideObj &&\n        overrideObj.location.start &&\n        overrideObj.forLocales[locale]\n      ) {\n        return formattedCurrency.replace(\n          currencyCodeFrontMatch[0],\n          supportedCurrencySymbols[code]\n        );\n      } else {\n        return formattedCurrency;\n      }\n    }\n\n    // If currency code is at the back\n    const currencyCodeBackMatch = formattedCurrency.match(/[A-Z]{3}$/);\n    if (currencyCodeBackMatch != null) {\n      const code = currencyCodeBackMatch[0];\n\n      // Replace currency code with symbol if whitelisted.\n      const overrideObj = symbolOverrides[code];\n      if (\n        overrideObj &&\n        overrideObj.location.end &&\n        overrideObj.forLocales[locale]\n      ) {\n        return formattedCurrency.replace(code, supportedCurrencySymbols[code]);\n      } else {\n        return formattedCurrency;\n      }\n    }\n\n    return formattedCurrency;\n  }\n\n  // Generates a formatter from Intl.NumberFormat\n  function generateIntlNumberFormatter(isoCode, locale, numDecimals, numSigFig) {\n    try {\n      const params = {\n        style: \"currency\",\n        currency: isoCode,\n        currencyDisplay: \"symbol\",\n      };\n      if (numDecimals !== undefined) {\n        params.minimumFractionDigits = numDecimals;\n        params.maximumFractionDigits = numDecimals;\n      } else if (numSigFig !== undefined) {\n        params.maximumSignificantDigits = numSigFig;\n      }\n      return new Intl.NumberFormat(locale, params);\n    } catch (e) {\n      // Unsupported currency, etc.\n      // Use primitive fallback\n      return generateFallbackFormatter(isoCode, locale, numDecimals);\n    }\n  }\n\n  // Generates a primitive fallback formatter with no symbol support.\n  function generateFallbackFormatter(isoCode, locale, numDecimals = 2) {\n    isoCode = isoCode.toUpperCase();\n\n    if (numDecimals > 2) {\n      return {\n        format: (value) => {\n          return isCrypto(isoCode)\n            ? `${value.toFixed(numDecimals)} ${isoCode}`\n            : `${isoCode} ${value.toFixed(numDecimals)}`;\n        },\n      };\n    } else {\n      return {\n        format: (value) => {\n          return isCrypto(isoCode)\n            ? `${value.toLocaleString(locale)} ${isoCode}`\n            : `${isoCode} ${value.toLocaleString(locale)}`;\n        },\n      };\n    }\n  }\n\n  function generateAbbreviatedFormatter(isoCode, locale) {\n    // Show regular numbers if no Intl.NumberFormat support.\n    if (!IntlNumberFormatSupported()) {\n      return generateFallbackFormatter(isoCode, locale, 0);\n    }\n\n    let numberFormatOptions = { style: \"decimal\", notation: \"compact\", minimumFractionDigits: 0, maximumFractionDigits: 3 };\n\n    // Currency symbol is supported if currency is Fiat/BTC/ETH.\n    if (!isCrypto(isoCode) || isBTCETH(isoCode)) {\n      numberFormatOptions.style = \"currency\";\n      numberFormatOptions.currency = isoCode;\n    }\n\n    return new Intl.NumberFormat(locale, numberFormatOptions);\n  }\n\n  function generateFormatter(isoCode, locale, numDecimals, numSigFig) {\n    const isNumberFormatSupported = IntlNumberFormatSupported();\n\n    const useIntlNumberFormatter =\n      isNumberFormatSupported && (!isCrypto(isoCode) || isBTCETH(isoCode));\n    return useIntlNumberFormatter\n      ? generateIntlNumberFormatter(isoCode, locale, numDecimals, numSigFig)\n      : generateFallbackFormatter(isoCode, locale, numDecimals);\n  }\n\n  // State variables\n  let currentISOCode;\n  let currentLocale;\n  let currencyFormatterNormal;\n  let currencyFormatterNoDecimal;\n  let currencyFormatterMedium;\n  let currencyFormatterTwoDecimal;\n  let currencyFormatterSmall;\n  let currencyFormatterVerySmall;\n  let currencyFormatterVeryVerySmall;\n  let currencyFormatter15DP;\n  let currencyFormatter18DP;\n  let currencyFormatterAbbreviated;\n\n  // If a page has to display multiple currencies, formatters would have to be created for each of them\n  // To save some effort, we save formatters for reuse\n  let formattersCache = {};\n\n  function clearCache() {\n    formattersCache = {};\n  }\n\n  function initializeFormatters(isoCode, locale) {\n    const cacheKey = `${isoCode}-${locale}`;\n    const cachedFormatter = formattersCache[cacheKey];\n\n    currencyFormatterNormal = cachedFormatter\n      ? cachedFormatter.currencyFormatterNormal\n      : generateFormatter(isoCode, locale);\n    currencyFormatterNoDecimal = cachedFormatter\n      ? cachedFormatter.currencyFormatterNoDecimal\n      : generateFormatter(isoCode, locale, 0);\n    currencyFormatterMedium = cachedFormatter\n      ? cachedFormatter.currencyFormatterMedium\n      : generateFormatter(isoCode, locale, 3);\n    currencyFormatterTwoDecimal = cachedFormatter\n      ? cachedFormatter.currencyFormatterTwoDecimal\n      : generateFormatter(isoCode, locale, 2);\n    currencyFormatterSmall = cachedFormatter\n      ? cachedFormatter.currencyFormatterSmall\n      : generateFormatter(isoCode, locale, 6);\n    currencyFormatterVerySmall = cachedFormatter\n      ? cachedFormatter.currencyFormatterVerySmall\n      : generateFormatter(isoCode, locale, 8);\n    currencyFormatterVeryVerySmall = cachedFormatter\n      ? cachedFormatter.currencyFormatterVeryVerySmall\n      : generateFormatter(isoCode, locale, 12);\n    currencyFormatter15DP = cachedFormatter\n      ? cachedFormatter.currencyFormatter15DP\n      : generateFormatter(isoCode, locale, 15);\n    currencyFormatter18DP = cachedFormatter\n      ? cachedFormatter.currencyFormatter18DP\n      : generateFormatter(isoCode, locale, 18);\n    currencyFormatterAbbreviated = cachedFormatter\n      ? cachedFormatter.currencyFormatterAbbreviated\n      : generateAbbreviatedFormatter(isoCode, locale);\n\n    // Save in cache\n    if (cachedFormatter == null) {\n      formattersCache[cacheKey] = {};\n      formattersCache[cacheKey].currencyFormatterNormal = currencyFormatterNormal;\n      formattersCache[cacheKey].currencyFormatterNoDecimal = currencyFormatterNoDecimal;\n      formattersCache[cacheKey].currencyFormatterMedium = currencyFormatterMedium;\n      formattersCache[cacheKey].currencyFormatterTwoDecimal = currencyFormatterTwoDecimal;\n      formattersCache[cacheKey].currencyFormatterSmall = currencyFormatterSmall;\n      formattersCache[cacheKey].currencyFormatterVerySmall = currencyFormatterVerySmall;\n      formattersCache[cacheKey].currencyFormatterVeryVerySmall = currencyFormatterVeryVerySmall;\n      formattersCache[cacheKey].currencyFormatter15DP = currencyFormatter15DP;\n      formattersCache[cacheKey].currencyFormatter18DP = currencyFormatter18DP;\n      formattersCache[cacheKey].currencyFormatterAbbreviated = currencyFormatterAbbreviated;\n    }\n  }\n\n  // Moderate crypto amount threshold\n  const MEDIUM_CRYPTO_THRESHOLD = 50;\n  // Large crypto amount threshold\n  const LARGE_CRYPTO_THRESHOLD = 1000;\n  // No decimal threshold for large amounts\n  const NO_DECIMAL_THRESHOLD = 100000;\n\n  function formatCurrency(\n    amount,\n    isoCode,\n    locale = \"en\",\n    raw = false,\n    noDecimal = false,\n    abbreviated = false,\n  ) {\n    isoCode = isoCode.toUpperCase();\n    let maximumDecimalTrailingZeroes = undefined;\n\n    if (currentISOCode !== isoCode || currentLocale != locale) {\n      currentISOCode = isoCode;\n      currentLocale = locale;\n\n      // Formatters are tied to currency code, we try to initialize as infrequently as possible.\n      initializeFormatters(isoCode, locale);\n    }\n\n    if (abbreviated) {\n      let formattedAbbreviatedCurrency = currencyFormatterAbbreviated.format(amount);\n\n      // Manually add currency code to the back for non-BTC/ETH crypto currencies.\n      if (isCrypto(isoCode) && !isBTCETH(isoCode)) {\n        formattedAbbreviatedCurrency = `${formattedAbbreviatedCurrency} ${isoCode}`;\n      }\n\n      return formatCurrencyOverride(formattedAbbreviatedCurrency, locale);\n    }\n\n    if (noDecimal === true && amount > 100.0) {\n      return formatCurrencyOverride(\n        currencyFormatterNoDecimal.format(amount),\n        locale\n      );\n    } else if (typeof noDecimal === \"object\" && noDecimal !== null) {\n      if (raw) {\n        // Limit to max n decimal places if applicable\n        let raw_amount = noDecimal.hasOwnProperty(\"decimalPlaces\")\n          ? amount.toFixed(noDecimal.decimalPlaces)\n          : amount;\n        // Round off to number of significant figures without trailing 0's\n        return `${parseFloat(raw_amount).toPrecision(noDecimal.significantFigures) / 1}`;\n      }\n\n      if (noDecimal.hasOwnProperty(\"maximumDecimalTrailingZeroes\")) {\n        maximumDecimalTrailingZeroes = noDecimal.maximumDecimalTrailingZeroes;\n      }\n\n      if (noDecimal.hasOwnProperty(\"decimalPlaces\") && noDecimal.hasOwnProperty(\"significantFigures\")) {\n        // Show specified number of significant digits with cutoff of specified fraction digits\n        const currencyFormatterCustom = generateFormatter(\n          isoCode,\n          locale,\n          undefined,\n          noDecimal.significantFigures\n        );\n\n        return formatCurrencyOverride(\n          currencyFormatterCustom.format(\n            Number.parseFloat(amount.toFixed(noDecimal.decimalPlaces))\n          ),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (noDecimal.hasOwnProperty(\"decimalPlaces\") || noDecimal.hasOwnProperty(\"significantFigures\")) {\n        const currencyFormatterCustom = generateFormatter(\n          isoCode,\n          locale,\n          noDecimal.decimalPlaces,\n          noDecimal.significantFigures\n        );\n\n        return formatCurrencyOverride(\n          currencyFormatterCustom.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      }\n    }\n\n    if (isCrypto(isoCode)) {\n      let price = parseFloat(amount);\n\n      if (raw) {\n        if (amount === 0.0) {\n          return price.toFixed(2);\n        }\n        return price.toPrecision(8);\n      }\n\n      if (amount === 0.0) {\n        return formatCurrencyOverride(\n          currencyFormatterNormal.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (price >= LARGE_CRYPTO_THRESHOLD) {\n        // Large crypto amount, show no decimal value\n        return formatCurrencyOverride(\n          currencyFormatterNoDecimal.format(amount),\n          locale\n        );\n      } else if (\n        price >= MEDIUM_CRYPTO_THRESHOLD &&\n        price < LARGE_CRYPTO_THRESHOLD\n      ) {\n        // Medium crypto amount, show 3 fraction digits\n        return formatCurrencyOverride(\n          currencyFormatterMedium.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (price >= 1.0 && price < MEDIUM_CRYPTO_THRESHOLD) {\n        //  crypto amount, show 6 fraction digits\n        return formatCurrencyOverride(\n          currencyFormatterSmall.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (price >= 0.000001 && price < 1.0) {\n        //  crypto amount, show 8 fraction digits\n        return formatCurrencyOverride(\n          currencyFormatterVerySmall.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (price >= 10**-9 && price < 10**-6) {\n        return formatCurrencyOverride(\n          currencyFormatterVeryVerySmall.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (price >= 10**-12 && price < 10**-9) {\n        return formatCurrencyOverride(\n          currencyFormatter15DP.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (price < 10**-12) {\n        return formatCurrencyOverride(\n          currencyFormatter18DP.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      }\n    } else {\n      const unsigned_amount = Math.abs(amount);\n      if (raw) {\n        if (unsigned_amount < 10**-12) {\n          return amount.toFixed(18);\n        } else if (unsigned_amount < 10**-9) {\n          return amount.toFixed(15);\n        } else if (unsigned_amount < 10**-6) {\n          return amount.toFixed(12);\n        } else if (unsigned_amount < 10**-3) {\n          return amount.toFixed(8);\n        } else if (unsigned_amount < 1.0) {\n          return amount.toFixed(6);\n        } else {\n          return amount.toFixed(2);\n        }\n      }\n\n      if (unsigned_amount === 0.0) {\n        return formatCurrencyOverride(\n          currencyFormatterNormal.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (unsigned_amount < 10**-12) {\n        return formatCurrencyOverride(\n          currencyFormatter18DP.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (unsigned_amount < 10**-9) {\n        return formatCurrencyOverride(\n          currencyFormatter15DP.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (unsigned_amount < 10**-6) {\n        return formatCurrencyOverride(\n          currencyFormatterVeryVerySmall.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (unsigned_amount < 0.05) {\n        return formatCurrencyOverride(\n          currencyFormatterVerySmall.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (unsigned_amount < 1.0) {\n        return formatCurrencyOverride(\n          currencyFormatterSmall.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (isoCode === \"JPY\" && unsigned_amount < 100) {\n        return formatCurrencyOverride(\n          currencyFormatterTwoDecimal.format(amount),\n          locale,\n          maximumDecimalTrailingZeroes\n        );\n      } else if (unsigned_amount > NO_DECIMAL_THRESHOLD) {\n        return formatCurrencyOverride(\n          currencyFormatterNoDecimal.format(amount),\n          locale\n        );\n      } else {\n        // Let the formatter do what it seems best. In particular, we should not set any fraction amount for Japanese Yen\n        return formatCurrencyOverride(\n          currencyFormatterNormal.format(amount),\n          locale\n        );\n      }\n    }\n  }\n\n  exports.clearCache = clearCache;\n  exports.formatCurrency = formatCurrency;\n  exports.isCrypto = isCrypto;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n","import { useCallback, useEffect, useRef } from 'react';\nimport useMemoizedFn from '../useMemoizedFn';\nimport { isNumber } from '../utils';\nvar useInterval = function (fn, delay, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  var timerCallback = useMemoizedFn(fn);\n  var timerRef = useRef(null);\n  var clear = useCallback(function () {\n    if (timerRef.current) {\n      clearInterval(timerRef.current);\n    }\n  }, []);\n  useEffect(function () {\n    if (!isNumber(delay) || delay < 0) {\n      return;\n    }\n    if (options.immediate) {\n      timerCallback();\n    }\n    timerRef.current = setInterval(timerCallback, delay);\n    return clear;\n  }, [delay, options.immediate]);\n  return clear;\n};\nexport default useInterval;","/**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\nfunction noop() {\n  // No operation performed.\n}\n\nexport default noop;\n","import Stack from './_Stack.js';\nimport baseIsEqual from './_baseIsEqual.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.isMatch` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Array} matchData The property names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\nfunction baseIsMatch(object, source, matchData, customizer) {\n  var index = matchData.length,\n      length = index,\n      noCustomizer = !customizer;\n\n  if (object == null) {\n    return !length;\n  }\n  object = Object(object);\n  while (index--) {\n    var data = matchData[index];\n    if ((noCustomizer && data[2])\n          ? data[1] !== object[data[0]]\n          : !(data[0] in object)\n        ) {\n      return false;\n    }\n  }\n  while (++index < length) {\n    data = matchData[index];\n    var key = data[0],\n        objValue = object[key],\n        srcValue = data[1];\n\n    if (noCustomizer && data[2]) {\n      if (objValue === undefined && !(key in object)) {\n        return false;\n      }\n    } else {\n      var stack = new Stack;\n      if (customizer) {\n        var result = customizer(objValue, srcValue, key, object, source, stack);\n      }\n      if (!(result === undefined\n            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n            : result\n          )) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\nexport default baseIsMatch;\n","import isObject from './isObject.js';\n\n/**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n *  equality comparisons, else `false`.\n */\nfunction isStrictComparable(value) {\n  return value === value && !isObject(value);\n}\n\nexport default isStrictComparable;\n","import isStrictComparable from './_isStrictComparable.js';\nimport keys from './keys.js';\n\n/**\n * Gets the property names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\nfunction getMatchData(object) {\n  var result = keys(object),\n      length = result.length;\n\n  while (length--) {\n    var key = result[length],\n        value = object[key];\n\n    result[length] = [key, value, isStrictComparable(value)];\n  }\n  return result;\n}\n\nexport default getMatchData;\n","/**\n * A specialized version of `matchesProperty` for source values suitable\n * for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction matchesStrictComparable(key, srcValue) {\n  return function(object) {\n    if (object == null) {\n      return false;\n    }\n    return object[key] === srcValue &&\n      (srcValue !== undefined || (key in Object(object)));\n  };\n}\n\nexport default matchesStrictComparable;\n","import baseIsMatch from './_baseIsMatch.js';\nimport getMatchData from './_getMatchData.js';\nimport matchesStrictComparable from './_matchesStrictComparable.js';\n\n/**\n * The base implementation of `_.matches` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatches(source) {\n  var matchData = getMatchData(source);\n  if (matchData.length == 1 && matchData[0][2]) {\n    return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n  }\n  return function(object) {\n    return object === source || baseIsMatch(object, source, matchData);\n  };\n}\n\nexport default baseMatches;\n","import isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n    reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n  if (isArray(value)) {\n    return false;\n  }\n  var type = typeof value;\n  if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n      value == null || isSymbol(value)) {\n    return true;\n  }\n  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n    (object != null && value in Object(object));\n}\n\nexport default isKey;\n","import MapCache from './_MapCache.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n  if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  var memoized = function() {\n    var args = arguments,\n        key = resolver ? resolver.apply(this, args) : args[0],\n        cache = memoized.cache;\n\n    if (cache.has(key)) {\n      return cache.get(key);\n    }\n    var result = func.apply(this, args);\n    memoized.cache = cache.set(key, result) || cache;\n    return result;\n  };\n  memoized.cache = new (memoize.Cache || MapCache);\n  return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nexport default memoize;\n","import memoize from './memoize.js';\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n  var result = memoize(func, function(key) {\n    if (cache.size === MAX_MEMOIZE_SIZE) {\n      cache.clear();\n    }\n    return key;\n  });\n\n  var cache = result.cache;\n  return result;\n}\n\nexport default memoizeCapped;\n","import memoizeCapped from './_memoizeCapped.js';\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n  var result = [];\n  if (string.charCodeAt(0) === 46 /* . */) {\n    result.push('');\n  }\n  string.replace(rePropName, function(match, number, quote, subString) {\n    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n  });\n  return result;\n});\n\nexport default stringToPath;\n","import isArray from './isArray.js';\nimport isKey from './_isKey.js';\nimport stringToPath from './_stringToPath.js';\nimport toString from './toString.js';\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n  if (isArray(value)) {\n    return value;\n  }\n  return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nexport default castPath;\n","import isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n  if (typeof value == 'string' || isSymbol(value)) {\n    return value;\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default toKey;\n","import castPath from './_castPath.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n  path = castPath(path, object);\n\n  var index = 0,\n      length = path.length;\n\n  while (object != null && index < length) {\n    object = object[toKey(path[index++])];\n  }\n  return (index && index == length) ? object : undefined;\n}\n\nexport default baseGet;\n","import baseGet from './_baseGet.js';\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n  var result = object == null ? undefined : baseGet(object, path);\n  return result === undefined ? defaultValue : result;\n}\n\nexport default get;\n","/**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHasIn(object, key) {\n  return object != null && key in Object(object);\n}\n\nexport default baseHasIn;\n","import castPath from './_castPath.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isIndex from './_isIndex.js';\nimport isLength from './isLength.js';\nimport toKey from './_toKey.js';\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      result = false;\n\n  while (++index < length) {\n    var key = toKey(path[index]);\n    if (!(result = object != null && hasFunc(object, key))) {\n      break;\n    }\n    object = object[key];\n  }\n  if (result || ++index != length) {\n    return result;\n  }\n  length = object == null ? 0 : object.length;\n  return !!length && isLength(length) && isIndex(key, length) &&\n    (isArray(object) || isArguments(object));\n}\n\nexport default hasPath;\n","import baseHasIn from './_baseHasIn.js';\nimport hasPath from './_hasPath.js';\n\n/**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\nfunction hasIn(object, path) {\n  return object != null && hasPath(object, path, baseHasIn);\n}\n\nexport default hasIn;\n","import baseIsEqual from './_baseIsEqual.js';\nimport get from './get.js';\nimport hasIn from './hasIn.js';\nimport isKey from './_isKey.js';\nimport isStrictComparable from './_isStrictComparable.js';\nimport matchesStrictComparable from './_matchesStrictComparable.js';\nimport toKey from './_toKey.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatchesProperty(path, srcValue) {\n  if (isKey(path) && isStrictComparable(srcValue)) {\n    return matchesStrictComparable(toKey(path), srcValue);\n  }\n  return function(object) {\n    var objValue = get(object, path);\n    return (objValue === undefined && objValue === srcValue)\n      ? hasIn(object, path)\n      : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n  };\n}\n\nexport default baseMatchesProperty;\n","/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n  return function(object) {\n    return object == null ? undefined : object[key];\n  };\n}\n\nexport default baseProperty;\n","import baseGet from './_baseGet.js';\n\n/**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyDeep(path) {\n  return function(object) {\n    return baseGet(object, path);\n  };\n}\n\nexport default basePropertyDeep;\n","import baseProperty from './_baseProperty.js';\nimport basePropertyDeep from './_basePropertyDeep.js';\nimport isKey from './_isKey.js';\nimport toKey from './_toKey.js';\n\n/**\n * Creates a function that returns the value at `path` of a given object.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var objects = [\n *   { 'a': { 'b': 2 } },\n *   { 'a': { 'b': 1 } }\n * ];\n *\n * _.map(objects, _.property('a.b'));\n * // => [2, 1]\n *\n * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n * // => [1, 2]\n */\nfunction property(path) {\n  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n}\n\nexport default property;\n","import baseMatches from './_baseMatches.js';\nimport baseMatchesProperty from './_baseMatchesProperty.js';\nimport identity from './identity.js';\nimport isArray from './isArray.js';\nimport property from './property.js';\n\n/**\n * The base implementation of `_.iteratee`.\n *\n * @private\n * @param {*} [value=_.identity] The value to convert to an iteratee.\n * @returns {Function} Returns the iteratee.\n */\nfunction baseIteratee(value) {\n  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n  if (typeof value == 'function') {\n    return value;\n  }\n  if (value == null) {\n    return identity;\n  }\n  if (typeof value == 'object') {\n    return isArray(value)\n      ? baseMatchesProperty(value[0], value[1])\n      : baseMatches(value);\n  }\n  return property(value);\n}\n\nexport default baseIteratee;\n","import baseIndexOf from './_baseIndexOf.js';\n\n/**\n * A specialized version of `_.includes` for arrays without support for\n * specifying an index to search from.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\nfunction arrayIncludes(array, value) {\n  var length = array == null ? 0 : array.length;\n  return !!length && baseIndexOf(array, value, 0) > -1;\n}\n\nexport default arrayIncludes;\n","/**\n * This function is like `arrayIncludes` except that it accepts a comparator.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\nfunction arrayIncludesWith(array, value, comparator) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (comparator(value, array[index])) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport default arrayIncludesWith;\n","import Set from './_Set.js';\nimport noop from './noop.js';\nimport setToArray from './_setToArray.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Creates a set object of `values`.\n *\n * @private\n * @param {Array} values The values to add to the set.\n * @returns {Object} Returns the new set.\n */\nvar createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n  return new Set(values);\n};\n\nexport default createSet;\n","import SetCache from './_SetCache.js';\nimport arrayIncludes from './_arrayIncludes.js';\nimport arrayIncludesWith from './_arrayIncludesWith.js';\nimport cacheHas from './_cacheHas.js';\nimport createSet from './_createSet.js';\nimport setToArray from './_setToArray.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n */\nfunction baseUniq(array, iteratee, comparator) {\n  var index = -1,\n      includes = arrayIncludes,\n      length = array.length,\n      isCommon = true,\n      result = [],\n      seen = result;\n\n  if (comparator) {\n    isCommon = false;\n    includes = arrayIncludesWith;\n  }\n  else if (length >= LARGE_ARRAY_SIZE) {\n    var set = iteratee ? null : createSet(array);\n    if (set) {\n      return setToArray(set);\n    }\n    isCommon = false;\n    includes = cacheHas;\n    seen = new SetCache;\n  }\n  else {\n    seen = iteratee ? [] : result;\n  }\n  outer:\n  while (++index < length) {\n    var value = array[index],\n        computed = iteratee ? iteratee(value) : value;\n\n    value = (comparator || value !== 0) ? value : 0;\n    if (isCommon && computed === computed) {\n      var seenIndex = seen.length;\n      while (seenIndex--) {\n        if (seen[seenIndex] === computed) {\n          continue outer;\n        }\n      }\n      if (iteratee) {\n        seen.push(computed);\n      }\n      result.push(value);\n    }\n    else if (!includes(seen, computed, comparator)) {\n      if (seen !== result) {\n        seen.push(computed);\n      }\n      result.push(value);\n    }\n  }\n  return result;\n}\n\nexport default baseUniq;\n","import baseIteratee from './_baseIteratee.js';\nimport baseUniq from './_baseUniq.js';\n\n/**\n * This method is like `_.uniq` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * uniqueness is computed. The order of result values is determined by the\n * order they occur in the array. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n * // => [2.1, 1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }, { 'x': 2 }]\n */\nfunction uniqBy(array, iteratee) {\n  return (array && array.length) ? baseUniq(array, baseIteratee(iteratee, 2)) : [];\n}\n\nexport default uniqBy;\n"],"names":["factory","exports","currentISOCode","currentLocale","currencyFormatterNormal","currencyFormatterNoDecimal","currencyFormatterMedium","currencyFormatterTwoDecimal","currencyFormatterSmall","currencyFormatterVerySmall","currencyFormatterVeryVerySmall","currencyFormatter15DP","currencyFormatter18DP","currencyFormatterAbbreviated","supportedCurrencySymbols","BTC","ETH","USD","CAD","GBP","EUR","CHF","SEK","JPY","CNY","INR","RUB","AUD","HKD","SGD","TWD","BRL","KRW","ZAR","MYR","IDR","NZD","MXN","PHP","DKK","PLN","AED","ARS","CLP","CZK","HUF","ILS","KWD","LKR","NOK","PKR","SAR","THB","TRY","XAU","XAG","XDR","symbolOverrides","location","start","forLocales","en","IntlNumberFormatSupported","Intl","NumberFormat","isBTCETH","isoCode","isCrypto","formatCurrencyOverride","formattedCurrency","locale","maximumDecimalTrailingZeroes","decimalTrailingZeroesToExponent","decimalTrailingZeroesPattern","replace","_match","separator","decimalTrailingZeroes","length","currencyCodeFrontMatch","match","code","trim","overrideObj","currencyCodeBackMatch","end","generateFallbackFormatter","numDecimals","toUpperCase","format","value","toFixed","toLocaleString","generateFormatter","numSigFig","isNumberFormatSupported","useIntlNumberFormatter","generateIntlNumberFormatter","params","style","currency","currencyDisplay","undefined","minimumFractionDigits","maximumFractionDigits","maximumSignificantDigits","e","formattersCache","clearCache","formatCurrency","amount","raw","noDecimal","abbreviated","initializeFormatters","cacheKey","cachedFormatter","generateAbbreviatedFormatter","numberFormatOptions","notation","formattedAbbreviatedCurrency","parseFloat","hasOwnProperty","decimalPlaces","toPrecision","significantFigures","currencyFormatterCustom","Number","price","unsigned_amount","Math","abs","Object","defineProperty","__webpack_exports__","fn","delay","options","timerCallback","_useMemoizedFn__WEBPACK_IMPORTED_MODULE_1__","Z","timerRef","react__WEBPACK_IMPORTED_MODULE_0__","useRef","clear","useCallback","current","clearInterval","useEffect","_utils__WEBPACK_IMPORTED_MODULE_2__","hj","immediate","setInterval","result","cache","_baseIsMatch","object","source","matchData","customizer","index","noCustomizer","data","key","objValue","srcValue","stack","_Stack","_baseIsEqual","COMPARE_PARTIAL_FLAG","_isStrictComparable","isObject","_getMatchData","keys","_matchesStrictComparable","_baseMatches","reIsDeepProp","reIsPlainProp","_isKey","isArray","type","isSymbol","test","memoize","func","resolver","memoized","args","arguments","apply","has","get","set","Cache","_MapCache","rePropName","reEscapeChar","stringToPath","lodash_es_memoize","string","charCodeAt","push","number","quote","subString","size","_castPath","_stringToPath","lodash_es_toString","INFINITY","_toKey","_baseGet","path","lodash_es_get","defaultValue","_baseHasIn","_hasPath","hasFunc","isLength","_isIndex","isArguments","lodash_es_property","_baseIteratee","identity","_baseMatchesProperty_COMPARE_PARTIAL_FLAG","_arrayIncludes","array","_baseIndexOf","_arrayIncludesWith","comparator","createSet","_setToArray","_Set","values","noop","_baseUniq","iteratee","includes","isCommon","seen","_createSet","_cacheHas","_SetCache","outer","computed","seenIndex","lodash_es_uniqBy"],"sourceRoot":""}