{"version":3,"file":"market-portfolio.js","mappings":"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","sources":["webpack://portfolio/webpack/runtime/load script","webpack://portfolio/./src/utils/constants.ts","webpack://portfolio/./src/pages/types.ts","webpack://portfolio/./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js","webpack://portfolio/./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js","webpack://portfolio/./node_modules/style-loader/dist/runtime/styleTagTransform.js","webpack://portfolio/./node_modules/systemjs-webpack-interop/auto-public-path/auto-public-path.js","webpack://portfolio/./src/context/focusPeriod/periodSelector.css","webpack://portfolio/./src/lib/analytics/tools.ts","webpack://portfolio/./src/context/markets.css","webpack://portfolio/external system \"@ecosystem/newron-client-collections\"","webpack://portfolio/./node_modules/css-loader/dist/runtime/api.js","webpack://portfolio/./node_modules/react-dom/client.js","webpack://portfolio/./node_modules/css-loader/dist/runtime/sourceMaps.js","webpack://portfolio/./node_modules/systemjs-webpack-interop/public-path.js","webpack://portfolio/external system \"@ecosystem/newron-client-lib\"","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://portfolio/./node_modules/style-loader/dist/runtime/insertStyleElement.js","webpack://portfolio/./node_modules/@remix-run/router/dist/router.js","webpack://portfolio/./src/lib/constants.ts","webpack://portfolio/./node_modules/style-loader/dist/runtime/insertBySelector.js","webpack://portfolio/./node_modules/@ecosystem/newron-core/types/index.js","webpack://portfolio/external system \"react\"","webpack://portfolio/./node_modules/react-router/dist/index.js","webpack://portfolio/./node_modules/style-loader/dist/runtime/styleDomAPI.js","webpack://portfolio/external system \"@ecosystem/newron-core\"","webpack://portfolio/external system \"react-dom\"","webpack://portfolio/external system \"@ecosystem/newron-design-system\"","webpack://portfolio/./src/context/focusPeriod/focusPeriod.css","webpack://portfolio/webpack/bootstrap","webpack://portfolio/webpack/runtime/__system_context__","webpack://portfolio/webpack/runtime/compat get default export","webpack://portfolio/webpack/runtime/define property getters","webpack://portfolio/webpack/runtime/ensure chunk","webpack://portfolio/webpack/runtime/get javascript chunk filename","webpack://portfolio/webpack/runtime/hasOwnProperty shorthand","webpack://portfolio/webpack/runtime/make namespace object","webpack://portfolio/webpack/runtime/publicPath","webpack://portfolio/webpack/runtime/jsonp chunk loading","webpack://portfolio/webpack/runtime/nonce","webpack://portfolio/./node_modules/systemjs-webpack-interop/auto-public-path/1.js","webpack://portfolio/./node_modules/single-spa-react/lib/esm/single-spa-react.js","webpack://portfolio/./node_modules/react-router-dom/dist/index.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack://portfolio/./src/assets/SortIcon.tsx","webpack://portfolio/./src/context/markets.css?5f16","webpack://portfolio/./src/context/markets.tsx","webpack://portfolio/./src/context/brands.tsx","webpack://portfolio/./src/context/market/selected.tsx","webpack://portfolio/./src/context/market/selector.tsx","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack://portfolio/./src/context/types.ts","webpack://portfolio/./src/context/common.tsx","webpack://portfolio/./node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack://portfolio/./src/utils/currentProposition.ts","webpack://portfolio/./src/context/market/recent.tsx","webpack://portfolio/./src/context/market/market.tsx","webpack://portfolio/./src/context/focusPeriod/periodSelector.css?c0c5","webpack://portfolio/./src/context/focusPeriod/monthsSelector.utils.ts","webpack://portfolio/./src/context/focusPeriod/periodSelector.utils.ts","webpack://portfolio/./src/context/focusPeriod/applyPeriod.button.tsx","webpack://portfolio/./src/context/focusPeriod/constants.ts","webpack://portfolio/./src/context/focusPeriod/monthsSelector.tsx","webpack://portfolio/./node_modules/date-fns/constructFrom.mjs","webpack://portfolio/./node_modules/date-fns/toDate.mjs","webpack://portfolio/./node_modules/date-fns/_lib/defaultOptions.mjs","webpack://portfolio/./node_modules/date-fns/startOfWeek.mjs","webpack://portfolio/./node_modules/date-fns/startOfISOWeek.mjs","webpack://portfolio/./node_modules/date-fns/startOfISOWeekYear.mjs","webpack://portfolio/./node_modules/date-fns/getISOWeekYear.mjs","webpack://portfolio/./node_modules/date-fns/startOfWeekYear.mjs","webpack://portfolio/./node_modules/date-fns/getWeekYear.mjs","webpack://portfolio/./node_modules/date-fns/addDays.mjs","webpack://portfolio/./src/context/focusPeriod/weeksSelector.utils.ts","webpack://portfolio/./src/context/focusPeriod/weeksSelector.tsx","webpack://portfolio/./src/context/focusPeriod/periodSelector.tsx","webpack://portfolio/./src/context/focusPeriod/incompletePeriod.tsx","webpack://portfolio/./src/context/focusPeriod/missingSubscriptions.tsx","webpack://portfolio/./src/context/focusPeriod/focusPeriod.css?ee8b","webpack://portfolio/./src/context/focusPeriod/util.ts","webpack://portfolio/./src/context/focusPeriod/focusPeriod.tsx","webpack://portfolio/./src/filters/filters.ts","webpack://portfolio/./src/filters/viewSavedFilterHandler.tsx","webpack://portfolio/./src/filters/registerViewNotification.ts","webpack://portfolio/./src/lib/impersonation.ts","webpack://portfolio/./src/lib/bff.client.ts","webpack://portfolio/./src/providers/collection.provider.tsx","webpack://portfolio/./src/pages/dp/overview.tsx","webpack://portfolio/./src/root/Root.tsx","webpack://portfolio/./src/utils/savedView.ts","webpack://portfolio/./src/content/special.static.tsx","webpack://portfolio/./src/market-portfolio.tsx"],"sourcesContent":["var inProgress = {};\nvar dataWebpackPrefix = \"portfolio:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","export const FEATURE_TAGS_STORAGE_KEY = 'gfknewron-feature-toggle';\nexport const FEATURE_TAGS_SEPARATOR = ',';\nexport const SAVED_VIEW_KEY = 'savedViewKey_marketPortfolio';\n\nexport const Proposition = {\n  Market: 'market',\n  DistributionPanel: 'dp',\n} as const;\nexport const MARKET_ROUTE_PREFIX = {\n  Mo: 'mo',\n  MoLight: 'mo-light',\n  Mi: 'mi',\n  Ml: 'ml',\n  Market: 'market',\n} as const;\n\nexport const DP_ROUTE_PREFIX = {\n  Dpo: 'dpo',\n  Dpi: 'dpi',\n  Dpl: 'dpl',\n  Dp: 'dp',\n} as const;\n\nexport const ROUTE_PREFIX = { ...MARKET_ROUTE_PREFIX, ...DP_ROUTE_PREFIX } as const;\n\nexport const MarketPrefixTypes = Object.values(MARKET_ROUTE_PREFIX) as string[];\nexport const DPPrefixTypes = Object.values(DP_ROUTE_PREFIX) as string[];\n","export enum MlParam {\n  plPeriod = 'plPeriod',\n  plColumns = 'plColumns',\n  plFeatures = 'plFeatures',\n  plGroups = 'plGroups',\n  analyseOption = 'analyseOption',\n  ids = 'ids',\n  scKpis = 'scKpis',\n  scPeriod = 'scPeriod',\n  tsDuration = 'tsDuration',\n  tsSummary = 'tsSummary',\n  sgSegment = 'sgSegment',\n  sgPeriod = 'sgPeriod',\n  customComparisonPeriod = 'customComparisonPeriod',\n}\n\nexport enum LeaderboardParams {\n  lbPeriod = 'lbPeriod',\n  lbColumns = 'lbColumns',\n  lbFeatures = 'lbFeatures',\n  lbGroups = 'lbGroups',\n  analyseOption = 'analyseOption',\n}\n\nexport enum MiParam {\n  customComparisonPeriod = 'customComparisonPeriod',\n  grouping = 'grouping',\n  tsDuration = 'tsDuration',\n  tsSummary = 'tsSummary',\n  sgPeriod = 'sgPeriod',\n  sgSegment = 'sgSegment',\n  scPeriod = 'scPeriod',\n  scKpis = 'scKpis',\n  ids = 'ids',\n  customFeatureTiers = 'customFeatureTiers',\n}\n\nexport const Page = {\n  time: 'time',\n  segmentation: 'segments',\n  scorecard: 'scorecard',\n  leaderboard: 'leaderboard',\n  analyseLeaderboard: 'analyse_leaderboard',\n  products: 'products',\n  analyseProducts: 'analyse-products',\n  overview: 'overview',\n} as const;\n\nexport const DpPage = {\n  products: 'dp-products',\n  analyseProducts: 'dp-analyse-products',\n  scorecard: 'dp-scorecard',\n  segmentation: 'dp-segments',\n  time: 'dp-time',\n  leaderboard: 'dp-leaderboard',\n  analyseLeaderboard: 'dp-analyse-leaderboard',\n  overview: 'dp-overview',\n} as const;\n\nexport enum ContentType {\n  productLeaders = 'productLeaders',\n  productsScorecard = 'productsScorecard',\n  productsTimeSeries = 'productsTimeSeries',\n  productsSegmentation = 'productsSegmentation',\n  timeSeries = 'timeSeries',\n  segmentation = 'segmentation',\n  scorecard = 'scorecard',\n  leaderboard = 'leaderboard',\n}\n\nexport enum Category {\n  brands = 'brands',\n  prices = 'prices',\n  channels = 'channels',\n  features = 'features',\n  productGroups = 'product-groups',\n  countries = 'countries',\n  regions = 'regions',\n  firstActivity = 'first-activity',\n}\n\nexport enum UiDataParams {\n  uiEnrichments = 'uiEnrichments',\n}\n\nexport const ContextName = {\n  market: 'market',\n  dp: 'distribution-panel',\n} as const;\n","\"use strict\";\n\n/* istanbul ignore next  */\nfunction setAttributesWithoutAttributes(styleElement) {\n  var nonce = typeof __webpack_nonce__ !== \"undefined\" ? __webpack_nonce__ : null;\n  if (nonce) {\n    styleElement.setAttribute(\"nonce\", nonce);\n  }\n}\nmodule.exports = setAttributesWithoutAttributes;","\"use strict\";\n\nvar stylesInDOM = [];\nfunction getIndexByIdentifier(identifier) {\n  var result = -1;\n  for (var i = 0; i < stylesInDOM.length; i++) {\n    if (stylesInDOM[i].identifier === identifier) {\n      result = i;\n      break;\n    }\n  }\n  return result;\n}\nfunction modulesToDom(list, options) {\n  var idCountMap = {};\n  var identifiers = [];\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i];\n    var id = options.base ? item[0] + options.base : item[0];\n    var count = idCountMap[id] || 0;\n    var identifier = \"\".concat(id, \" \").concat(count);\n    idCountMap[id] = count + 1;\n    var indexByIdentifier = getIndexByIdentifier(identifier);\n    var obj = {\n      css: item[1],\n      media: item[2],\n      sourceMap: item[3],\n      supports: item[4],\n      layer: item[5]\n    };\n    if (indexByIdentifier !== -1) {\n      stylesInDOM[indexByIdentifier].references++;\n      stylesInDOM[indexByIdentifier].updater(obj);\n    } else {\n      var updater = addElementStyle(obj, options);\n      options.byIndex = i;\n      stylesInDOM.splice(i, 0, {\n        identifier: identifier,\n        updater: updater,\n        references: 1\n      });\n    }\n    identifiers.push(identifier);\n  }\n  return identifiers;\n}\nfunction addElementStyle(obj, options) {\n  var api = options.domAPI(options);\n  api.update(obj);\n  var updater = function updater(newObj) {\n    if (newObj) {\n      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {\n        return;\n      }\n      api.update(obj = newObj);\n    } else {\n      api.remove();\n    }\n  };\n  return updater;\n}\nmodule.exports = function (list, options) {\n  options = options || {};\n  list = list || [];\n  var lastIdentifiers = modulesToDom(list, options);\n  return function update(newList) {\n    newList = newList || [];\n    for (var i = 0; i < lastIdentifiers.length; i++) {\n      var identifier = lastIdentifiers[i];\n      var index = getIndexByIdentifier(identifier);\n      stylesInDOM[index].references--;\n    }\n    var newLastIdentifiers = modulesToDom(newList, options);\n    for (var _i = 0; _i < lastIdentifiers.length; _i++) {\n      var _identifier = lastIdentifiers[_i];\n      var _index = getIndexByIdentifier(_identifier);\n      if (stylesInDOM[_index].references === 0) {\n        stylesInDOM[_index].updater();\n        stylesInDOM.splice(_index, 1);\n      }\n    }\n    lastIdentifiers = newLastIdentifiers;\n  };\n};","\"use strict\";\n\n/* istanbul ignore next  */\nfunction styleTagTransform(css, styleElement) {\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css;\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild);\n    }\n    styleElement.appendChild(document.createTextNode(css));\n  }\n}\nmodule.exports = styleTagTransform;","const resolveDirectory = require(\"../public-path\").resolveDirectory;\n\nexports.autoPublicPath = function autoPublicPath(rootDirLevel) {\n  if (!rootDirLevel) {\n    rootDirLevel = 1;\n  }\n\n  if (typeof __webpack_public_path__ !== \"undefined\") {\n    if (typeof __system_context__ === \"undefined\") {\n      throw Error(\n        \"systemjs-webpack-interop requires webpack@>=5.0.0-beta.15 and output.libraryTarget set to 'system'\"\n      );\n    }\n\n    if (!__system_context__.meta || !__system_context__.meta.url) {\n      console.error(\"__system_context__\", __system_context__);\n      throw Error(\n        \"systemjs-webpack-interop was provided an unknown SystemJS context. Expected context.meta.url, but none was provided\"\n      );\n    }\n\n    __webpack_public_path__ = resolveDirectory(\n      __system_context__.meta.url,\n      rootDirLevel\n    );\n  }\n};\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.period-row {\n  transition: ease-out;\n  transition-duration: 120ms;\n}\n\n.period-row:hover {\n  transition: none;\n}\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/context/focusPeriod/periodSelector.css\"],\"names\":[],\"mappings\":\"AAAA;EACE,oBAAoB;EACpB,0BAA0B;AAC5B;;AAEA;EACE,gBAAgB;AAClB\",\"sourcesContent\":[\".period-row {\\n  transition: ease-out;\\n  transition-duration: 120ms;\\n}\\n\\n.period-row:hover {\\n  transition: none;\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","import { PropositionSection, TrackingMeta } from '@ecosystem/newron-core/types';\nimport { InternalEventParams } from './types';\nimport { Proposition } from '../../utils/constants';\n\nexport const mapCoreMetaParams = (\n  proposition: string,\n  meta: TrackingMeta,\n  subsection: string,\n  pageName: string\n): InternalEventParams => {\n  // cell information\n  // format is ['BE-DEC_GARDEN_PRES']\n  const cells = meta.pageContext.cell || [];\n\n  const splitCells = cells.map(c => {\n    const parts = c.split('-');\n    return { country: parts[0], itemGroup: parts[1] };\n  });\n\n  const cellsFormatted = splitCells.map(({ country, itemGroup }) => `${country}/${itemGroup}`);\n  const countries = Array.from(new Set(splitCells.map(o => o.country)));\n  const itemGroups = Array.from(new Set(splitCells.map(o => o.itemGroup)));\n  const periodicity = meta.pageContext.timeFrame ? meta.pageContext.timeFrame[0].split(':')[0] : '';\n\n  const currentSection: PropositionSection =\n    proposition === Proposition.DistributionPanel ? 'Supply Chain' : 'Market 2.0';\n\n  return {\n    section: currentSection,\n    subsection,\n    pageName,\n    cells: cellsFormatted,\n    periodicity,\n    itemGroup: itemGroups,\n    locationId: countries,\n    numberOfCells: cells.length.toString(),\n    cellAggregation: cells.length > 1 ? 'multicell' : 'singlecell',\n    locationIdAggregation: countries.length > 1 ? 'many' : 'single',\n    itemGroupAggregation: itemGroups.length > 1 ? 'many' : 'single',\n    proposition,\n    ...meta.eventParams,\n  };\n};\n\n/**\n * Maps internal market 2 tab names (ie. scorecard, time, segments) to their tracking equivalents\n *\n * @param tabName\n * @returns\n */\nexport const mapTabName = (tabName: string): string => {\n  const lookup = {\n    segments: 'Segmentation',\n    time: 'Time Series',\n    scorecard: 'Scorecard',\n  };\n  return lookup[tabName] ?? tabName;\n};\n\n/**\n * Splits a timeframe parameter value into its consistuent parts\n */\nexport const splitTimeframeValue = (paramValue: string | string[]) => {\n  const [aggregation = '', sequenceInfo = '', aggregationMethod = ''] = (\n    Array.isArray(paramValue) ? paramValue[0] : paramValue\n  ).split(':');\n\n  let aggregationValue: string = aggregation;\n  let aggregationMethodValue: string = aggregationMethod;\n\n  switch (aggregationMethod) {\n    case 'Year':\n    case 'MAT':\n    case 'YTD':\n      aggregationValue = 'Year';\n      break;\n    case 'Quarter':\n    case 'RollingQuarter':\n      aggregationValue = 'Quarter';\n      aggregationMethodValue = 'Rolling Quarter';\n      break;\n  }\n\n  return {\n    aggregation: aggregationValue,\n    aggregationMethod: aggregationMethodValue,\n    sequenceInfo,\n  };\n};\n\nexport const addTimeAggregationValues = (params: InternalEventParams, timeFrameValue: string | string[]): void => {\n  const split = splitTimeframeValue(timeFrameValue);\n  params.timeAggregation = split.aggregation;\n  params.timeAggregationMethod = split.aggregationMethod;\n};\n","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `.heading-grid,\n.item-grid {\n  grid-template-columns: 1fr 25% 25%;\n}\n\n/* Stops the icon from resizing when checked */\n.market-checkbox .icon {\n  width: 20px !important;\n  height: 20px !important;\n}\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/context/markets.css\"],\"names\":[],\"mappings\":\"AAAA;;EAEE,kCAAkC;AACpC;;AAEA,8CAA8C;AAC9C;EACE,sBAAsB;EACtB,uBAAuB;AACzB\",\"sourcesContent\":[\".heading-grid,\\n.item-grid {\\n  grid-template-columns: 1fr 25% 25%;\\n}\\n\\n/* Stops the icon from resizing when checked */\\n.market-checkbox .icon {\\n  width: 20px !important;\\n  height: 20px !important;\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","module.exports = __WEBPACK_EXTERNAL_MODULE__267__;","\"use strict\";\n\n/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n*/\nmodule.exports = function (cssWithMappingToString) {\n  var list = [];\n\n  // return the list of modules as css string\n  list.toString = function toString() {\n    return this.map(function (item) {\n      var content = \"\";\n      var needLayer = typeof item[5] !== \"undefined\";\n      if (item[4]) {\n        content += \"@supports (\".concat(item[4], \") {\");\n      }\n      if (item[2]) {\n        content += \"@media \".concat(item[2], \" {\");\n      }\n      if (needLayer) {\n        content += \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\");\n      }\n      content += cssWithMappingToString(item);\n      if (needLayer) {\n        content += \"}\";\n      }\n      if (item[2]) {\n        content += \"}\";\n      }\n      if (item[4]) {\n        content += \"}\";\n      }\n      return content;\n    }).join(\"\");\n  };\n\n  // import a list of modules into the list\n  list.i = function i(modules, media, dedupe, supports, layer) {\n    if (typeof modules === \"string\") {\n      modules = [[null, modules, undefined]];\n    }\n    var alreadyImportedModules = {};\n    if (dedupe) {\n      for (var k = 0; k < this.length; k++) {\n        var id = this[k][0];\n        if (id != null) {\n          alreadyImportedModules[id] = true;\n        }\n      }\n    }\n    for (var _k = 0; _k < modules.length; _k++) {\n      var item = [].concat(modules[_k]);\n      if (dedupe && alreadyImportedModules[item[0]]) {\n        continue;\n      }\n      if (typeof layer !== \"undefined\") {\n        if (typeof item[5] === \"undefined\") {\n          item[5] = layer;\n        } else {\n          item[1] = \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\").concat(item[1], \"}\");\n          item[5] = layer;\n        }\n      }\n      if (media) {\n        if (!item[2]) {\n          item[2] = media;\n        } else {\n          item[1] = \"@media \".concat(item[2], \" {\").concat(item[1], \"}\");\n          item[2] = media;\n        }\n      }\n      if (supports) {\n        if (!item[4]) {\n          item[4] = \"\".concat(supports);\n        } else {\n          item[1] = \"@supports (\".concat(item[4], \") {\").concat(item[1], \"}\");\n          item[4] = supports;\n        }\n      }\n      list.push(item);\n    }\n  };\n  return list;\n};","'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n  exports.createRoot = m.createRoot;\n  exports.hydrateRoot = m.hydrateRoot;\n} else {\n  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  exports.createRoot = function(c, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.createRoot(c, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n  exports.hydrateRoot = function(c, h, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.hydrateRoot(c, h, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n}\n","\"use strict\";\n\nmodule.exports = function (item) {\n  var content = item[1];\n  var cssMapping = item[3];\n  if (!cssMapping) {\n    return content;\n  }\n  if (typeof btoa === \"function\") {\n    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));\n    var data = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\".concat(base64);\n    var sourceMapping = \"/*# \".concat(data, \" */\");\n    return [content].concat([sourceMapping]).join(\"\\n\");\n  }\n  return [content].join(\"\\n\");\n};","exports.setPublicPath = function setPublicPath(\n  systemjsModuleName,\n  rootDirectoryLevel\n) {\n  if (!rootDirectoryLevel) {\n    rootDirectoryLevel = 1;\n  }\n  if (\n    typeof systemjsModuleName !== \"string\" ||\n    systemjsModuleName.trim().length === 0\n  ) {\n    throw Error(\n      \"systemjs-webpack-interop: setPublicPath(systemjsModuleName) must be called with a non-empty string 'systemjsModuleName'\"\n    );\n  }\n\n  if (\n    typeof rootDirectoryLevel !== \"number\" ||\n    rootDirectoryLevel <= 0 ||\n    isNaN(rootDirectoryLevel) ||\n    !isInteger(rootDirectoryLevel)\n  ) {\n    throw Error(\n      \"systemjs-webpack-interop: setPublicPath(systemjsModuleName, rootDirectoryLevel) must be called with a positive integer 'rootDirectoryLevel'\"\n    );\n  }\n\n  var moduleUrl;\n  try {\n    moduleUrl = window.System.resolve(systemjsModuleName);\n    if (!moduleUrl) {\n      throw Error();\n    }\n  } catch (err) {\n    throw Error(\n      \"systemjs-webpack-interop: There is no such module '\" +\n        systemjsModuleName +\n        \"' in the SystemJS registry. Did you misspell the name of your module?\"\n    );\n  }\n\n  __webpack_public_path__ = resolveDirectory(moduleUrl, rootDirectoryLevel);\n};\n\nfunction resolveDirectory(urlString, rootDirectoryLevel) {\n  // Our friend IE11 doesn't support new URL()\n  // https://github.com/single-spa/single-spa/issues/612\n  // https://gist.github.com/jlong/2428561\n\n  var a = document.createElement(\"a\");\n  a.href = urlString;\n\n  var pathname = a.pathname[0] === \"/\" ? a.pathname : \"/\" + a.pathname;\n  var numDirsProcessed = 0,\n    index = pathname.length;\n  while (numDirsProcessed !== rootDirectoryLevel && index >= 0) {\n    var char = pathname[--index];\n    if (char === \"/\") {\n      numDirsProcessed++;\n    }\n  }\n\n  if (numDirsProcessed !== rootDirectoryLevel) {\n    throw Error(\n      \"systemjs-webpack-interop: rootDirectoryLevel (\" +\n        rootDirectoryLevel +\n        \") is greater than the number of directories (\" +\n        numDirsProcessed +\n        \") in the URL path \" +\n        urlString\n    );\n  }\n\n  var finalPath = pathname.slice(0, index + 1);\n\n  return a.protocol + \"//\" + a.host + finalPath;\n}\n\nexports.resolveDirectory = resolveDirectory;\n\n// borrowed from https://github.com/parshap/js-is-integer/blob/master/index.js\nvar isInteger =\n  Number.isInteger ||\n  function isInteger(val) {\n    return typeof val === \"number\" && isFinite(val) && Math.floor(val) === val;\n  };\n","module.exports = __WEBPACK_EXTERNAL_MODULE__425__;","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperty(e, r, t) {\n  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nexport { _defineProperty as default };","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}\nexport { _typeof as default };","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nexport { toPropertyKey as default };","import _typeof from \"./typeof.js\";\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nexport { toPrimitive as default };","\"use strict\";\n\n/* istanbul ignore next  */\nfunction insertStyleElement(options) {\n  var element = document.createElement(\"style\");\n  options.setAttributes(element, options.attributes);\n  options.insert(element, options.options);\n  return element;\n}\nmodule.exports = insertStyleElement;","/**\n * @remix-run/router v1.23.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n(function (Action) {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Action[\"Push\"] = \"PUSH\";\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\nconst PopStateEventType = \"popstate\";\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === \"string\" ? null : entry.state, index === 0 ? \"default\" : undefined));\n  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);\n  let action = Action.Pop;\n  let listener = null;\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation() {\n    return entries[index];\n  }\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n  function createHref(to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  let history = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\"\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 1\n        });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 0\n        });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta\n        });\n      }\n    },\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    }\n  };\n  return history;\n}\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createBrowserLocation(window, globalHistory) {\n    let {\n      pathname,\n      search,\n      hash\n    } = window.location;\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);\n}\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n  function validateHashLocation(location, to) {\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience, so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location, index) {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\n  let location = _extends({\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\"\n  }, typeof to === \"string\" ? parsePath(to) : to, {\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: to && to.key || key || createKey()\n  });\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nfunction createPath(_ref) {\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\"\n  } = _ref;\n  if (search && search !== \"?\") pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\") pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nfunction parsePath(path) {\n  let parsedPath = {};\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n  return parsedPath;\n}\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    window = document.defaultView,\n    v5Compat = false\n  } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener = null;\n  let index = getIndex();\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), \"\");\n  }\n  function getIndex() {\n    let state = globalHistory.state || {\n      idx: null\n    };\n    return state.idx;\n  }\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({\n        action,\n        location: history.location,\n        delta\n      });\n    }\n  }\n  function push(to, state) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 1\n      });\n    }\n  }\n  function replace(to, state) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 0\n      });\n    }\n  }\n  function createURL(to) {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base = window.location.origin !== \"null\" ? window.location.origin : window.location.href;\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n    return new URL(href, base);\n  }\n  let history = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    }\n  };\n  return history;\n}\n//#endregion\n\nvar ResultType;\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\nfunction isIndexRoute(route) {\n  return route.index === true;\n}\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nfunction convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  if (manifest === void 0) {\n    manifest = {};\n  }\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, String(index)];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n    invariant(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, mapRouteProperties(route), {\n        id\n      });\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {\n        id,\n        children: undefined\n      });\n      manifest[id] = pathOrLayoutRoute;\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);\n      }\n      return pathOrLayoutRoute;\n    }\n  });\n}\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/v6/utils/match-routes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\nfunction matchRoutesImpl(routes, locationArg, basename, allowPartial) {\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n  if (pathname == null) {\n    return null;\n  }\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch(branches[i], decoded, allowPartial);\n  }\n  return matches;\n}\nfunction convertRouteMatchToUiMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n  let flattenRoute = (route, index, relativePath) => {\n    let meta = {\n      relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(meta.relativePath.startsWith(parentPath), \"Absolute route path \\\"\" + meta.relativePath + \"\\\" nested under path \" + (\"\\\"\" + parentPath + \"\\\" is not valid. An absolute child route path \") + \"must start with the combined path of all its parent routes.\");\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n      // Our types know better, but runtime JS may not!\n      // @ts-expect-error\n      route.index !== true, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  };\n  routes.forEach((route, index) => {\n    var _route$path;\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !((_route$path = route.path) != null && _route$path.includes(\"?\"))) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n  return branches;\n}\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path) {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n  let [first, ...rest] = segments;\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n  let result = [];\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\")));\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\n}\nfunction rankRouteBranches(branches) {\n  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = s => s === \"*\";\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\nfunction compareIndexes(a, b) {\n  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n  return siblings ?\n  // If two routes are siblings, we should try to match the earlier sibling\n  // first. This allows people to have fine-grained control over the matching\n  // behavior by simply putting routes with identical paths in the order they\n  // want them tried.\n  a[a.length - 1] - b[b.length - 1] :\n  // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\nfunction matchRouteBranch(branch, pathname, allowPartial) {\n  if (allowPartial === void 0) {\n    allowPartial = false;\n  }\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath({\n      path: meta.relativePath,\n      caseSensitive: meta.caseSensitive,\n      end\n    }, remainingPathname);\n    let route = meta.route;\n    if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {\n      match = matchPath({\n        path: meta.relativePath,\n        caseSensitive: meta.caseSensitive,\n        end: false\n      }, remainingPathname);\n    }\n    if (!match) {\n      return null;\n    }\n    Object.assign(matchedParams, match.params);\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/v6/utils/generate-path\n */\nfunction generatePath(originalPath, params) {\n  if (params === void 0) {\n    params = {};\n  }\n  let path = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(false, \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n    path = path.replace(/\\*$/, \"/*\");\n  }\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n  const stringify = p => p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n  const segments = path.split(/\\/+/).map((segment, index, array) => {\n    const isLastSegment = index === array.length - 1;\n    // only apply the splat if it's the last segment\n    if (isLastSegment && segment === \"*\") {\n      const star = \"*\";\n      // Apply the splat\n      return stringify(params[star]);\n    }\n    const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n    if (keyMatch) {\n      const [, key, optional] = keyMatch;\n      let param = params[key];\n      invariant(optional === \"?\" || param != null, \"Missing \\\":\" + key + \"\\\" param\");\n      return stringify(param);\n    }\n    // Remove any optional markers from optional static segments\n    return segment.replace(/\\?$/g, \"\");\n  })\n  // Remove empty segments\n  .filter(segment => !!segment);\n  return prefix + segments.join(\"/\");\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/v6/utils/match-path\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = compiledParams.reduce((memo, _ref, index) => {\n    let {\n      paramName,\n      isOptional\n    } = _ref;\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n    const value = captureGroups[index];\n    if (isOptional && !value) {\n      memo[paramName] = undefined;\n    } else {\n      memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n    }\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n  if (end === void 0) {\n    end = true;\n  }\n  warning(path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"), \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n  let params = [];\n  let regexpSource = \"^\" + path.replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n  .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n  .replace(/[\\\\.*+^${}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n  .replace(/\\/:([\\w-]+)(\\?)?/g, (_, paramName, isOptional) => {\n    params.push({\n      paramName,\n      isOptional: isOptional != null\n    });\n    return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n  });\n  if (path.endsWith(\"*\")) {\n    params.push({\n      paramName: \"*\"\n    });\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else ;\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, params];\n}\nfunction decodePath(value) {\n  try {\n    return value.split(\"/\").map(v => decodeURIComponent(v).replace(/\\//g, \"%2F\")).join(\"/\");\n  } catch (error) {\n    warning(false, \"The URL path \\\"\" + value + \"\\\" could not be decoded because it is is a \" + \"malformed URL segment. This is probably due to a bad percent \" + (\"encoding (\" + error + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n  return pathname.slice(startIndex) || \"/\";\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/v6/utils/resolve-path\n */\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\"\n  } = typeof to === \"string\" ? parsePath(to) : to;\n  let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash)\n  };\n}\nfunction resolvePathname(relativePath, fromPathname) {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n  relativeSegments.forEach(segment => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\nfunction getInvalidPathError(char, field, dest, path) {\n  return \"Cannot include a '\" + char + \"' character in a manually specified \" + (\"`to.\" + field + \"` field [\" + JSON.stringify(path) + \"].  Please separate it out to the \") + (\"`to.\" + dest + \"` field. Alternatively you may provide the full path as \") + \"a string in <Link to=\\\"...\\\"> and the router will parse it for you.\";\n}\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nfunction getResolveToMatches(matches, v7_relativeSplatPath) {\n  let pathMatches = getPathContributingMatches(matches);\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);\n  }\n  return pathMatches.map(match => match.pathnameBase);\n}\n/**\n * @private\n */\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n  let to;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = _extends({}, toArg);\n    invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n    invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n    invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n  }\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from;\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n      to.pathname = toSegments.join(\"/\");\n    }\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n  let path = resolvePath(to, from);\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n  return path;\n}\n/**\n * @private\n */\nfunction getToPathname(to) {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n *\n * @deprecated The `json` method is deprecated in favor of returning raw objects.\n * This method will be removed in v7.\n */\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass DataWithResponseInit {\n  constructor(data, init) {\n    this.type = \"DataWithResponseInit\";\n    this.data = data;\n    this.init = init || null;\n  }\n}\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nfunction data(data, init) {\n  return new DataWithResponseInit(data, typeof init === \"number\" ? {\n    status: init\n  } : init);\n}\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data, responseInit) {\n    this.pendingKeysSet = new Set();\n    this.subscribers = new Set();\n    this.deferredKeys = [];\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\");\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n    this.init = responseInit;\n  }\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\n  onSettle(promise, key, error, data) {\n    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      return Promise.reject(error);\n    }\n    this.pendingKeysSet.delete(key);\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\"Deferred data for key \\\"\" + key + \"\\\" resolved/rejected with `undefined`, \" + \"you must resolve/reject with a value or `null`.\");\n      Object.defineProperty(promise, \"_error\", {\n        get: () => undefinedError\n      });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    this.emit(false, key);\n    return data;\n  }\n  emit(aborted, settledKey) {\n    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n  }\n  subscribe(fn) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n  async resolveData(signal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref3) => {\n      let [key, value] = _ref3;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\n/**\n * @deprecated The `defer` method is deprecated in favor of returning raw\n * objects. This method will be removed in v7.\n */\nconst defer = function defer(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n  return new Response(null, _extends({}, responseInit, {\n    headers\n  }));\n};\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirectDocument = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst replace = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"true\");\n  return response;\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nclass ErrorResponseImpl {\n  constructor(status, statusText, data, internal) {\n    if (internal === void 0) {\n      internal = false;\n    }\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nfunction isRouteErrorResponse(error) {\n  return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_BLOCKER = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst defaultMapRouteProperties = route => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary)\n});\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a router and listen to history POP navigations\n */\nfunction createRouter(init) {\n  const routerWindow = init.window ? init.window : typeof window !== \"undefined\" ? window : undefined;\n  const isBrowser = typeof routerWindow !== \"undefined\" && typeof routerWindow.document !== \"undefined\" && typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let mapRouteProperties;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Routes keyed by ID\n  let manifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);\n  let inFlightDataRoutes;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;\n  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;\n  // Config driven behavior flags\n  let future = _extends({\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    v7_skipActionErrorRevalidation: false\n  }, init.future);\n  // Cleanup function for history\n  let unlistenHistory = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialMatchesIsFOW = false;\n  let initialErrors = null;\n  if (initialMatches == null && !patchRoutesOnNavigationImpl) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname\n    });\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n  let initialized;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnNavigation` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatchesIsFOW = true;\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some(m => m.route.lazy)) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!initialMatches.some(m => m.route.loader)) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);\n      initialized = initialMatches.slice(0, idx + 1).every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    } else {\n      initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map()\n  };\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction = Action.Pop;\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n  // AbortController for the active navigation\n  let pendingNavigationController;\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions = new Map();\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener = null;\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes = [];\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads = new Set();\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map();\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map();\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set();\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map();\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map();\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set();\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map();\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map();\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let unblockBlockerHistoryUpdate = undefined;\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(_ref => {\n      let {\n        action: historyAction,\n        location,\n        delta\n      } = _ref;\n      // Ignore this event if it was just us resetting the URL from a\n      // blocked POP navigation\n      if (unblockBlockerHistoryUpdate) {\n        unblockBlockerHistoryUpdate();\n        unblockBlockerHistoryUpdate = undefined;\n        return;\n      }\n      warning(blockerFunctions.size === 0 || delta != null, \"You are trying to use a blocker on a POP navigation to a location \" + \"that was not created by @remix-run/router. This will fail silently in \" + \"production. This can happen if you are navigating outside the router \" + \"via `window.history.pushState`/`window.location.hash` instead of using \" + \"router navigation APIs.  This can also happen if you are using \" + \"createHashRouter and the user manually changes the URL.\");\n      let blockerKey = shouldBlockNavigation({\n        currentLocation: state.location,\n        nextLocation: location,\n        historyAction\n      });\n      if (blockerKey && delta != null) {\n        // Restore the URL to match the current UI, but don't update router state\n        let nextHistoryUpdatePromise = new Promise(resolve => {\n          unblockBlockerHistoryUpdate = resolve;\n        });\n        init.history.go(delta * -1);\n        // Put the blocker into a blocked state\n        updateBlocker(blockerKey, {\n          state: \"blocked\",\n          location,\n          proceed() {\n            updateBlocker(blockerKey, {\n              state: \"proceeding\",\n              proceed: undefined,\n              reset: undefined,\n              location\n            });\n            // Re-do the same POP navigation we just blocked, after the url\n            // restoration is also complete.  See:\n            // https://github.com/remix-run/react-router/issues/11613\n            nextHistoryUpdatePromise.then(() => init.history.go(delta));\n          },\n          reset() {\n            let blockers = new Map(state.blockers);\n            blockers.set(blockerKey, IDLE_BLOCKER);\n            updateState({\n              blockers\n            });\n          }\n        });\n        return;\n      }\n      return startNavigation(historyAction, location);\n    });\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () => routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location, {\n        initialHydration: true\n      });\n    }\n    return router;\n  }\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n  // Subscribe to state updates for the router\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n  // Update our state and notify the calling context of the change\n  function updateState(newState, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state = _extends({}, state, newState);\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers = [];\n    let deletedFetchersKeys = [];\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n    // Remove any lingering deleted fetchers that have already been removed\n    // from state.fetchers\n    deletedFetchers.forEach(key => {\n      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {\n        deletedFetchersKeys.push(key);\n      }\n    });\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach(subscriber => subscriber(state, {\n      deletedFetchers: deletedFetchersKeys,\n      viewTransitionOpts: opts.viewTransitionOpts,\n      flushSync: opts.flushSync === true\n    }));\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach(key => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach(key => deleteFetcher(key));\n    } else {\n      // We already called deleteFetcher() on these, can remove them from this\n      // Set now that we've handed the keys off to the data layer\n      deletedFetchersKeys.forEach(key => deletedFetchers.delete(key));\n    }\n  }\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(location, newState, _temp) {\n    var _location$state, _location$state2;\n    let {\n      flushSync\n    } = _temp === void 0 ? {} : _temp;\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === \"loading\" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;\n    let actionData;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === Action.Replace) {\n      init.history.replace(location, location.state);\n    }\n    let viewTransitionOpts;\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === Action.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location\n      };\n    }\n    updateState(_extends({}, newState, {\n      actionData,\n      loaderData,\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset,\n      blockers\n    }), {\n      viewTransitionOpts,\n      flushSync: flushSync === true\n    });\n    // Reset stateful navigation vars\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n  }\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n    let historyAction = Action.Push;\n    if (userReplace === true) {\n      historyAction = Action.Replace;\n    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = Action.Replace;\n    }\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    let flushSync = (opts && opts.flushSync) === true;\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction\n    });\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey, IDLE_BLOCKER);\n          updateState({\n            blockers\n          });\n        }\n      });\n      return;\n    }\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.viewTransition,\n      flushSync\n    });\n  }\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\n    });\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\n    }\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation,\n      // Proxy through any rending view transition\n      enableViewTransition: pendingViewTransitionEnabled === true\n    });\n  }\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(historyAction, location, opts) {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = opts != null && opts.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ?\n    // `matchRoutes()` has already been called if we're in here via `router.initialize()`\n    state.matches : matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial hydration will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (matches && state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\n      completeNavigation(location, {\n        matches\n      }, {\n        flushSync\n      });\n      return;\n    }\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let {\n        error,\n        notFoundMatches,\n        route\n      } = handleNavigational404(location.pathname);\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionResult;\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingActionResult = [findNearestBoundary(matches).route.id, {\n        type: ResultType.error,\n        error: opts.pendingError\n      }];\n    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {\n        replace: opts.replace,\n        flushSync\n      });\n      if (actionResult.shortCircuited) {\n        return;\n      }\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {\n          pendingNavigationController = null;\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error\n            }\n          });\n          return;\n        }\n      }\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = false;\n      // Create a GET request for the loaders\n      request = createClientSideRequest(init.history, request.url, request.signal);\n    }\n    // Call loaders\n    let {\n      shortCircuited,\n      matches: updatedMatches,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);\n    if (shortCircuited) {\n      return;\n    }\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n    completeNavigation(location, _extends({\n      matches: updatedMatches || matches\n    }, getActionDataForCommit(pendingActionResult), {\n      loaderData,\n      errors\n    }));\n  }\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(request, location, submission, matches, isFogOfWar, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    interruptActiveLoads();\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({\n      navigation\n    }, {\n      flushSync: opts.flushSync === true\n    });\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n      if (discoverResult.type === \"aborted\") {\n        return {\n          shortCircuited: true\n        };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [boundaryId, {\n            type: ResultType.error,\n            error: discoverResult.error\n          }]\n        };\n      } else if (!discoverResult.matches) {\n        let {\n          notFoundMatches,\n          error,\n          route\n        } = handleNavigational404(location.pathname);\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [route.id, {\n            type: ResultType.error,\n            error\n          }]\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n    // Call our action and get the result\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id\n        })\n      };\n    } else {\n      let results = await callDataStrategy(\"action\", state, request, [actionMatch], matches, null);\n      result = results[actionMatch.route.id];\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n    if (isRedirectResult(result)) {\n      let replace;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(result.response.headers.get(\"Location\"), new URL(request.url), basename);\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, true, {\n        submission,\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      // By default, all submissions to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result]\n      };\n    }\n    return {\n      matches,\n      pendingActionResult: [actionMatch.route.id, result]\n    };\n  }\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(_extends({\n          navigation: loadingNavigation\n        }, actionData !== undefined ? {\n          actionData\n        } : {}), {\n          flushSync\n        });\n      }\n      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);\n      if (discoverResult.type === \"aborted\") {\n        return {\n          shortCircuited: true\n        };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: discoverResult.error\n          }\n        };\n      } else if (!discoverResult.matches) {\n        let {\n          error,\n          notFoundMatches,\n          route\n        } = handleNavigational404(location.pathname);\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error\n          }\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));\n    pendingNavigationLoadId = ++incrementingLoadId;\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(location, _extends({\n        matches,\n        loaderData: {},\n        // Commit pending error if we're short circuiting\n        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n          [pendingActionResult[0]]: pendingActionResult[1].error\n        } : null\n      }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (shouldUpdateNavigationState) {\n      let updates = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, {\n        flushSync\n      });\n    }\n    revalidatingFetchers.forEach(rf => {\n      abortFetcher(rf.key);\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    let {\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\n      };\n    }\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe(aborted => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n    // Preserve SSR errors during partial hydration\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      errors = _extends({}, state.errors, errors);\n    }\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n    return _extends({\n      matches,\n      loaderData,\n      errors\n    }, shouldUpdateFetchers ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n  function getUpdatedActionData(pendingActionResult) {\n    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n      // This is cast to `any` currently because `RouteData`uses any and it\n      // would be a breaking change to use any.\n      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n  function getUpdatedRevalidatingFetchers(revalidatingFetchers) {\n    revalidatingFetchers.forEach(rf => {\n      let fetcher = state.fetchers.get(rf.key);\n      let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);\n      state.fetchers.set(rf.key, revalidatingFetcher);\n    });\n    return new Map(state.fetchers);\n  }\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(key, routeId, href, opts) {\n    if (isServer) {\n      throw new Error(\"router.fetch() was called during the server render, but it shouldn't be. \" + \"You are likely calling a useFetcher() method in the body of your component. \" + \"Try moving it to a useEffect or a callback.\");\n    }\n    abortFetcher(key);\n    let flushSync = (opts && opts.flushSync) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n    if (!matches) {\n      setFetcherError(key, routeId, getInternalRouterError(404, {\n        pathname: normalizedPath\n      }), {\n        flushSync\n      });\n      return;\n    }\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);\n    if (error) {\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    let match = getTargetMatch(matches, path);\n    let preventScrollReset = (opts && opts.preventScrollReset) === true;\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);\n      return;\n    }\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, {\n      routeId,\n      path\n    });\n    handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);\n  }\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n    function detectAndHandle405Error(m) {\n      if (!m.route.action && !m.route.lazy) {\n        let error = getInternalRouterError(405, {\n          method: submission.formMethod,\n          pathname: path,\n          routeId: routeId\n        });\n        setFetcherError(key, routeId, error, {\n          flushSync\n        });\n        return true;\n      }\n      return false;\n    }\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\n      return;\n    }\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync\n    });\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, {\n          flushSync\n        });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(key, routeId, getInternalRouterError(404, {\n          pathname: path\n        }), {\n          flushSync\n        });\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\"action\", state, fetchRequest, [match], requestMatches, key);\n    let actionResult = actionResults[match.route.id];\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, false, {\n            fetcherSubmission: submission,\n            preventScrollReset\n          });\n        }\n      }\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {\n      let staleKey = rf.key;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      abortFetcher(staleKey);\n      if (rf.controller) {\n        fetchControllers.set(staleKey, rf.controller);\n      }\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));\n    abortController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    let {\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n    if (abortController.signal.aborted) {\n      return;\n    }\n    abortController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      return startRedirectNavigation(revalidationRequest, redirect.result, false, {\n        preventScrollReset\n      });\n    }\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      return startRedirectNavigation(revalidationRequest, redirect.result, false, {\n        preventScrollReset\n      });\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n    abortStaleFetchLoads(loadId);\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),\n        fetchers: new Map(state.fetchers)\n      });\n      isRevalidationRequired = false;\n    }\n  }\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n      flushSync\n    });\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, {\n          flushSync\n        });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(key, routeId, getInternalRouterError(404, {\n          pathname: path\n        }), {\n          flushSync\n        });\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\"loader\", state, fetchRequest, [match], matches, key);\n    let result = results[match.route.id];\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    }\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result, false, {\n          preventScrollReset\n        });\n        return;\n      }\n    }\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(request, redirect, isNavigation, _temp2) {\n    let {\n      submission,\n      fetcherSubmission,\n      preventScrollReset,\n      replace\n    } = _temp2 === void 0 ? {} : _temp2;\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(location, new URL(request.url), basename);\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true\n    });\n    if (isBrowser) {\n      let isDocumentReload = false;\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n        // Hard reload if it's an absolute URL to a new origin\n        url.origin !== routerWindow.location.origin ||\n        // Hard reload if it's an absolute URL that does not match our basename\n        stripBasename(url.pathname, basename) == null;\n      }\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true || redirect.response.headers.has(\"X-Remix-Replace\") ? Action.Replace : Action.Push;\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let {\n      formMethod,\n      formAction,\n      formEncType\n    } = state.navigation;\n    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: _extends({}, activeSubmission, {\n          formAction: location\n        }),\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined\n      });\n    }\n  }\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(type, state, request, matchesToLoad, matches, fetcherKey) {\n    let results;\n    let dataResults = {};\n    try {\n      results = await callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties);\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      matchesToLoad.forEach(m => {\n        dataResults[m.route.id] = {\n          type: ResultType.error,\n          error: e\n        };\n      });\n      return dataResults;\n    }\n    for (let [routeId, result] of Object.entries(results)) {\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result;\n        dataResults[routeId] = {\n          type: ResultType.redirect,\n          response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)\n        };\n      } else {\n        dataResults[routeId] = await convertDataStrategyResultToDataResult(result);\n      }\n    }\n    return dataResults;\n  }\n  async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {\n    let currentMatches = state.matches;\n    // Kick off loaders and fetchers in parallel\n    let loaderResultsPromise = callDataStrategy(\"loader\", state, request, matchesToLoad, matches, null);\n    let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {\n      if (f.matches && f.match && f.controller) {\n        let results = await callDataStrategy(\"loader\", state, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);\n        let result = results[f.match.route.id];\n        // Fetcher results are keyed by fetcher key from here on out, not routeId\n        return {\n          [f.key]: result\n        };\n      } else {\n        return Promise.resolve({\n          [f.key]: {\n            type: ResultType.error,\n            error: getInternalRouterError(404, {\n              pathname: f.path\n            })\n          }\n        });\n      }\n    }));\n    let loaderResults = await loaderResultsPromise;\n    let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});\n    await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);\n    return {\n      loaderResults,\n      fetcherResults\n    };\n  }\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.add(key);\n      }\n      abortFetcher(key);\n    });\n  }\n  function updateFetcherState(key, fetcher, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function setFetcherError(key, routeId, error, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function getFetcher(key) {\n    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n    // If this fetcher was previously marked for deletion, unmark it since we\n    // have a new instance\n    if (deletedFetchers.has(key)) {\n      deletedFetchers.delete(key);\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n  function deleteFetcher(key) {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (fetchControllers.has(key) && !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    // If we opted into the flag we can clear this now since we're calling\n    // deleteFetcher() at the end of updateState() and we've already handed the\n    // deleted fetcher keys off to the data layer.\n    // If not, we're eagerly calling deleteFetcher() and we need to keep this\n    // Set populated until the next updateState call, and we'll clear\n    // `deletedFetchers` then\n    if (future.v7_fetcherPersist) {\n      deletedFetchers.delete(key);\n    }\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n  function deleteFetcherAndUpdateState(key) {\n    let count = (activeFetchers.get(key) || 0) - 1;\n    if (count <= 0) {\n      activeFetchers.delete(key);\n      deletedFetchers.add(key);\n      if (!future.v7_fetcherPersist) {\n        deleteFetcher(key);\n      }\n    } else {\n      activeFetchers.set(key, count);\n    }\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    if (controller) {\n      controller.abort();\n      fetchControllers.delete(key);\n    }\n  }\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, \"Expected fetcher: \" + key);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n  function getBlocker(key, fn) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n    return blocker;\n  }\n  function deleteBlocker(key) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key, newBlocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(blocker.state === \"unblocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"proceeding\" || blocker.state === \"blocked\" && newBlocker.state === \"unblocked\" || blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\", \"Invalid blocker state transition: \" + blocker.state + \" -> \" + newBlocker.state);\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({\n      blockers\n    });\n  }\n  function shouldBlockNavigation(_ref2) {\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = _ref2;\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({\n      currentLocation,\n      nextLocation,\n      historyAction\n    })) {\n      return blockerKey;\n    }\n  }\n  function handleNavigational404(pathname) {\n    let error = getInternalRouterError(404, {\n      pathname\n    });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(routesToUse);\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n    return {\n      notFoundMatches: matches,\n      route,\n      error\n    };\n  }\n  function cancelActiveDeferreds(predicate) {\n    let cancelledRouteIds = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n  function getScrollKey(location, matches) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));\n      return key || location.key;\n    }\n    return location.key;\n  }\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n  function checkFogOfWar(matches, routesToUse, pathname) {\n    if (patchRoutesOnNavigationImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n        return {\n          active: true,\n          matches: fogMatches || []\n        };\n      } else {\n        if (Object.keys(matches[0].params).length > 0) {\n          // If we matched a dynamic param or a splat, it might only be because\n          // we haven't yet discovered other routes that would match with a\n          // higher score.  Call patchRoutesOnNavigation just to be sure\n          let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n          return {\n            active: true,\n            matches: partialMatches\n          };\n        }\n      }\n    }\n    return {\n      active: false,\n      matches: null\n    };\n  }\n  async function discoverRoutes(matches, pathname, signal, fetcherKey) {\n    if (!patchRoutesOnNavigationImpl) {\n      return {\n        type: \"success\",\n        matches\n      };\n    }\n    let partialMatches = matches;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      let localManifest = manifest;\n      try {\n        await patchRoutesOnNavigationImpl({\n          signal,\n          path: pathname,\n          matches: partialMatches,\n          fetcherKey,\n          patch: (routeId, children) => {\n            if (signal.aborted) return;\n            patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);\n          }\n        });\n      } catch (e) {\n        return {\n          type: \"error\",\n          error: e,\n          partialMatches\n        };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR && !signal.aborted) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n      if (signal.aborted) {\n        return {\n          type: \"aborted\"\n        };\n      }\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      if (newMatches) {\n        return {\n          type: \"success\",\n          matches: newMatches\n        };\n      }\n      let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);\n      // Avoid loops if the second pass results in the same partial matches\n      if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {\n        return {\n          type: \"success\",\n          matches: null\n        };\n      }\n      partialMatches = newPartialMatches;\n    }\n  }\n  function _internalSetRoutes(newRoutes) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n  }\n  function patchRoutes(routeId, children) {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\n    }\n  }\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: to => init.history.createHref(to),\n    encodeLocation: to => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    patchRoutes,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes\n  };\n  return router;\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n  let manifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties;\n  if (opts != null && opts.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts != null && opts.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future = _extends({\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false\n  }, opts ? opts.future : null);\n  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(request, _temp3) {\n    let {\n      requestContext,\n      skipLoaderErrorBubbling,\n      dataStrategy\n    } = _temp3 === void 0 ? {} : _temp3;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, {\n        method\n      });\n      let {\n        matches: methodNotAllowedMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);\n    if (isResponse(result)) {\n      return result;\n    }\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return _extends({\n      location,\n      basename\n    }, result);\n  }\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(request, _temp4) {\n    let {\n      routeId,\n      requestContext,\n      dataStrategy\n    } = _temp4 === void 0 ? {} : _temp4;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, {\n        method\n      });\n    } else if (!matches) {\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);\n    if (isResponse(result)) {\n      return result;\n    }\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n    if (result.loaderData) {\n      var _result$activeDeferre;\n      let data = Object.values(result.loaderData)[0];\n      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n    return undefined;\n  }\n  async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null);\n        return result;\n      }\n      let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);\n      return isResponse(result) ? result : _extends({}, result, {\n        actionData: null,\n        actionHeaders: {}\n      });\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isDataStrategyResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {\n    let result;\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    } else {\n      let results = await callDataStrategy(\"action\", request, [actionMatch], matches, isRouteRequest, requestContext, dataStrategy);\n      result = results[actionMatch.route.id];\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")\n        }\n      });\n    }\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    }\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: {\n          [actionMatch.route.id]: result.data\n        },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal\n    });\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);\n      let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);\n      // action status codes take precedence over loader status codes\n      return _extends({}, context, {\n        statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,\n        actionData: null,\n        actionHeaders: _extends({}, result.headers ? {\n          [actionMatch.route.id]: result.headers\n        } : {})\n      });\n    }\n    let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null);\n    return _extends({}, context, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      }\n    }, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionHeaders: result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {}\n    });\n  }\n  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {\n    let isRouteRequest = routeMatch != null;\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch == null ? void 0 : routeMatch.route.id\n      });\n    }\n    let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;\n    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce((acc, m) => Object.assign(acc, {\n          [m.route.id]: null\n        }), {}),\n        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {\n          [pendingActionResult[0]]: pendingActionResult[1].error\n        } : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let results = await callDataStrategy(\"loader\", request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy);\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n    // Process and commit output from loaders\n    let activeDeferreds = new Map();\n    let context = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));\n    matches.forEach(match => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n    return _extends({}, context, {\n      matches,\n      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null\n    });\n  }\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {\n    let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, type, null, request, matchesToLoad, matches, null, manifest, mapRouteProperties, requestContext);\n    let dataResults = {};\n    await Promise.all(matches.map(async match => {\n      if (!(match.route.id in results)) {\n        return;\n      }\n      let result = results[match.route.id];\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result;\n        // Throw redirects and let the server handle them with an HTTP redirect\n        throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename, future.v7_relativeSplatPath);\n      }\n      if (isResponse(result.result) && isRouteRequest) {\n        // For SSR single-route requests, we want to hand Responses back\n        // directly without unwrapping\n        throw result;\n      }\n      dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);\n    }));\n    return dataResults;\n  }\n  return {\n    dataRoutes,\n    query,\n    queryRoute\n  };\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nfunction getStaticContextFromError(routes, context, error) {\n  let newContext = _extends({}, context, {\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n  return newContext;\n}\nfunction throwStaticHandlerAbortedError(request, isRouteRequest, future) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n}\nfunction isSubmissionNavigation(opts) {\n  return opts != null && (\"formData\" in opts && opts.formData != null || \"body\" in opts && opts.body !== undefined);\n}\nfunction normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {\n  let contextualMatches;\n  let activeRouteMatch;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n  // Resolve the relative path\n  let path = resolveTo(to ? to : \".\", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === \"path\");\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n  // Account for `?index` params when routing to the current location\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch) {\n    let nakedIndex = hasNakedIndexQuery(path.search);\n    if (activeRouteMatch.route.index && !nakedIndex) {\n      // Add one when we're targeting an index route\n      path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n    } else if (!activeRouteMatch.route.index && nakedIndex) {\n      // Remove existing ones when we're not\n      let params = new URLSearchParams(path.search);\n      let indexValues = params.getAll(\"index\");\n      params.delete(\"index\");\n      indexValues.filter(v => v).forEach(v => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? \"?\" + qs : \"\";\n    }\n  }\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return {\n      path\n    };\n  }\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, {\n        method: opts.formMethod\n      })\n    };\n  }\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, {\n      type: \"invalid-body\"\n    })\n  });\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();\n  let formAction = stripHashFromPath(path);\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      let text = typeof opts.body === \"string\" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?\n      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n      Array.from(opts.body.entries()).reduce((acc, _ref3) => {\n        let [name, value] = _ref3;\n        return \"\" + acc + name + \"=\" + value + \"\\n\";\n      }, \"\") : String(opts.body);\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text\n        }\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      try {\n        let json = typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined\n          }\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n  invariant(typeof FormData === \"function\", \"FormData is not available in this environment\");\n  let searchParams;\n  let formData;\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n  let submission = {\n    formMethod,\n    formAction,\n    formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined\n  };\n  if (isMutationMethod(submission.formMethod)) {\n    return {\n      path,\n      submission\n    };\n  }\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = \"?\" + searchParams;\n  return {\n    path: createPath(parsedPath),\n    submission\n  };\n}\n// Filter out all routes at/below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {\n  if (includeBoundary === void 0) {\n    includeBoundary = false;\n  }\n  let index = matches.findIndex(m => m.route.id === boundaryId);\n  if (index >= 0) {\n    return matches.slice(0, includeBoundary ? index + 1 : index);\n  }\n  return matches;\n}\nfunction getMatchesToLoad(history, state, matches, submission, location, initialHydration, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {\n  let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryMatches = matches;\n  if (initialHydration && state.errors) {\n    // On initial hydration, only consider matches up to _and including_ the boundary.\n    // This is inclusive to handle cases where a server loader ran successfully,\n    // a child server loader bubbled up to this route, but this route has\n    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that\n    // we have a complete version of `loaderData`\n    boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);\n  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {\n    // If an action threw an error, we call loaders up to, but not including the\n    // boundary\n    boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);\n  }\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;\n  let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let {\n      route\n    } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n    if (route.loader == null) {\n      return false;\n    }\n    if (initialHydration) {\n      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);\n    }\n    // Always call the loader on new route instances and pending defer cancellations\n    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {\n      return true;\n    }\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n    return shouldRevalidateLoader(match, _extends({\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params\n    }, submission, {\n      actionResult,\n      actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation ? false :\n      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||\n      // Search params affect all loaders\n      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n    }));\n  });\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial hydration (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (initialHydration || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {\n      return;\n    }\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null\n      });\n      return;\n    }\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\n      shouldRevalidate = true;\n    } else if (fetcher && fetcher.state !== \"idle\" && fetcher.data === undefined) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params\n      }, submission, {\n        actionResult,\n        actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired\n      }));\n    }\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController()\n      });\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\nfunction shouldLoadRouteOnHydration(route, loaderData, errors) {\n  // We dunno if we have a loader - gotta find out!\n  if (route.lazy) {\n    return true;\n  }\n  // No loader, nothing to initialize\n  if (!route.loader) {\n    return false;\n  }\n  let hasData = loaderData != null && loaderData[route.id] !== undefined;\n  let hasError = errors != null && errors[route.id] !== undefined;\n  // Don't run if we error'd during SSR\n  if (!hasData && hasError) {\n    return false;\n  }\n  // Explicitly opting-in to running on hydration\n  if (typeof route.loader === \"function\" && route.loader.hydrate === true) {\n    return true;\n  }\n  // Otherwise, run if we're not yet initialized with anything\n  return !hasData && !hasError;\n}\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew =\n  // [a] -> [a, b]\n  !currentMatch ||\n  // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id;\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath != null && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n  return arg.defaultShouldRevalidate;\n}\nfunction patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {\n  var _childrenToPatch;\n  let childrenToPatch;\n  if (routeId) {\n    let route = manifest[routeId];\n    invariant(route, \"No route found to patch children into: routeId = \" + routeId);\n    if (!route.children) {\n      route.children = [];\n    }\n    childrenToPatch = route.children;\n  } else {\n    childrenToPatch = routesToUse;\n  }\n  // Don't patch in routes we already know about so that `patch` is idempotent\n  // to simplify user-land code. This is useful because we re-call the\n  // `patchRoutesOnNavigation` function for matched routes with params.\n  let uniqueChildren = children.filter(newRoute => !childrenToPatch.some(existingRoute => isSameRoute(newRoute, existingRoute)));\n  let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [routeId || \"_\", \"patch\", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || \"0\")], manifest);\n  childrenToPatch.push(...newRoutes);\n}\nfunction isSameRoute(newRoute, existingRoute) {\n  // Most optimal check is by id\n  if (\"id\" in newRoute && \"id\" in existingRoute && newRoute.id === existingRoute.id) {\n    return true;\n  }\n  // Second is by pathing differences\n  if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {\n    return false;\n  }\n  // Pathless layout routes are trickier since we need to check children.\n  // If they have no children then they're the same as far as we can tell\n  if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {\n    return true;\n  }\n  // Otherwise, we look to see if every child in the new route is already\n  // represented in the existing route's children\n  return newRoute.children.every((aChild, i) => {\n    var _existingRoute$childr;\n    return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));\n  });\n}\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(route, mapRouteProperties, manifest) {\n  if (!route.lazy) {\n    return;\n  }\n  let lazyRoute = await route.lazy();\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue = routeToUpdate[lazyRouteProperty];\n    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&\n    // This property isn't static since it should always be updated based\n    // on the route updates\n    lazyRouteProperty !== \"hasErrorBoundary\";\n    warning(!isPropertyStaticallyDefined, \"Route \\\"\" + routeToUpdate.id + \"\\\" has a static property \\\"\" + lazyRouteProperty + \"\\\" \" + \"defined but its lazy function is also returning a value for this property. \" + (\"The lazy route property \\\"\" + lazyRouteProperty + \"\\\" will be ignored.\"));\n    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\n    }\n  }\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {\n    lazy: undefined\n  }));\n}\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nasync function defaultDataStrategy(_ref4) {\n  let {\n    matches\n  } = _ref4;\n  let matchesToLoad = matches.filter(m => m.shouldLoad);\n  let results = await Promise.all(matchesToLoad.map(m => m.resolve()));\n  return results.reduce((acc, result, i) => Object.assign(acc, {\n    [matchesToLoad[i].route.id]: result\n  }), {});\n}\nasync function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties, requestContext) {\n  let loadRouteDefinitionsPromises = matches.map(m => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties, manifest) : undefined);\n  let dsMatches = matches.map((match, i) => {\n    let loadRoutePromise = loadRouteDefinitionsPromises[i];\n    let shouldLoad = matchesToLoad.some(m => m.route.id === match.route.id);\n    // `resolve` encapsulates route.lazy(), executing the loader/action,\n    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users\n    // can pass a callback to take fine-grained control over the execution\n    // of the loader/action\n    let resolve = async handlerOverride => {\n      if (handlerOverride && request.method === \"GET\" && (match.route.lazy || match.route.loader)) {\n        shouldLoad = true;\n      }\n      return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({\n        type: ResultType.data,\n        result: undefined\n      });\n    };\n    return _extends({}, match, {\n      shouldLoad,\n      resolve\n    });\n  });\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: dsMatches,\n    request,\n    params: matches[0].params,\n    fetcherKey,\n    context: requestContext\n  });\n  // Wait for all routes to load here but 'swallow the error since we want\n  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -\n  // called from `match.resolve()`\n  try {\n    await Promise.all(loadRouteDefinitionsPromises);\n  } catch (e) {\n    // No-op\n  }\n  return results;\n}\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {\n  let result;\n  let onReject;\n  let runHandler = handler => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject;\n    // This will never resolve so safe to type it as Promise<DataStrategyResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise((_, r) => reject = r);\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n    let actualHandler = ctx => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(new Error(\"You cannot call the handler for a route which defines a boolean \" + (\"\\\"\" + type + \"\\\" [routeId: \" + match.route.id + \"]\")));\n      }\n      return handler({\n        request,\n        params: match.params,\n        context: staticContext\n      }, ...(ctx !== undefined ? [ctx] : []));\n    };\n    let handlerPromise = (async () => {\n      try {\n        let val = await (handlerOverride ? handlerOverride(ctx => actualHandler(ctx)) : actualHandler());\n        return {\n          type: \"data\",\n          result: val\n        };\n      } catch (e) {\n        return {\n          type: \"error\",\n          result: e\n        };\n      }\n    })();\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n  try {\n    let handler = match.route[type];\n    // If we have a route.lazy promise, await that first\n    if (loadRoutePromise) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [value] = await Promise.all([\n        // If the handler throws, don't let it immediately bubble out,\n        // since we need to let the lazy() execution finish so we know if this\n        // route has a boundary that can handle the error\n        runHandler(handler).catch(e => {\n          handlerError = e;\n        }), loadRoutePromise]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadRoutePromise;\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return {\n            type: ResultType.data,\n            result: undefined\n          };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n    invariant(result.result !== undefined, \"You defined \" + (type === \"action\" ? \"an action\" : \"a loader\") + \" for route \" + (\"\\\"\" + match.route.id + \"\\\" but didn't return anything from your `\" + type + \"` \") + \"function. Please return a value or `null`.\");\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // DataStrategyResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return {\n      type: ResultType.error,\n      result: e\n    };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n  return result;\n}\nasync function convertDataStrategyResultToDataResult(dataStrategyResult) {\n  let {\n    result,\n    type\n  } = dataStrategyResult;\n  if (isResponse(result)) {\n    let data;\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\n        headers: result.headers\n      };\n    }\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n  if (type === ResultType.error) {\n    if (isDataWithResponseInit(result)) {\n      var _result$init3, _result$init4;\n      if (result.data instanceof Error) {\n        var _result$init, _result$init2;\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,\n          headers: (_result$init2 = result.init) != null && _result$init2.headers ? new Headers(result.init.headers) : undefined\n        };\n      }\n      // Convert thrown data() to ErrorResponse instances\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(((_result$init3 = result.init) == null ? void 0 : _result$init3.status) || 500, undefined, result.data),\n        statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n        headers: (_result$init4 = result.init) != null && _result$init4.headers ? new Headers(result.init.headers) : undefined\n      };\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined\n    };\n  }\n  if (isDeferredData(result)) {\n    var _result$init5, _result$init6;\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,\n      headers: ((_result$init6 = result.init) == null ? void 0 : _result$init6.headers) && new Headers(result.init.headers)\n    };\n  }\n  if (isDataWithResponseInit(result)) {\n    var _result$init7, _result$init8;\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: (_result$init7 = result.init) == null ? void 0 : _result$init7.status,\n      headers: (_result$init8 = result.init) != null && _result$init8.headers ? new Headers(result.init.headers) : undefined\n    };\n  }\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {\n  let location = response.headers.get(\"Location\");\n  invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\");\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);\n    location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);\n    response.headers.set(\"Location\", location);\n  }\n  return response;\n}\nfunction normalizeRedirectLocation(location, currentUrl, basename) {\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n  return location;\n}\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(history, location, signal, submission) {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let {\n      formMethod,\n      formEncType\n    } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({\n        \"Content-Type\": formEncType\n      });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (formEncType === \"application/x-www-form-urlencoded\" && submission.formData) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n  return new Request(url, init);\n}\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n  return searchParams;\n}\nfunction convertSearchParamsToFormData(searchParams) {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\nfunction processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {\n  // Fill in loaderData/errors from our loaders\n  let loaderData = {};\n  let errors = null;\n  let statusCode;\n  let foundError = false;\n  let loaderHeaders = {};\n  let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;\n  // Process loader results into state.loaderData/state.errors\n  matches.forEach(match => {\n    if (!(match.route.id in results)) {\n      return;\n    }\n    let id = match.route.id;\n    let result = results[id];\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n      errors = errors || {};\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } else {\n        loaderData[id] = result.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = {\n      [pendingActionResult[0]]: pendingError\n    };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\n}\nfunction processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble\n  );\n  // Process results from our revalidating fetchers\n  revalidatingFetchers.forEach(rf => {\n    let {\n      key,\n      match,\n      controller\n    } = rf;\n    let result = fetcherResults[key];\n    invariant(result, \"Did not find corresponding fetcher result\");\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      return;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  });\n  return {\n    loaderData,\n    errors\n  };\n}\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\nfunction getActionDataForCommit(pendingActionResult) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1]) ? {\n    // Clear out prior actionData on errors\n    actionData: {}\n  } : {\n    actionData: {\n      [pendingActionResult[0]]: pendingActionResult[1].data\n    }\n  };\n}\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(matches, routeId) {\n  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\nfunction getShortCircuitMatches(routes) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-error-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route\n  };\n}\nfunction getInternalRouterError(status, _temp5) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type,\n    message\n  } = _temp5 === void 0 ? {} : _temp5;\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide a `loader` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = \"Route \\\"\" + routeId + \"\\\" does not match URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = \"No route matches URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method.toUpperCase() + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide an `action` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (method) {\n      errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n    }\n  }\n  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);\n}\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(results) {\n  let entries = Object.entries(results);\n  for (let i = entries.length - 1; i >= 0; i--) {\n    let [key, result] = entries[i];\n    if (isRedirectResult(result)) {\n      return {\n        key,\n        result\n      };\n    }\n  }\n}\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\nfunction isHashChangeOnly(a, b) {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\nfunction isDataStrategyResult(result) {\n  return result != null && typeof result === \"object\" && \"type\" in result && \"result\" in result && (result.type === ResultType.data || result.type === ResultType.error);\n}\nfunction isRedirectDataStrategyResultResult(result) {\n  return isResponse(result.result) && redirectStatusCodes.has(result.result.status);\n}\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\nfunction isDataWithResponseInit(value) {\n  return typeof value === \"object\" && value != null && \"type\" in value && \"data\" in value && \"init\" in value && value.type === \"DataWithResponseInit\";\n}\nfunction isDeferredData(value) {\n  let deferred = value;\n  return deferred && typeof deferred === \"object\" && typeof deferred.data === \"object\" && typeof deferred.subscribe === \"function\" && typeof deferred.cancel === \"function\" && typeof deferred.resolveData === \"function\";\n}\nfunction isResponse(value) {\n  return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\nfunction isRedirectResponse(result) {\n  if (!isResponse(result)) {\n    return false;\n  }\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\nfunction isValidMethod(method) {\n  return validRequestMethods.has(method.toLowerCase());\n}\nfunction isMutationMethod(method) {\n  return validMutationMethods.has(method.toLowerCase());\n}\nasync function resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {\n  let entries = Object.entries(results);\n  for (let index = 0; index < entries.length; index++) {\n    let [routeId, result] = entries[index];\n    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n    if (isDeferredResult(result) && isRevalidatingLoader) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      await resolveDeferredData(result, signal, false).then(result => {\n        if (result) {\n          results[routeId] = result;\n        }\n      });\n    }\n  }\n}\nasync function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let {\n      key,\n      routeId,\n      controller\n    } = revalidatingFetchers[index];\n    let result = results[key];\n    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    if (isDeferredResult(result)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      invariant(controller, \"Expected an AbortController for revalidating fetcher deferred result\");\n      await resolveDeferredData(result, controller.signal, true).then(result => {\n        if (result) {\n          results[key] = result;\n        }\n      });\n    }\n  }\n}\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n  }\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n}\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\nfunction getSubmissionFromNavigation(navigation) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    text,\n    formData,\n    json\n  } = navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined\n    };\n  }\n}\nfunction getLoadingNavigation(location, submission) {\n  if (submission) {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text\n    };\n    return navigation;\n  } else {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined\n    };\n    return navigation;\n  }\n}\nfunction getSubmittingNavigation(location, submission) {\n  let navigation = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text\n  };\n  return navigation;\n}\nfunction getLoadingFetcher(submission, data) {\n  if (submission) {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data\n    };\n    return fetcher;\n  } else {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data\n    };\n    return fetcher;\n  }\n}\nfunction getSubmittingFetcher(submission, existingFetcher) {\n  let fetcher = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined\n  };\n  return fetcher;\n}\nfunction getDoneFetcher(data) {\n  let fetcher = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data\n  };\n  return fetcher;\n}\nfunction restoreAppliedTransitions(_window, transitions) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\nfunction persistAppliedTransitions(_window, transitions) {\n  if (transitions.size > 0) {\n    let json = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));\n    } catch (error) {\n      warning(false, \"Failed to save applied view transitions in sessionStorage (\" + error + \").\");\n    }\n  }\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, decodePath as UNSAFE_decodePath, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, data, defer, generatePath, getStaticContextFromError, getToPathname, isDataWithResponseInit, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, replace, resolvePath, resolveTo, stripBasename };\n//# sourceMappingURL=router.js.map\n","// replaced during CI build step\nexport const APP_VERSION = 'v1.0-480-g0a01faf';\nconst bffRoot = process.env.BFF_ROOT || window.location.origin;\nconst bffEndpoint = process.env.BFF_ENDPOINT || '/portfolio-bff';\nexport const BFF_HOST = `${bffRoot}${bffEndpoint}`;\n","\"use strict\";\n\nvar memo = {};\n\n/* istanbul ignore next  */\nfunction getTarget(target) {\n  if (typeof memo[target] === \"undefined\") {\n    var styleTarget = document.querySelector(target);\n\n    // Special case to return head of iframe instead of iframe itself\n    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n      try {\n        // This will throw an exception if access to iframe is blocked\n        // due to cross-origin restrictions\n        styleTarget = styleTarget.contentDocument.head;\n      } catch (e) {\n        // istanbul ignore next\n        styleTarget = null;\n      }\n    }\n    memo[target] = styleTarget;\n  }\n  return memo[target];\n}\n\n/* istanbul ignore next  */\nfunction insertBySelector(insert, style) {\n  var target = getTarget(insert);\n  if (!target) {\n    throw new Error(\"Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.\");\n  }\n  target.appendChild(style);\n}\nmodule.exports = insertBySelector;","\"use strict\";var e,t,r,o,a,i,n,p,s,l,d,c,x,m,g,u,C,h,v,y,S,T,P,D,E,k,F,b;Object.defineProperty(exports,\"__esModule\",{value:!0}),exports.Periodicity=void 0,(e=exports.Periodicity||(exports.Periodicity={})).Monthly=\"Monthly\",e.Weekly=\"Weekly\",exports.ChangeType=void 0,(t=exports.ChangeType||(exports.ChangeType={})).percent=\"percent\",t.absolute=\"absolute\",exports.CurrencyOption=void 0,(r=exports.CurrencyOption||(exports.CurrencyOption={})).eur=\"eur\",r.local=\"local\",r.usd=\"usd\",exports.DataType=void 0,(o=exports.DataType||(exports.DataType={})).String=\"String\",o.Integer=\"Integer\",o.Date=\"Date\",o.Decimal=\"Decimal\",exports.FormatHint=void 0,(a=exports.FormatHint||(exports.FormatHint={})).Percentage=\"Percentage\",a.PercentagePoints=\"PercentagePoints\",a.Money=\"Money\",a.Index=\"Index\",a.MonthYear=\"MonthYear\",a.Month=\"Month\",a.Year=\"Year\",a.WholeMoney=\"WholeMoney\",exports.SortType=void 0,(i=exports.SortType||(exports.SortType={})).Absolute=\"Absolute\",i.Change=\"Change\",i.Alpha=\"Alpha\",i.Date=\"Date\",exports.SortDirection=void 0,(n=exports.SortDirection||(exports.SortDirection={})).ascending=\"ascending\",n.descending=\"descending\",exports.GenericWarningScope=void 0,(p=exports.GenericWarningScope||(exports.GenericWarningScope={})).Global=\"GLOBAL\",p.Local=\"LOCAL\",exports.ColumnType=void 0,(s=exports.ColumnType||(exports.ColumnType={})).Identifier=\"Identifier\",s.Kpi=\"Kpi\",s.KpiWithChange=\"KpiWithChange\",s.Text=\"Text\",s.Date=\"Date\",s.Number=\"Number\",exports.ColumnRelationship=void 0,(l=exports.ColumnRelationship||(exports.ColumnRelationship={})).Change=\"Change\",l.Share=\"Share\",l.Description=\"Description\",l.QueryArgs=\"QueryArgs\",l.Detail=\"Detail\",exports.HTTPMethod=void 0,(d=exports.HTTPMethod||(exports.HTTPMethod={})).GET=\"GET\",d.POST=\"POST\",exports.PreferenceName=void 0,(c=exports.PreferenceName||(exports.PreferenceName={})).segment_price=\"segment_price\",c.segment_feature=\"segment_feature\",exports.SettingSelector=void 0,(x=exports.SettingSelector||(exports.SettingSelector={})).singleSelect=\"singleSelect\",x.radioGroup=\"radioGroup\",x.multiSelect=\"multiSelect\",x.custom=\"custom\",exports.FilterType=void 0,(m=exports.FilterType||(exports.FilterType={})).multiSelect=\"multiSelect\",m.numericRange=\"numericRange\",m.dateRange=\"dateRange\",m.select=\"select\",exports.DataVizType=void 0,(g=exports.DataVizType||(exports.DataVizType={})).table=\"table\",g.chart=\"chart\",g.horizontalBarChart=\"horizontalBarChart\",g.verticalBarChart=\"verticalBarChart\",g.stackedBarChart=\"stackedBarChart\",g.bubbleChart=\"bubbleChart\",g.valueWithChangeChart=\"valueWithChangeChart\",g.lineChart=\"lineChart\",exports.CoreContents=void 0,(u=exports.CoreContents||(exports.CoreContents={})).unknown=\"unknown\",u.dataError=\"dataError\",u.timeSeries=\"timeSeries\",u.segmentation=\"segmentation\",u.multiKpi=\"multiKpi\",u.leaderBoard=\"leaderBoard\",u.statsTable=\"statsTable\",u.keyIndicators=\"keyIndicators\",u.kpiTrends=\"kpiTrends\",u.billboard=\"billboard\",u.alertPanel=\"alertPanel\",u.singleKpiTrend=\"singleKpiTrend\",u.heatmap=\"heatmap\",u.kpiDecompositon=\"kpiDecomposition\",exports.ExportFormat=void 0,(C=exports.ExportFormat||(exports.ExportFormat={})).Xlsx=\"xlsx\",C.Pptx=\"pptx\",C.Png=\"png\",exports.DataMode=void 0,(h=exports.DataMode||(exports.DataMode={})).isProvider=\"isProvider\",h.takeFromProvider=\"takeFromProvider\",h.isPresent=\"isPresent\",exports.SortingDisplayLevel=void 0,(v=exports.SortingDisplayLevel||(exports.SortingDisplayLevel={})).atProvider=\"atProvider\",v.atContent=\"atContent\",exports.SortingLocation=void 0,(y=exports.SortingLocation||(exports.SortingLocation={})).onBrowser=\"onBrowser\",y.onServer=\"onServer\",exports.ModalName=void 0,(S=exports.ModalName||(exports.ModalName={})).KeyIndicators=\"key indicators\",S.Heatmap=\"heatmap\",S.Trends=\"trends\",exports.SectionType=void 0,(T=exports.SectionType||(exports.SectionType={})).unknown=\"unknown\",T.column=\"column\",T.tabbed=\"tabbed\",exports.SectionColumnWidth=void 0,(P=exports.SectionColumnWidth||(exports.SectionColumnWidth={})).full=\"full\",P.half=\"half\",P[\"1/3\"]=\"1/3\",P[\"2/3\"]=\"2/3\",P[\"1/4\"]=\"1/4\",P[\"3/4\"]=\"3/4\",exports.EventName=void 0,(D=exports.EventName||(exports.EventName={})).PageViewed=\"Page Viewed\",D.PageElementViewed=\"Page Element Viewed\",D.ChartInteractions=\"Chart Interactions\",D.FilterApplied=\"Filter Applied\",D.FilterAppliedDetails=\"Filter Applied Details\",D.NavigationClicked=\"Navigation Clicked\",D.PageElementClicked=\"Page Element Clicked\",D.TableClicked=\"Table Clicked\",D.DataExported=\"Data Exported\",D.DataExportInitiated=\"Data Export Initiated\",D.SearchClicked=\"Search Clicked\",D.PageScrolled=\"Page Scrolled\",exports.EventElementType=void 0,(E=exports.EventElementType||(exports.EventElementType={})).Button=\"Button\",E.Group=\"Group\",E.Card=\"Card\",E.Link=\"Link\",E.Sort=\"Sort\",E.Overlay=\"Overlay\",E.CheckBox=\"Check Box\",exports.EventElementCategory=void 0,(k=exports.EventElementCategory||(exports.EventElementCategory={})).CustomFilter=\"Custom Filter\",k.SaveFilter=\"Saved Filters\",k.CustomPriceFilter=\"Custom Price Filter\",k.CustomFeatureFilter=\"Custom Feature Filter\",k.DeleteFeatureFilter=\"Delete Feature Filter\",k.ShareFeatureFilter=\"Share Feature Filter\",exports.EventKeyIndicators=void 0,(F=exports.EventKeyIndicators||(exports.EventKeyIndicators={})).Market=\"Market\",F.Brand=\"Brand\",exports.TrackingElementType=void 0,(b=exports.TrackingElementType||(exports.TrackingElementType={})).Tooltip=\"Tooltip\",b.Selectors=\"Selectors\",b.Table=\"Table\",b.Chart=\"Chart\";\n","module.exports = __WEBPACK_EXTERNAL_MODULE__726__;","/**\n * React Router v6.30.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport { UNSAFE_invariant, joinPaths, matchPath, UNSAFE_decodePath, UNSAFE_getResolveToMatches, UNSAFE_warning, resolveTo, parsePath, matchRoutes, Action, UNSAFE_convertRouteMatchToUiMatch, stripBasename, IDLE_BLOCKER, isRouteErrorResponse, createMemoryHistory, AbortedDeferredError, createRouter } from '@remix-run/router';\nexport { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, replace, resolvePath } from '@remix-run/router';\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nconst DataRouterContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterContext.displayName = \"DataRouter\";\n}\nconst DataRouterStateContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\nconst AwaitContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  AwaitContext.displayName = \"Await\";\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level `<Router>` API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\n\nconst NavigationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\nconst LocationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\nconst RouteContext = /*#__PURE__*/React.createContext({\n  outlet: null,\n  matches: [],\n  isDataRoute: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\nconst RouteErrorContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  RouteErrorContext.displayName = \"RouteError\";\n}\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/v6/hooks/use-href\n */\nfunction useHref(to, _temp) {\n  let {\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useHref() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    hash,\n    pathname,\n    search\n  } = useResolvedPath(to, {\n    relative\n  });\n  let joinedPathname = pathname;\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the href.  If this is a root navigation, then just use the raw\n  // basename which allows the basename to have full control over the presence\n  // of a trailing slash on root links\n  if (basename !== \"/\") {\n    joinedPathname = pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\n}\n\n/**\n * Returns true if this component is a descendant of a `<Router>`.\n *\n * @see https://reactrouter.com/v6/hooks/use-in-router-context\n */\nfunction useInRouterContext() {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/v6/hooks/use-location\n */\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useLocation() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/v6/hooks/use-navigation-type\n */\nfunction useNavigationType() {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * `<NavLink>`.\n *\n * @see https://reactrouter.com/v6/hooks/use-match\n */\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useMatch() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return React.useMemo(() => matchPath(pattern, UNSAFE_decodePath(pathname)), [pathname, pattern]);\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\n\nconst navigateEffectWarning = \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\";\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(cb) {\n  let isStatic = React.useContext(NavigationContext).static;\n  if (!isStatic) {\n    // We should be able to get rid of this once react 18.3 is released\n    // See: https://github.com/facebook/react/pull/26395\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(cb);\n  }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by `<Link>`s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/v6/hooks/use-navigate\n */\nfunction useNavigate() {\n  let {\n    isDataRoute\n  } = React.useContext(RouteContext);\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\nfunction useNavigateUnstable() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useNavigate() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let {\n    basename,\n    future,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\n\n    // Short circuit here since if this happens on first render the navigate\n    // is useless because we haven't wired up our history listener yet\n    if (!activeRef.current) return;\n    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === \"path\");\n\n    // If we're operating within a basename, prepend it to the pathname prior\n    // to handing off to history (but only if we're not in a data router,\n    // otherwise it'll prepend the basename inside of the router).\n    // If this is a root navigation, then we navigate to the raw basename\n    // which allows the basename to have full control over the presence of a\n    // trailing slash on root links\n    if (dataRouterContext == null && basename !== \"/\") {\n      path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n    }\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);\n  }, [basename, navigator, routePathnamesJson, locationPathname, dataRouterContext]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/v6/hooks/use-outlet-context\n */\nfunction useOutletContext() {\n  return React.useContext(OutletContext);\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by `<Outlet>` to render child routes.\n *\n * @see https://reactrouter.com/v6/hooks/use-outlet\n */\nfunction useOutlet(context) {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return /*#__PURE__*/React.createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/v6/hooks/use-params\n */\nfunction useParams() {\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? routeMatch.params : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/v6/hooks/use-resolved-path\n */\nfunction useResolvedPath(to, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    future\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === \"path\"), [to, routePathnamesJson, locationPathname, relative]);\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an `<Outlet>` to render their child route's\n * element.\n *\n * @see https://reactrouter.com/v6/hooks/use-routes\n */\nfunction useRoutes(routes, locationArg) {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nfunction useRoutesImpl(routes, locationArg, dataRouterState, future) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useRoutes() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    navigator,\n    static: isStatic\n  } = React.useContext(NavigationContext);\n  let {\n    matches: parentMatches\n  } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n  if (process.env.NODE_ENV !== \"production\") {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = parentRoute && parentRoute.path || \"\";\n    warningOnce(parentPathname, !parentRoute || parentPath.endsWith(\"*\"), \"You rendered descendant <Routes> (or called `useRoutes()`) at \" + (\"\\\"\" + parentPathname + \"\\\" (under <Route path=\\\"\" + parentPath + \"\\\">) but the \") + \"parent route path has no trailing \\\"*\\\". This means if you navigate \" + \"deeper, the parent won't match anymore and therefore the child \" + \"routes will never render.\\n\\n\" + (\"Please change the parent <Route path=\\\"\" + parentPath + \"\\\"> to <Route \") + (\"path=\\\"\" + (parentPath === \"/\" ? \"*\" : parentPath + \"/*\") + \"\\\">.\"));\n  }\n  let locationFromContext = useLocation();\n  let location;\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n    let parsedLocationArg = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n    !(parentPathnameBase === \"/\" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, \" + \"the location pathname must begin with the portion of the URL pathname that was \" + (\"matched by all parent routes. The current pathname base is \\\"\" + parentPathnameBase + \"\\\" \") + (\"but pathname \\\"\" + parsedLocationArg.pathname + \"\\\" was given in the `location` prop.\")) : UNSAFE_invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n  let pathname = location.pathname || \"/\";\n  let remainingPathname = pathname;\n  if (parentPathnameBase !== \"/\") {\n    // Determine the remaining pathname by removing the # of URL segments the\n    // parentPathnameBase has, instead of removing based on character count.\n    // This is because we can't guarantee that incoming/outgoing encodings/\n    // decodings will match exactly.\n    // We decode paths before matching on a per-segment basis with\n    // decodeURIComponent(), but we re-encode pathnames via `new URL()` so they\n    // match what `window.location.pathname` would reflect.  Those don't 100%\n    // align when it comes to encoded URI characters such as % and &.\n    //\n    // So we may end up with:\n    //   pathname:           \"/descendant/a%25b/match\"\n    //   parentPathnameBase: \"/descendant/a%b\"\n    //\n    // And the direct substring removal approach won't work :/\n    let parentSegments = parentPathnameBase.replace(/^\\//, \"\").split(\"/\");\n    let segments = pathname.replace(/^\\//, \"\").split(\"/\");\n    remainingPathname = \"/\" + segments.slice(parentSegments.length).join(\"/\");\n  }\n  let matches = !isStatic && dataRouterState && dataRouterState.matches && dataRouterState.matches.length > 0 ? dataRouterState.matches : matchRoutes(routes, {\n    pathname: remainingPathname\n  });\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(matches == null || matches[matches.length - 1].route.element !== undefined || matches[matches.length - 1].route.Component !== undefined || matches[matches.length - 1].route.lazy !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \" + \"does not have an element or Component. This means it will render an <Outlet /> with a \" + \"null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase])\n  })), parentMatches, dataRouterState, future);\n\n  // When a user passes in a `locationArg`, the associated routes need to\n  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n  // to use the scoped location instead of the global location.\n  if (locationArg && renderedMatches) {\n    return /*#__PURE__*/React.createElement(LocationContext.Provider, {\n      value: {\n        location: _extends({\n          pathname: \"/\",\n          search: \"\",\n          hash: \"\",\n          state: null,\n          key: \"default\"\n        }, location),\n        navigationType: Action.Pop\n      }\n    }, renderedMatches);\n  }\n  return renderedMatches;\n}\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error) ? error.status + \" \" + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = {\n    padding: \"0.5rem\",\n    backgroundColor: lightgrey\n  };\n  let codeStyles = {\n    padding: \"2px 4px\",\n    backgroundColor: lightgrey\n  };\n  let devInfo = null;\n  if (process.env.NODE_ENV !== \"production\") {\n    console.error(\"Error handled by React Router default ErrorBoundary:\", error);\n    devInfo = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"p\", null, \"\\uD83D\\uDCBF Hey developer \\uD83D\\uDC4B\"), /*#__PURE__*/React.createElement(\"p\", null, \"You can provide a way better UX than this when your app throws errors by providing your own \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"ErrorBoundary\"), \" or\", \" \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"errorElement\"), \" prop on your route.\"));\n  }\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"h2\", null, \"Unexpected Application Error!\"), /*#__PURE__*/React.createElement(\"h3\", {\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, message), stack ? /*#__PURE__*/React.createElement(\"pre\", {\n    style: preStyles\n  }, stack) : null, devInfo);\n}\nconst defaultErrorElement = /*#__PURE__*/React.createElement(DefaultErrorComponent, null);\nclass RenderErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error: error\n    };\n  }\n  static getDerivedStateFromProps(props, state) {\n    // When we get into an error state, the user will likely click \"back\" to the\n    // previous page that didn't have an error. Because this wraps the entire\n    // application, that will have no effect--the error page continues to display.\n    // This gives us a mechanism to recover from the error when the location changes.\n    //\n    // Whether we're in an error state or not, we update the location in state\n    // so that when we are in an error state, it gets reset when a new location\n    // comes in and the user recovers from the error.\n    if (state.location !== props.location || state.revalidation !== \"idle\" && props.revalidation === \"idle\") {\n      return {\n        error: props.error,\n        location: props.location,\n        revalidation: props.revalidation\n      };\n    }\n\n    // If we're not changing locations, preserve the location but still surface\n    // any new errors that may come through. We retain the existing error, we do\n    // this because the error provided from the app state may be cleared without\n    // the location changing.\n    return {\n      error: props.error !== undefined ? props.error : state.error,\n      location: state.location,\n      revalidation: props.revalidation || state.revalidation\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"React Router caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    return this.state.error !== undefined ? /*#__PURE__*/React.createElement(RouteContext.Provider, {\n      value: this.props.routeContext\n    }, /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {\n      value: this.state.error,\n      children: this.props.component\n    })) : this.props.children;\n  }\n}\nfunction RenderedRoute(_ref) {\n  let {\n    routeContext,\n    match,\n    children\n  } = _ref;\n  let dataRouterContext = React.useContext(DataRouterContext);\n\n  // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n  if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n  return /*#__PURE__*/React.createElement(RouteContext.Provider, {\n    value: routeContext\n  }, children);\n}\nfunction _renderMatches(matches, parentMatches, dataRouterState, future) {\n  var _dataRouterState;\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n  if (dataRouterState === void 0) {\n    dataRouterState = null;\n  }\n  if (future === void 0) {\n    future = null;\n  }\n  if (matches == null) {\n    var _future;\n    if (!dataRouterState) {\n      return null;\n    }\n    if (dataRouterState.errors) {\n      // Don't bail if we have data router errors so we can render them in the\n      // boundary.  Use the pre-matched (or shimmed) matches\n      matches = dataRouterState.matches;\n    } else if ((_future = future) != null && _future.v7_partialHydration && parentMatches.length === 0 && !dataRouterState.initialized && dataRouterState.matches.length > 0) {\n      // Don't bail if we're initializing with partial hydration and we have\n      // router matches.  That means we're actively running `patchRoutesOnNavigation`\n      // so we should render down the partial matches to the appropriate\n      // `HydrateFallback`.  We only do this if `parentMatches` is empty so it\n      // only impacts the root matches for `RouterProvider` and no descendant\n      // `<Routes>`\n      matches = dataRouterState.matches;\n    } else {\n      return null;\n    }\n  }\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = (_dataRouterState = dataRouterState) == null ? void 0 : _dataRouterState.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(m => m.route.id && (errors == null ? void 0 : errors[m.route.id]) !== undefined);\n    !(errorIndex >= 0) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"Could not find a matching route for errors on route IDs: \" + Object.keys(errors).join(\",\")) : UNSAFE_invariant(false) : void 0;\n    renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));\n  }\n\n  // If we're in a partial hydration mode, detect if we need to render down to\n  // a given HydrateFallback while we load the rest of the hydration data\n  let renderFallback = false;\n  let fallbackIndex = -1;\n  if (dataRouterState && future && future.v7_partialHydration) {\n    for (let i = 0; i < renderedMatches.length; i++) {\n      let match = renderedMatches[i];\n      // Track the deepest fallback up until the first route without data\n      if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {\n        fallbackIndex = i;\n      }\n      if (match.route.id) {\n        let {\n          loaderData,\n          errors\n        } = dataRouterState;\n        let needsToRunLoader = match.route.loader && loaderData[match.route.id] === undefined && (!errors || errors[match.route.id] === undefined);\n        if (match.route.lazy || needsToRunLoader) {\n          // We found the first route that's not ready to render (waiting on\n          // lazy, or has a loader that hasn't run yet).  Flag that we need to\n          // render a fallback and render up until the appropriate fallback\n          renderFallback = true;\n          if (fallbackIndex >= 0) {\n            renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);\n          } else {\n            renderedMatches = [renderedMatches[0]];\n          }\n          break;\n        }\n      }\n    }\n  }\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    // Only data routers handle errors/fallbacks\n    let error;\n    let shouldRenderHydrateFallback = false;\n    let errorElement = null;\n    let hydrateFallbackElement = null;\n    if (dataRouterState) {\n      error = errors && match.route.id ? errors[match.route.id] : undefined;\n      errorElement = match.route.errorElement || defaultErrorElement;\n      if (renderFallback) {\n        if (fallbackIndex < 0 && index === 0) {\n          warningOnce(\"route-fallback\", false, \"No `HydrateFallback` element provided to render during initial hydration\");\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = null;\n        } else if (fallbackIndex === index) {\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = match.route.hydrateFallbackElement || null;\n        }\n      }\n    }\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children;\n      if (error) {\n        children = errorElement;\n      } else if (shouldRenderHydrateFallback) {\n        children = hydrateFallbackElement;\n      } else if (match.route.Component) {\n        // Note: This is a de-optimized path since React won't re-use the\n        // ReactElement since it's identity changes with each new\n        // React.createElement call.  We keep this so folks can use\n        // `<Route Component={...}>` in `<Routes>` but generally `Component`\n        // usage is only advised in `RouterProvider` when we can convert it to\n        // `element` ahead of time.\n        children = /*#__PURE__*/React.createElement(match.route.Component, null);\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return /*#__PURE__*/React.createElement(RenderedRoute, {\n        match: match,\n        routeContext: {\n          outlet,\n          matches,\n          isDataRoute: dataRouterState != null\n        },\n        children: children\n      });\n    };\n    // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {\n      location: dataRouterState.location,\n      revalidation: dataRouterState.revalidation,\n      component: errorElement,\n      error: error,\n      children: getChildren(),\n      routeContext: {\n        outlet: null,\n        matches,\n        isDataRoute: true\n      }\n    }) : getChildren();\n  }, null);\n}\nvar DataRouterHook = /*#__PURE__*/function (DataRouterHook) {\n  DataRouterHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterHook[\"UseNavigateStable\"] = \"useNavigate\";\n  return DataRouterHook;\n}(DataRouterHook || {});\nvar DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterStateHook[\"UseLoaderData\"] = \"useLoaderData\";\n  DataRouterStateHook[\"UseActionData\"] = \"useActionData\";\n  DataRouterStateHook[\"UseRouteError\"] = \"useRouteError\";\n  DataRouterStateHook[\"UseNavigation\"] = \"useNavigation\";\n  DataRouterStateHook[\"UseRouteLoaderData\"] = \"useRouteLoaderData\";\n  DataRouterStateHook[\"UseMatches\"] = \"useMatches\";\n  DataRouterStateHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterStateHook[\"UseNavigateStable\"] = \"useNavigate\";\n  DataRouterStateHook[\"UseRouteId\"] = \"useRouteId\";\n  return DataRouterStateHook;\n}(DataRouterStateHook || {});\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/v6/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\nfunction useRouteContext(hookName) {\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, hookName + \" can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nfunction useRouteId() {\n  return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nfunction useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nfunction useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return React.useMemo(() => ({\n    revalidate: dataRouterContext.router.revalidate,\n    state: state.revalidation\n  }), [dataRouterContext.router.revalidate, state.revalidation]);\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nfunction useMatches() {\n  let {\n    matches,\n    loaderData\n  } = useDataRouterState(DataRouterStateHook.UseMatches);\n  return React.useMemo(() => matches.map(m => UNSAFE_convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nfunction useLoaderData() {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\"You cannot `useLoaderData` in an errorElement (routeId: \" + routeId + \")\");\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nfunction useRouteLoaderData(routeId) {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nfunction useActionData() {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  return state.actionData ? state.actionData[routeId] : undefined;\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error.  This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nfunction useRouteError() {\n  var _state$errors;\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n  // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n  if (error !== undefined) {\n    return error;\n  }\n\n  // Otherwise look for errors from our data router state\n  return (_state$errors = state.errors) == null ? void 0 : _state$errors[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor `<Await />` value\n */\nfunction useAsyncValue() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._data;\n}\n\n/**\n * Returns the error from the nearest ancestor `<Await />` value\n */\nfunction useAsyncError() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._error;\n}\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\nfunction useBlocker(shouldBlock) {\n  let {\n    router,\n    basename\n  } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback(arg => {\n    if (typeof shouldBlock !== \"function\") {\n      return !!shouldBlock;\n    }\n    if (basename === \"/\") {\n      return shouldBlock(arg);\n    }\n\n    // If they provided us a function and we've got an active basename, strip\n    // it from the locations we expose to the user to match the behavior of\n    // useLocation\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = arg;\n    return shouldBlock({\n      currentLocation: _extends({}, currentLocation, {\n        pathname: stripBasename(currentLocation.pathname, basename) || currentLocation.pathname\n      }),\n      nextLocation: _extends({}, nextLocation, {\n        pathname: stripBasename(nextLocation.pathname, basename) || nextLocation.pathname\n      }),\n      historyAction\n    });\n  }, [basename, shouldBlock]);\n\n  // This effect is in charge of blocker key assignment and deletion (which is\n  // tightly coupled to the key)\n  React.useEffect(() => {\n    let key = String(++blockerId);\n    setBlockerKey(key);\n    return () => router.deleteBlocker(key);\n  }, [router]);\n\n  // This effect handles assigning the blockerFunction.  This is to handle\n  // unstable blocker function identities, and happens only after the prior\n  // effect so we don't get an orphaned blockerFunction in the router with a\n  // key of \"\".  Until then we just have the IDLE_BLOCKER.\n  React.useEffect(() => {\n    if (blockerKey !== \"\") {\n      router.getBlocker(blockerKey, blockerFunction);\n    }\n  }, [router, blockerKey, blockerFunction]);\n\n  // Prefer the blocker from `state` not `router.state` since DataRouterContext\n  // is memoized so this ensures we update on blocker state updates\n  return blockerKey && state.blockers.has(blockerKey) ? state.blockers.get(blockerKey) : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\n\n    // Short circuit here since if this happens on first render the navigate\n    // is useless because we haven't wired up our router subscriber yet\n    if (!activeRef.current) return;\n    if (typeof to === \"number\") {\n      router.navigate(to);\n    } else {\n      router.navigate(to, _extends({\n        fromRouteId: id\n      }, options));\n    }\n  }, [router, id]);\n  return navigate;\n}\nconst alreadyWarned$1 = {};\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned$1[key]) {\n    alreadyWarned$1[key] = true;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, message) : void 0;\n  }\n}\n\nconst alreadyWarned = {};\nfunction warnOnce(key, message) {\n  if (process.env.NODE_ENV !== \"production\" && !alreadyWarned[message]) {\n    alreadyWarned[message] = true;\n    console.warn(message);\n  }\n}\nconst logDeprecation = (flag, msg, link) => warnOnce(flag, \"\\u26A0\\uFE0F React Router Future Flag Warning: \" + msg + \". \" + (\"You can use the `\" + flag + \"` future flag to opt-in early. \") + (\"For more information, see \" + link + \".\"));\nfunction logV6DeprecationWarnings(renderFuture, routerFuture) {\n  if ((renderFuture == null ? void 0 : renderFuture.v7_startTransition) === undefined) {\n    logDeprecation(\"v7_startTransition\", \"React Router will begin wrapping state updates in `React.startTransition` in v7\", \"https://reactrouter.com/v6/upgrading/future#v7_starttransition\");\n  }\n  if ((renderFuture == null ? void 0 : renderFuture.v7_relativeSplatPath) === undefined && (!routerFuture || !routerFuture.v7_relativeSplatPath)) {\n    logDeprecation(\"v7_relativeSplatPath\", \"Relative route resolution within Splat routes is changing in v7\", \"https://reactrouter.com/v6/upgrading/future#v7_relativesplatpath\");\n  }\n  if (routerFuture) {\n    if (routerFuture.v7_fetcherPersist === undefined) {\n      logDeprecation(\"v7_fetcherPersist\", \"The persistence behavior of fetchers is changing in v7\", \"https://reactrouter.com/v6/upgrading/future#v7_fetcherpersist\");\n    }\n    if (routerFuture.v7_normalizeFormMethod === undefined) {\n      logDeprecation(\"v7_normalizeFormMethod\", \"Casing of `formMethod` fields is being normalized to uppercase in v7\", \"https://reactrouter.com/v6/upgrading/future#v7_normalizeformmethod\");\n    }\n    if (routerFuture.v7_partialHydration === undefined) {\n      logDeprecation(\"v7_partialHydration\", \"`RouterProvider` hydration behavior is changing in v7\", \"https://reactrouter.com/v6/upgrading/future#v7_partialhydration\");\n    }\n    if (routerFuture.v7_skipActionErrorRevalidation === undefined) {\n      logDeprecation(\"v7_skipActionErrorRevalidation\", \"The revalidation behavior after 4xx/5xx `action` responses is changing in v7\", \"https://reactrouter.com/v6/upgrading/future#v7_skipactionerrorrevalidation\");\n    }\n  }\n}\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    if (v7_startTransition && startTransitionImpl) {\n      startTransitionImpl(() => setStateImpl(newState));\n    } else {\n      setStateImpl(newState);\n    }\n  }, [setStateImpl, v7_startTransition]);\n\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\n  React.useEffect(() => logV6DeprecationWarnings(future, router.future), [router, future]);\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    location: state.location,\n    navigationType: state.historyAction,\n    navigator: navigator,\n    future: {\n      v7_relativeSplatPath: router.future.v7_relativeSplatPath\n    }\n  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(DataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))), null);\n}\nfunction DataRoutes(_ref2) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref2;\n  return useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` that stores all entries in memory.\n *\n * @see https://reactrouter.com/v6/router-components/memory-router\n */\nfunction MemoryRouter(_ref3) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex,\n    future\n  } = _ref3;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  React.useEffect(() => logV6DeprecationWarnings(future), [future]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/v6/components/navigate\n */\nfunction Navigate(_ref4) {\n  let {\n    to,\n    replace,\n    state,\n    relative\n  } = _ref4;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of\n  // the router loaded. We can help them understand how to avoid that.\n  \"<Navigate> may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    future,\n    static: isStatic\n  } = React.useContext(NavigationContext);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(!isStatic, \"<Navigate> must not be used on the initial render in a <StaticRouter>. \" + \"This is a no-op, but you should modify your code so the <Navigate> is \" + \"only ever rendered in response to some user interaction or state change.\") : void 0;\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let navigate = useNavigate();\n\n  // Resolve the path outside of the effect so that when effects run twice in\n  // StrictMode they navigate to the same place\n  let path = resolveTo(to, UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath), locationPathname, relative === \"path\");\n  let jsonPath = JSON.stringify(path);\n  React.useEffect(() => navigate(JSON.parse(jsonPath), {\n    replace,\n    state,\n    relative\n  }), [navigate, jsonPath, relative, replace, state]);\n  return null;\n}\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/v6/components/outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/v6/components/route\n */\nfunction Route(_props) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"A <Route> is only ever to be used as the child of <Routes> element, \" + \"never rendered directly. Please wrap your <Route> in a <Routes>.\") : UNSAFE_invariant(false) ;\n}\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a `<Router>` directly. Instead, you'll render a\n * router that is more specific to your environment such as a `<BrowserRouter>`\n * in web browsers or a `<StaticRouter>` for server rendering.\n *\n * @see https://reactrouter.com/v6/router-components/router\n */\nfunction Router(_ref5) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false,\n    future\n  } = _ref5;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : UNSAFE_invariant(false) : void 0;\n\n  // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(() => ({\n    basename,\n    navigator,\n    static: staticProp,\n    future: _extends({\n      v7_relativeSplatPath: false\n    }, future)\n  }), [basename, future, navigator, staticProp]);\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n    if (trailingPathname == null) {\n      return null;\n    }\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key\n      },\n      navigationType\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(locationContext != null, \"<Router basename=\\\"\" + basename + \"\\\"> is not able to match the URL \" + (\"\\\"\" + pathname + search + hash + \"\\\" because it does not start with the \") + \"basename, so the <Router> won't render anything.\") : void 0;\n  if (locationContext == null) {\n    return null;\n  }\n  return /*#__PURE__*/React.createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/React.createElement(LocationContext.Provider, {\n    children: children,\n    value: locationContext\n  }));\n}\n/**\n * A container for a nested tree of `<Route>` elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/v6/components/routes\n */\nfunction Routes(_ref6) {\n  let {\n    children,\n    location\n  } = _ref6;\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nfunction Await(_ref7) {\n  let {\n    children,\n    errorElement,\n    resolve\n  } = _ref7;\n  return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {\n    resolve: resolve,\n    errorElement: errorElement\n  }, /*#__PURE__*/React.createElement(ResolveAwait, null, children));\n}\nvar AwaitRenderStatus = /*#__PURE__*/function (AwaitRenderStatus) {\n  AwaitRenderStatus[AwaitRenderStatus[\"pending\"] = 0] = \"pending\";\n  AwaitRenderStatus[AwaitRenderStatus[\"success\"] = 1] = \"success\";\n  AwaitRenderStatus[AwaitRenderStatus[\"error\"] = 2] = \"error\";\n  return AwaitRenderStatus;\n}(AwaitRenderStatus || {});\nconst neverSettledPromise = new Promise(() => {});\nclass AwaitErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      error: null\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"<Await> caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    let {\n      children,\n      errorElement,\n      resolve\n    } = this.props;\n    let promise = null;\n    let status = AwaitRenderStatus.pending;\n    if (!(resolve instanceof Promise)) {\n      // Didn't get a promise - provide as a resolved promise\n      status = AwaitRenderStatus.success;\n      promise = Promise.resolve();\n      Object.defineProperty(promise, \"_tracked\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_data\", {\n        get: () => resolve\n      });\n    } else if (this.state.error) {\n      // Caught a render error, provide it as a rejected promise\n      status = AwaitRenderStatus.error;\n      let renderError = this.state.error;\n      promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n      Object.defineProperty(promise, \"_tracked\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_error\", {\n        get: () => renderError\n      });\n    } else if (resolve._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status = \"_error\" in promise ? AwaitRenderStatus.error : \"_data\" in promise ? AwaitRenderStatus.success : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", {\n        get: () => true\n      });\n      promise = resolve.then(data => Object.defineProperty(resolve, \"_data\", {\n        get: () => data\n      }), error => Object.defineProperty(resolve, \"_error\", {\n        get: () => error\n      }));\n    }\n    if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: errorElement\n      });\n    }\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: children\n      });\n    }\n\n    // Throw to the suspense boundary\n    throw promise;\n  }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on `<Await>`\n */\nfunction ResolveAwait(_ref8) {\n  let {\n    children\n  } = _ref8;\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, toRender);\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/v6/utils/create-routes-from-children\n */\nfunction createRoutesFromChildren(children, parentPath) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  let routes = [];\n  React.Children.forEach(children, (element, index) => {\n    if (! /*#__PURE__*/React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n    let treePath = [...parentPath, index];\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children, treePath));\n      return;\n    }\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"[\" + (typeof element.type === \"string\" ? element.type : element.type.name) + \"] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>\") : UNSAFE_invariant(false) : void 0;\n    !(!element.props.index || !element.props.children) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"An index route cannot have child routes.\") : UNSAFE_invariant(false) : void 0;\n    let route = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary: element.props.ErrorBoundary != null || element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy\n    };\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children, treePath);\n    }\n    routes.push(route);\n  });\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n\nfunction mapRouteProperties(route) {\n  let updates = {\n    // Note: this check also occurs in createRoutesFromChildren so update\n    // there if you change this -- please and thank you!\n    hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null\n  };\n  if (route.Component) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.element) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `Component` and `element` on your route - \" + \"`Component` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      element: /*#__PURE__*/React.createElement(route.Component),\n      Component: undefined\n    });\n  }\n  if (route.HydrateFallback) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.hydrateFallbackElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - \" + \"`HydrateFallback` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      hydrateFallbackElement: /*#__PURE__*/React.createElement(route.HydrateFallback),\n      HydrateFallback: undefined\n    });\n  }\n  if (route.ErrorBoundary) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.errorElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" + \"`ErrorBoundary` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      errorElement: /*#__PURE__*/React.createElement(route.ErrorBoundary),\n      ErrorBoundary: undefined\n    });\n  }\n  return updates;\n}\nfunction createMemoryRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createMemoryHistory({\n      initialEntries: opts == null ? void 0 : opts.initialEntries,\n      initialIndex: opts == null ? void 0 : opts.initialIndex\n    }),\n    hydrationData: opts == null ? void 0 : opts.hydrationData,\n    routes,\n    mapRouteProperties,\n    dataStrategy: opts == null ? void 0 : opts.dataStrategy,\n    patchRoutesOnNavigation: opts == null ? void 0 : opts.patchRoutesOnNavigation\n  }).initialize();\n}\n\nexport { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, logV6DeprecationWarnings as UNSAFE_logV6DeprecationWarnings, mapRouteProperties as UNSAFE_mapRouteProperties, useRouteId as UNSAFE_useRouteId, useRoutesImpl as UNSAFE_useRoutesImpl, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };\n//# sourceMappingURL=index.js.map\n","\"use strict\";\n\n/* istanbul ignore next  */\nfunction apply(styleElement, options, obj) {\n  var css = \"\";\n  if (obj.supports) {\n    css += \"@supports (\".concat(obj.supports, \") {\");\n  }\n  if (obj.media) {\n    css += \"@media \".concat(obj.media, \" {\");\n  }\n  var needLayer = typeof obj.layer !== \"undefined\";\n  if (needLayer) {\n    css += \"@layer\".concat(obj.layer.length > 0 ? \" \".concat(obj.layer) : \"\", \" {\");\n  }\n  css += obj.css;\n  if (needLayer) {\n    css += \"}\";\n  }\n  if (obj.media) {\n    css += \"}\";\n  }\n  if (obj.supports) {\n    css += \"}\";\n  }\n  var sourceMap = obj.sourceMap;\n  if (sourceMap && typeof btoa !== \"undefined\") {\n    css += \"\\n/*# sourceMappingURL=data:application/json;base64,\".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), \" */\");\n  }\n\n  // For old IE\n  /* istanbul ignore if  */\n  options.styleTagTransform(css, styleElement, options.options);\n}\nfunction removeStyleElement(styleElement) {\n  // istanbul ignore if\n  if (styleElement.parentNode === null) {\n    return false;\n  }\n  styleElement.parentNode.removeChild(styleElement);\n}\n\n/* istanbul ignore next  */\nfunction domAPI(options) {\n  if (typeof document === \"undefined\") {\n    return {\n      update: function update() {},\n      remove: function remove() {}\n    };\n  }\n  var styleElement = options.insertStyleElement(options);\n  return {\n    update: function update(obj) {\n      apply(styleElement, options, obj);\n    },\n    remove: function remove() {\n      removeStyleElement(styleElement);\n    }\n  };\n}\nmodule.exports = domAPI;","module.exports = __WEBPACK_EXTERNAL_MODULE__831__;","module.exports = __WEBPACK_EXTERNAL_MODULE__867__;","module.exports = __WEBPACK_EXTERNAL_MODULE__936__;","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, `hr {\n  border: 0;\n  margin-bottom: 10px;\n  border-top: 1px solid var(--color-bg-dark);\n}\n`, \"\",{\"version\":3,\"sources\":[\"webpack://./src/context/focusPeriod/focusPeriod.css\"],\"names\":[],\"mappings\":\"AAAA;EACE,SAAS;EACT,mBAAmB;EACnB,0CAA0C;AAC5C\",\"sourcesContent\":[\"hr {\\n  border: 0;\\n  margin-bottom: 10px;\\n  border-top: 1px solid var(--color-bg-dark);\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","__webpack_require__.y = __system_context__;","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \".market-portfolio.js\";\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.p = \"\";","// no baseURI\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t792: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunkportfolio\"] = self[\"webpackChunkportfolio\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","__webpack_require__.nc = undefined;","const autoPublicPath = require(\"./auto-public-path\").autoPublicPath;\n\nautoPublicPath(1);\n","function e(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var o=Object.getOwnPropertySymbols(e);t&&(o=o.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,o)}return n}function t(t){for(var n=1;n<arguments.length;n++){var r=null!=arguments[n]?arguments[n]:{};n%2?e(Object(r),!0).forEach((function(e){o(t,e,r[e])})):Object.getOwnPropertyDescriptors?Object.defineProperties(t,Object.getOwnPropertyDescriptors(r)):e(Object(r)).forEach((function(e){Object.defineProperty(t,e,Object.getOwnPropertyDescriptor(r,e))}))}return t}function n(e){return(n=\"function\"==typeof Symbol&&\"symbol\"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&\"function\"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?\"symbol\":typeof e})(e)}function o(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function r(e){return(r=\"function\"==typeof Symbol&&\"symbol\"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&\"function\"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?\"symbol\":typeof e})(e)}function a(e,t){var n;if(\"function\"!=typeof(n=t.domElement?function(){return t.domElement}:t.domElementGetter?t.domElementGetter:e.domElementGetter?e.domElementGetter:function(e){var t=e.appName||e.name;if(!t)throw Error(\"single-spa's dom-element-getter-helpers was not given an application name as a prop, so it can't make a unique dom element container for the react application\");var n=\"single-spa-application:\".concat(t);return function(){var e=document.getElementById(n);return e||((e=document.createElement(\"div\")).id=n,document.body.appendChild(e)),e}}(t)))throw Error(\"single-spa's dom-element-getter-helpers was given an invalid domElementGetter for application or parcel '\".concat(t.name,\"'. Expected a function, received \").concat(r(n)));return function(){var e=n(t);if(!(e instanceof HTMLElement))throw Error(\"single-spa's dom-element-getter-helpers: domElementGetter returned an invalid dom element for application or parcel '\".concat(t.name,\"'. Expected HTMLElement, received \").concat(r(e)));return e}}var c=null;try{c=require(\"react\").createContext()}catch(e){}var u={React:null,ReactDOM:null,ReactDOMClient:null,rootComponent:null,loadRootComponent:null,errorBoundary:null,errorBoundaryClass:null,domElementGetter:null,parcelCanUpdate:!0,suppressComponentDidCatchWarning:!1,domElements:{},renderResults:{},updateResolves:{},unmountResolves:{}};function i(e){if(\"object\"!==n(e))throw new Error(\"single-spa-react requires a configuration object\");var o,r=t(t({},u),e);if(!r.React)throw new Error(\"single-spa-react must be passed opts.React\");if(!r.ReactDOM&&!r.ReactDOMClient)throw new Error(\"single-spa-react must be passed opts.ReactDOM or opts.ReactDOMClient\");r.renderType||(null!==(o=r.ReactDOMClient)&&void 0!==o&&o.createRoot?r.renderType=\"createRoot\":r.renderType=\"render\");if(!r.rootComponent&&!r.loadRootComponent)throw new Error(\"single-spa-react must be passed opts.rootComponent or opts.loadRootComponent\");if(r.errorBoundary&&\"function\"!=typeof r.errorBoundary)throw Error(\"The errorBoundary opt for single-spa-react must either be omitted or be a function that returns React elements\");!c&&r.React.createContext&&(c=r.React.createContext()),r.SingleSpaRoot=function(e){function t(e){t.displayName=\"SingleSpaRoot(\".concat(e.name,\")\")}return t.prototype=Object.create(e.React.Component.prototype),t.prototype.componentDidMount=function(){setTimeout(this.props.mountFinished)},t.prototype.componentWillUnmount=function(){setTimeout(this.props.unmountFinished)},t.prototype.render=function(){return setTimeout(this.props.updateFinished),this.props.children},t}(r);var a={bootstrap:s.bind(null,r),mount:p.bind(null,r),unmount:l.bind(null,r)};return r.parcelCanUpdate&&(a.update=m.bind(null,r)),a}function s(e,t){return e.rootComponent?Promise.resolve():e.loadRootComponent(t).then((function(t){e.rootComponent=t}))}function p(e,t){return new Promise((function(n,o){e.suppressComponentDidCatchWarning||!function(e){if(!(e&&\"string\"==typeof e.version&&e.version.indexOf(\".\")>=0))return!1;var t=e.version.slice(0,e.version.indexOf(\".\"));try{return Number(t)>=16}catch(e){return!1}}(e.React)||e.errorBoundary||e.errorBoundaryClass||(e.rootComponent.prototype?e.rootComponent.prototype.componentDidCatch||console.warn(\"single-spa-react: \".concat(t.name||t.appName||t.childAppName,\"'s rootComponent should implement componentDidCatch to avoid accidentally unmounting the entire single-spa application.\")):console.warn(\"single-spa-react: \".concat(t.name||t.appName||t.childAppName,\"'s rootComponent does not implement an error boundary.  If using a functional component, consider providing an opts.errorBoundary to singleSpaReact(opts).\")));var r=y(e,t,(function(){n(this)})),c=a(e,t)(),u=function(e){var t=e.reactDom,n=e.renderType,o=e.elementToRender,r=e.domElement,a=t[n];if(\"function\"!=typeof a)throw new Error('renderType \"'.concat(n,'\" did not return a function.'));switch(n){case\"createRoot\":case\"unstable_createRoot\":case\"createBlockingRoot\":case\"unstable_createBlockingRoot\":var c=a(r);return c.render(o),c;case\"hydrateRoot\":return a(r,o);case\"hydrate\":default:return a(o,r),null}}({elementToRender:r,domElement:c,reactDom:d(e),renderType:f(e)});e.domElements[t.name]=c,e.renderResults[t.name]=u}))}function l(e,t){return new Promise((function(n){e.unmountResolves[t.name]=n;var o=e.renderResults[t.name];o&&o.unmount?o.unmount():d(e).unmountComponentAtNode(e.domElements[t.name]),delete e.domElements[t.name],delete e.renderResults[t.name]}))}function m(e,t){return new Promise((function(n){e.updateResolves[t.name]||(e.updateResolves[t.name]=[]),e.updateResolves[t.name].push(n);var o=y(e,t,null),r=e.renderResults[t.name];if(r&&r.render)r.render(o);else{var c=a(e,t)();d(e).render(o,c)}}))}function d(e){return e.ReactDOMClient||e.ReactDOM}function f(e){return\"function\"==typeof e.renderType?e.renderType():e.renderType}function y(e,n,o){var r=e.React.createElement(e.rootComponent,n),a=c?e.React.createElement(c.Provider,{value:n},r):r;return(e.errorBoundary||n.errorBoundary||e.errorBoundaryClass||n.errorBoundaryClass)&&(e.errorBoundaryClass=e.errorBoundaryClass||n.errorBoundaryClass||function(e,t){function n(t){e.React.Component.apply(this,arguments),this.state={caughtError:null,caughtErrorInfo:null},n.displayName=\"SingleSpaReactErrorBoundary(\".concat(t.name,\")\")}return n.prototype=Object.create(e.React.Component.prototype),n.prototype.render=function(){return this.state.caughtError?(e.errorBoundary||t.errorBoundary)(this.state.caughtError,this.state.caughtErrorInfo,this.props):this.props.children},n.prototype.componentDidCatch=function(e,t){this.setState({caughtError:e,caughtErrorInfo:t})},n}(e,n),a=e.React.createElement(e.errorBoundaryClass,n,a)),a=e.React.createElement(e.SingleSpaRoot,t(t({},n),{},{mountFinished:o,updateFinished:function(){e.updateResolves[n.name]&&(e.updateResolves[n.name].forEach((function(e){return e()})),delete e.updateResolves[n.name])},unmountFinished:function(){e.unmountResolves[n.name]&&(e.unmountResolves[n.name](),delete e.unmountResolves[n.name])}}),a)}export{c as SingleSpaContext,i as default};\n//# sourceMappingURL=single-spa-react.js.map\n","/**\n * React Router DOM v6.30.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { UNSAFE_mapRouteProperties, UNSAFE_logV6DeprecationWarnings, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, Router, UNSAFE_useRoutesImpl, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, useBlocker } from 'react-router';\nexport { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, replace, resolvePath, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';\nimport { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, UNSAFE_ErrorResponseImpl, UNSAFE_invariant, joinPaths, IDLE_FETCHER, matchPath } from '@remix-run/router';\nexport { UNSAFE_ErrorResponseImpl } from '@remix-run/router';\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\n\nconst defaultMethod = \"get\";\nconst defaultEncType = \"application/x-www-form-urlencoded\";\nfunction isHtmlElement(object) {\n  return object != null && typeof object.tagName === \"string\";\n}\nfunction isButtonElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\nfunction isFormElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\nfunction isInputElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\nfunction shouldProcessLinkClick(event, target) {\n  return event.button === 0 && (\n  // Ignore everything but left clicks\n  !target || target === \"_self\") &&\n  // Let browser handle \"target=_blank\" etc.\n  !isModifiedEvent(event) // Ignore clicks with modifier keys\n  ;\n}\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\nfunction createSearchParams(init) {\n  if (init === void 0) {\n    init = \"\";\n  }\n  return new URLSearchParams(typeof init === \"string\" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {\n    let value = init[key];\n    return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);\n  }, []));\n}\nfunction getSearchParamsForLocation(locationSearch, defaultSearchParams) {\n  let searchParams = createSearchParams(locationSearch);\n  if (defaultSearchParams) {\n    // Use `defaultSearchParams.forEach(...)` here instead of iterating of\n    // `defaultSearchParams.keys()` to work-around a bug in Firefox related to\n    // web extensions. Relevant Bugzilla tickets:\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984\n    defaultSearchParams.forEach((_, key) => {\n      if (!searchParams.has(key)) {\n        defaultSearchParams.getAll(key).forEach(value => {\n          searchParams.append(key, value);\n        });\n      }\n    });\n  }\n  return searchParams;\n}\n// One-time check for submitter support\nlet _formDataSupportsSubmitter = null;\nfunction isFormDataSubmitterSupported() {\n  if (_formDataSupportsSubmitter === null) {\n    try {\n      new FormData(document.createElement(\"form\"),\n      // @ts-expect-error if FormData supports the submitter parameter, this will throw\n      0);\n      _formDataSupportsSubmitter = false;\n    } catch (e) {\n      _formDataSupportsSubmitter = true;\n    }\n  }\n  return _formDataSupportsSubmitter;\n}\nconst supportedFormEncTypes = new Set([\"application/x-www-form-urlencoded\", \"multipart/form-data\", \"text/plain\"]);\nfunction getFormEncType(encType) {\n  if (encType != null && !supportedFormEncTypes.has(encType)) {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"\\\"\" + encType + \"\\\" is not a valid `encType` for `<Form>`/`<fetcher.Form>` \" + (\"and will default to \\\"\" + defaultEncType + \"\\\"\")) : void 0;\n    return null;\n  }\n  return encType;\n}\nfunction getFormSubmissionInfo(target, basename) {\n  let method;\n  let action;\n  let encType;\n  let formData;\n  let body;\n  if (isFormElement(target)) {\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n    formData = new FormData(target);\n  } else if (isButtonElement(target) || isInputElement(target) && (target.type === \"submit\" || target.type === \"image\")) {\n    let form = target.form;\n    if (form == null) {\n      throw new Error(\"Cannot submit a <button> or <input type=\\\"submit\\\"> without a <form>\");\n    }\n    // <button>/<input type=\"submit\"> may override attributes of <form>\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"formaction\") || form.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"formmethod\") || form.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"formenctype\")) || getFormEncType(form.getAttribute(\"enctype\")) || defaultEncType;\n    // Build a FormData object populated from a form and submitter\n    formData = new FormData(form, target);\n    // If this browser doesn't support the `FormData(el, submitter)` format,\n    // then tack on the submitter value at the end.  This is a lightweight\n    // solution that is not 100% spec compliant.  For complete support in older\n    // browsers, consider using the `formdata-submitter-polyfill` package\n    if (!isFormDataSubmitterSupported()) {\n      let {\n        name,\n        type,\n        value\n      } = target;\n      if (type === \"image\") {\n        let prefix = name ? name + \".\" : \"\";\n        formData.append(prefix + \"x\", \"0\");\n        formData.append(prefix + \"y\", \"0\");\n      } else if (name) {\n        formData.append(name, value);\n      }\n    }\n  } else if (isHtmlElement(target)) {\n    throw new Error(\"Cannot submit element that is not <form>, <button>, or \" + \"<input type=\\\"submit|image\\\">\");\n  } else {\n    method = defaultMethod;\n    action = null;\n    encType = defaultEncType;\n    body = target;\n  }\n  // Send body for <Form encType=\"text/plain\" so we encode it into text\n  if (formData && encType === \"text/plain\") {\n    body = formData;\n    formData = undefined;\n  }\n  return {\n    action,\n    method: method.toLowerCase(),\n    encType,\n    formData,\n    body\n  };\n}\n\nconst _excluded = [\"onClick\", \"relative\", \"reloadDocument\", \"replace\", \"state\", \"target\", \"to\", \"preventScrollReset\", \"viewTransition\"],\n  _excluded2 = [\"aria-current\", \"caseSensitive\", \"className\", \"end\", \"style\", \"to\", \"viewTransition\", \"children\"],\n  _excluded3 = [\"fetcherKey\", \"navigate\", \"reloadDocument\", \"replace\", \"state\", \"method\", \"action\", \"onSubmit\", \"relative\", \"preventScrollReset\", \"viewTransition\"];\n// HEY YOU! DON'T TOUCH THIS VARIABLE!\n//\n// It is replaced with the proper version at build time via a babel plugin in\n// the rollup config.\n//\n// Export a global property onto the window for React Router detection by the\n// Core Web Vitals Technology Report.  This way they can configure the `wappalyzer`\n// to detect and properly classify live websites as being built with React Router:\n// https://github.com/HTTPArchive/wappalyzer/blob/main/src/technologies/r.json\nconst REACT_ROUTER_VERSION = \"6\";\ntry {\n  window.__reactRouterVersion = REACT_ROUTER_VERSION;\n} catch (e) {\n  // no-op\n}\nfunction createBrowserRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createBrowserHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    mapRouteProperties: UNSAFE_mapRouteProperties,\n    dataStrategy: opts == null ? void 0 : opts.dataStrategy,\n    patchRoutesOnNavigation: opts == null ? void 0 : opts.patchRoutesOnNavigation,\n    window: opts == null ? void 0 : opts.window\n  }).initialize();\n}\nfunction createHashRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createHashHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    mapRouteProperties: UNSAFE_mapRouteProperties,\n    dataStrategy: opts == null ? void 0 : opts.dataStrategy,\n    patchRoutesOnNavigation: opts == null ? void 0 : opts.patchRoutesOnNavigation,\n    window: opts == null ? void 0 : opts.window\n  }).initialize();\n}\nfunction parseHydrationData() {\n  var _window;\n  let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;\n  if (state && state.errors) {\n    state = _extends({}, state, {\n      errors: deserializeErrors(state.errors)\n    });\n  }\n  return state;\n}\nfunction deserializeErrors(errors) {\n  if (!errors) return null;\n  let entries = Object.entries(errors);\n  let serialized = {};\n  for (let [key, val] of entries) {\n    // Hey you!  If you change this, please change the corresponding logic in\n    // serializeErrors in react-router-dom/server.tsx :)\n    if (val && val.__type === \"RouteErrorResponse\") {\n      serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true);\n    } else if (val && val.__type === \"Error\") {\n      // Attempt to reconstruct the right type of Error (i.e., ReferenceError)\n      if (val.__subType) {\n        let ErrorConstructor = window[val.__subType];\n        if (typeof ErrorConstructor === \"function\") {\n          try {\n            // @ts-expect-error\n            let error = new ErrorConstructor(val.message);\n            // Wipe away the client-side stack trace.  Nothing to fill it in with\n            // because we don't serialize SSR stack traces for security reasons\n            error.stack = \"\";\n            serialized[key] = error;\n          } catch (e) {\n            // no-op - fall through and create a normal Error\n          }\n        }\n      }\n      if (serialized[key] == null) {\n        let error = new Error(val.message);\n        // Wipe away the client-side stack trace.  Nothing to fill it in with\n        // because we don't serialize SSR stack traces for security reasons\n        error.stack = \"\";\n        serialized[key] = error;\n      }\n    } else {\n      serialized[key] = val;\n    }\n  }\n  return serialized;\n}\nconst ViewTransitionContext = /*#__PURE__*/React.createContext({\n  isTransitioning: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  ViewTransitionContext.displayName = \"ViewTransition\";\n}\nconst FetchersContext = /*#__PURE__*/React.createContext(new Map());\nif (process.env.NODE_ENV !== \"production\") {\n  FetchersContext.displayName = \"Fetchers\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Components\n////////////////////////////////////////////////////////////////////////////////\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\nconst FLUSH_SYNC = \"flushSync\";\nconst flushSyncImpl = ReactDOM[FLUSH_SYNC];\nconst USE_ID = \"useId\";\nconst useIdImpl = React[USE_ID];\nfunction startTransitionSafe(cb) {\n  if (startTransitionImpl) {\n    startTransitionImpl(cb);\n  } else {\n    cb();\n  }\n}\nfunction flushSyncSafe(cb) {\n  if (flushSyncImpl) {\n    flushSyncImpl(cb);\n  } else {\n    cb();\n  }\n}\nclass Deferred {\n  constructor() {\n    this.status = \"pending\";\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = value => {\n        if (this.status === \"pending\") {\n          this.status = \"resolved\";\n          resolve(value);\n        }\n      };\n      this.reject = reason => {\n        if (this.status === \"pending\") {\n          this.status = \"rejected\";\n          reject(reason);\n        }\n      };\n    });\n  }\n}\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let [pendingState, setPendingState] = React.useState();\n  let [vtContext, setVtContext] = React.useState({\n    isTransitioning: false\n  });\n  let [renderDfd, setRenderDfd] = React.useState();\n  let [transition, setTransition] = React.useState();\n  let [interruption, setInterruption] = React.useState();\n  let fetcherData = React.useRef(new Map());\n  let {\n    v7_startTransition\n  } = future || {};\n  let optInStartTransition = React.useCallback(cb => {\n    if (v7_startTransition) {\n      startTransitionSafe(cb);\n    } else {\n      cb();\n    }\n  }, [v7_startTransition]);\n  let setState = React.useCallback((newState, _ref2) => {\n    let {\n      deletedFetchers,\n      flushSync: flushSync,\n      viewTransitionOpts: viewTransitionOpts\n    } = _ref2;\n    newState.fetchers.forEach((fetcher, key) => {\n      if (fetcher.data !== undefined) {\n        fetcherData.current.set(key, fetcher.data);\n      }\n    });\n    deletedFetchers.forEach(key => fetcherData.current.delete(key));\n    let isViewTransitionUnavailable = router.window == null || router.window.document == null || typeof router.window.document.startViewTransition !== \"function\";\n    // If this isn't a view transition or it's not available in this browser,\n    // just update and be done with it\n    if (!viewTransitionOpts || isViewTransitionUnavailable) {\n      if (flushSync) {\n        flushSyncSafe(() => setStateImpl(newState));\n      } else {\n        optInStartTransition(() => setStateImpl(newState));\n      }\n      return;\n    }\n    // flushSync + startViewTransition\n    if (flushSync) {\n      // Flush through the context to mark DOM elements as transition=ing\n      flushSyncSafe(() => {\n        // Cancel any pending transitions\n        if (transition) {\n          renderDfd && renderDfd.resolve();\n          transition.skipTransition();\n        }\n        setVtContext({\n          isTransitioning: true,\n          flushSync: true,\n          currentLocation: viewTransitionOpts.currentLocation,\n          nextLocation: viewTransitionOpts.nextLocation\n        });\n      });\n      // Update the DOM\n      let t = router.window.document.startViewTransition(() => {\n        flushSyncSafe(() => setStateImpl(newState));\n      });\n      // Clean up after the animation completes\n      t.finished.finally(() => {\n        flushSyncSafe(() => {\n          setRenderDfd(undefined);\n          setTransition(undefined);\n          setPendingState(undefined);\n          setVtContext({\n            isTransitioning: false\n          });\n        });\n      });\n      flushSyncSafe(() => setTransition(t));\n      return;\n    }\n    // startTransition + startViewTransition\n    if (transition) {\n      // Interrupting an in-progress transition, cancel and let everything flush\n      // out, and then kick off a new transition from the interruption state\n      renderDfd && renderDfd.resolve();\n      transition.skipTransition();\n      setInterruption({\n        state: newState,\n        currentLocation: viewTransitionOpts.currentLocation,\n        nextLocation: viewTransitionOpts.nextLocation\n      });\n    } else {\n      // Completed navigation update with opted-in view transitions, let 'er rip\n      setPendingState(newState);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: viewTransitionOpts.currentLocation,\n        nextLocation: viewTransitionOpts.nextLocation\n      });\n    }\n  }, [router.window, transition, renderDfd, fetcherData, optInStartTransition]);\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n  // When we start a view transition, create a Deferred we can use for the\n  // eventual \"completed\" render\n  React.useEffect(() => {\n    if (vtContext.isTransitioning && !vtContext.flushSync) {\n      setRenderDfd(new Deferred());\n    }\n  }, [vtContext]);\n  // Once the deferred is created, kick off startViewTransition() to update the\n  // DOM and then wait on the Deferred to resolve (indicating the DOM update has\n  // happened)\n  React.useEffect(() => {\n    if (renderDfd && pendingState && router.window) {\n      let newState = pendingState;\n      let renderPromise = renderDfd.promise;\n      let transition = router.window.document.startViewTransition(async () => {\n        optInStartTransition(() => setStateImpl(newState));\n        await renderPromise;\n      });\n      transition.finished.finally(() => {\n        setRenderDfd(undefined);\n        setTransition(undefined);\n        setPendingState(undefined);\n        setVtContext({\n          isTransitioning: false\n        });\n      });\n      setTransition(transition);\n    }\n  }, [optInStartTransition, pendingState, renderDfd, router.window]);\n  // When the new location finally renders and is committed to the DOM, this\n  // effect will run to resolve the transition\n  React.useEffect(() => {\n    if (renderDfd && pendingState && state.location.key === pendingState.location.key) {\n      renderDfd.resolve();\n    }\n  }, [renderDfd, transition, state.location, pendingState]);\n  // If we get interrupted with a new navigation during a transition, we skip\n  // the active transition, let it cleanup, then kick it off again here\n  React.useEffect(() => {\n    if (!vtContext.isTransitioning && interruption) {\n      setPendingState(interruption.state);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: interruption.currentLocation,\n        nextLocation: interruption.nextLocation\n      });\n      setInterruption(undefined);\n    }\n  }, [vtContext.isTransitioning, interruption]);\n  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\n  let routerFuture = React.useMemo(() => ({\n    v7_relativeSplatPath: router.future.v7_relativeSplatPath\n  }), [router.future.v7_relativeSplatPath]);\n  React.useEffect(() => UNSAFE_logV6DeprecationWarnings(future, router.future), [future, router.future]);\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(UNSAFE_DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(UNSAFE_DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(FetchersContext.Provider, {\n    value: fetcherData.current\n  }, /*#__PURE__*/React.createElement(ViewTransitionContext.Provider, {\n    value: vtContext\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    location: state.location,\n    navigationType: state.historyAction,\n    navigator: navigator,\n    future: routerFuture\n  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(MemoizedDataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))))), null);\n}\n// Memoize to avoid re-renders when updating `ViewTransitionContext`\nconst MemoizedDataRoutes = /*#__PURE__*/React.memo(DataRoutes);\nfunction DataRoutes(_ref3) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref3;\n  return UNSAFE_useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nfunction BrowserRouter(_ref4) {\n  let {\n    basename,\n    children,\n    future,\n    window\n  } = _ref4;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({\n      window,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  React.useEffect(() => UNSAFE_logV6DeprecationWarnings(future), [future]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nfunction HashRouter(_ref5) {\n  let {\n    basename,\n    children,\n    future,\n    window\n  } = _ref5;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({\n      window,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  React.useEffect(() => UNSAFE_logV6DeprecationWarnings(future), [future]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter(_ref6) {\n  let {\n    basename,\n    children,\n    future,\n    history\n  } = _ref6;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  React.useEffect(() => UNSAFE_logV6DeprecationWarnings(future), [future]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\nif (process.env.NODE_ENV !== \"production\") {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n/**\n * The public API for rendering a history-aware `<a>`.\n */\nconst Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref7, ref) {\n  let {\n      onClick,\n      relative,\n      reloadDocument,\n      replace,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      viewTransition\n    } = _ref7,\n    rest = _objectWithoutPropertiesLoose(_ref7, _excluded);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  // Rendered into <a href> for absolute URLs\n  let absoluteHref;\n  let isExternal = false;\n  if (typeof to === \"string\" && ABSOLUTE_URL_REGEX.test(to)) {\n    // Render the absolute href server- and client-side\n    absoluteHref = to;\n    // Only check for external origins client-side\n    if (isBrowser) {\n      try {\n        let currentUrl = new URL(window.location.href);\n        let targetUrl = to.startsWith(\"//\") ? new URL(currentUrl.protocol + to) : new URL(to);\n        let path = stripBasename(targetUrl.pathname, basename);\n        if (targetUrl.origin === currentUrl.origin && path != null) {\n          // Strip the protocol/origin/basename for same-origin absolute URLs\n          to = path + targetUrl.search + targetUrl.hash;\n        } else {\n          isExternal = true;\n        }\n      } catch (e) {\n        // We can't do external URL detection without a valid URL\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"<Link to=\\\"\" + to + \"\\\"> contains an invalid URL which will probably break \" + \"when clicked - please update to a valid URL path.\") : void 0;\n      }\n    }\n  }\n  // Rendered into <a href> for relative URLs\n  let href = useHref(to, {\n    relative\n  });\n  let internalOnClick = useLinkClickHandler(to, {\n    replace,\n    state,\n    target,\n    preventScrollReset,\n    relative,\n    viewTransition\n  });\n  function handleClick(event) {\n    if (onClick) onClick(event);\n    if (!event.defaultPrevented) {\n      internalOnClick(event);\n    }\n  }\n  return (\n    /*#__PURE__*/\n    // eslint-disable-next-line jsx-a11y/anchor-has-content\n    React.createElement(\"a\", _extends({}, rest, {\n      href: absoluteHref || href,\n      onClick: isExternal || reloadDocument ? onClick : handleClick,\n      ref: ref,\n      target: target\n    }))\n  );\n});\nif (process.env.NODE_ENV !== \"production\") {\n  Link.displayName = \"Link\";\n}\n/**\n * A `<Link>` wrapper that knows if it's \"active\" or not.\n */\nconst NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref8, ref) {\n  let {\n      \"aria-current\": ariaCurrentProp = \"page\",\n      caseSensitive = false,\n      className: classNameProp = \"\",\n      end = false,\n      style: styleProp,\n      to,\n      viewTransition,\n      children\n    } = _ref8,\n    rest = _objectWithoutPropertiesLoose(_ref8, _excluded2);\n  let path = useResolvedPath(to, {\n    relative: rest.relative\n  });\n  let location = useLocation();\n  let routerState = React.useContext(UNSAFE_DataRouterStateContext);\n  let {\n    navigator,\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let isTransitioning = routerState != null &&\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  useViewTransitionState(path) && viewTransition === true;\n  let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;\n  let locationPathname = location.pathname;\n  let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;\n  if (!caseSensitive) {\n    locationPathname = locationPathname.toLowerCase();\n    nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;\n    toPathname = toPathname.toLowerCase();\n  }\n  if (nextLocationPathname && basename) {\n    nextLocationPathname = stripBasename(nextLocationPathname, basename) || nextLocationPathname;\n  }\n  // If the `to` has a trailing slash, look at that exact spot.  Otherwise,\n  // we're looking for a slash _after_ what's in `to`.  For example:\n  //\n  // <NavLink to=\"/users\"> and <NavLink to=\"/users/\">\n  // both want to look for a / at index 6 to match URL `/users/matt`\n  const endSlashPosition = toPathname !== \"/\" && toPathname.endsWith(\"/\") ? toPathname.length - 1 : toPathname.length;\n  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(endSlashPosition) === \"/\";\n  let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === \"/\");\n  let renderProps = {\n    isActive,\n    isPending,\n    isTransitioning\n  };\n  let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n  let className;\n  if (typeof classNameProp === \"function\") {\n    className = classNameProp(renderProps);\n  } else {\n    // If the className prop is not a function, we use a default `active`\n    // class for <NavLink />s that are active. In v5 `active` was the default\n    // value for `activeClassName`, but we are removing that API and can still\n    // use the old default behavior for a cleaner upgrade path and keep the\n    // simple styling rules working as they currently do.\n    className = [classNameProp, isActive ? \"active\" : null, isPending ? \"pending\" : null, isTransitioning ? \"transitioning\" : null].filter(Boolean).join(\" \");\n  }\n  let style = typeof styleProp === \"function\" ? styleProp(renderProps) : styleProp;\n  return /*#__PURE__*/React.createElement(Link, _extends({}, rest, {\n    \"aria-current\": ariaCurrent,\n    className: className,\n    ref: ref,\n    style: style,\n    to: to,\n    viewTransition: viewTransition\n  }), typeof children === \"function\" ? children(renderProps) : children);\n});\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n}\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\nconst Form = /*#__PURE__*/React.forwardRef((_ref9, forwardedRef) => {\n  let {\n      fetcherKey,\n      navigate,\n      reloadDocument,\n      replace,\n      state,\n      method = defaultMethod,\n      action,\n      onSubmit,\n      relative,\n      preventScrollReset,\n      viewTransition\n    } = _ref9,\n    props = _objectWithoutPropertiesLoose(_ref9, _excluded3);\n  let submit = useSubmit();\n  let formAction = useFormAction(action, {\n    relative\n  });\n  let formMethod = method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n  let submitHandler = event => {\n    onSubmit && onSubmit(event);\n    if (event.defaultPrevented) return;\n    event.preventDefault();\n    let submitter = event.nativeEvent.submitter;\n    let submitMethod = (submitter == null ? void 0 : submitter.getAttribute(\"formmethod\")) || method;\n    submit(submitter || event.currentTarget, {\n      fetcherKey,\n      method: submitMethod,\n      navigate,\n      replace,\n      state,\n      relative,\n      preventScrollReset,\n      viewTransition\n    });\n  };\n  return /*#__PURE__*/React.createElement(\"form\", _extends({\n    ref: forwardedRef,\n    method: formMethod,\n    action: formAction,\n    onSubmit: reloadDocument ? onSubmit : submitHandler\n  }, props));\n});\nif (process.env.NODE_ENV !== \"production\") {\n  Form.displayName = \"Form\";\n}\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\nfunction ScrollRestoration(_ref10) {\n  let {\n    getKey,\n    storageKey\n  } = _ref10;\n  useScrollRestoration({\n    getKey,\n    storageKey\n  });\n  return null;\n}\nif (process.env.NODE_ENV !== \"production\") {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\nvar DataRouterHook;\n(function (DataRouterHook) {\n  DataRouterHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n  DataRouterHook[\"UseSubmit\"] = \"useSubmit\";\n  DataRouterHook[\"UseSubmitFetcher\"] = \"useSubmitFetcher\";\n  DataRouterHook[\"UseFetcher\"] = \"useFetcher\";\n  DataRouterHook[\"useViewTransitionState\"] = \"useViewTransitionState\";\n})(DataRouterHook || (DataRouterHook = {}));\nvar DataRouterStateHook;\n(function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseFetcher\"] = \"useFetcher\";\n  DataRouterStateHook[\"UseFetchers\"] = \"useFetchers\";\n  DataRouterStateHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n})(DataRouterStateHook || (DataRouterStateHook = {}));\n// Internal hooks\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/v6/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(UNSAFE_DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(UNSAFE_DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\n// External hooks\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nfunction useLinkClickHandler(to, _temp) {\n  let {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative,\n    viewTransition\n  } = _temp === void 0 ? {} : _temp;\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to, {\n    relative\n  });\n  return React.useCallback(event => {\n    if (shouldProcessLinkClick(event, target)) {\n      event.preventDefault();\n      // If the URL hasn't changed, a regular <a> will do a replace instead of\n      // a push, so do the same here unless the replace prop is explicitly set\n      let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);\n      navigate(to, {\n        replace,\n        state,\n        preventScrollReset,\n        relative,\n        viewTransition\n      });\n    }\n  }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, viewTransition]);\n}\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nfunction useSearchParams(defaultInit) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(typeof URLSearchParams !== \"undefined\", \"You cannot use the `useSearchParams` hook in a browser that does not \" + \"support the URLSearchParams API. If you need to support Internet \" + \"Explorer 11, we recommend you load a polyfill such as \" + \"https://github.com/ungap/url-search-params.\") : void 0;\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n  let hasSetSearchParamsRef = React.useRef(false);\n  let location = useLocation();\n  let searchParams = React.useMemo(() =>\n  // Only merge in the defaults if we haven't yet called setSearchParams.\n  // Once we call that we want those to take precedence, otherwise you can't\n  // remove a param with setSearchParams({}) if it has an initial value\n  getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]);\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback((nextInit, navigateOptions) => {\n    const newSearchParams = createSearchParams(typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit);\n    hasSetSearchParamsRef.current = true;\n    navigate(\"?\" + newSearchParams, navigateOptions);\n  }, [navigate, searchParams]);\n  return [searchParams, setSearchParams];\n}\nfunction validateClientSideSubmission() {\n  if (typeof document === \"undefined\") {\n    throw new Error(\"You are calling submit during the server render. \" + \"Try calling submit within a `useEffect` or callback instead.\");\n  }\n}\nlet fetcherId = 0;\nlet getUniqueFetcherId = () => \"__\" + String(++fetcherId) + \"__\";\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\nfunction useSubmit() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseSubmit);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let currentRouteId = UNSAFE_useRouteId();\n  return React.useCallback(function (target, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    validateClientSideSubmission();\n    let {\n      action,\n      method,\n      encType,\n      formData,\n      body\n    } = getFormSubmissionInfo(target, basename);\n    if (options.navigate === false) {\n      let key = options.fetcherKey || getUniqueFetcherId();\n      router.fetch(key, currentRouteId, options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || method,\n        formEncType: options.encType || encType,\n        flushSync: options.flushSync\n      });\n    } else {\n      router.navigate(options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || method,\n        formEncType: options.encType || encType,\n        replace: options.replace,\n        state: options.state,\n        fromRouteId: currentRouteId,\n        flushSync: options.flushSync,\n        viewTransition: options.viewTransition\n      });\n    }\n  }, [router, basename, currentRouteId]);\n}\n// v7: Eventually we should deprecate this entirely in favor of using the\n// router method directly?\nfunction useFormAction(action, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let routeContext = React.useContext(UNSAFE_RouteContext);\n  !routeContext ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFormAction must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  let [match] = routeContext.matches.slice(-1);\n  // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n  let path = _extends({}, useResolvedPath(action ? action : \".\", {\n    relative\n  }));\n  // If no action was specified, browsers will persist current search params\n  // when determining the path, so match that behavior\n  // https://github.com/remix-run/remix/issues/927\n  let location = useLocation();\n  if (action == null) {\n    // Safe to write to this directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    path.search = location.search;\n    // When grabbing search params from the URL, remove any included ?index param\n    // since it might not apply to our contextual route.  We add it back based\n    // on match.route.index below\n    let params = new URLSearchParams(path.search);\n    let indexValues = params.getAll(\"index\");\n    let hasNakedIndexParam = indexValues.some(v => v === \"\");\n    if (hasNakedIndexParam) {\n      params.delete(\"index\");\n      indexValues.filter(v => v).forEach(v => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? \"?\" + qs : \"\";\n    }\n  }\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the form action.  If this is a root navigation, then just use\n  // the raw basename which allows the basename to have full control over the\n  // presence of a trailing slash on root actions\n  if (basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// TODO: (v7) Change the useFetcher generic default from `any` to `unknown`\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\nfunction useFetcher(_temp3) {\n  var _route$matches;\n  let {\n    key\n  } = _temp3 === void 0 ? {} : _temp3;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseFetcher);\n  let state = useDataRouterState(DataRouterStateHook.UseFetcher);\n  let fetcherData = React.useContext(FetchersContext);\n  let route = React.useContext(UNSAFE_RouteContext);\n  let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;\n  !fetcherData ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a FetchersContext\") : UNSAFE_invariant(false) : void 0;\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  // Fetcher key handling\n  // OK to call conditionally to feature detect `useId`\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  let defaultKey = useIdImpl ? useIdImpl() : \"\";\n  let [fetcherKey, setFetcherKey] = React.useState(key || defaultKey);\n  if (key && key !== fetcherKey) {\n    setFetcherKey(key);\n  } else if (!fetcherKey) {\n    // We will only fall through here when `useId` is not available\n    setFetcherKey(getUniqueFetcherId());\n  }\n  // Registration/cleanup\n  React.useEffect(() => {\n    router.getFetcher(fetcherKey);\n    return () => {\n      // Tell the router we've unmounted - if v7_fetcherPersist is enabled this\n      // will not delete immediately but instead queue up a delete after the\n      // fetcher returns to an `idle` state\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\n  // Fetcher additions\n  let load = React.useCallback((href, opts) => {\n    !routeId ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No routeId available for fetcher.load()\") : UNSAFE_invariant(false) : void 0;\n    router.fetch(fetcherKey, routeId, href, opts);\n  }, [fetcherKey, routeId, router]);\n  let submitImpl = useSubmit();\n  let submit = React.useCallback((target, opts) => {\n    submitImpl(target, _extends({}, opts, {\n      navigate: false,\n      fetcherKey\n    }));\n  }, [fetcherKey, submitImpl]);\n  let FetcherForm = React.useMemo(() => {\n    let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => {\n      return /*#__PURE__*/React.createElement(Form, _extends({}, props, {\n        navigate: false,\n        fetcherKey: fetcherKey,\n        ref: ref\n      }));\n    });\n    if (process.env.NODE_ENV !== \"production\") {\n      FetcherForm.displayName = \"fetcher.Form\";\n    }\n    return FetcherForm;\n  }, [fetcherKey]);\n  // Exposed FetcherWithComponents\n  let fetcher = state.fetchers.get(fetcherKey) || IDLE_FETCHER;\n  let data = fetcherData.get(fetcherKey);\n  let fetcherWithComponents = React.useMemo(() => _extends({\n    Form: FetcherForm,\n    submit,\n    load\n  }, fetcher, {\n    data\n  }), [FetcherForm, submit, load, fetcher, data]);\n  return fetcherWithComponents;\n}\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\nfunction useFetchers() {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return Array.from(state.fetchers.entries()).map(_ref11 => {\n    let [key, fetcher] = _ref11;\n    return _extends({}, fetcher, {\n      key\n    });\n  });\n}\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions = {};\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\nfunction useScrollRestoration(_temp4) {\n  let {\n    getKey,\n    storageKey\n  } = _temp4 === void 0 ? {} : _temp4;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let {\n    restoreScrollPosition,\n    preventScrollReset\n  } = useDataRouterState(DataRouterStateHook.UseScrollRestoration);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation();\n  // Trigger manual scroll restoration while we're active\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []);\n  // Save positions on pagehide\n  usePageHide(React.useCallback(() => {\n    if (navigation.state === \"idle\") {\n      let key = (getKey ? getKey(location, matches) : null) || location.key;\n      savedScrollPositions[key] = window.scrollY;\n    }\n    try {\n      sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));\n    } catch (error) {\n      process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (\" + error + \").\") : void 0;\n    }\n    window.history.scrollRestoration = \"auto\";\n  }, [storageKey, getKey, navigation.state, location, matches]));\n  // Read in any saved scroll locations\n  if (typeof document !== \"undefined\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      try {\n        let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);\n        if (sessionPositions) {\n          savedScrollPositions = JSON.parse(sessionPositions);\n        }\n      } catch (e) {\n        // no-op, use default empty object\n      }\n    }, [storageKey]);\n    // Enable scroll restoration in the router\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      let getKeyWithoutBasename = getKey && basename !== \"/\" ? (location, matches) => getKey( // Strip the basename to match useLocation()\n      _extends({}, location, {\n        pathname: stripBasename(location.pathname, basename) || location.pathname\n      }), matches) : getKey;\n      let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename);\n      return () => disableScrollRestoration && disableScrollRestoration();\n    }, [router, basename, getKey]);\n    // Restore scrolling when state.restoreScrollPosition changes\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      // Explicit false means don't do anything (used for submissions)\n      if (restoreScrollPosition === false) {\n        return;\n      }\n      // been here before, scroll to it\n      if (typeof restoreScrollPosition === \"number\") {\n        window.scrollTo(0, restoreScrollPosition);\n        return;\n      }\n      // try to scroll to the hash\n      if (location.hash) {\n        let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));\n        if (el) {\n          el.scrollIntoView();\n          return;\n        }\n      }\n      // Don't reset if this navigation opted out\n      if (preventScrollReset === true) {\n        return;\n      }\n      // otherwise go to the top on new locations\n      window.scrollTo(0, 0);\n    }, [location, restoreScrollPosition, preventScrollReset]);\n  }\n}\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction useBeforeUnload(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"beforeunload\", callback, opts);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.  This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction usePageHide(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"pagehide\", callback, opts);\n    return () => {\n      window.removeEventListener(\"pagehide\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open.  Use at your own risk.\n */\nfunction usePrompt(_ref12) {\n  let {\n    when,\n    message\n  } = _ref12;\n  let blocker = useBlocker(when);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\") {\n      let proceed = window.confirm(message);\n      if (proceed) {\n        // This timeout is needed to avoid a weird \"race\" on POP navigations\n        // between the `window.history` revert navigation and the result of\n        // `window.confirm`\n        setTimeout(blocker.proceed, 0);\n      } else {\n        blocker.reset();\n      }\n    }\n  }, [blocker, message]);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\" && !when) {\n      blocker.reset();\n    }\n  }, [blocker, when]);\n}\n/**\n * Return a boolean indicating if there is an active view transition to the\n * given href.  You can use this value to render CSS classes or viewTransitionName\n * styles onto your elements\n *\n * @param href The destination href\n * @param [opts.relative] Relative routing type (\"route\" | \"path\")\n */\nfunction useViewTransitionState(to, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  let vtContext = React.useContext(ViewTransitionContext);\n  !(vtContext != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"`useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  \" + \"Did you accidentally import `RouterProvider` from `react-router`?\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename\n  } = useDataRouterContext(DataRouterHook.useViewTransitionState);\n  let path = useResolvedPath(to, {\n    relative: opts.relative\n  });\n  if (!vtContext.isTransitioning) {\n    return false;\n  }\n  let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;\n  let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;\n  // Transition is active if we're going to or coming from the indicated\n  // destination.  This ensures that other PUSH navigations that reverse\n  // an indicated transition apply.  I.e., on the list view you have:\n  //\n  //   <NavLink to=\"/details/1\" viewTransition>\n  //\n  // If you click the breadcrumb back to the list view:\n  //\n  //   <NavLink to=\"/list\" viewTransition>\n  //\n  // We should apply the transition because it's indicated as active going\n  // from /list -> /details/1 and therefore should be active on the reverse\n  // (even though this isn't strictly a POP reverse)\n  return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;\n}\n//#endregion\n\nexport { BrowserRouter, Form, HashRouter, Link, NavLink, RouterProvider, ScrollRestoration, FetchersContext as UNSAFE_FetchersContext, ViewTransitionContext as UNSAFE_ViewTransitionContext, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit, useViewTransitionState };\n//# sourceMappingURL=index.js.map\n","function _arrayLikeToArray(r, a) {\n  (null == a || a > r.length) && (a = r.length);\n  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n  return n;\n}\nexport { _arrayLikeToArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _unsupportedIterableToArray(r, a) {\n  if (r) {\n    if (\"string\" == typeof r) return arrayLikeToArray(r, a);\n    var t = {}.toString.call(r).slice(8, -1);\n    return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;\n  }\n}\nexport { _unsupportedIterableToArray as default };","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nfunction _toConsumableArray(r) {\n  return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();\n}\nexport { _toConsumableArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _arrayWithoutHoles(r) {\n  if (Array.isArray(r)) return arrayLikeToArray(r);\n}\nexport { _arrayWithoutHoles as default };","function _iterableToArray(r) {\n  if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nexport { _iterableToArray as default };","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableSpread as default };","function asyncGeneratorStep(n, t, e, r, o, a, c) {\n  try {\n    var i = n[a](c),\n      u = i.value;\n  } catch (n) {\n    return void e(n);\n  }\n  i.done ? t(u) : Promise.resolve(u).then(r, o);\n}\nfunction _asyncToGenerator(n) {\n  return function () {\n    var t = this,\n      e = arguments;\n    return new Promise(function (r, o) {\n      var a = n.apply(t, e);\n      function _next(n) {\n        asyncGeneratorStep(a, r, o, _next, _throw, \"next\", n);\n      }\n      function _throw(n) {\n        asyncGeneratorStep(a, r, o, _next, _throw, \"throw\", n);\n      }\n      _next(void 0);\n    });\n  };\n}\nexport { _asyncToGenerator as default };","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nfunction _slicedToArray(r, e) {\n  return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();\n}\nexport { _slicedToArray as default };","function _arrayWithHoles(r) {\n  if (Array.isArray(r)) return r;\n}\nexport { _arrayWithHoles as default };","function _iterableToArrayLimit(r, l) {\n  var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"];\n  if (null != t) {\n    var e,\n      n,\n      i,\n      u,\n      a = [],\n      f = !0,\n      o = !1;\n    try {\n      if (i = (t = t.call(r)).next, 0 === l) {\n        if (Object(t) !== t) return;\n        f = !1;\n      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);\n    } catch (r) {\n      o = !0, n = r;\n    } finally {\n      try {\n        if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return;\n      } finally {\n        if (o) throw n;\n      }\n    }\n    return a;\n  }\n}\nexport { _iterableToArrayLimit as default };","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableRest as default };","import React from 'react';\n\ntype SortIconsProps = {\n  sizePx?: number;\n  direction?: 'asc' | 'desc';\n};\n\nfunction SortIcon({ sizePx, direction }: SortIconsProps) {\n  let upArrowColor = '#DADDE3';\n  let downArrowColor = '#DADDE3';\n\n  if (direction === 'asc') {\n    upArrowColor = '#9499a3';\n  }\n  if (direction === 'desc') {\n    downArrowColor = '#9499a3';\n  }\n\n  return (\n    <svg\n      role=\"img\"\n      width={sizePx}\n      height={sizePx}\n      xmlns=\"http://www.w3.org/2000/svg\"\n      strokeWidth=\"0\"\n      viewBox=\"0 0 24 24\"\n    >\n      <path d=\"M7 14L12 20L17 14H7Z\" fill={upArrowColor} />\n      <path d=\"M17 10L12 4L7 10L17 10Z\" fill={downArrowColor} />\n    </svg>\n  );\n}\n\nexport { SortIcon };\n","\n      import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js??ruleSet[1].rules[1].use[1]!./markets.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js??ruleSet[1].rules[1].use[1]!./markets.css\";\n       export default content && content.locals ? content.locals : undefined;\n","import { logger } from '@ecosystem/newron-client-lib';\nimport { ContextSelectorMenu, ContextSettingSelectorProps, useEditContextSettings } from '@ecosystem/newron-core';\nimport { Entity, Periodicity, MarketPeriod as MarketPeriod2 } from '@ecosystem/newron-core/types';\nimport { actions, feedback, feedbackV2, inputs } from '@ecosystem/newron-design-system';\nimport React, { useEffect, useState } from 'react';\n\nimport { SortIcon } from '../assets/SortIcon';\n\nimport './markets.css';\nimport { Market, MarketPeriod } from './types';\n\nconst { Checkbox, CheckboxState, TextInput } = inputs;\nconst { Button } = actions;\nconst { DotsLoader, Tooltip } = feedback;\nconst { Alert } = feedbackV2;\n\nconst SEARCH_BAR_COUNT = 10;\nconst LOADING_OPACITY = 50;\nconst LOADED_OPACITY = 1;\nconst TOOLTIP_COUNT = 10;\n\ntype Header = {\n  label: string;\n  sortBy: SortBy;\n};\n\nenum SortBy {\n  productGroup,\n  country,\n  lastMonth,\n  lastWeek,\n}\n\nenum SortDirection {\n  ascending = 'asc',\n  descending = 'desc',\n}\n\nexport function MarketSelector({ onClose, onChange }: ContextSettingSelectorProps) {\n  const [isLoading, setLoading] = useState(true);\n\n  // State from Context Settings\n  const [markets, setMarkets] = useState<Market[]>([]);\n  const [selectedMarkets, setSelectedMarkets] = useState<Market[]>([]);\n\n  const { getContextSettings } = useEditContextSettings();\n\n  useEffect(() => {\n    const fetch = async () => {\n      try {\n        setLoading(true);\n        const settings = await getContextSettings(['openMarkets', 'cell']);\n        const markets: Market[] = settings['openMarkets'].definition.selection.options.filter(\n          opt => typeof opt !== 'string'\n        ) as Market[];\n        setMarkets(markets);\n\n        const cells = settings['cell'].values;\n        const selected: Market[] = [];\n        markets.forEach(market => {\n          if (cells.find(cell => cell.value === market.value)) {\n            selected.push(market);\n          }\n        });\n        setSelectedMarkets(selected);\n        setLoading(false);\n      } catch (error) {\n        logger.error(error);\n        setLoading(false);\n      }\n    };\n\n    fetch();\n\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  const onMarketCheckboxChange = (isSelected: boolean, market: Market) => {\n    if (isSelected) {\n      setSelectedMarkets(prev => [...prev, market]);\n    } else {\n      setSelectedMarkets(prev => prev.filter(p => p.value !== market.value));\n    }\n  };\n\n  const AllMarketCheckboxChange = (state: inputs.CheckboxState, markets: Market[]) => {\n    if (state === CheckboxState.UNCHECKED) {\n      setSelectedMarkets([]);\n    } else {\n      setSelectedMarkets(markets);\n    }\n  };\n\n  const handleView = () => {\n    let cells: Entity[] = [];\n\n    selectedMarkets.forEach(sm => {\n      cells.push({ value: `${sm.countryCode}-${sm.productCode}`, label: `${sm.productName} in ${sm.countryName}` });\n    });\n\n    onChange({\n      cell: cells,\n    });\n\n    onClose();\n  };\n\n  return (\n    <ContextSelectorMenu>\n      <div\n        style={{ maxHeight: '80vh' }}\n        className={`relative flex-column flex w-192 opacity-${isLoading ? LOADING_OPACITY : LOADED_OPACITY}`}\n      >\n        <>\n          <MarketList\n            isLoading={isLoading}\n            markets={markets}\n            selectedMarkets={selectedMarkets}\n            onChange={onMarketCheckboxChange}\n            onAllChange={AllMarketCheckboxChange}\n          />\n          <Footer handleView={handleView} handleCancel={onClose} selectedMarkets={selectedMarkets} />\n        </>\n      </div>\n    </ContextSelectorMenu>\n  );\n}\n\ntype MarketListProps = {\n  isLoading: boolean;\n  markets: Market[];\n  selectedMarkets: Market[];\n  onChange: (state: boolean, market: Market) => void;\n  onAllChange: (state: inputs.CheckboxState, markets: Market[]) => void;\n};\nfunction MarketList({ isLoading, markets, selectedMarkets, onChange, onAllChange }: MarketListProps) {\n  const [search, setSearch] = useState<string>('');\n  const [sortBy, setSortBy] = useState<SortBy>(SortBy.productGroup);\n  const [sortDirection, setSortDirection] = useState<SortDirection>(SortDirection.ascending);\n\n  const searchFilter = (market: Market) => {\n    const countryName = market.countryName.toLowerCase();\n    const productName = market.productName.toLowerCase();\n\n    return countryName.includes(search.toLowerCase()) || productName.includes(search.toLowerCase());\n  };\n\n  const onSort = (header: Header) => {\n    setSortDirection(prev => (prev === SortDirection.ascending ? SortDirection.descending : SortDirection.ascending));\n    setSortBy(header.sortBy);\n  };\n\n  const sortByColumn = (a: Market, b: Market, sortDirection: SortDirection) => {\n    const getSequence = (market: Market, periodicity: Periodicity) => {\n      return market.periods.find(p => p.periodicity === periodicity)?.sequence;\n    };\n\n    const comparePeriods = (per1: number, per2: number) => {\n      if (per1 === undefined && per2 === undefined) return 0;\n      if (per1 === undefined) return 1;\n      if (per2 === undefined) return -1;\n\n      return sortDirection === SortDirection.ascending ? per1 - per2 : per2 - per1;\n    };\n\n    const compareStrings = (str1: string, str2: string) => {\n      return sortDirection === SortDirection.ascending ? str1.localeCompare(str2) : str2.localeCompare(str1);\n    };\n\n    switch (sortBy) {\n      case SortBy.productGroup:\n        return compareStrings(a.productName, b.productName) || compareStrings(a.countryName, b.countryName);\n      case SortBy.country:\n        return compareStrings(a.countryName, b.countryName) || compareStrings(a.productName, b.productName);\n      case SortBy.lastMonth:\n        const sequenceMonthlyA = getSequence(a, Periodicity.Monthly);\n        const sequenceMonthlyB = getSequence(b, Periodicity.Monthly);\n        return comparePeriods(sequenceMonthlyA, sequenceMonthlyB);\n      case SortBy.lastWeek:\n        const sequenceWeeklyA = getSequence(a, Periodicity.Weekly);\n        const sequenceWeeklyB = getSequence(b, Periodicity.Weekly);\n        return comparePeriods(sequenceWeeklyA, sequenceWeeklyB);\n    }\n  };\n  const headers: Header[] = [\n    {\n      label: 'Product group',\n      sortBy: SortBy.productGroup,\n    },\n    {\n      label: 'Country',\n      sortBy: SortBy.country,\n    },\n    {\n      label: 'Last month',\n      sortBy: SortBy.lastMonth,\n    },\n    {\n      label: 'Last week',\n      sortBy: SortBy.lastWeek,\n    },\n  ];\n\n  const marketRows = markets.filter(searchFilter).sort((a, b) => sortByColumn(a, b, sortDirection));\n\n  return (\n    <>\n      <div className=\"mx-4 my-2\">\n        {markets.length >= SEARCH_BAR_COUNT && <TextInput placeholder=\"Search\" onChange={setSearch} autoFocus />}\n      </div>\n      <div className=\"flex-grow overflow-y-auto pb-6 overscroll-contain cursor-none\">\n        <table className=\"w-full\" style={{ tableLayout: 'fixed' }}>\n          <colgroup>\n            <col className=\"w-60\" />\n            <col className=\"w-48\" />\n          </colgroup>\n          <thead className=\"sticky top-0 text-left bg-white z-10\">\n            <tr>\n              <th onClick={() => onSort(headers[0])} className=\"pb-1 px-3 w-60\">\n                <div className=\"flex cursor-pointer\">\n                  <Checkbox\n                    state={selectedMarkets.length === 0 ? CheckboxState.UNCHECKED : CheckboxState.CHECKED}\n                    onChange={state => onAllChange(state, marketRows)}\n                  />\n                  <div className=\"pl-3\">{headers[0].label}</div>\n                  <SortIcon sizePx={24} direction={sortBy === headers[0].sortBy && sortDirection} />\n                </div>\n              </th>\n              {headers.slice(1).map(header => (\n                <th key={header.label} onClick={() => onSort(header)} className=\"pb-2\">\n                  <div className={`flex cursor-pointer`}>\n                    {header.label}\n                    <SortIcon sizePx={24} direction={sortBy === header.sortBy && sortDirection} />\n                  </div>\n                </th>\n              ))}\n            </tr>\n          </thead>\n          <tbody>\n            {marketRows.map(market => {\n              const periodLabel = (period: MarketPeriod | MarketPeriod2) => (\n                <div\n                  className=\"text-lighter\"\n                  style={{\n                    fontStyle: period?.sequence ? 'normal' : 'italic',\n                  }}\n                >\n                  {period?.name || 'not subscribed'}\n                </div>\n              );\n\n              const tableData = (children: string | JSX.Element) => (\n                <td className=\"py-1\" style={{ verticalAlign: 'text-top' }}>\n                  {children}\n                </td>\n              );\n\n              const isSelected = selectedMarkets.some(\n                sm => sm.countryCode == market.countryCode && sm.productCode === market.productCode\n              );\n\n              return (\n                <tr\n                  key={market.value}\n                  onClick={() => onChange(!isSelected, market)}\n                  className={`${isSelected && 'bg-brand-light'} hover:bg-brand-light cursor-pointer`}\n                >\n                  <td className=\"px-3 py-1\">\n                    <div className=\"flex\">\n                      <Checkbox\n                        onChange={state => onChange(state === CheckboxState.CHECKED, market)}\n                        state={isSelected ? CheckboxState.CHECKED : CheckboxState.UNCHECKED}\n                      />\n                      <span className=\"pl-3\">{market.productName}</span>\n                    </div>\n                  </td>\n                  {tableData(market.countryName)}\n                  {tableData(periodLabel(market.periods.find(p => p.periodicity === Periodicity.Monthly)))}\n                  {tableData(periodLabel(market.periods.find(p => p.periodicity === Periodicity.Weekly)))}\n                </tr>\n              );\n            })}\n            {/* Empty and Loading states */}\n            {marketRows.length === 0 && !isLoading && (\n              <tr>\n                <td colSpan={5}>\n                  <div className=\"mx-2 mt-4\">\n                    <Alert title=\"No markets found\" type=\"info\" />\n                  </div>\n                </td>\n              </tr>\n            )}\n            {isLoading && (\n              <tr>\n                <td colSpan={4}>\n                  <DotsLoader />\n                </td>\n              </tr>\n            )}\n          </tbody>\n        </table>\n      </div>\n    </>\n  );\n}\n\ntype FooterProps = {\n  handleView: () => void;\n  handleCancel: () => void;\n  selectedMarkets: Market[];\n};\nfunction Footer({ handleView, handleCancel, selectedMarkets }: FooterProps) {\n  const MarketsSelected = (\n    <Tooltip placement=\"bottom\">\n      <span className=\"underline\">{selectedMarkets.length} markets</span> selected\n      <Tooltip.Content>\n        {selectedMarkets\n          .map(sm => sm.label)\n          .slice(0, TOOLTIP_COUNT)\n          .join(', ')}\n        {selectedMarkets.length > TOOLTIP_COUNT && '...'}\n      </Tooltip.Content>\n    </Tooltip>\n  );\n\n  return (\n    <div className=\"flex h-18 items-center justify-between border-t border-light px-4 py-4 flex items-end gap-3\">\n      <Button mode=\"secondary\" onClick={handleCancel}>\n        Cancel\n      </Button>\n      <div>\n        <span className=\"text-lighter text-base mr-2\">\n          {selectedMarkets.length !== 0 ? MarketsSelected : 'Select any number of product groups'}\n        </span>\n        {selectedMarkets.length !== 0 && <Button onClick={handleView}>View selected</Button>}\n      </div>\n    </div>\n  );\n}\n","import React, { useEffect, useState } from 'react';\nimport { actions, inputs, feedback } from '@ecosystem/newron-design-system';\nimport { ContextSettingSelectorProps, useEditContextSettings } from '@ecosystem/newron-core';\nimport { Entity } from '@ecosystem/newron-core/types';\n\nconst { RadioButtons, Select } = inputs;\nconst { Button, IconButton } = actions;\nconst { DotsLoader } = feedback;\n\nfunction BrandOptionsSelector({ onClose, onChange }: ContextSettingSelectorProps) {\n  const [competitorBrands, setCompetitorBrands] = useState<Entity[]>([]);\n  const [brandOptions, setBrandOptions] = useState<Entity[]>();\n  const [competitorOptions, setCompetitorOptions] = useState<Entity[]>();\n  const [competitorValue, setCompetitorValue] = useState<Entity[]>();\n  const [highlightedValue, setHighLightedValue] = useState<Entity[]>();\n\n  const { getContextSettings } = useEditContextSettings();\n\n  useEffect(() => {\n    const fetch = async () => {\n      const settings = await getContextSettings([\n        'brandLimitingOptions',\n        'highlightedBrand',\n        'competitorBrandOption',\n        'competitorBrandList',\n      ]);\n      setBrandOptions(\n        settings['brandLimitingOptions'].definition.selection.options.filter(v => typeof v !== 'string') as Entity[]\n      );\n      setCompetitorOptions(\n        settings['competitorBrandOption'].definition.selection.options.filter(v => typeof v !== 'string') as Entity[]\n      );\n      setHighLightedValue(settings['highlightedBrand'].values);\n      setCompetitorValue(settings['competitorBrandOption'].values);\n      setCompetitorBrands(settings['competitorBrandList'].values);\n    };\n    fetch();\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  const handleCompetitorChange = (value: string) => {\n    const option = competitorOptions.find(e => e.value === value);\n    if (option) {\n      setCompetitorValue([option]);\n    }\n  };\n\n  const handleHighlightedChange = (value: string | string[] | null) => {\n    if (typeof value !== 'string') {\n      return;\n    }\n    const brand = brandOptions?.find(opt => opt.value === value);\n    if (brand) {\n      setHighLightedValue([brand]);\n    }\n  };\n\n  const handleAddCompetitorBrand = (value: string | string[] | null) => {\n    if (typeof value !== 'string') {\n      return;\n    }\n    const brand = brandOptions?.find(opt => opt.value === value);\n    if (brand) {\n      setCompetitorBrands([...competitorBrands, brand]);\n    }\n  };\n\n  const handleRemoveCompetitorBrand = (value: string) => {\n    setCompetitorBrands(competitorBrands.filter(e => e.value !== value));\n  };\n\n  const clearCompetitorBrands = () => {\n    setCompetitorBrands([]);\n  };\n\n  const handleApply = () => {\n    onChange({\n      highlightedBrand: highlightedValue,\n      competitorBrandOption: competitorValue,\n      competitorBrandList: competitorBrands,\n    });\n    onClose();\n  };\n\n  if (!brandOptions || !competitorOptions) {\n    return (\n      <div className=\"h-32\">\n        <DotsLoader active stretch />\n      </div>\n    );\n  }\n\n  const preventApply = competitorValue?.[0]?.value === 'exactList' && !competitorBrands?.length;\n  const enableCompetitorsSelection = competitorValue?.[0]?.value === 'exactList';\n  const competitorBrandsOptions =\n    brandOptions?.filter(e => !highlightedValue?.includes(e) && !competitorBrands?.includes(e)) || [];\n\n  return (\n    <div className=\"overflow-y-auto\">\n      <div className=\"py-3 px-4\">\n        <div className=\"font-bold text-heading text-sm pb-2\">Focus brand</div>\n        <Select value={highlightedValue?.[0].value} options={brandOptions || []} onChange={handleHighlightedChange} />\n      </div>\n      <div className=\"pt-2 px-4\">\n        <div className=\"font-bold text-heading text-sm\">Competitor brands</div>\n        <div className=\"pl-2 py-2\">\n          <RadioButtons\n            options={competitorOptions || []}\n            value={competitorValue?.[0]?.value}\n            onChange={handleCompetitorChange}\n          />\n        </div>\n      </div>\n      <div className=\"pb-2 pl-15 pr-4\">\n        <div className=\"border-b border-light flex items-baseline\">\n          <span\n            className={`text-sm font-bold flex-grow ${enableCompetitorsSelection ? 'text-lighter' : 'text-inactive'}`}\n          >\n            Competitor brands ({competitorBrands?.length || 0})\n          </span>\n          <Button\n            disabled={!enableCompetitorsSelection || !competitorBrands?.length}\n            onClick={clearCompetitorBrands}\n            mode=\"simple\"\n          >\n            Clear all\n          </Button>\n        </div>\n        <div className=\"h-36 mb-2 overflow-y-auto overscroll-contain\">\n          {!competitorBrands?.length && (\n            <span className=\"text-sm block mx-14 text-inactive pt-2 text-center\">\n              Select at least one competitor brand\n            </span>\n          )}\n          {competitorBrands?.map(b => (\n            <div\n              key={b.value}\n              className={`text-sm flex items-center pr-2 ${!enableCompetitorsSelection ? 'text-inactive' : ''}`}\n            >\n              <span className=\"flex-grow\">{b.label}</span>\n              <IconButton disabled={!enableCompetitorsSelection} onClick={() => handleRemoveCompetitorBrand(b.value)}>\n                <IconButton.icons.Close />\n              </IconButton>\n            </div>\n          ))}\n        </div>\n        <Select\n          disabled={!enableCompetitorsSelection}\n          options={competitorBrandsOptions}\n          onChange={handleAddCompetitorBrand}\n          placeholder=\"Add a competitor brand\"\n        />\n      </div>\n      <div className=\"flex justify-between px-4 py-3 border-t border-default\">\n        <Button mode=\"secondary\" onClick={onClose}>\n          Cancel\n        </Button>\n        <Button disabled={preventApply} onClick={handleApply}>\n          Apply\n        </Button>\n      </div>\n    </div>\n  );\n}\n\nexport { BrandOptionsSelector };\n","import React from 'react';\nimport { EntryChild, EntryRow, Mode } from './types';\nimport { Entity } from '@ecosystem/newron-core/types';\nimport { elements, actions } from '@ecosystem/newron-design-system';\nimport { Market } from '../types';\n\nconst { Icon } = elements;\nconst { IconButton, Button } = actions;\n\ntype Props = {\n  mode: Mode;\n  cells: Entity[];\n  markets: Market[];\n  indicateSubscriptions: boolean;\n  onRemoveCells: (cellsToRemove: string[]) => void;\n};\nfunction SelectedMarkets({ mode, cells, markets, onRemoveCells, indicateSubscriptions }: Props) {\n  const parentCodes = new Set<string>();\n\n  const rows: EntryRow[] = [];\n  cells.forEach(cell => {\n    const market = markets.find(m => m.value === cell.value);\n    const parent: Entity = {\n      value: mode === 'byCountry' ? market.countryCode : market.productCode,\n      label: mode === 'byCountry' ? market.countryName : market.productName,\n    };\n    const child: EntryChild = {\n      value: mode === 'byCountry' ? market.productCode : market.countryCode,\n      label: mode === 'byCountry' ? market.productName : market.countryName,\n      subscriptions: market.subscriptions,\n    };\n\n    if (!parentCodes.has(parent.value)) {\n      rows.push({\n        parent,\n        children: [child],\n      });\n      parentCodes.add(parent.value);\n    } else {\n      const row = rows.find(r => r.parent.value === parent.value);\n      if (row) {\n        row.children.push(child);\n        row.children.sort((a, b) => a.label.localeCompare(b.label));\n      }\n    }\n  });\n\n  rows.sort((a, b) => a.parent.label.localeCompare(b.parent.label));\n\n  const handleRemoveItem = (parentCode: string, childCode: string) => {\n    const cell = mode === 'byCountry' ? `${parentCode}-${childCode}` : `${childCode}-${parentCode}`;\n    onRemoveCells([cell]);\n  };\n\n  const handleRemoveRow = (row: EntryRow) => {\n    const cells = row.children.map(child => {\n      const cell = mode === 'byCountry' ? `${row.parent.value}-${child.value}` : `${child.value}-${row.parent.value}`;\n      return cell;\n    });\n    onRemoveCells(cells);\n  };\n\n  const handleRemoveAll = () => {\n    onRemoveCells(cells.map(c => c.value));\n  };\n\n  return (\n    <div className=\"relative flex-shrink-0 w-96 flex flex-column border-l border-light\">\n      <div className=\"min-h-14 h-14 flex-shrink-0 flex items-center justify-between border-b border-light px-4\">\n        <span className=\"flex-grow text-sm text-heading font-bold\">Selected markets</span>\n        <Button mode=\"simple\" onClick={handleRemoveAll}>\n          Clear all\n        </Button>\n      </div>\n      {!cells.length && <div className=\"text-lighter text-center py-10 px-20\">Select at least one market to view</div>}\n      {cells.length > 0 && (\n        <div className=\"pb-4 flex-grow overflow-y-auto overscroll-contain bg-brand-lightest\">\n          {rows.map((row, idx) => (\n            <div\n              className={`flex flex-row py-2 ${idx !== rows.length - 1 ? 'border-b border-light' : ''}`}\n              key={row.parent.value}\n            >\n              <div className=\"pl-4 pr-1 py-1 w-28 min-w-28 flex-shrink-0 font-bold text-xs\">{row.parent.label}</div>\n              <div className=\"flex-grow flex flex-row gap-x-2 gap-y-1 flex-wrap\">\n                {row.children.map(child => (\n                  <button\n                    onClick={() => handleRemoveItem(row.parent.value, child.value)}\n                    className=\"text-left text-xs flex flex-row gap-1 items-center px-2 h-8 rounded transition-colors border border-brand bg-white hover:bg-brand-lightest\"\n                    key={child.value}\n                  >\n                    <span className=\"nowrap overflow-ellipses max-w-40\">{child.label}</span>\n                    {indicateSubscriptions && <span className=\"text-lighter\">({child.subscriptions})</span>}\n                    <Icon size=\"sm\" color=\"default\">\n                      <Icon.icons.Close />\n                    </Icon>\n                  </button>\n                ))}\n              </div>\n              <div className=\"pr-4 flex-shrink-0\">\n                <IconButton onClick={() => handleRemoveRow(row)}>\n                  <IconButton.icons.Close />\n                </IconButton>\n              </div>\n            </div>\n          ))}\n        </div>\n      )}\n    </div>\n  );\n}\n\nexport { SelectedMarkets };\n","import React, { useState } from 'react';\nimport { EntryChild, EntryRow, Mode } from './types';\nimport { Entity } from '@ecosystem/newron-core/types';\nimport { inputs, elements, actions } from '@ecosystem/newron-design-system';\nimport { Market } from '../types';\n\nconst { TextInput } = inputs;\nconst { Icon } = elements;\nconst { Button, IconButton } = actions;\n\nfunction search(item: Entity, term: string): boolean {\n  const terms = term.trim().toLocaleLowerCase().split(' ');\n  const parts = item.label.trim().toLocaleLowerCase().split(' ');\n\n  return terms.some(t => parts.some(part => part.includes(t)));\n}\n\ntype Props = {\n  mode: Mode;\n  markets: Market[];\n  cells: Entity[];\n  onAddCells: (cellsToAdd: Entity[]) => void;\n  indicateSubscriptions: boolean;\n};\nfunction MarketsSelector({ mode, cells, markets, onAddCells, indicateSubscriptions }: Props) {\n  const [term, setTerm] = useState<string | undefined>();\n\n  const selectedCells = cells.map(c => c.value);\n  const parentCodes = new Set<string>();\n\n  let rows: EntryRow[] = [];\n  markets.forEach(market => {\n    if (!selectedCells.includes(market.value)) {\n      const parent: Entity = {\n        value: mode === 'byCountry' ? market.countryCode : market.productCode,\n        label: mode === 'byCountry' ? market.countryName : market.productName,\n      };\n      const child: EntryChild = {\n        value: mode === 'byCountry' ? market.productCode : market.countryCode,\n        label: mode === 'byCountry' ? market.productName : market.countryName,\n        subscriptions: market.subscriptions,\n      };\n\n      if (!parentCodes.has(parent.value)) {\n        rows.push({\n          parent,\n          children: [child],\n        });\n        parentCodes.add(parent.value);\n      } else {\n        const row = rows.find(r => r.parent.value === parent.value);\n        if (row) {\n          row.children.push(child);\n          row.children.sort((a, b) => a.label.localeCompare(b.label));\n        }\n      }\n    }\n  });\n\n  rows.sort((a, b) => a.parent.label.localeCompare(b.parent.label));\n\n  if (term && term.length) {\n    // search parent first\n    const filteredRows: EntryRow[] = rows.filter(row => search(row.parent, term));\n    // now children of any non matching rows\n    const matched = filteredRows.map(r => r.parent.value);\n    rows\n      .filter(r => !matched.includes(r.parent.value))\n      .forEach(row => {\n        const matchingChildren = row.children.filter(child => search(child, term));\n        if (matchingChildren.length) {\n          const filteredRow: EntryRow = {\n            parent: row.parent,\n            children: matchingChildren,\n          };\n          filteredRows.push(filteredRow);\n        }\n      });\n    filteredRows.sort((a, b) => a.parent.label.localeCompare(b.parent.label));\n    rows = filteredRows;\n  }\n\n  const handleAddItem = (parentCode: string, childCode: string) => {\n    const cell = mode === 'byCountry' ? `${parentCode}-${childCode}` : `${childCode}-${parentCode}`;\n    const market = markets.find(m => m.value === cell);\n    if (market) {\n      onAddCells([\n        {\n          value: market.value,\n          label: market.label,\n        },\n      ]);\n    }\n  };\n\n  const handleAddRow = (row: EntryRow) => {\n    const cells = row.children.map(child => {\n      const cell = mode === 'byCountry' ? `${row.parent.value}-${child.value}` : `${child.value}-${row.parent.value}`;\n      return cell;\n    });\n    const marketsToAdd = markets.filter(m => cells.includes(m.value));\n    if (marketsToAdd.length) {\n      onAddCells(\n        marketsToAdd.map(m => ({\n          value: m.value,\n          label: m.label,\n        }))\n      );\n    }\n  };\n\n  const handleAddAll = () => {\n    const cells = rows.flatMap(row =>\n      row.children.map(child => {\n        const cell = mode === 'byCountry' ? `${row.parent.value}-${child.value}` : `${child.value}-${row.parent.value}`;\n        return cell;\n      })\n    );\n\n    const marketsToAdd = markets.filter(m => cells.includes(m.value));\n    if (marketsToAdd.length) {\n      onAddCells(\n        marketsToAdd.map(m => ({\n          value: m.value,\n          label: m.label,\n        }))\n      );\n    }\n  };\n\n  let noRowsMsg = '';\n  if (!rows.length) {\n    noRowsMsg = term ? 'No markets match your search' : 'No markets left to add';\n  }\n\n  return (\n    <div className=\"relative flex-shrink-0 w-96 flex flex-column\">\n      <div className=\"min-h-14 h-14 flex-shrink-0 flex items-center justify-between border-b border-light px-4 gap-2\">\n        <div className=\"flex-grow\" style={{ marginTop: '-4px' }}>\n          <TextInput value={term} onChange={val => setTerm(val)} placeholder=\"Search for markets to add\">\n            <TextInput.Prefix>\n              <Icon>\n                <Icon.icons.Search />\n              </Icon>\n            </TextInput.Prefix>\n            {term && (\n              <TextInput.Suffix>\n                <IconButton size=\"sm\" onClick={() => setTerm(undefined)}>\n                  <IconButton.icons.Close />\n                </IconButton>\n              </TextInput.Suffix>\n            )}\n          </TextInput>\n        </div>\n        <Button mode=\"simple\" onClick={handleAddAll}>\n          Add all\n        </Button>\n      </div>\n      <div className=\"pb-4 flex-grow overflow-y-auto overscroll-contain\">\n        {!rows.length && <div className=\"text-lighter text-center py-10 px-20\">{noRowsMsg}</div>}\n        {rows.map((row, idx) => (\n          <div\n            className={`flex flex-row py-2 ${idx !== rows.length - 1 ? 'border-b border-light' : ''}`}\n            key={row.parent.value}\n          >\n            <div className=\"pl-4 pr-1 py-1 w-28 min-w-28 flex-shrink-0 font-bold text-xs\">{row.parent.label}</div>\n            <div className=\"flex-grow flex flex-row gap-x-2 gap-y-1 flex-wrap\">\n              {row.children.map(child => (\n                <button\n                  onClick={() => handleAddItem(row.parent.value, child.value)}\n                  className=\"text-left text-xs flex flex-row gap-1 items-center px-2 h-8 rounded transition-colors border border-default bg-white hover:bg-brand-lightest\"\n                  key={child.value}\n                >\n                  <span className=\"nowrap overflow-ellipses max-w-40\">{child.label}</span>\n                  {indicateSubscriptions && <span className=\"text-lighter\">({child.subscriptions})</span>}\n                  <Icon size=\"sm\" color=\"brand\">\n                    <Icon.icons.Add />\n                  </Icon>\n                </button>\n              ))}\n            </div>\n            <div className=\"pr-4 flex-shrink-0\">\n              <IconButton onClick={() => handleAddRow(row)}>\n                <IconButton.icons.Add />\n              </IconButton>\n            </div>\n          </div>\n        ))}\n      </div>\n    </div>\n  );\n}\n\nexport { MarketsSelector };\n","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(e, r) {\n  for (var t = 0; t < r.length; t++) {\n    var o = r[t];\n    o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);\n  }\n}\nfunction _createClass(e, r, t) {\n  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n    writable: !1\n  }), e;\n}\nexport { _createClass as default };","import { Entity, Periodicity } from '@ecosystem/newron-core/types';\n\nexport type MarketPeriod = {\n  sequence: number;\n  periodicity: Periodicity;\n  name: string;\n  value: string;\n  published: string;\n};\n\nexport type Market = Entity & {\n  countryCode: string;\n  countryName: string;\n  productCode: string;\n  productName: string;\n  periods: MarketPeriod[];\n  subscriptions: string;\n};\n\nexport enum PeriodAggregation {\n  Week = 'Week',\n  Month = 'Month',\n  Quarter = 'Quarter',\n  RollingQuarter = 'RollingQuarter',\n  Year = 'Year',\n  Custom = 'Custom',\n  MAT = 'MAT',\n  YTD = 'YTD',\n}\n\nexport type TimeFrame = {\n  periodicity: Periodicity;\n  endSequence: number;\n  startSequence?: number;\n  aggregation: PeriodAggregation;\n  label: string;\n  value: string;\n};\n\nexport type TimeFrameOption = TimeFrame & {\n  availableOnAll: boolean;\n};\n","import React from 'react';\nimport { Market, PeriodAggregation, TimeFrame } from './types';\nimport { Entity, Periodicity } from '@ecosystem/newron-core/types';\n\ntype Props = {\n  label: string;\n  isActive: boolean;\n  isDisabled?: boolean;\n  onClick: () => void;\n};\nfunction NavMenuButton({ label, isActive, isDisabled = false, onClick }: Props) {\n  return (\n    <button\n      disabled={isDisabled}\n      className={`w-full text-left px-2 h-8 flex items-center rounded block mb-2 transition-colors ${\n        isActive ? 'text-brand cursor-default bg-medium' : 'bg-light'\n      } ${isDisabled ? 'text-inactive cursor-not-allowed' : 'hover:bg-medium'}`}\n      onClick={onClick}\n    >\n      {label}\n    </button>\n  );\n}\n\nfunction NavMenuSeparator() {\n  return <div className=\"border-t border-light mx-2 my-2\" style={{ height: '1px' }} />;\n}\nclass TimeFrames {\n  static toTimeFrame(entity: Entity): TimeFrame {\n    const [periodicity, period, periodAggregation] = entity.value.split(':');\n\n    let endPeriod = period;\n    let startPeriod: string | undefined;\n    if (period.includes('-')) {\n      const [startPeriodSplitted, endPeriodSplitted] = period.split('-');\n      startPeriod = startPeriodSplitted;\n      endPeriod = endPeriodSplitted;\n    }\n\n    const aggregation = periodAggregation\n      ? (periodAggregation as PeriodAggregation)\n      : periodicity === Periodicity.Weekly\n      ? PeriodAggregation.Week\n      : PeriodAggregation.Month;\n\n    return {\n      aggregation,\n      periodicity: periodicity as Periodicity,\n      endSequence: Number(endPeriod),\n      startSequence: startPeriod && Number(startPeriod),\n      label: entity.label,\n      value: entity.value,\n    };\n  }\n\n  static toEntity(timeFrame: TimeFrame): Entity {\n    return {\n      label: timeFrame.label,\n      value: timeFrame.value,\n    };\n  }\n\n  static validateTimeFrame(timeFrame: TimeFrame, forMarkets: Market[], withinTimeFrames: TimeFrame[]): TimeFrame {\n    let validTimeFrame = timeFrame;\n\n    if (!forMarkets.every(m => m.periods.find(p => p.periodicity === timeFrame.periodicity))) {\n      // probably weekly but not on all markets, default to a monthly time frame\n      const allMonths = forMarkets.map(m => m.periods.find(p => p.periodicity === Periodicity.Monthly));\n      const commonMonthlySequence = Math.min(...allMonths.map(p => p.sequence));\n      return withinTimeFrames.find(\n        tf => tf.aggregation === PeriodAggregation.Month && tf.endSequence === commonMonthlySequence\n      );\n    }\n\n    const allMatchingPeriods = forMarkets.map(m => m.periods.find(p => p.periodicity === timeFrame.periodicity));\n    const lowestCommonSequence = Math.min(...allMatchingPeriods.map(p => p.sequence));\n\n    if (Number(timeFrame.endSequence) > lowestCommonSequence) {\n      validTimeFrame = withinTimeFrames.find(\n        tf => tf.aggregation === timeFrame.aggregation && tf.endSequence <= lowestCommonSequence\n      );\n    }\n\n    return validTimeFrame;\n  }\n}\n\nexport { NavMenuButton, NavMenuSeparator, TimeFrames };\n","function _classCallCheck(a, n) {\n  if (!(a instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n}\nexport { _classCallCheck as default };","import { DPPrefixTypes, MarketPrefixTypes, Proposition } from './constants';\n\nconst getUrlPathPrefix = (): string => {\n  const urlPath = window.location.pathname;\n  const path = urlPath.split('/');\n  return path.length > 1 ? path[1] : '';\n};\n\nexport const currentProposition = (): string | undefined => {\n  const pathPrefix = getUrlPathPrefix();\n  let proposition: string | undefined = undefined;\n\n  if (MarketPrefixTypes.includes(pathPrefix)) {\n    proposition = Proposition.Market;\n  } else if (DPPrefixTypes.includes(pathPrefix)) {\n    proposition = Proposition.DistributionPanel;\n  }\n\n  if (proposition === undefined) {\n    console.error(`Unknown proposition for path prefix: ${pathPrefix}`);\n  }\n\n  return proposition;\n};\n","import React, { useEffect, useState } from 'react';\nimport { elements } from '@ecosystem/newron-design-system';\nimport { Entity } from '@ecosystem/newron-core/types';\nimport { RecentMarket } from './types';\nimport { Market } from '../types';\nimport { currentProposition } from '../../utils/currentProposition';\n\nconst { Icon } = elements;\n\nexport const RECENT_MARKETS_KEY = () => `${currentProposition()}_recents`;\n\ntype RecentRowMarket = {\n  product: Entity;\n  countries: Entity[];\n};\n\ntype RecentRow = RecentMarket & {\n  displayDate: string;\n  markets: RecentRowMarket[];\n};\n\ntype Props = {\n  markets: Market[];\n  onSelect: (cells: Entity[]) => void;\n};\nfunction RecentMarkets({ markets, onSelect }: Props) {\n  const [recentEntries, setRecentEntries] = useState<RecentMarket[] | undefined>();\n  const [products, setProducts] = useState<Record<string, Entity>>();\n  const [countries, setCountries] = useState<Record<string, Entity>>();\n\n  useEffect(() => {\n    const storedEntry = localStorage.getItem(RECENT_MARKETS_KEY());\n    const entries = storedEntry ? (JSON.parse(storedEntry) as RecentMarket[]) : [];\n    setRecentEntries(entries);\n  }, []);\n\n  useEffect(() => {\n    if (!markets) {\n      return;\n    }\n    const products: Record<string, Entity> = {};\n    const countries: Record<string, Entity> = {};\n    markets.forEach(market => {\n      products[market.productCode] = {\n        value: market.productCode,\n        label: market.productName,\n      };\n      countries[market.countryCode] = {\n        value: market.countryCode,\n        label: market.countryName,\n      };\n      setProducts(products);\n      setCountries(countries);\n    });\n  }, [markets]);\n\n  const formatter = new Intl.DateTimeFormat('en-GB', {\n    dateStyle: 'medium',\n    timeStyle: 'short',\n  });\n\n  const rows: RecentRow[] = [];\n  if (markets && recentEntries) {\n    recentEntries.forEach(entry => {\n      let allValid = true;\n      const rowMarkets: RecentRowMarket[] = [];\n      const productCodes = new Set<string>();\n      for (let cell of entry.cells) {\n        if (!markets.find(m => m.value === cell.value)) {\n          allValid = false;\n          break;\n        }\n        const parts = cell.value.split('-');\n        if (!productCodes.has(parts[1])) {\n          productCodes.add(parts[1]);\n          const product = products[parts[1]];\n          const country = countries[parts[0]];\n          rowMarkets.push({\n            product,\n            countries: [country],\n          });\n        } else {\n          const country = countries[parts[0]];\n          const rowMarket = rowMarkets.find(rm => rm.product.value === parts[1]);\n          rowMarket?.countries.push(country);\n          rowMarket?.countries.sort((a, b) => a.value.localeCompare(b.value));\n        }\n      }\n      if (allValid) {\n        rowMarkets.sort((a, b) => a.product.label.localeCompare(b.product.label));\n        rows.push({\n          ...entry,\n          displayDate: formatter.format(new Date(entry.used)),\n          markets: rowMarkets,\n        });\n      }\n    });\n  }\n\n  const handleRowClick = (row: RecentRow) => {\n    onSelect(row.cells);\n  };\n\n  return (\n    <div className=\"w-192 overflow-y-auto overscroll-contain px-4\">\n      <div className=\"text-heading text-lg py-3\">Recently used markets</div>\n      {rows.length === 0 && (\n        <div className=\"flex gap-2 pt-10 text-light text-sm\">\n          <Icon color=\"info\">\n            <Icon.icons.Info />\n          </Icon>\n          Recent markets you view will be visible here so you can easily retrieve them again.\n        </div>\n      )}\n      {rows.map((row, idx) => (\n        <RowButton key={idx} row={row} onClick={() => handleRowClick(row)} />\n      ))}\n    </div>\n  );\n}\n\ntype RowProps = {\n  row: RecentRow;\n  onClick: () => void;\n};\nfunction RowButton({ row, onClick }: RowProps) {\n  const { displayDate, markets } = row;\n\n  return (\n    <button\n      className=\"relative mb-2 w-full max-w-full px-2 py-2 flex text-left rounded text-sm hover:bg-light\"\n      onClick={onClick}\n    >\n      <div className=\"flex-grow\">\n        {markets.map(market => (\n          <div key={market.product.value} className=\"flex gap-1 pb-1\">\n            <div className=\"flex-none font-bold\">{market.product.label}</div>\n            <div className=\"text-lighter flex-none\">in</div>\n            <div className=\"flex-grow\">\n              {market.countries.length === 1 && market.countries[0].value}\n              {market.countries.length > 1 &&\n                `${market.countries\n                  .slice(0, -1)\n                  .map(c => c.value)\n                  .join(', ')} & ${market.countries[market.countries.length - 1].value}`}\n            </div>\n          </div>\n        ))}\n      </div>\n      <div className=\"flex-none pl-4\">\n        <span className=\"block text-lighter font-bold\">Last viewed</span>\n        <span>{displayDate}</span>\n      </div>\n    </button>\n  );\n}\n\nfunction updateRecentMarkets(cells: Entity[]) {\n  const storedEntry = localStorage.getItem(RECENT_MARKETS_KEY());\n  const entries = storedEntry ? (JSON.parse(storedEntry) as RecentMarket[]) : [];\n\n  const cellStr = cells.sort((a, b) => a.value.localeCompare(b.value)).join(',');\n  const matchingEntry = entries.findIndex(entry => {\n    const checkCellStr = entry.cells.sort((a, b) => a.value.localeCompare(b.value)).join(',');\n    return checkCellStr === cellStr;\n  });\n\n  if (matchingEntry !== -1) {\n    entries.splice(matchingEntry, 1);\n  }\n\n  if (entries.length >= 10) {\n    entries.pop();\n  }\n  entries.unshift({\n    used: Date.now(),\n    cells,\n  });\n  localStorage.setItem(RECENT_MARKETS_KEY(), JSON.stringify(entries));\n}\n\nexport { RecentMarkets, updateRecentMarkets };\n","import React, { useEffect, useState } from 'react';\nimport { ContextSelectorMenu, ContextSettingSelectorProps, useEditContextSettings } from '@ecosystem/newron-core';\nimport { actions, feedback, inputs } from '@ecosystem/newron-design-system';\nimport { Entity, Periodicity } from '@ecosystem/newron-core/types';\nimport { Mode } from './types';\nimport { SelectedMarkets } from './selected';\nimport { MarketsSelector } from './selector';\nimport { Market } from '../types';\nimport { NavMenuButton, NavMenuSeparator } from '../common';\nimport { RecentMarkets, updateRecentMarkets } from './recent';\n\nconst { Button } = actions;\nconst { DotsLoader } = feedback;\nconst { Checkbox, CheckboxState } = inputs;\n\nfunction MarketContextSelector({ onChange, onClose }: ContextSettingSelectorProps) {\n  const [mode, setMode] = useState<Mode>('byProduct');\n  const [markets, setMarkets] = useState<Market[] | undefined>();\n  const [cells, setCells] = useState<Entity[]>([]);\n  const [indicateSubscriptions, setIndicateSubscriptions] = useState<boolean>(false);\n\n  const { getContextSettings } = useEditContextSettings();\n\n  useEffect(() => {\n    const fetch = async () => {\n      const settings = await getContextSettings(['openMarkets', 'cell']);\n      const markets: Market[] = settings['openMarkets'].definition.selection.options.filter(\n        opt => typeof opt !== 'string'\n      ) as Market[];\n\n      markets.forEach(market => {\n        let subscriptions = 'M';\n        if (market.periods.find(p => p.periodicity === Periodicity.Weekly)) {\n          subscriptions += '/W';\n        }\n        market.subscriptions = subscriptions;\n      });\n      setMarkets(markets);\n      setCells(settings['cell'].values);\n    };\n\n    fetch();\n\n    /* eslint-disable react-hooks/exhaustive-deps */\n  }, []);\n\n  const handleRemoveCells = (cellsToRemove: string[]) => {\n    setCells(cells.filter(c => !cellsToRemove.includes(c.value)));\n  };\n\n  const handleAddCells = (cellsToAdd: Entity[]) => {\n    setCells([...cells, ...cellsToAdd]);\n  };\n\n  const handleApply = () => {\n    openMarkets(cells);\n  };\n\n  const handleRevisit = (cells: Entity[]) => {\n    openMarkets(cells);\n  };\n\n  const openMarkets = (cells: Entity[]) => {\n    if (!cells.length) {\n      return;\n    }\n    updateRecentMarkets(cells);\n    onChange({\n      cell: cells,\n    });\n    onClose();\n  };\n\n  return (\n    <ContextSelectorMenu>\n      {!markets && (\n        <div className=\"w-192 h-72\">\n          <DotsLoader stretch />\n        </div>\n      )}\n      {markets && (\n        <div className=\"relative\">\n          <div className=\"relative flex flex-row items-stretch\" style={{ height: '460px' }}>\n            <div className=\"flex-shrink-0 flex flex-column w-40 min-w-40 px-2 py-2 bg-light border-r border-light\">\n              <div className=\"flex-grow\">\n                <NavMenuButton\n                  label=\"Recently used\"\n                  isActive={mode === 'byRecent'}\n                  onClick={() => setMode('byRecent')}\n                />\n                <NavMenuSeparator />\n                <NavMenuButton\n                  label=\"By product\"\n                  isActive={mode === 'byProduct'}\n                  onClick={() => setMode('byProduct')}\n                />\n                <NavMenuButton\n                  label=\"By country\"\n                  isActive={mode === 'byCountry'}\n                  onClick={() => setMode('byCountry')}\n                />\n              </div>\n              {mode !== 'byRecent' && (\n                /* eslint-disable jsx-a11y/label-has-associated-control */\n                <label className=\"text-xs flex gap-1 cursor-pointer\">\n                  <Checkbox\n                    onChange={state => setIndicateSubscriptions(state === CheckboxState.CHECKED)}\n                    state={indicateSubscriptions ? CheckboxState.CHECKED : CheckboxState.UNCHECKED}\n                  />\n                  Indicate (M)onthly or (W)eekly\n                </label>\n              )}\n            </div>\n            {mode === 'byRecent' && <RecentMarkets markets={markets} onSelect={handleRevisit} />}\n            {mode !== 'byRecent' && (\n              <MarketsSelector\n                onAddCells={handleAddCells}\n                mode={mode}\n                cells={cells}\n                markets={markets}\n                indicateSubscriptions={indicateSubscriptions}\n              />\n            )}\n            {mode !== 'byRecent' && (\n              <SelectedMarkets\n                onRemoveCells={handleRemoveCells}\n                mode={mode}\n                cells={cells}\n                markets={markets}\n                indicateSubscriptions={indicateSubscriptions}\n              />\n            )}\n          </div>\n          <div className=\"border-t border-default px-4 py-2 flex items-center justify-between\">\n            <Button mode=\"secondary\" onClick={onClose}>\n              Cancel\n            </Button>\n            {mode !== 'byRecent' && (\n              <Button onClick={handleApply} disabled={cells.length === 0}>\n                {cells.length > 0 && `View (${cells.length}) market(s)`}\n                {cells.length === 0 && 'Select at least one market'}\n              </Button>\n            )}\n          </div>\n        </div>\n      )}\n    </ContextSelectorMenu>\n  );\n}\n\nexport { MarketContextSelector };\n","\n      import API from \"!../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../node_modules/css-loader/dist/cjs.js??ruleSet[1].rules[1].use[1]!./periodSelector.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../node_modules/css-loader/dist/cjs.js??ruleSet[1].rules[1].use[1]!./periodSelector.css\";\n       export default content && content.locals ? content.locals : undefined;\n","import { TimeFrameOption } from '../types';\n\nexport const numberToMonthName = {\n  0: 'Jan',\n  1: 'Feb',\n  2: 'Mar',\n  3: 'Apr',\n  4: 'May',\n  5: 'Jun',\n  6: 'Jul',\n  7: 'Aug',\n  8: 'Sep',\n  9: 'Oct',\n  10: 'Nov',\n  11: 'Dec',\n};\n\nexport const monthNameToNumber = Object.keys(numberToMonthName).reduce((acc, key) => {\n  acc[numberToMonthName[key]] = key;\n  return acc;\n}, {});\n\nexport const timeFrameToDate = (timeFrame: TimeFrameOption) => {\n  const [month, year] = timeFrame.label.split(' ');\n  return new Date(parseInt(year), monthNameToNumber[month]);\n};\n\nexport const dateToTimeFrame = (date: Date, availableMonths: TimeFrameOption[]) => {\n  return {\n    timeFrame: availableMonths.find(el => {\n      const [month, year] = el.label.split(' ');\n      return numberToMonthName[date.getMonth()] === month && date.getFullYear() === parseInt(year);\n    }),\n    date,\n  };\n};\n","import { Periodicity } from '@ecosystem/newron-core/types';\nimport { PeriodAggregation, TimeFrame } from '../types';\n\nexport const isCustomWeekly = (currentValue: TimeFrame) =>\n  !!currentValue &&\n  currentValue.aggregation === PeriodAggregation.Custom &&\n  currentValue.periodicity === Periodicity.Weekly;\n\nexport const isCustomMonthly = (currentValue: TimeFrame) =>\n  !!currentValue &&\n  currentValue.aggregation === PeriodAggregation.Custom &&\n  currentValue.periodicity === Periodicity.Monthly;\n","import React from 'react';\nimport { actions, elements, feedback } from '@ecosystem/newron-design-system';\nimport { Market } from '../types';\n\nconst { Button } = actions;\nconst { Icon } = elements;\nconst { Tooltip } = feedback;\n\ntype Props = {\n  onApply: () => void;\n  notPublishedMarkets?: Market[];\n  notAvailableMarkets?: Market[];\n  disabled?: boolean;\n};\n\nexport function ApplyPeriodButton({\n  onApply,\n  notPublishedMarkets = [],\n  notAvailableMarkets = [],\n  disabled = false,\n}: Props): JSX.Element {\n  const showIncompleteTooltip = notPublishedMarkets.length > 0 || notAvailableMarkets.length > 0;\n\n  return (\n    <div className={'mx-3 self-end'}>\n      <Tooltip placement=\"right\">\n        <div className=\"flex items-center gap-2\">\n          {showIncompleteTooltip && (\n            <Icon color=\"lighter\">\n              <Icon.icons.Fractional />\n            </Icon>\n          )}\n          <Button disabled={disabled} onClick={onApply}>\n            Apply\n          </Button>\n        </div>\n\n        {showIncompleteTooltip && (\n          <Tooltip.Content>\n            {notPublishedMarkets.length > 0 && (\n              <>\n                <p>Data is not available for:</p>\n                <ul className=\"ml-5\" style={{ listStyleType: 'disc' }}>\n                  {notPublishedMarkets.slice(0, 4).map(({ label }) => (\n                    <li key={label}>{label}</li>\n                  ))}\n                  {notPublishedMarkets.slice(4).length > 0 && (\n                    <span>{`and ${notPublishedMarkets.slice(4).length} more`}</span>\n                  )}\n                </ul>\n              </>\n            )}\n            {notAvailableMarkets.length > 0 && (\n              <>\n                <p>Data is available for the below, but currently outside of your subscription:</p>\n                <ul className=\"ml-5\" style={{ listStyleType: 'disc' }}>\n                  {notAvailableMarkets.slice(0, 4).map(({ label }) => (\n                    <li key={label}>{label}</li>\n                  ))}\n                  {notAvailableMarkets.slice(4).length > 0 && (\n                    <span>{`and ${notPublishedMarkets.slice(4).length} more`}</span>\n                  )}\n                </ul>\n              </>\n            )}\n          </Tooltip.Content>\n        )}\n      </Tooltip>\n    </div>\n  );\n}\n","export const WARNING_MESSAGE_ON_APPLY = 'The end date must be greater than the start date';\n","import React, { useCallback, useEffect, useMemo, useState } from 'react';\nimport { inputs } from '@ecosystem/newron-design-system';\nimport { Market, TimeFrame, TimeFrameOption } from '../types';\nimport { dateToTimeFrame, timeFrameToDate } from './monthsSelector.utils';\nimport { isCustomMonthly } from './periodSelector.utils';\nimport { ApplyPeriodButton } from './applyPeriod.button';\nimport { Periodicity } from '@ecosystem/newron-core/types';\nimport { WARNING_MESSAGE_ON_APPLY } from './constants';\n\nconst { MonthPicker, MonthFormatType } = inputs;\n\ntype TimeFrameOptionWithDate = {\n  timeFrame: TimeFrameOption;\n  date: Date;\n};\n\nexport type Props = {\n  monthlyOptions: TimeFrameOption[];\n  markets: Market[];\n  currentValue: TimeFrame;\n  onSelect: (value: TimeFrameOption, removeAffectedMarkets: boolean) => void;\n};\n\nexport function MonthsSelector({ monthlyOptions = [], markets = [], currentValue, onSelect }: Props) {\n  const [monthFrom, setMonthFrom] = useState<TimeFrameOptionWithDate>(null);\n  const [monthTo, setMonthTo] = useState<TimeFrameOptionWithDate>(null);\n  const [isWrongDateRange, setIsWrongDateRange] = useState(false);\n\n  const notPublishedMarkets = markets.filter(m =>\n    m.periods.find(p => p.periodicity === Periodicity.Monthly && p.sequence < monthTo?.timeFrame.endSequence)\n  );\n\n  useEffect(() => {\n    setIsWrongDateRange(monthFrom?.date.getTime() > monthTo?.date.getTime());\n  }, [monthFrom?.date, monthTo?.date]);\n\n  const sortMonthlyOptions = useMemo(() => {\n    return monthlyOptions.sort((a, b) => a.endSequence - b.endSequence);\n  }, [monthlyOptions]);\n\n  const sequenceToTimeFrame = useCallback(\n    (month: number): TimeFrameOptionWithDate => {\n      const timeFrame = sortMonthlyOptions.find(el => el.endSequence === month);\n      if (!timeFrame) {\n        return null;\n      }\n\n      return {\n        date: timeFrameToDate(timeFrame),\n        timeFrame,\n      };\n    },\n    [sortMonthlyOptions]\n  );\n\n  useEffect(() => {\n    const setCurrentlySelectedValueOnMonthPickers = () => {\n      const fromMonth = sequenceToTimeFrame(currentValue.startSequence);\n      const toMonth = sequenceToTimeFrame(currentValue.endSequence);\n      if (fromMonth && toMonth) {\n        setMonthFrom({\n          timeFrame: fromMonth.timeFrame,\n          date: fromMonth.date,\n        });\n        setMonthTo({\n          timeFrame: toMonth.timeFrame,\n          date: toMonth.date,\n        });\n      }\n    };\n\n    const setLastTwoMonthsOnMonthPickers = () => {\n      if (sortMonthlyOptions.length < 2) {\n        return;\n      }\n      // get the last month\n      const lastMonthTimeFrame = sortMonthlyOptions.at(-1);\n      setMonthTo({\n        timeFrame: lastMonthTimeFrame,\n        date: timeFrameToDate(lastMonthTimeFrame),\n      });\n\n      // get the month before the last month\n      const beforeLastMonthTimeFrame = sortMonthlyOptions.at(-2);\n      setMonthFrom({\n        timeFrame: beforeLastMonthTimeFrame,\n        date: timeFrameToDate(beforeLastMonthTimeFrame),\n      });\n    };\n\n    if (!monthFrom && !monthTo) {\n      if (sortMonthlyOptions.length > 0 && isCustomMonthly(currentValue)) {\n        setCurrentlySelectedValueOnMonthPickers();\n      } else {\n        setLastTwoMonthsOnMonthPickers();\n      }\n    }\n  }, [currentValue, sortMonthlyOptions, monthFrom, monthTo, sequenceToTimeFrame]);\n\n  const handleApply = () => {\n    const customTimeFramePeriod = {\n      ...monthFrom?.timeFrame,\n      value: `Monthly:${monthFrom?.timeFrame.endSequence}-${monthTo?.timeFrame.endSequence}:Custom`,\n    };\n    if (monthFrom && monthTo) {\n      onSelect(customTimeFramePeriod, false);\n    }\n  };\n\n  const lowestPossibleMonth = () => {\n    const firstElement = sortMonthlyOptions.at(0);\n    if (!firstElement) {\n      return null;\n    }\n    return timeFrameToDate(firstElement);\n  };\n\n  const highestPossibleMonth = () => {\n    const lastElement = sortMonthlyOptions.at(-1);\n    if (!lastElement) {\n      return null;\n    }\n    return timeFrameToDate(lastElement);\n  };\n\n  return (\n    <div className={'flex flex-column h-full justify-end'}>\n      <div\n        className={'p-4 pt-0'}\n        style={{\n          marginBottom: 'auto',\n        }}\n      >\n        <MonthPicker\n          label={'From'}\n          dateFormat={MonthFormatType['MMM yyyy']}\n          defaultDate={monthFrom?.date}\n          minDate={lowestPossibleMonth()}\n          maxDate={highestPossibleMonth()}\n          onChange={(val: Date) => {\n            setMonthFrom(dateToTimeFrame(val, monthlyOptions));\n          }}\n        />\n        <MonthPicker\n          label={'To'}\n          dateFormat={MonthFormatType['MMM yyyy']}\n          defaultDate={monthTo?.date}\n          minDate={lowestPossibleMonth()}\n          maxDate={highestPossibleMonth()}\n          onChange={(val: Date) => {\n            setMonthTo(dateToTimeFrame(val, monthlyOptions));\n          }}\n        />\n        {isWrongDateRange && <span className=\"text-ui-red\">{WARNING_MESSAGE_ON_APPLY}</span>}\n      </div>\n      <hr />\n\n      <ApplyPeriodButton\n        notPublishedMarkets={notPublishedMarkets}\n        onApply={handleApply}\n        disabled={!monthFrom || !monthTo || isWrongDateRange}\n      />\n    </div>\n  );\n}\n","/**\n * @name constructFrom\n * @category Generic Helpers\n * @summary Constructs a date using the reference date and the value\n *\n * @description\n * The function constructs a new date using the constructor from the reference\n * date and the given value. It helps to build generic functions that accept\n * date extensions.\n *\n * It defaults to `Date` if the passed reference date is a number or a string.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The reference date to take constructor from\n * @param value - The value to create the date\n *\n * @returns Date initialized using the given date and value\n *\n * @example\n * import { constructFrom } from 'date-fns'\n *\n * // A function that clones a date preserving the original type\n * function cloneDate<DateType extends Date(date: DateType): DateType {\n *   return constructFrom(\n *     date, // Use contrustor from the given date\n *     date.getTime() // Use the date value to create a new date\n *   )\n * }\n */\nexport function constructFrom(date, value) {\n  if (date instanceof Date) {\n    return new date.constructor(value);\n  } else {\n    return new Date(value);\n  }\n}\n\n// Fallback for modularized imports:\nexport default constructFrom;\n","/**\n * @name toDate\n * @category Common Helpers\n * @summary Convert the given argument to an instance of Date.\n *\n * @description\n * Convert the given argument to an instance of Date.\n *\n * If the argument is an instance of Date, the function returns its clone.\n *\n * If the argument is a number, it is treated as a timestamp.\n *\n * If the argument is none of the above, the function returns Invalid Date.\n *\n * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param argument - The value to convert\n *\n * @returns The parsed date in the local time zone\n *\n * @example\n * // Clone the date:\n * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))\n * //=> Tue Feb 11 2014 11:30:30\n *\n * @example\n * // Convert the timestamp to date:\n * const result = toDate(1392098430000)\n * //=> Tue Feb 11 2014 11:30:30\n */\nexport function toDate(argument) {\n  const argStr = Object.prototype.toString.call(argument);\n\n  // Clone the date\n  if (\n    argument instanceof Date ||\n    (typeof argument === \"object\" && argStr === \"[object Date]\")\n  ) {\n    // Prevent the date to lose the milliseconds when passed to new Date() in IE10\n    return new argument.constructor(+argument);\n  } else if (\n    typeof argument === \"number\" ||\n    argStr === \"[object Number]\" ||\n    typeof argument === \"string\" ||\n    argStr === \"[object String]\"\n  ) {\n    // TODO: Can we get rid of as?\n    return new Date(argument);\n  } else {\n    // TODO: Can we get rid of as?\n    return new Date(NaN);\n  }\n}\n\n// Fallback for modularized imports:\nexport default toDate;\n","let defaultOptions = {};\n\nexport function getDefaultOptions() {\n  return defaultOptions;\n}\n\nexport function setDefaultOptions(newOptions) {\n  defaultOptions = newOptions;\n}\n","import { toDate } from \"./toDate.mjs\";\nimport { getDefaultOptions } from \"./_lib/defaultOptions.mjs\";\n\n/**\n * The {@link startOfWeek} function options.\n */\n\n/**\n * @name startOfWeek\n * @category Week Helpers\n * @summary Return the start of a week for the given date.\n *\n * @description\n * Return the start of a week for the given date.\n * The result will be in the local timezone.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The original date\n * @param options - An object with options\n *\n * @returns The start of a week\n *\n * @example\n * // The start of a week for 2 September 2014 11:55:00:\n * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Sun Aug 31 2014 00:00:00\n *\n * @example\n * // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:\n * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })\n * //=> Mon Sep 01 2014 00:00:00\n */\nexport function startOfWeek(date, options) {\n  const defaultOptions = getDefaultOptions();\n  const weekStartsOn =\n    options?.weekStartsOn ??\n    options?.locale?.options?.weekStartsOn ??\n    defaultOptions.weekStartsOn ??\n    defaultOptions.locale?.options?.weekStartsOn ??\n    0;\n\n  const _date = toDate(date);\n  const day = _date.getDay();\n  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;\n\n  _date.setDate(_date.getDate() - diff);\n  _date.setHours(0, 0, 0, 0);\n  return _date;\n}\n\n// Fallback for modularized imports:\nexport default startOfWeek;\n","import { startOfWeek } from \"./startOfWeek.mjs\";\n\n/**\n * @name startOfISOWeek\n * @category ISO Week Helpers\n * @summary Return the start of an ISO week for the given date.\n *\n * @description\n * Return the start of an ISO week for the given date.\n * The result will be in the local timezone.\n *\n * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The original date\n *\n * @returns The start of an ISO week\n *\n * @example\n * // The start of an ISO week for 2 September 2014 11:55:00:\n * const result = startOfISOWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Mon Sep 01 2014 00:00:00\n */\nexport function startOfISOWeek(date) {\n  return startOfWeek(date, { weekStartsOn: 1 });\n}\n\n// Fallback for modularized imports:\nexport default startOfISOWeek;\n","import { getISOWeekYear } from \"./getISOWeekYear.mjs\";\nimport { startOfISOWeek } from \"./startOfISOWeek.mjs\";\nimport { constructFrom } from \"./constructFrom.mjs\";\n\n/**\n * @name startOfISOWeekYear\n * @category ISO Week-Numbering Year Helpers\n * @summary Return the start of an ISO week-numbering year for the given date.\n *\n * @description\n * Return the start of an ISO week-numbering year,\n * which always starts 3 days before the year's first Thursday.\n * The result will be in the local timezone.\n *\n * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The original date\n *\n * @returns The start of an ISO week-numbering year\n *\n * @example\n * // The start of an ISO week-numbering year for 2 July 2005:\n * const result = startOfISOWeekYear(new Date(2005, 6, 2))\n * //=> Mon Jan 03 2005 00:00:00\n */\nexport function startOfISOWeekYear(date) {\n  const year = getISOWeekYear(date);\n  const fourthOfJanuary = constructFrom(date, 0);\n  fourthOfJanuary.setFullYear(year, 0, 4);\n  fourthOfJanuary.setHours(0, 0, 0, 0);\n  return startOfISOWeek(fourthOfJanuary);\n}\n\n// Fallback for modularized imports:\nexport default startOfISOWeekYear;\n","import { constructFrom } from \"./constructFrom.mjs\";\nimport { startOfISOWeek } from \"./startOfISOWeek.mjs\";\nimport { toDate } from \"./toDate.mjs\";\n\n/**\n * @name getISOWeekYear\n * @category ISO Week-Numbering Year Helpers\n * @summary Get the ISO week-numbering year of the given date.\n *\n * @description\n * Get the ISO week-numbering year of the given date,\n * which always starts 3 days before the year's first Thursday.\n *\n * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The given date\n *\n * @returns The ISO week-numbering year\n *\n * @example\n * // Which ISO-week numbering year is 2 January 2005?\n * const result = getISOWeekYear(new Date(2005, 0, 2))\n * //=> 2004\n */\nexport function getISOWeekYear(date) {\n  const _date = toDate(date);\n  const year = _date.getFullYear();\n\n  const fourthOfJanuaryOfNextYear = constructFrom(date, 0);\n  fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);\n  fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);\n  const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);\n\n  const fourthOfJanuaryOfThisYear = constructFrom(date, 0);\n  fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);\n  fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);\n  const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);\n\n  if (_date.getTime() >= startOfNextYear.getTime()) {\n    return year + 1;\n  } else if (_date.getTime() >= startOfThisYear.getTime()) {\n    return year;\n  } else {\n    return year - 1;\n  }\n}\n\n// Fallback for modularized imports:\nexport default getISOWeekYear;\n","import { constructFrom } from \"./constructFrom.mjs\";\nimport { getWeekYear } from \"./getWeekYear.mjs\";\nimport { startOfWeek } from \"./startOfWeek.mjs\";\nimport { getDefaultOptions } from \"./_lib/defaultOptions.mjs\";\n\n/**\n * The {@link startOfWeekYear} function options.\n */\n\n/**\n * @name startOfWeekYear\n * @category Week-Numbering Year Helpers\n * @summary Return the start of a local week-numbering year for the given date.\n *\n * @description\n * Return the start of a local week-numbering year.\n * The exact calculation depends on the values of\n * `options.weekStartsOn` (which is the index of the first day of the week)\n * and `options.firstWeekContainsDate` (which is the day of January, which is always in\n * the first week of the week-numbering year)\n *\n * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The original date\n * @param options - An object with options\n *\n * @returns The start of a week-numbering year\n *\n * @example\n * // The start of an a week-numbering year for 2 July 2005 with default settings:\n * const result = startOfWeekYear(new Date(2005, 6, 2))\n * //=> Sun Dec 26 2004 00:00:00\n *\n * @example\n * // The start of a week-numbering year for 2 July 2005\n * // if Monday is the first day of week\n * // and 4 January is always in the first week of the year:\n * const result = startOfWeekYear(new Date(2005, 6, 2), {\n *   weekStartsOn: 1,\n *   firstWeekContainsDate: 4\n * })\n * //=> Mon Jan 03 2005 00:00:00\n */\nexport function startOfWeekYear(date, options) {\n  const defaultOptions = getDefaultOptions();\n  const firstWeekContainsDate =\n    options?.firstWeekContainsDate ??\n    options?.locale?.options?.firstWeekContainsDate ??\n    defaultOptions.firstWeekContainsDate ??\n    defaultOptions.locale?.options?.firstWeekContainsDate ??\n    1;\n\n  const year = getWeekYear(date, options);\n  const firstWeek = constructFrom(date, 0);\n  firstWeek.setFullYear(year, 0, firstWeekContainsDate);\n  firstWeek.setHours(0, 0, 0, 0);\n  const _date = startOfWeek(firstWeek, options);\n  return _date;\n}\n\n// Fallback for modularized imports:\nexport default startOfWeekYear;\n","import { constructFrom } from \"./constructFrom.mjs\";\nimport { startOfWeek } from \"./startOfWeek.mjs\";\nimport { toDate } from \"./toDate.mjs\";\nimport { getDefaultOptions } from \"./_lib/defaultOptions.mjs\";\n\n/**\n * The {@link getWeekYear} function options.\n */\n\n/**\n * @name getWeekYear\n * @category Week-Numbering Year Helpers\n * @summary Get the local week-numbering year of the given date.\n *\n * @description\n * Get the local week-numbering year of the given date.\n * The exact calculation depends on the values of\n * `options.weekStartsOn` (which is the index of the first day of the week)\n * and `options.firstWeekContainsDate` (which is the day of January, which is always in\n * the first week of the week-numbering year)\n *\n * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The given date\n * @param options - An object with options.\n *\n * @returns The local week-numbering year\n *\n * @example\n * // Which week numbering year is 26 December 2004 with the default settings?\n * const result = getWeekYear(new Date(2004, 11, 26))\n * //=> 2005\n *\n * @example\n * // Which week numbering year is 26 December 2004 if week starts on Saturday?\n * const result = getWeekYear(new Date(2004, 11, 26), { weekStartsOn: 6 })\n * //=> 2004\n *\n * @example\n * // Which week numbering year is 26 December 2004 if the first week contains 4 January?\n * const result = getWeekYear(new Date(2004, 11, 26), { firstWeekContainsDate: 4 })\n * //=> 2004\n */\nexport function getWeekYear(date, options) {\n  const _date = toDate(date);\n  const year = _date.getFullYear();\n\n  const defaultOptions = getDefaultOptions();\n  const firstWeekContainsDate =\n    options?.firstWeekContainsDate ??\n    options?.locale?.options?.firstWeekContainsDate ??\n    defaultOptions.firstWeekContainsDate ??\n    defaultOptions.locale?.options?.firstWeekContainsDate ??\n    1;\n\n  const firstWeekOfNextYear = constructFrom(date, 0);\n  firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);\n  firstWeekOfNextYear.setHours(0, 0, 0, 0);\n  const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);\n\n  const firstWeekOfThisYear = constructFrom(date, 0);\n  firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);\n  firstWeekOfThisYear.setHours(0, 0, 0, 0);\n  const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);\n\n  if (_date.getTime() >= startOfNextYear.getTime()) {\n    return year + 1;\n  } else if (_date.getTime() >= startOfThisYear.getTime()) {\n    return year;\n  } else {\n    return year - 1;\n  }\n}\n\n// Fallback for modularized imports:\nexport default getWeekYear;\n","import { toDate } from \"./toDate.mjs\";\nimport { constructFrom } from \"./constructFrom.mjs\";\n\n/**\n * @name addDays\n * @category Day Helpers\n * @summary Add the specified number of days to the given date.\n *\n * @description\n * Add the specified number of days to the given date.\n *\n * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).\n *\n * @param date - The date to be changed\n * @param amount - The amount of days to be added.\n *\n * @returns The new date with the days added\n *\n * @example\n * // Add 10 days to 1 September 2014:\n * const result = addDays(new Date(2014, 8, 1), 10)\n * //=> Thu Sep 11 2014 00:00:00\n */\nexport function addDays(date, amount) {\n  const _date = toDate(date);\n  if (isNaN(amount)) return constructFrom(date, NaN);\n  if (!amount) {\n    // If 0 days, no-op to avoid changing times in the hour before end of DST\n    return _date;\n  }\n  _date.setDate(_date.getDate() + amount);\n  return _date;\n}\n\n// Fallback for modularized imports:\nexport default addDays;\n","import { Periodicity } from '@ecosystem/newron-core/types';\nimport { PeriodAggregation, TimeFrameOption } from '../types';\nimport { FirstWeekContainsDate, addDays, startOfISOWeekYear, startOfWeekYear } from 'date-fns';\n\nconst getWeekDates = (option: TimeFrameOption, isISOWeekNumber: boolean): [Date, Date] => {\n  if (!option || option.aggregation !== PeriodAggregation.Week) {\n    return [undefined, undefined];\n  }\n\n  const [week, year] = option.label.split(' ');\n  const weekNumber = Number(week.replace('W', ''));\n  const yearNumber = Number(year);\n\n  const weekNumberToDate = (weekNumber: number, year: number, isISOWeekNumber: boolean) => {\n    const randomDateInYear = new Date(year, 5, 5);\n    const startOfFirstWeekDate = isISOWeekNumber\n      ? startOfISOWeekYear(randomDateInYear)\n      : startOfWeekYear(randomDateInYear, {\n          firstWeekContainsDate: 3 as FirstWeekContainsDate,\n        });\n    const targetDate = addDays(startOfFirstWeekDate, (weekNumber - 1) * 7);\n    return targetDate;\n  };\n\n  const date = weekNumberToDate(weekNumber, yearNumber, isISOWeekNumber);\n\n  return [date, addDays(date, 6)];\n};\n\nconst getWeekStart = (option: TimeFrameOption, isISOWeekNumber: boolean): Date => {\n  const [start, _end] = getWeekDates(option, isISOWeekNumber);\n  return start;\n};\n\nconst getWeekEnd = (option: TimeFrameOption, isISOWeekNumber: boolean): Date => {\n  const [_start, end] = getWeekDates(option, isISOWeekNumber);\n  return end;\n};\n\nconst getPeriodicity = (aggregation: PeriodAggregation): Periodicity => {\n  return aggregation === PeriodAggregation.Week ? Periodicity.Weekly : Periodicity.Monthly;\n};\n\nexport { getWeekStart, getWeekEnd, getPeriodicity };\n","import React, { useEffect, useState } from 'react';\nimport { inputs } from '@ecosystem/newron-design-system';\nimport { Market, TimeFrame, TimeFrameOption } from '../types';\nimport { getWeekEnd, getWeekStart } from './weeksSelector.utils';\nimport { isCustomWeekly } from './periodSelector.utils';\nimport { Periodicity } from '@ecosystem/newron-core/types';\nimport { ApplyPeriodButton } from './applyPeriod.button';\nimport { WARNING_MESSAGE_ON_APPLY } from './constants';\n\nconst { WeekPicker, WeekFormatType } = inputs;\n\nconst isISOWeekNumber = false;\n\ntype Props = {\n  weeklyOptions: TimeFrameOption[];\n  markets: Market[];\n  currentValue: TimeFrame;\n  onSelect: (value: TimeFrameOption, removeAffectedMarkets: boolean) => void;\n};\n\nexport function WeeksSelector({ weeklyOptions = [], markets = [], currentValue, onSelect }: Props) {\n  const [weekFrom, setWeekFrom] = useState<{ timeFrame: TimeFrameOption; startDate: Date }>(null);\n  const [weekTo, setWeekTo] = useState<{ timeFrame: TimeFrameOption; startDate: Date }>(null);\n  const [isWrongDateRange, setIsWrongDateRange] = useState(false);\n\n  // chack markets\n  const notAvailableMarkets = markets.filter(m => m.periods.every(p => p.periodicity !== Periodicity.Weekly));\n  const notPublishedMarkets = markets.filter(m =>\n    m.periods.find(p => p.periodicity === Periodicity.Weekly && p.sequence < weekTo?.timeFrame.endSequence)\n  );\n\n  //  sort and map options for fast direct access\n  const optionsMap = new Map(weeklyOptions.map(opt => [opt.label, opt]));\n  const optionsSorted = [...weeklyOptions].sort((a, b) => a.endSequence - b.endSequence);\n\n  // get min and max possible options\n  const minDate = getWeekStart(optionsSorted[0], isISOWeekNumber);\n  const maxDate = getWeekEnd(optionsSorted.at(-1), isISOWeekNumber);\n\n  useEffect(() => {\n    // prefill values - either current value or the latest period\n    if (!!weekFrom && !!weekTo) {\n      return;\n    }\n    if (!optionsSorted || optionsSorted.length === 0) {\n      return;\n    }\n\n    const setCurrentDates = () => {\n      const startPeriod = optionsSorted.find(opt => opt.endSequence === currentValue.startSequence);\n      const endPeriod = optionsSorted.find(opt => opt.endSequence === currentValue.endSequence);\n      setWeekFrom({ timeFrame: startPeriod, startDate: getWeekStart(startPeriod, isISOWeekNumber) });\n      setWeekTo({ timeFrame: endPeriod, startDate: getWeekStart(endPeriod, isISOWeekNumber) });\n    };\n\n    const setLatestPeriod = () => {\n      const defaultWeekFrom = optionsSorted.at(-2);\n      const defaultWeekTo = optionsSorted.at(-1);\n      setWeekFrom({ timeFrame: defaultWeekFrom, startDate: getWeekStart(defaultWeekFrom, isISOWeekNumber) });\n      setWeekTo({ timeFrame: defaultWeekTo, startDate: getWeekStart(defaultWeekTo, isISOWeekNumber) });\n    };\n\n    if (currentValue && isCustomWeekly(currentValue)) {\n      setCurrentDates();\n    } else {\n      setLatestPeriod();\n    }\n  }, [optionsSorted, currentValue, weekFrom, weekTo]);\n\n  useEffect(() => {\n    // check if dates are valid\n    if (!!weekFrom?.startDate && !!weekTo?.startDate) {\n      setIsWrongDateRange(weekFrom?.startDate > weekTo?.startDate);\n    }\n  }, [weekFrom?.startDate, weekTo?.startDate]);\n\n  const handleApply = () => {\n    if (weekFrom && weekTo) {\n      const customTimeFramePeriod = {\n        ...weekFrom?.timeFrame,\n        value: `Weekly:${weekFrom.timeFrame.endSequence}-${weekTo.timeFrame.endSequence}:Custom`,\n      };\n      onSelect(customTimeFramePeriod, false);\n    }\n  };\n\n  return (\n    <div className={'flex flex-column h-full justify-end'}>\n      <div\n        className={'p-4 pt-0'}\n        style={{\n          marginBottom: 'auto',\n        }}\n      >\n        <WeekPicker\n          label={'From'}\n          defaultDate={weekFrom?.startDate}\n          dateFormat={WeekFormatType['Ww yyyy']}\n          isISOWeekNumber={isISOWeekNumber}\n          minDate={minDate}\n          maxDate={maxDate}\n          placeholder=\"Select week\"\n          onChange={val => {\n            if (val !== weekFrom?.timeFrame?.label && optionsMap.has(val)) {\n              const selected = optionsMap.get(val);\n              const startDate = getWeekStart(selected, isISOWeekNumber);\n              setWeekFrom({ timeFrame: selected, startDate });\n            }\n          }}\n        />\n        <WeekPicker\n          label={'To'}\n          defaultDate={weekTo?.startDate}\n          dateFormat={WeekFormatType['Ww yyyy']}\n          isISOWeekNumber={isISOWeekNumber}\n          minDate={minDate}\n          maxDate={maxDate}\n          placeholder=\"Select week\"\n          onChange={val => {\n            if (val !== weekTo?.timeFrame?.label && optionsMap.has(val)) {\n              const selected = optionsMap.get(val);\n              const startDate = getWeekStart(selected, isISOWeekNumber);\n              setWeekTo({ timeFrame: selected, startDate });\n            }\n          }}\n        />\n        {isWrongDateRange && <div className={'error-message'}>{WARNING_MESSAGE_ON_APPLY}</div>}\n      </div>\n      <hr />\n      <ApplyPeriodButton\n        notPublishedMarkets={notPublishedMarkets}\n        notAvailableMarkets={notAvailableMarkets}\n        onApply={handleApply}\n        disabled={!weekFrom || !weekTo || isWrongDateRange}\n      />\n    </div>\n  );\n}\n","import React, { useEffect, useState } from 'react';\nimport { elements, inputs, feedback } from '@ecosystem/newron-design-system';\nimport { Market, PeriodAggregation, TimeFrame, TimeFrameOption } from '../types';\nimport './periodSelector.css';\nimport { MonthsSelector } from './monthsSelector';\nimport { WeeksSelector } from './weeksSelector';\nimport { isCustomMonthly, isCustomWeekly } from './periodSelector.utils';\nimport { getPeriodicity } from './weeksSelector.utils';\nimport { currentProposition } from '../../utils/currentProposition';\n\nconst { Icon } = elements;\nconst { Checkbox, CheckboxState, RadioButtons } = inputs;\nconst { Tooltip } = feedback;\n\nexport const DISMISSED_KEY = () => `incomplete_period_notice_dismissed_${currentProposition()}`;\n\ntype Props = {\n  options: TimeFrameOption[];\n  markets: Market[];\n  aggregation: PeriodAggregation;\n  currentValue: TimeFrame;\n  isDistributionPanel?: boolean;\n  onSelect: (value: TimeFrameOption, removeAffectedMarkets?: boolean) => void;\n  onAggregationChange: (aggregation: PeriodAggregation) => void;\n  handlePartialTimeFrameData?: (option: TimeFrameOption, removeAffectedMarkets: boolean) => void;\n};\n\nfunction PeriodSelector({\n  options,\n  markets,\n  aggregation,\n  currentValue,\n  isDistributionPanel,\n  onSelect,\n  onAggregationChange,\n  handlePartialTimeFrameData,\n}: Props) {\n  const periodicity = getPeriodicity(aggregation);\n\n  const defaultAggregation = isDistributionPanel ? PeriodAggregation.Week : PeriodAggregation.Month;\n  const [showIncompleteMsg, setShowIncompleteMsg] = useState<boolean>(false);\n  const [customAggregation, setCustomAggregation] = useState<PeriodAggregation.Month | PeriodAggregation.Week>(\n    defaultAggregation\n  );\n\n  useEffect(() => {\n    const dismissed = localStorage.getItem(DISMISSED_KEY());\n    setShowIncompleteMsg(dismissed !== 'true');\n  }, []);\n\n  useEffect(() => {\n    if (isCustomWeekly(currentValue)) {\n      setCustomAggregation(PeriodAggregation.Week);\n    } else if (isCustomMonthly(currentValue)) {\n      setCustomAggregation(PeriodAggregation.Month);\n    }\n  }, [currentValue]);\n\n  const notOnAll = options.filter(opt => opt.aggregation === aggregation && !opt.availableOnAll);\n  const onAll = options.filter(opt => opt.aggregation === aggregation && opt.availableOnAll);\n  const hasWeekly = options.some(opt => opt.aggregation === PeriodAggregation.Week);\n\n  const handleItemClick = (opt: TimeFrameOption) => {\n    onSelect(opt);\n  };\n\n  const handleDismiss = () => {\n    setShowIncompleteMsg(false);\n    localStorage.setItem(DISMISSED_KEY(), 'true');\n  };\n\n  return (\n    <div\n      className={`flex flex-column overflow-visible flex-grow ${\n        PeriodAggregation.Custom === aggregation ? 'overflow-visible' : 'overflow-y-auto'\n      } overscroll-contain pb-2 pt-2`}\n    >\n      {[PeriodAggregation.Quarter, PeriodAggregation.RollingQuarter].includes(aggregation) && (\n        <div className=\"border-b border-light mx-3.5 pt-2 pb-4 mb-2\">\n          <Checkbox\n            label=\"Rolling quarters\"\n            state={aggregation === PeriodAggregation.RollingQuarter ? CheckboxState.CHECKED : CheckboxState.UNCHECKED}\n            onChange={state =>\n              onAggregationChange(\n                state === CheckboxState.CHECKED ? PeriodAggregation.RollingQuarter : PeriodAggregation.Quarter\n              )\n            }\n          />\n        </div>\n      )}\n      {[PeriodAggregation.Year, PeriodAggregation.MAT, PeriodAggregation.YTD].includes(aggregation) && (\n        <div className=\"border-b border-light mx-3.5 pt-2 pb-4 mb-2\">\n          <RadioButtons\n            options={[\n              {\n                value: PeriodAggregation.Year,\n                label: 'Whole year',\n              },\n              {\n                value: PeriodAggregation.MAT,\n                label: 'Moving annual total',\n              },\n              {\n                value: PeriodAggregation.YTD,\n                label: 'Year to date',\n              },\n            ]}\n            value={aggregation}\n            onChange={val => onAggregationChange(val as PeriodAggregation)}\n          />\n        </div>\n      )}\n      {PeriodAggregation.Custom === aggregation && (\n        <>\n          {hasWeekly && (\n            <div className=\"border-b border-light mx-3.5 pt-2 pb-4 mb-2\">\n              <Checkbox\n                label=\"Weekly\"\n                disabled={isDistributionPanel}\n                state={customAggregation === PeriodAggregation.Week ? CheckboxState.CHECKED : CheckboxState.UNCHECKED}\n                onChange={state =>\n                  setCustomAggregation(\n                    state === CheckboxState.CHECKED ? PeriodAggregation.Week : PeriodAggregation.Month\n                  )\n                }\n              />\n            </div>\n          )}\n          {customAggregation === PeriodAggregation.Week && (\n            <WeeksSelector\n              currentValue={currentValue}\n              onSelect={handlePartialTimeFrameData}\n              weeklyOptions={options.filter(opt => opt.aggregation === PeriodAggregation.Week)}\n              markets={markets}\n            />\n          )}\n          {customAggregation === PeriodAggregation.Month && (\n            <MonthsSelector\n              currentValue={currentValue}\n              onSelect={handlePartialTimeFrameData}\n              monthlyOptions={options.filter(opt => opt.aggregation === PeriodAggregation.Month)}\n              markets={markets}\n            />\n          )}\n        </>\n      )}\n      {aggregation !== PeriodAggregation.Custom && (\n        <>\n          {notOnAll.length > 0 && showIncompleteMsg && (\n            <div className=\"text-sm px-4 py-3 bg-brand-lightest mb-2\">\n              <div className=\"flex flex-row gap-2\">\n                <Icon color=\"lighter\">\n                  <Icon.icons.Fractional />\n                </Icon>\n                <p className=\"flex-grow text sm\">This mark means data is not available for all selected markets yet.</p>\n              </div>\n              <button className=\"block text-brand py-2\" onClick={handleDismiss}>\n                Dismiss\n              </button>\n            </div>\n          )}\n          {notOnAll.map(opt => (\n            <PeriodItem\n              key={opt.value}\n              option={opt}\n              isActive={opt.value === currentValue.value}\n              onClick={() => handleItemClick(opt)}\n              periodicity={periodicity}\n              selectedMarkets={markets}\n              handlePartialTimeFrameData={handlePartialTimeFrameData}\n            />\n          ))}\n          {notOnAll.length > 0 && <div className=\"border-b border-light my-2 mx-2 h-px\" />}\n          {onAll.map(opt => (\n            <>\n              <PeriodItem\n                key={opt.value}\n                option={opt}\n                isActive={opt.value === currentValue.value}\n                onClick={() => handleItemClick(opt)}\n                periodicity={periodicity}\n                selectedMarkets={markets}\n              />\n              {aggregation === PeriodAggregation.Quarter && opt.label.startsWith('Q1') && (\n                <div className=\"border-b border-light my-2 mx-2 h-px\" />\n              )}\n            </>\n          ))}\n        </>\n      )}\n    </div>\n  );\n}\n\ntype ItemProps = {\n  option: TimeFrameOption;\n  isActive: boolean;\n  onClick: () => void;\n  selectedMarkets: Market[];\n  periodicity: string;\n  handlePartialTimeFrameData?: (option: TimeFrameOption, removeAffectedMarkets: boolean) => void;\n};\n\nfunction PeriodItem({\n  option,\n  isActive,\n  onClick,\n  selectedMarkets,\n  periodicity,\n  handlePartialTimeFrameData,\n}: ItemProps) {\n  const { label, availableOnAll, endSequence } = option;\n\n  const affectedMarkets = selectedMarkets.filter(m =>\n    m.periods.some(p => p.periodicity === periodicity && p.sequence < endSequence)\n  );\n\n  const unavailableMarkets = selectedMarkets.filter(m => !m.periods.some(p => p.periodicity === periodicity));\n\n  const handleClick = () => {\n    if (isActive) {\n      return;\n    }\n    if (unavailableMarkets.length > 0 || affectedMarkets.length > 0) {\n      handlePartialTimeFrameData(option, false);\n      return;\n    }\n    onClick();\n  };\n\n  const partialDataMessage = () => (\n    <Tooltip placement=\"right\">\n      <Icon size=\"sm\" color=\"lighter\">\n        <Icon.icons.Fractional />\n      </Icon>\n      <Tooltip.Content>\n        <div className=\"flex flex-column gap-3\" style={{ maxHeight: '12rem', overflowY: 'auto' }}>\n          {affectedMarkets.length > 0 && (\n            <div>\n              Data is not available for:\n              <ul className=\"ml-5\" style={{ listStyleType: 'disc' }}>\n                {affectedMarkets.slice(0, 4).map(({ label }) => (\n                  <li key={label}>{label}</li>\n                ))}\n                {affectedMarkets.slice(4).length > 0 && <span>{`and ${affectedMarkets.slice(4).length} more`}</span>}\n              </ul>\n            </div>\n          )}\n          {unavailableMarkets.length > 0 && (\n            <div>\n              Data is available for the below markets, but currently outside of your subscription:\n              <ul className=\"ml-5\" style={{ listStyleType: 'disc' }}>\n                {unavailableMarkets.slice(0, 4).map(({ label }) => (\n                  <li key={label}>{label}</li>\n                ))}\n                {unavailableMarkets.slice(4).length > 0 && (\n                  <span>{`and ${unavailableMarkets.slice(4).length} more`}</span>\n                )}\n              </ul>\n            </div>\n          )}\n        </div>\n      </Tooltip.Content>\n    </Tooltip>\n  );\n\n  return (\n    <button\n      className={`text-left w-full p-2 flex flex-row items-center gap-2 period-row ${\n        !isActive ? 'transition-colors hover:bg-brand-lightest' : 'cursor-default'\n      }`}\n      onClick={handleClick}\n    >\n      <span className={isActive ? 'visible' : 'hidden'}>\n        <Icon>\n          <Icon.icons.Check />\n        </Icon>\n      </span>\n      <span className=\"flex-grow nowrap\">{label}</span>\n      {!availableOnAll && partialDataMessage()}\n    </button>\n  );\n}\n\nexport { PeriodSelector };\n","import React from 'react';\nimport { elements, actions } from '@ecosystem/newron-design-system';\nimport { Market, TimeFrameOption } from '../types';\n\nconst { Icon } = elements;\nconst { Button } = actions;\n\ntype Props = {\n  option: TimeFrameOption;\n  markets: Market[];\n  onBack: () => void;\n  onSelect: (option: TimeFrameOption, removeAffectedMarkets: boolean) => void;\n};\nfunction IncompletePeriod({ option, markets, onBack, onSelect }: Props) {\n  const { endSequence, periodicity, label } = option;\n  const affectedMarkets = markets.filter(m =>\n    m.periods.find(p => p.periodicity === periodicity && p.sequence < endSequence)\n  );\n\n  return (\n    <div className=\"py-3 px-4 overflow-y-auto overscroll-contain\">\n      <button onClick={onBack} className=\"flex items-center text-sm text-brand py-1\">\n        <Icon size=\"sm\" color=\"brand\">\n          <Icon.icons.ChevronLeft />\n        </Icon>\n        back\n      </button>\n      <div className=\"font-bold text-heading flex gap-2 mt-2 mb-2\">\n        <Icon color=\"info\">\n          <Icon.icons.Info />\n        </Icon>\n        <span>Data not published</span>\n      </div>\n      <p className=\"text-sm\">\n        <b>{label}</b> data is not yet available for <b>{affectedMarkets.length}</b> of your <b>{markets.length}</b>{' '}\n        selected markets.\n      </p>\n      <div className=\"my-4\">\n        {affectedMarkets.slice(0, 5).map(m => (\n          <div className=\"text-xs font-bold\" key={m.value}>\n            {m.label}\n          </div>\n        ))}\n        {affectedMarkets.length > 5 && (\n          <span className=\"text-lighter text-xs\">+ {affectedMarkets.length - 5} more</span>\n        )}\n      </div>\n      <p className=\"text-sm mt-4\">Do you want to remove the affected markets before moving to {label}?</p>\n      <div className=\"relative px-2 pt-4 flex flex-column items-stretch gap-2\">\n        <div className=\"relative flex h-10\">\n          <Button onClick={() => onSelect(option, true)} stretch>\n            Yes, remove them\n          </Button>\n        </div>\n        <div className=\"relative flex h-10\">\n          <Button mode=\"secondary\" onClick={() => onSelect(option, false)} stretch>\n            No, continue anyway\n          </Button>\n        </div>\n      </div>\n    </div>\n  );\n}\n\nexport { IncompletePeriod };\n","import React from 'react';\nimport { Market } from '../types';\nimport { Periodicity } from '@ecosystem/newron-core/types';\nimport { actions, elements } from '@ecosystem/newron-design-system';\n\nconst { Button } = actions;\nconst { Icon } = elements;\n\ntype Props = {\n  isLoading: boolean;\n  markets: Market[];\n  periodicity: Periodicity;\n  onRemoveNonSubscribed: (markets: Market[]) => void;\n};\nfunction MissingSubscriptions({ isLoading, markets, periodicity, onRemoveNonSubscribed }: Props) {\n  const affectedMarkets = markets.filter(m => !m.periods.find(p => p.periodicity === periodicity));\n\n  const handleRemove = () => {\n    onRemoveNonSubscribed(affectedMarkets);\n  };\n\n  return (\n    <div className=\"py-6 px-4 overflow-y-auto overscroll-contain\">\n      {markets.length === affectedMarkets.length && (\n        <div className=\"text-sm flex flex-column gap-2\">\n          <Icon color=\"info\">\n            <Icon.icons.Info />\n          </Icon>\n          <span>{periodicity} periods are not available due to your current subscription.</span>\n          <span className=\"text-xs\">Need this data? Please contact your account manager to discuss your options.</span>\n        </div>\n      )}\n      {markets.length > affectedMarkets.length && (\n        <>\n          <div className=\"text-heading font-bold flex gap-2\">\n            <Icon color=\"info\">\n              <Icon.icons.Info />\n            </Icon>\n            <span>Missing subscriptions</span>\n          </div>\n          <div className=\"text-sm mt-4\">\n            A subscription to {periodicity} data is missing for <b>{affectedMarkets.length}</b> of your{' '}\n            <b>{markets.length}</b> selected markets.\n          </div>\n          <div className=\"my-4\">\n            {affectedMarkets.slice(0, 5).map(m => (\n              <div className=\"text-xs font-bold\" key={m.value}>\n                {m.label}\n              </div>\n            ))}\n            {affectedMarkets.length > 5 && (\n              <span className=\"text-lighter text-xs\">+ {affectedMarkets.length - 5} more</span>\n            )}\n          </div>\n          <div className=\"text-sm\">\n            Do you want to remove the affected markets from your selection so you can view {periodicity} data?\n          </div>\n          <div className=\"pt-4 flex justify-center\">\n            <Button disabled={isLoading} onClick={handleRemove}>\n              Yes, remove them\n            </Button>\n          </div>\n        </>\n      )}\n    </div>\n  );\n}\n\nexport { MissingSubscriptions };\n","\n      import API from \"!../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../../node_modules/css-loader/dist/cjs.js??ruleSet[1].rules[1].use[1]!./focusPeriod.css\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../../node_modules/css-loader/dist/cjs.js??ruleSet[1].rules[1].use[1]!./focusPeriod.css\";\n       export default content && content.locals ? content.locals : undefined;\n","import { Entity, Periodicity } from '@ecosystem/newron-core/types';\nimport { Market, TimeFrameOption } from '../types';\nimport { TimeFrames } from '../common';\n\nexport const getSelectedMarkets = settings => {\n  const cells = settings['cell'].values.map(c => c.value);\n  const allMarkets: Market[] = settings['openMarkets'].definition.selection.options.filter(\n    opt => typeof opt !== 'string'\n  ) as Market[];\n  const selectedMarkets = allMarkets.filter(m => cells.includes(m.value));\n  return selectedMarkets;\n};\n\nexport const getTimeFrameOptions = (settings, selectedMarkets: Market[]): TimeFrameOption[] => {\n  const earliestWeekly = Math.min(\n    ...selectedMarkets.map(m => m.periods.find(p => p.periodicity === Periodicity.Weekly)?.sequence || -1)\n  );\n  const earliestMonthly = Math.min(\n    ...selectedMarkets.map(m => m.periods.find(p => p.periodicity === Periodicity.Monthly)?.sequence || -1)\n  );\n\n  const periodOptions = settings['focusPeriod'].definition.selection.options.filter(\n    o => typeof o !== 'string'\n  ) as Entity[];\n\n  const timeFrameOptions: TimeFrameOption[] = periodOptions.map(po => {\n    const timeFrame = TimeFrames.toTimeFrame(po);\n    return {\n      ...timeFrame,\n      availableOnAll:\n        Number(timeFrame.endSequence) <=\n        (timeFrame.periodicity === Periodicity.Weekly ? earliestWeekly : earliestMonthly),\n    };\n  });\n  return timeFrameOptions;\n};\n","import React, { useEffect, useState } from 'react';\nimport { feedback } from '@ecosystem/newron-design-system';\nimport { ContextSelectorMenu, ContextSettingSelectorProps, useEditContextSettings } from '@ecosystem/newron-core';\nimport { Market, PeriodAggregation, TimeFrame, TimeFrameOption } from '../types';\nimport { Entity, Periodicity } from '@ecosystem/newron-core/types';\nimport { PeriodSelector } from './periodSelector';\nimport { IncompletePeriod } from './incompletePeriod';\nimport { MissingSubscriptions } from './missingSubscriptions';\nimport { NavMenuButton, TimeFrames } from '../common';\nimport { updateRecentMarkets } from '../market/recent';\nimport './focusPeriod.css';\nimport { getPeriodicity } from './weeksSelector.utils';\nimport { currentProposition } from '../../utils/currentProposition';\nimport { Proposition } from '../../utils/constants';\nimport { getSelectedMarkets, getTimeFrameOptions } from './util';\n\nconst { DotsLoader } = feedback;\n\nconst HEIGHT = '360px';\nconst WIDTH = '372px';\nconst PENDING_AGGREGATION_KEY = 'market_focus_period_aggregation';\n\nfunction FocusPeriodContextSelector({ isLoading, definition, onChange, onClose }: ContextSettingSelectorProps) {\n  const [selectedMarkets, setSelectedMarkets] = useState<Market[] | undefined>();\n  const [aggregation, setAggregation] = useState<PeriodAggregation>();\n  const [timeFrame, setTimeFrame] = useState<TimeFrame>();\n  const [timeFrameOptions, setTimeFrameOptions] = useState<TimeFrameOption[]>([]);\n  const [notAllAvailableOption, setNotAllAvailableOption] = useState<TimeFrameOption | undefined>();\n\n  const { getContextSettings } = useEditContextSettings();\n\n  useEffect(() => {\n    const fetch = async () => {\n      const settings = await getContextSettings(['openMarkets', 'focusPeriod', 'timeFrame', 'cell']);\n\n      const selectedMarkets = getSelectedMarkets(settings);\n      setSelectedMarkets(selectedMarkets);\n\n      const timeFrame = TimeFrames.toTimeFrame(settings['timeFrame'].values[0]);\n      setTimeFrame(timeFrame);\n\n      const pendingAggregation = sessionStorage.getItem(PENDING_AGGREGATION_KEY);\n      sessionStorage.removeItem(PENDING_AGGREGATION_KEY);\n\n      const aggregation = (pendingAggregation as PeriodAggregation) || timeFrame.aggregation;\n      setAggregation(aggregation);\n\n      const timeFrameOptions = getTimeFrameOptions(settings, selectedMarkets);\n      setTimeFrameOptions(timeFrameOptions);\n    };\n\n    fetch();\n\n    /* eslint-disable react-hooks/exhaustive-deps */\n  }, [definition]);\n\n  const handleAggregationChange = (value: PeriodAggregation) => {\n    setNotAllAvailableOption(undefined);\n    setAggregation(value);\n  };\n\n  const handleTimeFrameSelect = (option: TimeFrameOption) => {\n    if (!option.availableOnAll) {\n      setNotAllAvailableOption(option);\n      return;\n    }\n\n    onChange({\n      timeFrame: [TimeFrames.toEntity(option)],\n    });\n    onClose();\n  };\n\n  const handleNotAllAvailableTimeFrameSelect = (option: TimeFrameOption, removeAffectedMarkets: boolean) => {\n    const updates: Record<string, Entity[]> = {\n      timeFrame: [TimeFrames.toEntity(option)],\n    };\n\n    if (removeAffectedMarkets) {\n      const affectedMarkets = selectedMarkets\n        .filter(m =>\n          m.periods.find(p => p.periodicity === option.periodicity && p.sequence < Number(option.endSequence))\n        )\n        .map(m => m.value);\n\n      updates.cell = selectedMarkets\n        .filter(m => !affectedMarkets.includes(m.value))\n        .map(m => ({\n          value: m.value,\n          label: m.label,\n        }));\n\n      updateRecentMarkets(updates.cell);\n    }\n\n    onChange(updates);\n    onClose();\n  };\n\n  const handleRemoveNonSubscribed = (marketsToRemove: Market[]) => {\n    sessionStorage.setItem(PENDING_AGGREGATION_KEY, aggregation);\n    const marketsToKeep = selectedMarkets.filter(m => !marketsToRemove.find(mtr => mtr.value === m.value));\n    const validTimeFrame = TimeFrames.validateTimeFrame(timeFrame, marketsToKeep, timeFrameOptions);\n    const cellsToKeep = marketsToKeep.map(m => ({\n      value: m.value,\n      label: m.label,\n    }));\n    onChange({\n      timeFrame: [TimeFrames.toEntity(validTimeFrame)],\n      cell: cellsToKeep,\n    });\n    updateRecentMarkets(cellsToKeep);\n  };\n\n  let hasMissingSubscriptions = false;\n  let hasCompleteData = false;\n\n  if (selectedMarkets) {\n    const periodicity = getPeriodicity(aggregation);\n    const affectedMarkets = selectedMarkets.filter(m => !m.periods.some(p => p.periodicity === periodicity));\n    hasCompleteData = selectedMarkets.length === affectedMarkets.length;\n    hasMissingSubscriptions = affectedMarkets.length > 0;\n  }\n\n  const isDistributionPanel = currentProposition() === Proposition.DistributionPanel;\n  const hideCustomWarning = isDistributionPanel && aggregation === PeriodAggregation.Custom;\n\n  return (\n    <ContextSelectorMenu>\n      {!selectedMarkets && (\n        <div style={{ height: HEIGHT, width: WIDTH }}>\n          <DotsLoader stretch />\n        </div>\n      )}\n      {selectedMarkets && (\n        <div style={{ height: HEIGHT, width: WIDTH }} className=\"flex flex-row items-stretch\">\n          <div className=\"relative w-32 flex-shrink-0 bg-light px-2 py-2 rounded-bl\">\n            <NavMenuButton\n              label={PeriodAggregation.Week}\n              isActive={aggregation === PeriodAggregation.Week}\n              onClick={() => handleAggregationChange(PeriodAggregation.Week)}\n            />\n            <NavMenuButton\n              isDisabled={isDistributionPanel}\n              label={PeriodAggregation.Month}\n              isActive={aggregation === PeriodAggregation.Month}\n              onClick={() => handleAggregationChange(PeriodAggregation.Month)}\n            />\n            <NavMenuButton\n              isDisabled={isDistributionPanel}\n              label={PeriodAggregation.Quarter}\n              isActive={aggregation === PeriodAggregation.Quarter || aggregation === PeriodAggregation.RollingQuarter}\n              onClick={() => handleAggregationChange(PeriodAggregation.Quarter)}\n            />\n            <NavMenuButton\n              isDisabled={isDistributionPanel}\n              label={PeriodAggregation.Year}\n              isActive={[PeriodAggregation.Year, PeriodAggregation.MAT, PeriodAggregation.YTD].includes(aggregation)}\n              onClick={() => handleAggregationChange(PeriodAggregation.Year)}\n            />\n            <hr />\n            <NavMenuButton\n              label={PeriodAggregation.Custom}\n              isActive={[PeriodAggregation.Custom].includes(aggregation)}\n              onClick={() => handleAggregationChange(PeriodAggregation.Custom)}\n            />\n          </div>\n          {hasMissingSubscriptions && hasCompleteData && !hideCustomWarning && (\n            <MissingSubscriptions\n              isLoading={isLoading}\n              onRemoveNonSubscribed={handleRemoveNonSubscribed}\n              markets={selectedMarkets}\n              periodicity={aggregation === PeriodAggregation.Week ? Periodicity.Weekly : Periodicity.Monthly}\n            />\n          )}\n          {!hasMissingSubscriptions && notAllAvailableOption && (\n            <IncompletePeriod\n              onSelect={handleNotAllAvailableTimeFrameSelect}\n              option={notAllAvailableOption}\n              markets={selectedMarkets}\n              onBack={() => setNotAllAvailableOption(undefined)}\n            />\n          )}\n          {!notAllAvailableOption && (\n            <PeriodSelector\n              currentValue={timeFrame}\n              markets={selectedMarkets}\n              options={timeFrameOptions}\n              aggregation={aggregation}\n              isDistributionPanel={isDistributionPanel}\n              onSelect={handleTimeFrameSelect}\n              onAggregationChange={handleAggregationChange}\n              handlePartialTimeFrameData={handleNotAllAvailableTimeFrameSelect}\n            />\n          )}\n        </div>\n      )}\n    </ContextSelectorMenu>\n  );\n}\n\nexport { FocusPeriodContextSelector };\n","import { FilterContext } from '@ecosystem/newron-client-lib';\n\nexport const filterContext: FilterContext = { product: 'newron', namespace: 'market-portfolio' };\n","import { useEffect } from 'react';\nimport { useLocation, useNavigate } from 'react-router-dom';\nimport { registerViewFilterFunction } from './registerViewNotification';\nimport { useSavedFiltersContext } from '@ecosystem/newron-core';\n\nconst NEW_FILTER_URL_PARAM = 'filterId';\n\nconst M2_PATH = /\\/mi|\\/ml|\\/mo/;\nconst DP_PATH = /\\/dpi|\\/dpl|\\/dpo/;\nconst PL_ANALYSE_PATHS = /ml\\/products\\/analyse/;\n\nfunction deleteFilterParam() {\n  const url = new URL(window.location.href);\n  const urlSearchParams = url.searchParams;\n  urlSearchParams.delete(NEW_FILTER_URL_PARAM);\n  url.search = urlSearchParams.toString();\n  history.replaceState({}, '', url.href);\n}\n\nfunction ViewSavedFilterHandler() {\n  const navigate = useNavigate();\n  const location = useLocation();\n  const searchParams = new URLSearchParams(location.search);\n  const urlFilterId = searchParams.has(NEW_FILTER_URL_PARAM) ? searchParams.get(NEW_FILTER_URL_PARAM) : null;\n  const { setNewFilterId } = useSavedFiltersContext();\n\n  // register view filter function\n  useEffect(() => {\n    const viewFilterFunction = filterData => {\n      const isMarket2Page = Boolean(window.location.pathname.match(M2_PATH));\n      const isAnalysePage = Boolean(window.location.pathname.match(PL_ANALYSE_PATHS));\n      const isDpPage = Boolean(window.location.pathname.match(DP_PATH));\n\n      if ((!isMarket2Page && !isDpPage) || isAnalysePage) {\n        navigate(`/mo?filterId=${filterData.filterId}`);\n      } else {\n        setNewFilterId(filterData.filterId);\n      }\n    };\n\n    registerViewFilterFunction(viewFilterFunction);\n  }, [navigate, setNewFilterId]);\n\n  // write filter id from the url to the saved filter context\n  useEffect(() => {\n    const isMarket2Page = Boolean(window.location.pathname.match(M2_PATH));\n    if (isMarket2Page && urlFilterId) {\n      setNewFilterId(urlFilterId);\n      deleteFilterParam();\n    }\n  }, [urlFilterId, setNewFilterId]);\n\n  return null;\n}\n\nexport { ViewSavedFilterHandler };\n","import { ViewNotificationsRegister, ViewNotificationDataType } from '@ecosystem/newron-client-lib';\n\nconst FILTER_DOMAIN_NAME = 'market-portfolio';\n\nconst registerViewFilterFunction = (viewFilterFunction: (filterData: ViewNotificationDataType) => void) => {\n  ViewNotificationsRegister?.getInstance().register({\n    domainName: FILTER_DOMAIN_NAME,\n    viewFilterFunction,\n  });\n};\n\nexport { registerViewFilterFunction };\n","import { authentication, isInternal } from '@ecosystem/newron-client-lib';\n\ninterface ImpersonationHeader {\n  'X-Impersonate-Client': string;\n}\n\nconst IMPERSONATION_STORAGE_KEY = 'impersonation';\n\n/**\n * Returns the impersonation header to use for API calls.\n */\nexport function getImpersonationHeader(): ImpersonationHeader | null {\n  const isInternalUser = isInternal(authentication.getUser());\n  if (!isInternalUser) {\n    return null;\n  }\n\n  const storage = localStorage.getItem(IMPERSONATION_STORAGE_KEY);\n  if (storage) {\n    return {\n      'X-Impersonate-Client': storage,\n    };\n  }\n\n  return null;\n}\n","import { authentication } from '@ecosystem/newron-client-lib';\nimport { getImpersonationHeader } from './impersonation';\nimport { BFF_HOST } from './constants';\n\nexport interface AuthResult {\n  product: string;\n  internalProduct: string;\n  approved: { cell: string }[];\n}\n\nexport const fetchCollectionsRegistry = async (): Promise<any[]> => {\n  const token = await authentication.getAccessToken();\n  const impersonationHeader = getImpersonationHeader();\n  const fullApiUrl = `${BFF_HOST}/collection/config`;\n\n  const result = await fetch(fullApiUrl, {\n    headers: {\n      Authorization: `Bearer ${token}`,\n      ...impersonationHeader,\n    },\n  });\n\n  return (await result.json()) as AuthResult[];\n};\n","import React, { useEffect } from 'react';\nimport { CollectionsInsightRenderRegister, Proposition } from '@ecosystem/newron-client-collections';\nimport { InsightElement, getInsightInfo, getConfigItemCallbacks } from '@ecosystem/newron-core';\n\nimport { fetchCollectionsRegistry } from '../lib/bff.client';\nimport { InsightData } from '@ecosystem/newron-core/content/collection/types';\n\nexport const CollectionProvider = ({ children }) => {\n  useEffect(() => {\n    loadCollectionsRegister();\n  }, []);\n  return <>{children}</>;\n};\n\nconst loadCollectionsRegister = async () => {\n  const collectionsRegister = await fetchCollectionsRegistry();\n  collectionsRegister.forEach(collection => {\n    const instance = CollectionsInsightRenderRegister.getInstance();\n    instance.register<InsightData>(\n      { proposition: Proposition.Market, type: collection.collectionKey },\n      {\n        InsightRenderer: InsightElement,\n        getInsightInfo: insight => getInsightInfo(insight, collection),\n        configItemCallbacks: getConfigItemCallbacks(),\n      }\n    );\n\n    instance.register<InsightData>(\n      { proposition: Proposition.DistributionPanel, type: collection.collectionKey },\n      {\n        InsightRenderer: InsightElement,\n        getInsightInfo: insight => getInsightInfo(insight, collection),\n      }\n    );\n  });\n};\n","import { CorePage } from '@ecosystem/newron-core';\nimport React from 'react';\nimport { useNavigate } from 'react-router-dom';\nimport { APP_VERSION, BFF_HOST } from '../../lib/constants';\nimport { mapCoreMetaParams } from '../../lib/analytics/tools';\nimport { ContextName } from '../types';\nimport { Proposition, ROUTE_PREFIX } from '../../utils/constants';\n\nfunction DPOverviewPage() {\n  const navigate = useNavigate();\n  const defaultSubsection = 'Overview';\n  const calcTrackingParams = (_eventName, meta) => {\n    return mapCoreMetaParams(Proposition.DistributionPanel, meta, defaultSubsection, defaultSubsection);\n  };\n  const { Dpo, Dp } = ROUTE_PREFIX;\n\n  return (\n    <CorePage\n      context={{\n        name: ContextName.dp,\n        url: `${BFF_HOST}/context/${Dp}/overview`,\n        excludeFilters: false,\n        excludePriceFilter: false,\n      }}\n      page={{\n        name: 'dp-overview',\n        url: `${BFF_HOST}/${Dpo}/page`,\n        appVersion: APP_VERSION,\n      }}\n      data={{\n        url: `${BFF_HOST}/${Dpo}/data`,\n      }}\n      collection={{\n        url: `${BFF_HOST}/context/collection/overview?proposition=${Dp}`,\n      }}\n      navigate={navigate}\n      defaultSubsection={defaultSubsection}\n      calcTrackingParams={calcTrackingParams}\n    />\n  );\n}\n\nexport { DPOverviewPage };\nexport default DPOverviewPage;\n","import React from 'react';\nimport { BrowserRouter, Navigate, Route, Routes } from 'react-router-dom';\nimport { feedback } from '@ecosystem/newron-design-system';\nimport { AuthenticationProvider } from '@ecosystem/newron-client-lib';\nimport { ContentProviderRegister, SavedFiltersProvider } from '@ecosystem/newron-core';\nimport { SpecialStatic } from '../content/special.static';\nimport { MarketSelector } from '../context/markets';\nimport { BrandOptionsSelector } from '../context/brands';\nimport { MarketContextSelector } from '../context/market/market';\nimport { FocusPeriodContextSelector } from '../context/focusPeriod/focusPeriod';\nimport { filterContext } from '../filters/filters';\nimport { ViewSavedFilterHandler } from '../filters/viewSavedFilterHandler';\nimport { CollectionProvider } from '../providers/collection.provider';\nimport { addSavedViewKeyToSessionStorage } from '../utils/savedView';\nimport { ROUTE_PREFIX } from '../utils/constants';\nimport DPOverviewPage from '../pages/dp/overview';\n\nconst OverviewPage = React.lazy(() => import('../pages/market/overview'));\nconst OverviewLightPage = React.lazy(() => import('../pages/market/overviewLight'));\nconst MiPage = React.lazy(() => import('../pages/market/mi'));\nconst ProductsPage = React.lazy(() => import('../pages/market/products'));\nconst AnalyseProductsPage = React.lazy(() => import('../pages/market/analyse.products'));\nconst AnalyseLeaderboardPage = React.lazy(() => import('../pages/market/analyse.leaderboard'));\n\nconst DPiPage = React.lazy(() => import('../pages/dp/dpi'));\nconst AnalyseDPProductsPage = React.lazy(() => import('../pages/dp/analyse.products'));\nconst DPProductsPage = React.lazy(() => import('../pages/dp/products'));\nconst AnalyseDPLeaderboardPage = React.lazy(() => import('../pages/dp/analyse.leaderboard'));\n\nif (localStorage.getItem('v2context') === 'true') {\n  ContentProviderRegister.getInstance().registerContextSettingSelector(MarketContextSelector, 'openMarkets');\n} else {\n  ContentProviderRegister.getInstance().registerContextSettingSelector(MarketSelector, 'openMarkets');\n}\nContentProviderRegister.getInstance().registerContextSettingSelector(FocusPeriodContextSelector, 'focusPeriod');\nContentProviderRegister.getInstance().registerContextSettingSelector(BrandOptionsSelector, 'brandLimitingOptions');\nContentProviderRegister.getInstance().registerContent(SpecialStatic, 'market-custom');\n\n// check if it is copy link view and save it in session storage will be removed after restoring the view\naddSavedViewKeyToSessionStorage();\n\nconst { Mo, Ml, Mi, Dpi, Dpl, Dpo } = ROUTE_PREFIX;\nfunction Root() {\n  return (\n    <AuthenticationProvider isGuard>\n      <SavedFiltersProvider filterContext={filterContext}>\n        <CollectionProvider>\n          <React.Suspense fallback={<feedback.DotsLoader stretch height=\"100vh\" />}>\n            <BrowserRouter>\n              <ViewSavedFilterHandler />\n              <Routes>\n                {/* Market routes */}\n                <Route path={Mo} element={<OverviewPage />} />\n                <Route path={`${Mo}-light`} element={<OverviewLightPage />} />\n                <Route path={`${Ml}/products`} element={<ProductsPage />} />\n                <Route path={`${Ml}/products/analyse/:tab`} element={<AnalyseProductsPage />} />\n                <Route path={`${Mi}/:page/:category`} element={<MiPage />} />\n                <Route path={`${Mi}/:page/:category/analyse/:tab`} element={<AnalyseLeaderboardPage />} />\n                <Route path={Mi} element={<Navigate to=\"scorecard/brands\" replace={true} />} />\n                {/* Distribution Panel routes */}\n                <Route path={Dpo} element={<DPOverviewPage />} />\n                <Route path={`${Dpl}/products`} element={<DPProductsPage />} />\n                <Route path={`${Dpl}/products/analyse/:tab`} element={<AnalyseDPProductsPage />} />\n                <Route path={`${Dpi}/:page/:category`} element={<DPiPage />} />\n                <Route path={`${Dpi}/:page/:category/analyse/:tab`} element={<AnalyseDPLeaderboardPage />} />\n                <Route path={Dpi} element={<Navigate to=\"scorecard/brands\" replace={true} />} />\n                {/* route to prevent console warning on no path match */}\n                <Route path=\"*\" element={<Noop />} />\n              </Routes>\n            </BrowserRouter>\n          </React.Suspense>\n        </CollectionProvider>\n      </SavedFiltersProvider>\n    </AuthenticationProvider>\n  );\n}\n\nfunction Noop() {\n  return null;\n}\n\nexport { Root };\n","import { SAVED_VIEW_KEY } from './constants';\n\nexport const addSavedViewKeyToSessionStorage = (): void => {\n  // check if it is copy link view and save it in session storage will be removed after restoring the view\n  const urlParams = new URLSearchParams(window.location.search);\n  const viewKey = urlParams.get('view');\n  if (viewKey) {\n    window.sessionStorage.setItem(SAVED_VIEW_KEY, viewKey);\n  }\n};\n","import React from 'react';\nimport type { DataContentProps } from '@ecosystem/newron-core';\n\nfunction SpecialStatic(_: DataContentProps) {\n  return <div className=\"bg-purple-100 rounded p-6\">I'm a special UI element provided from the market MFE</div>;\n}\n\nexport { SpecialStatic };\n","import React from 'react';\nimport ReactDOMClient from 'react-dom/client';\nimport singleSpaReact from 'single-spa-react';\nimport { logger } from '@ecosystem/newron-client-lib';\nimport { feedbackV2 } from '@ecosystem/newron-design-system';\nimport { Root } from './root/Root';\n\nconst lifecycles = singleSpaReact({\n  renderType: 'createRoot',\n  React,\n  ReactDOMClient,\n  rootComponent: Root,\n  errorBoundary(err: Error, info: React.ErrorInfo) {\n    logger.error(err, {\n      componentStack: info.componentStack,\n    });\n    return (\n      <div id=\"newron-content\">\n        <div className=\"mx-16 my-16\">\n          <feedbackV2.Alert\n            title={\n              <>\n                The requested data for this page has failed to load.\n                <br /> Please refresh your browser to try again. If this issue persists, please contact your GfK\n                representative.\n              </>\n            }\n            type=\"error\"\n          />\n        </div>\n      </div>\n    );\n  },\n});\n\nexport const { bootstrap, mount, unmount } = lifecycles;\n"],"names":["inProgress","dataWebpackPrefix","SAVED_VIEW_KEY","Proposition","Market","DistributionPanel","MARKET_ROUTE_PREFIX","Mo","MoLight","Mi","Ml","DP_ROUTE_PREFIX","Dpo","Dpi","Dpl","Dp","ROUTE_PREFIX","_objectSpread","MarketPrefixTypes","Object","values","DPPrefixTypes","MlParam","LeaderboardParams","MiParam","Page","time","segmentation","scorecard","leaderboard","analyseLeaderboard","products","analyseProducts","overview","DpPage","ContentType","Category","UiDataParams","ContextName","market","dp","module","exports","styleElement","nonce","setAttribute","stylesInDOM","getIndexByIdentifier","identifier","result","i","length","modulesToDom","list","options","idCountMap","identifiers","item","id","base","count","concat","indexByIdentifier","obj","css","media","sourceMap","supports","layer","references","updater","addElementStyle","byIndex","splice","push","api","domAPI","update","newObj","remove","lastIdentifiers","newList","index","newLastIdentifiers","_i","_index","styleSheet","cssText","firstChild","removeChild","appendChild","document","createTextNode","resolveDirectory","rootDirLevel","meta","url","console","error","Error","___CSS_LOADER_EXPORT___","mapCoreMetaParams","proposition","subsection","pageName","cells","pageContext","cell","splitCells","map","c","parts","split","country","itemGroup","cellsFormatted","_ref","countries","Array","from","Set","o","itemGroups","periodicity","timeFrame","section","locationId","numberOfCells","toString","cellAggregation","locationIdAggregation","itemGroupAggregation","eventParams","mapTabName","tabName","_lookup$tabName","segments","__WEBPACK_EXTERNAL_MODULE__267__","cssWithMappingToString","this","content","needLayer","join","modules","dedupe","undefined","alreadyImportedModules","k","_k","m","createRoot","hydrateRoot","cssMapping","btoa","base64","unescape","encodeURIComponent","JSON","stringify","data","sourceMapping","urlString","rootDirectoryLevel","a","createElement","href","pathname","numDirsProcessed","finalPath","slice","protocol","host","Number","isInteger","__WEBPACK_EXTERNAL_MODULE__425__","_defineProperty","e","r","t","defineProperty","value","enumerable","configurable","writable","_typeof","Symbol","iterator","constructor","prototype","toPropertyKey","toPrimitive","call","TypeError","String","element","setAttributes","attributes","insert","_extends","assign","bind","target","arguments","source","key","hasOwnProperty","apply","Action","PopStateEventType","createBrowserHistory","getLocation","createHref","validateLocation","window","defaultView","v5Compat","globalHistory","history","action","Pop","listener","getIndex","state","idx","handlePop","nextIndex","delta","location","createURL","to","origin","createPath","replace","invariant","URL","replaceState","listen","fn","addEventListener","removeEventListener","encodeLocation","search","hash","Push","createLocation","historyState","getHistoryState","pushState","DOMException","name","Replace","go","n","getUrlBasedHistory","usr","message","warning","cond","warn","current","parsePath","Math","random","substr","charAt","path","parsedPath","hashIndex","indexOf","searchIndex","ResultType","matchRoutes","routes","locationArg","basename","allowPartial","stripBasename","branches","flattenRoutes","sort","b","score","every","compareIndexes","routesMeta","childrenIndex","rankRouteBranches","matches","decoded","decodePath","matchRouteBranch","matchRoutesImpl","parentsMeta","parentPath","flattenRoute","route","relativePath","caseSensitive","startsWith","joinPaths","children","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","first","rest","isOptional","endsWith","required","restExploded","subpath","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","params","pathnameBase","normalizePathname","pattern","matcher","compiledParams","regexpSource","_","paramName","RegExp","compilePath","captureGroups","memo","splatValue","v","decodeURIComponent","toLowerCase","startIndex","nextChar","getInvalidPathError","char","field","dest","getResolveToMatches","v7_relativeSplatPath","pathMatches","getPathContributingMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","isEmptyPath","toPathname","routePathnameIndex","toSegments","shift","fromPathname","pop","resolvePathname","normalizeSearch","normalizeHash","resolvePath","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","AbortedDeferredError","isRouteErrorResponse","status","statusText","internal","validMutationMethodsArr","validRequestMethodsArr","APP_VERSION","bffRoot","process","BFF_ROOT","bffEndpoint","BFF_ENDPOINT","BFF_HOST","style","styleTarget","querySelector","HTMLIFrameElement","contentDocument","head","getTarget","p","l","d","x","g","u","C","h","y","S","T","P","D","E","F","Monthly","Weekly","percent","absolute","eur","local","usd","Integer","Date","Decimal","Percentage","PercentagePoints","Money","Index","MonthYear","Month","Year","WholeMoney","Absolute","Change","Alpha","ascending","descending","Global","Local","Identifier","Kpi","KpiWithChange","Text","Share","Description","QueryArgs","Detail","GET","POST","segment_price","segment_feature","singleSelect","radioGroup","multiSelect","custom","numericRange","dateRange","select","table","chart","horizontalBarChart","verticalBarChart","stackedBarChart","bubbleChart","valueWithChangeChart","lineChart","unknown","dataError","timeSeries","multiKpi","leaderBoard","statsTable","keyIndicators","kpiTrends","billboard","alertPanel","singleKpiTrend","heatmap","kpiDecompositon","Xlsx","Pptx","Png","isProvider","takeFromProvider","isPresent","atProvider","atContent","onBrowser","onServer","KeyIndicators","Heatmap","Trends","column","tabbed","full","half","PageViewed","PageElementViewed","ChartInteractions","FilterApplied","FilterAppliedDetails","NavigationClicked","PageElementClicked","TableClicked","DataExported","DataExportInitiated","SearchClicked","PageScrolled","Button","Group","Card","Link","Sort","Overlay","CheckBox","CustomFilter","SaveFilter","CustomPriceFilter","CustomFeatureFilter","DeleteFeatureFilter","ShareFeatureFilter","Brand","Tooltip","Selectors","Table","Chart","__WEBPACK_EXTERNAL_MODULE__726__","DataRouterContext","DataRouterStateContext","NavigationContext","LocationContext","RouteContext","outlet","isDataRoute","RouteErrorContext","useInRouterContext","useLocation","useIsomorphicLayoutEffect","cb","static","useNavigate","router","ctx","useDataRouterContext","DataRouterHook","UseNavigateStable","useCurrentRouteId","DataRouterStateHook","activeRef","navigate","fromRouteId","useNavigateStable","dataRouterContext","future","navigator","routePathnamesJson","parse","relative","useNavigateUnstable","useParams","routeMatch","useRoutesImpl","dataRouterState","isStatic","parentMatches","parentParams","parentPathnameBase","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parentSegments","renderedMatches","_dataRouterState","_future","errors","v7_partialHydration","initialized","errorIndex","findIndex","min","renderFallback","fallbackIndex","HydrateFallback","hydrateFallbackElement","loaderData","needsToRunLoader","loader","lazy","reduceRight","shouldRenderHydrateFallback","errorElement","defaultErrorElement","alreadyWarned$1","getChildren","Component","RenderedRoute","routeContext","ErrorBoundary","RenderErrorBoundary","revalidation","component","_renderMatches","Provider","navigationType","DefaultErrorComponent","_state$errors","useDataRouterState","UseRouteError","routeId","useRouteError","stack","preStyles","padding","backgroundColor","fontStyle","props","super","getDerivedStateFromError","getDerivedStateFromProps","componentDidCatch","errorInfo","render","staticContext","_deepestRenderedBoundaryId","hookName","useRouteContext","thisRoute","logDeprecation","flag","msg","link","logV6DeprecationWarnings","renderFuture","routerFuture","v7_startTransition","v7_fetcherPersist","v7_normalizeFormMethod","v7_skipActionErrorRevalidation","Navigate","_ref4","jsonPath","Route","_props","Router","_ref5","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","Routes","_ref6","createRoutesFromChildren","treePath","type","hasErrorBoundary","shouldRevalidate","handle","Promise","insertStyleElement","styleTagTransform","parentNode","removeStyleElement","__WEBPACK_EXTERNAL_MODULE__831__","__WEBPACK_EXTERNAL_MODULE__867__","__WEBPACK_EXTERNAL_MODULE__936__","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","__system_context__","getter","__esModule","definition","get","f","chunkId","all","keys","promises","prop","done","script","needAttach","scripts","getElementsByTagName","getAttribute","charset","timeout","nc","src","onScriptComplete","prev","event","onerror","onload","clearTimeout","doneFns","setTimeout","toStringTag","installedChunks","j","installedChunkData","promise","resolve","reject","errorType","realSrc","request","webpackJsonpCallback","parentChunkLoadingFunction","chunkIds","moreModules","runtime","chunkLoadingGlobal","self","autoPublicPath","getOwnPropertySymbols","getOwnPropertyDescriptor","getOwnPropertyDescriptors","defineProperties","domElement","domElementGetter","appName","getElementById","body","HTMLElement","require","createContext","React","ReactDOM","ReactDOMClient","rootComponent","loadRootComponent","errorBoundary","errorBoundaryClass","parcelCanUpdate","suppressComponentDidCatchWarning","domElements","renderResults","updateResolves","unmountResolves","then","version","childAppName","renderType","elementToRender","reactDom","unmount","unmountComponentAtNode","caughtError","caughtErrorInfo","displayName","create","setState","SingleSpaRoot","mountFinished","updateFinished","unmountFinished","__reactRouterVersion","Map","startTransitionImpl","BrowserRouter","historyRef","setStateImpl","newState","_arrayLikeToArray","_unsupportedIterableToArray","_toConsumableArray","isArray","asyncGeneratorStep","_asyncToGenerator","_next","_throw","_slicedToArray","next","SortIcon","sizePx","direction","upArrowColor","downArrowColor","role","width","height","xmlns","strokeWidth","viewBox","fill","locals","Checkbox","inputs","CheckboxState","TextInput","actions","DotsLoader","feedback","Alert","feedbackV2","SortBy","SortDirection","MarketList","_ref3","isLoading","markets","selectedMarkets","onChange","onAllChange","_useState8","useState","setSearch","_useState10","productGroup","sortBy","setSortBy","_useState12","sortDirection","setSortDirection","onSort","header","headers","label","lastMonth","lastWeek","marketRows","countryName","productName","getSequence","_market$periods$find","periods","find","sequence","comparePeriods","per1","per2","compareStrings","str1","str2","localeCompare","Periodicity","sortByColumn","className","placeholder","autoFocus","tableLayout","onClick","UNCHECKED","CHECKED","periodLabel","period","tableData","verticalAlign","isSelected","sm","countryCode","productCode","colSpan","title","Footer","handleView","handleCancel","MarketsSelected","placement","Content","mode","RadioButtons","Select","IconButton","Icon","elements","SelectedMarkets","onRemoveCells","indicateSubscriptions","parentCodes","rows","parent","child","subscriptions","has","row","add","parentCode","childCode","size","color","icons","Close","handleRemoveRow","term","terms","trim","toLocaleLowerCase","part","MarketsSelector","onAddCells","_useState2","setTerm","selectedCells","filteredRows","matched","matchingChildren","filteredRow","noRowsMsg","marginTop","val","Prefix","Search","Suffix","flatMap","marketsToAdd","Add","handleAddRow","_defineProperties","PeriodAggregation","NavMenuButton","isActive","_ref$isDisabled","isDisabled","disabled","NavMenuSeparator","TimeFrames","_createClass","_classCallCheck","entity","startPeriod","_entity$value$split2","periodAggregation","endPeriod","_period$split2","aggregation","Week","endSequence","startSequence","forMarkets","withinTimeFrames","validTimeFrame","allMonths","commonMonthlySequence","tf","allMatchingPeriods","lowestCommonSequence","currentProposition","pathPrefix","RECENT_MARKETS_KEY","RecentMarkets","onSelect","recentEntries","setRecentEntries","_useState4","setProducts","_useState6","setCountries","useEffect","storedEntry","localStorage","getItem","entries","formatter","Intl","DateTimeFormat","dateStyle","timeStyle","entry","_step","allValid","rowMarkets","productCodes","_iterator","_createForOfIteratorHelper","_loop","rowMarket","rm","product","err","displayDate","format","used","Info","RowButton","handleRowClick","_ref2","updateRecentMarkets","cellStr","matchingEntry","checkCellStr","unshift","now","setItem","numberToMonthName","monthNameToNumber","acc","timeFrameToDate","_timeFrame$label$spli2","month","year","parseInt","dateToTimeFrame","date","availableMonths","el","_el$label$split2","getMonth","getFullYear","isCustomWeekly","currentValue","Custom","isCustomMonthly","ApplyPeriodButton","onApply","_ref$notPublishedMark","notPublishedMarkets","_ref$notAvailableMark","notAvailableMarkets","_ref$disabled","showIncompleteTooltip","Fractional","listStyleType","WARNING_MESSAGE_ON_APPLY","MonthPicker","MonthFormatType","MonthsSelector","_ref$monthlyOptions","monthlyOptions","_ref$markets","monthFrom","setMonthFrom","monthTo","setMonthTo","isWrongDateRange","setIsWrongDateRange","getTime","sortMonthlyOptions","useMemo","sequenceToTimeFrame","useCallback","fromMonth","toMonth","lastMonthTimeFrame","at","beforeLastMonthTimeFrame","setLastTwoMonthsOnMonthPickers","lowestPossibleMonth","firstElement","highestPossibleMonth","lastElement","marginBottom","dateFormat","defaultDate","minDate","maxDate","customTimeFramePeriod","constructFrom","toDate","argument","argStr","NaN","defaultOptions","getDefaultOptions","startOfWeek","weekStartsOn","locale","_date","day","getDay","diff","setDate","getDate","setHours","startOfISOWeek","startOfISOWeekYear","fourthOfJanuaryOfNextYear","setFullYear","startOfNextYear","fourthOfJanuaryOfThisYear","startOfThisYear","getISOWeekYear","fourthOfJanuary","startOfWeekYear","firstWeekContainsDate","firstWeekOfNextYear","firstWeekOfThisYear","getWeekYear","firstWeek","addDays","amount","isNaN","getWeekDates","option","isISOWeekNumber","_option$label$split2","week","weekNumber","randomDateInYear","weekNumberToDate","getWeekStart","_getWeekDates2","start","getPeriodicity","WeekPicker","WeekFormatType","WeeksSelector","_getWeekDates4","_ref$weeklyOptions","weeklyOptions","weekFrom","setWeekFrom","weekTo","setWeekTo","optionsMap","opt","optionsSorted","defaultWeekFrom","defaultWeekTo","startDate","_weekFrom$timeFrame","selected","_weekTo$timeFrame","DISMISSED_KEY","PeriodSelector","isDistributionPanel","onAggregationChange","handlePartialTimeFrameData","defaultAggregation","showIncompleteMsg","setShowIncompleteMsg","customAggregation","setCustomAggregation","dismissed","notOnAll","availableOnAll","onAll","hasWeekly","handleItemClick","Quarter","RollingQuarter","MAT","YTD","PeriodItem","affectedMarkets","unavailableMarkets","Check","maxHeight","overflowY","IncompletePeriod","onBack","ChevronLeft","stretch","MissingSubscriptions","onRemoveNonSubscribed","getSelectedMarkets","settings","selection","getTimeFrameOptions","earliestWeekly","_m$periods$find","earliestMonthly","_m$periods$find2","periodOptions","po","toTimeFrame","HEIGHT","WIDTH","PENDING_AGGREGATION_KEY","filterContext","namespace","NEW_FILTER_URL_PARAM","M2_PATH","DP_PATH","PL_ANALYSE_PATHS","ViewSavedFilterHandler","searchParams","URLSearchParams","urlFilterId","setNewFilterId","useSavedFiltersContext","ViewNotificationsRegister","getInstance","register","domainName","viewFilterFunction","filterData","isMarket2Page","Boolean","isAnalysePage","isDpPage","filterId","urlSearchParams","getImpersonationHeader","isInternal","authentication","getUser","storage","fetchCollectionsRegistry","regeneratorRuntime","mark","_callee","token","impersonationHeader","fullApiUrl","wrap","_context","getAccessToken","sent","fetch","Authorization","json","abrupt","stop","CollectionProvider","loadCollectionsRegister","collection","instance","CollectionsInsightRenderRegister","collectionKey","InsightRenderer","InsightElement","getInsightInfo","insight","configItemCallbacks","getConfigItemCallbacks","defaultSubsection","CorePage","context","excludeFilters","excludePriceFilter","page","appVersion","calcTrackingParams","_eventName","viewKey","OverviewPage","OverviewLightPage","MiPage","ProductsPage","AnalyseProductsPage","AnalyseLeaderboardPage","DPiPage","AnalyseDPProductsPage","DPProductsPage","AnalyseDPLeaderboardPage","ContentProviderRegister","registerContextSettingSelector","onClose","setMode","setMarkets","setCells","setIndicateSubscriptions","getContextSettings","useEditContextSettings","openMarkets","ContextSelectorMenu","cellsToAdd","cellsToRemove","setLoading","setSelectedMarkets","_markets","t0","logger","setAggregation","setTimeFrame","timeFrameOptions","setTimeFrameOptions","notAllAvailableOption","setNotAllAvailableOption","pendingAggregation","sessionStorage","removeItem","handleAggregationChange","handleNotAllAvailableTimeFrameSelect","removeAffectedMarkets","updates","toEntity","hasMissingSubscriptions","hasCompleteData","hideCustomWarning","marketsToRemove","marketsToKeep","mtr","validateTimeFrame","cellsToKeep","_competitorValue$","_competitorValue$2","_competitorValue$3","competitorBrands","setCompetitorBrands","brandOptions","setBrandOptions","competitorOptions","setCompetitorOptions","competitorValue","setCompetitorValue","highlightedValue","setHighLightedValue","active","preventApply","enableCompetitorsSelection","competitorBrandsOptions","brand","highlightedBrand","competitorBrandOption","competitorBrandList","registerContent","Noop","lifecycles","componentDidMount","componentWillUnmount","bootstrap","mount","singleSpaReact","AuthenticationProvider","isGuard","SavedFiltersProvider","fallback","DPOverviewPage","info","componentStack"],"sourceRoot":""}