{"version":3,"file":"chunks/9711.9711.js","mappings":"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","sources":["webpack:///./node_modules/history/index.js","webpack:///./node_modules/react-router-dom/index.js","webpack:///./node_modules/react-router/index.js"],"sourcesContent":["import _extends from '@babel/runtime/helpers/esm/extends';\n\n/**\r\n * Actions represent the type of change to a location value.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#action\r\n */\nvar Action;\n\n(function (Action) {\n  /**\r\n   * A POP indicates a change to an arbitrary index in the history stack, such\r\n   * as a back or forward navigation. It does not describe the direction of the\r\n   * navigation, only that the current index changed.\r\n   *\r\n   * Note: This is the default action for newly created history objects.\r\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\r\n   * A PUSH indicates a new entry being added to the history stack, such as when\r\n   * a link is clicked and a new page loads. When this happens, all subsequent\r\n   * entries in the stack are lost.\r\n   */\n\n  Action[\"Push\"] = \"PUSH\";\n  /**\r\n   * A REPLACE indicates the entry at the current index in the history stack\r\n   * being replaced by a new one.\r\n   */\n\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\n\nvar readOnly = process.env.NODE_ENV !== \"production\" ? function (obj) {\n  return Object.freeze(obj);\n} : function (obj) {\n  return obj;\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\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n\nvar BeforeUnloadEventType = 'beforeunload';\nvar HashChangeEventType = 'hashchange';\nvar PopStateEventType = 'popstate';\n/**\r\n * Browser history stores the location in regular URLs. This is the standard for\r\n * most web apps, but it requires some configuration on the server to ensure you\r\n * serve the same app at multiple URLs.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\r\n */\n\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options = options,\n      _options$window = _options.window,\n      window = _options$window === void 0 ? document.defaultView : _options$window;\n  var globalHistory = window.history;\n\n  function getIndexAndLocation() {\n    var _window$location = window.location,\n        pathname = _window$location.pathname,\n        search = _window$location.search,\n        hash = _window$location.hash;\n    var state = globalHistory.state || {};\n    return [state.idx, readOnly({\n      pathname: pathname,\n      search: search,\n      hash: hash,\n      state: state.usr || null,\n      key: state.key || 'default'\n    })];\n  }\n\n  var blockedPopTx = null;\n\n  function handlePop() {\n    if (blockedPopTx) {\n      blockers.call(blockedPopTx);\n      blockedPopTx = null;\n    } else {\n      var nextAction = Action.Pop;\n\n      var _getIndexAndLocation = getIndexAndLocation(),\n          nextIndex = _getIndexAndLocation[0],\n          nextLocation = _getIndexAndLocation[1];\n\n      if (blockers.length) {\n        if (nextIndex != null) {\n          var delta = index - nextIndex;\n\n          if (delta) {\n            // Revert the POP\n            blockedPopTx = {\n              action: nextAction,\n              location: nextLocation,\n              retry: function retry() {\n                go(delta * -1);\n              }\n            };\n            go(delta);\n          }\n        } else {\n          // Trying to POP to a location with no index. We did not create\n          // this location, so we can't effectively block the navigation.\n          process.env.NODE_ENV !== \"production\" ? warning(false, // TODO: Write up a doc that explains our blocking strategy in\n          // detail and link to it here so people can understand better what\n          // is going on and how to avoid it.\n          \"You are trying to block a POP navigation to a location that was not \" + \"created by the history library. The block will fail silently in \" + \"production, but in general you should do all navigation with the \" + \"history library (instead of using window.history.pushState directly) \" + \"to avoid this situation.\") : void 0;\n        }\n      } else {\n        applyTx(nextAction);\n      }\n    }\n  }\n\n  window.addEventListener(PopStateEventType, handlePop);\n  var action = Action.Pop;\n\n  var _getIndexAndLocation2 = getIndexAndLocation(),\n      index = _getIndexAndLocation2[0],\n      location = _getIndexAndLocation2[1];\n\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), '');\n  }\n\n  function createHref(to) {\n    return typeof to === 'string' ? to : createPath(to);\n  } // state defaults to `null` because `window.history.state` does\n\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      hash: '',\n      search: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function getHistoryStateAndUrl(nextLocation, index) {\n    return [{\n      usr: nextLocation.state,\n      key: nextLocation.key,\n      idx: index\n    }, createHref(nextLocation)];\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction) {\n    action = nextAction;\n\n    var _getIndexAndLocation3 = getIndexAndLocation();\n\n    index = _getIndexAndLocation3[0];\n    location = _getIndexAndLocation3[1];\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1),\n          historyState = _getHistoryStateAndUr[0],\n          url = _getHistoryStateAndUr[1]; // TODO: Support forced reloading\n      // try...catch because iOS limits us to 100 pushState calls :/\n\n\n      try {\n        globalHistory.pushState(historyState, '', url);\n      } catch (error) {\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\n      applyTx(nextAction);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index),\n          historyState = _getHistoryStateAndUr2[0],\n          url = _getHistoryStateAndUr2[1]; // TODO: Support forced reloading\n\n\n      globalHistory.replaceState(historyState, '', url);\n      applyTx(nextAction);\n    }\n  }\n\n  function go(delta) {\n    globalHistory.go(delta);\n  }\n\n  var history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      var unblock = blockers.push(blocker);\n\n      if (blockers.length === 1) {\n        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);\n      }\n\n      return function () {\n        unblock(); // Remove the beforeunload listener so the document may\n        // still be salvageable in the pagehide event.\n        // See https://html.spec.whatwg.org/#unloading-documents\n\n        if (!blockers.length) {\n          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);\n        }\n      };\n    }\n  };\n  return history;\n}\n/**\r\n * Hash history stores the location in window.location.hash. This makes it ideal\r\n * for situations where you don't want to send the location to the server for\r\n * some reason, either because you do cannot configure it or the URL space is\r\n * reserved for something else.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\r\n */\n\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options2 = options,\n      _options2$window = _options2.window,\n      window = _options2$window === void 0 ? document.defaultView : _options2$window;\n  var globalHistory = window.history;\n\n  function getIndexAndLocation() {\n    var _parsePath = parsePath(window.location.hash.substr(1)),\n        _parsePath$pathname = _parsePath.pathname,\n        pathname = _parsePath$pathname === void 0 ? '/' : _parsePath$pathname,\n        _parsePath$search = _parsePath.search,\n        search = _parsePath$search === void 0 ? '' : _parsePath$search,\n        _parsePath$hash = _parsePath.hash,\n        hash = _parsePath$hash === void 0 ? '' : _parsePath$hash;\n\n    var state = globalHistory.state || {};\n    return [state.idx, readOnly({\n      pathname: pathname,\n      search: search,\n      hash: hash,\n      state: state.usr || null,\n      key: state.key || 'default'\n    })];\n  }\n\n  var blockedPopTx = null;\n\n  function handlePop() {\n    if (blockedPopTx) {\n      blockers.call(blockedPopTx);\n      blockedPopTx = null;\n    } else {\n      var nextAction = Action.Pop;\n\n      var _getIndexAndLocation4 = getIndexAndLocation(),\n          nextIndex = _getIndexAndLocation4[0],\n          nextLocation = _getIndexAndLocation4[1];\n\n      if (blockers.length) {\n        if (nextIndex != null) {\n          var delta = index - nextIndex;\n\n          if (delta) {\n            // Revert the POP\n            blockedPopTx = {\n              action: nextAction,\n              location: nextLocation,\n              retry: function retry() {\n                go(delta * -1);\n              }\n            };\n            go(delta);\n          }\n        } else {\n          // Trying to POP to a location with no index. We did not create\n          // this location, so we can't effectively block the navigation.\n          process.env.NODE_ENV !== \"production\" ? warning(false, // TODO: Write up a doc that explains our blocking strategy in\n          // detail and link to it here so people can understand better\n          // what is going on and how to avoid it.\n          \"You are trying to block a POP navigation to a location that was not \" + \"created by the history library. The block will fail silently in \" + \"production, but in general you should do all navigation with the \" + \"history library (instead of using window.history.pushState directly) \" + \"to avoid this situation.\") : void 0;\n        }\n      } else {\n        applyTx(nextAction);\n      }\n    }\n  }\n\n  window.addEventListener(PopStateEventType, handlePop); // popstate does not fire on hashchange in IE 11 and old (trident) Edge\n  // https://developer.mozilla.org/de/docs/Web/API/Window/popstate_event\n\n  window.addEventListener(HashChangeEventType, function () {\n    var _getIndexAndLocation5 = getIndexAndLocation(),\n        nextLocation = _getIndexAndLocation5[1]; // Ignore extraneous hashchange events.\n\n\n    if (createPath(nextLocation) !== createPath(location)) {\n      handlePop();\n    }\n  });\n  var action = Action.Pop;\n\n  var _getIndexAndLocation6 = getIndexAndLocation(),\n      index = _getIndexAndLocation6[0],\n      location = _getIndexAndLocation6[1];\n\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), '');\n  }\n\n  function getBaseHref() {\n    var base = document.querySelector('base');\n    var href = '';\n\n    if (base && base.getAttribute('href')) {\n      var url = window.location.href;\n      var hashIndex = url.indexOf('#');\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href;\n  }\n\n  function createHref(to) {\n    return getBaseHref() + '#' + (typeof to === 'string' ? to : createPath(to));\n  }\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      hash: '',\n      search: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function getHistoryStateAndUrl(nextLocation, index) {\n    return [{\n      usr: nextLocation.state,\n      key: nextLocation.key,\n      idx: index\n    }, createHref(nextLocation)];\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction) {\n    action = nextAction;\n\n    var _getIndexAndLocation7 = getIndexAndLocation();\n\n    index = _getIndexAndLocation7[0];\n    location = _getIndexAndLocation7[1];\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(nextLocation.pathname.charAt(0) === '/', \"Relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1),\n          historyState = _getHistoryStateAndUr3[0],\n          url = _getHistoryStateAndUr3[1]; // TODO: Support forced reloading\n      // try...catch because iOS limits us to 100 pushState calls :/\n\n\n      try {\n        globalHistory.pushState(historyState, '', url);\n      } catch (error) {\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\n      applyTx(nextAction);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(nextLocation.pathname.charAt(0) === '/', \"Relative pathnames are not supported in hash history.replace(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index),\n          historyState = _getHistoryStateAndUr4[0],\n          url = _getHistoryStateAndUr4[1]; // TODO: Support forced reloading\n\n\n      globalHistory.replaceState(historyState, '', url);\n      applyTx(nextAction);\n    }\n  }\n\n  function go(delta) {\n    globalHistory.go(delta);\n  }\n\n  var history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      var unblock = blockers.push(blocker);\n\n      if (blockers.length === 1) {\n        window.addEventListener(BeforeUnloadEventType, promptBeforeUnload);\n      }\n\n      return function () {\n        unblock(); // Remove the beforeunload listener so the document may\n        // still be salvageable in the pagehide event.\n        // See https://html.spec.whatwg.org/#unloading-documents\n\n        if (!blockers.length) {\n          window.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);\n        }\n      };\n    }\n  };\n  return history;\n}\n/**\r\n * Memory history stores the current location in memory. It is designed for use\r\n * in stateful non-browser environments like tests and React Native.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#creatememoryhistory\r\n */\n\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var _options3 = options,\n      _options3$initialEntr = _options3.initialEntries,\n      initialEntries = _options3$initialEntr === void 0 ? ['/'] : _options3$initialEntr,\n      initialIndex = _options3.initialIndex;\n  var entries = initialEntries.map(function (entry) {\n    var location = readOnly(_extends({\n      pathname: '/',\n      search: '',\n      hash: '',\n      state: null,\n      key: createKey()\n    }, typeof entry === 'string' ? parsePath(entry) : entry));\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in createMemoryHistory({ initialEntries }) (invalid entry: \" + JSON.stringify(entry) + \")\") : void 0;\n    return location;\n  });\n  var index = clamp(initialIndex == null ? entries.length - 1 : initialIndex, 0, entries.length - 1);\n  var action = Action.Pop;\n  var location = entries[index];\n  var listeners = createEvents();\n  var blockers = createEvents();\n\n  function createHref(to) {\n    return typeof to === 'string' ? to : createPath(to);\n  }\n\n  function getNextLocation(to, state) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    return readOnly(_extends({\n      pathname: location.pathname,\n      search: '',\n      hash: ''\n    }, typeof to === 'string' ? parsePath(to) : to, {\n      state: state,\n      key: createKey()\n    }));\n  }\n\n  function allowTx(action, location, retry) {\n    return !blockers.length || (blockers.call({\n      action: action,\n      location: location,\n      retry: retry\n    }), false);\n  }\n\n  function applyTx(nextAction, nextLocation) {\n    action = nextAction;\n    location = nextLocation;\n    listeners.call({\n      action: action,\n      location: location\n    });\n  }\n\n  function push(to, state) {\n    var nextAction = Action.Push;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      push(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in memory history.push(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  function replace(to, state) {\n    var nextAction = Action.Replace;\n    var nextLocation = getNextLocation(to, state);\n\n    function retry() {\n      replace(to, state);\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(location.pathname.charAt(0) === '/', \"Relative pathnames are not supported in memory history.replace(\" + JSON.stringify(to) + \")\") : void 0;\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      entries[index] = nextLocation;\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  function go(delta) {\n    var nextIndex = clamp(index + delta, 0, entries.length - 1);\n    var nextAction = Action.Pop;\n    var nextLocation = entries[nextIndex];\n\n    function retry() {\n      go(delta);\n    }\n\n    if (allowTx(nextAction, nextLocation, retry)) {\n      index = nextIndex;\n      applyTx(nextAction, nextLocation);\n    }\n  }\n\n  var history = {\n    get index() {\n      return index;\n    },\n\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return location;\n    },\n\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    back: function back() {\n      go(-1);\n    },\n    forward: function forward() {\n      go(1);\n    },\n    listen: function listen(listener) {\n      return listeners.push(listener);\n    },\n    block: function block(blocker) {\n      return blockers.push(blocker);\n    }\n  };\n  return history;\n} ////////////////////////////////////////////////////////////////////////////////\n// UTILS\n////////////////////////////////////////////////////////////////////////////////\n\nfunction clamp(n, lowerBound, upperBound) {\n  return Math.min(Math.max(n, lowerBound), upperBound);\n}\n\nfunction promptBeforeUnload(event) {\n  // Cancel the event.\n  event.preventDefault(); // Chrome (and legacy IE) requires returnValue to be set.\n\n  event.returnValue = '';\n}\n\nfunction createEvents() {\n  var handlers = [];\n  return {\n    get length() {\n      return handlers.length;\n    },\n\n    push: function push(fn) {\n      handlers.push(fn);\n      return function () {\n        handlers = handlers.filter(function (handler) {\n          return handler !== fn;\n        });\n      };\n    },\n    call: function call(arg) {\n      handlers.forEach(function (fn) {\n        return fn && fn(arg);\n      });\n    }\n  };\n}\n\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\r\n * Creates a string URL path from the given pathname, search, and hash components.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createpath\r\n */\n\n\nfunction createPath(_ref) {\n  var _ref$pathname = _ref.pathname,\n      pathname = _ref$pathname === void 0 ? '/' : _ref$pathname,\n      _ref$search = _ref.search,\n      search = _ref$search === void 0 ? '' : _ref$search,\n      _ref$hash = _ref.hash,\n      hash = _ref$hash === void 0 ? '' : _ref$hash;\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/**\r\n * Parses a string URL path into its separate pathname, search, and hash components.\r\n *\r\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#parsepath\r\n */\n\nfunction parsePath(path) {\n  var parsedPath = {};\n\n  if (path) {\n    var hashIndex = path.indexOf('#');\n\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    var searchIndex = path.indexOf('?');\n\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\n\nexport { Action, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, parsePath };\n//# sourceMappingURL=index.js.map\n","/**\n * React Router DOM v6.3.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 { useRef, useState, useLayoutEffect, createElement, forwardRef, useCallback, useMemo } from 'react';\nimport { createBrowserHistory, createHashHistory } from 'history';\nimport { Router, useHref, createPath, useLocation, useResolvedPath, useNavigate } from 'react-router';\nexport { MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, createPath, createRoutesFromChildren, generatePath, matchPath, matchRoutes, parsePath, renderMatches, resolvePath, useHref, useInRouterContext, useLocation, useMatch, useNavigate, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRoutes } from 'react-router';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\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\n  return target;\n}\n\nconst _excluded = [\"onClick\", \"reloadDocument\", \"replace\", \"state\", \"target\", \"to\"],\n      _excluded2 = [\"aria-current\", \"caseSensitive\", \"className\", \"end\", \"style\", \"to\", \"children\"];\n\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\n    try {\n      // Welcome to debugging React Router!\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n} ////////////////////////////////////////////////////////////////////////////////\n// COMPONENTS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nfunction BrowserRouter(_ref) {\n  let {\n    basename,\n    children,\n    window\n  } = _ref;\n  let historyRef = useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({\n      window\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = useState({\n    action: history.action,\n    location: history.location\n  });\n  useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\n  });\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(_ref2) {\n  let {\n    basename,\n    children,\n    window\n  } = _ref2;\n  let historyRef = useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({\n      window\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = useState({\n    action: history.action,\n    location: history.location\n  });\n  useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\n  });\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(_ref3) {\n  let {\n    basename,\n    children,\n    history\n  } = _ref3;\n  const [state, setState] = useState({\n    action: history.action,\n    location: history.location\n  });\n  useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\n  });\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\n\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\n/**\n * The public API for rendering a history-aware <a>.\n */\nconst Link = /*#__PURE__*/forwardRef(function LinkWithRef(_ref4, ref) {\n  let {\n    onClick,\n    reloadDocument,\n    replace = false,\n    state,\n    target,\n    to\n  } = _ref4,\n      rest = _objectWithoutPropertiesLoose(_ref4, _excluded);\n\n  let href = useHref(to);\n  let internalOnClick = useLinkClickHandler(to, {\n    replace,\n    state,\n    target\n  });\n\n  function handleClick(event) {\n    if (onClick) onClick(event);\n\n    if (!event.defaultPrevented && !reloadDocument) {\n      internalOnClick(event);\n    }\n  }\n\n  return (\n    /*#__PURE__*/\n    // eslint-disable-next-line jsx-a11y/anchor-has-content\n    createElement(\"a\", _extends({}, rest, {\n      href: href,\n      onClick: handleClick,\n      ref: ref,\n      target: target\n    }))\n  );\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  Link.displayName = \"Link\";\n}\n\n/**\n * A <Link> wrapper that knows if it's \"active\" or not.\n */\nconst NavLink = /*#__PURE__*/forwardRef(function NavLinkWithRef(_ref5, ref) {\n  let {\n    \"aria-current\": ariaCurrentProp = \"page\",\n    caseSensitive = false,\n    className: classNameProp = \"\",\n    end = false,\n    style: styleProp,\n    to,\n    children\n  } = _ref5,\n      rest = _objectWithoutPropertiesLoose(_ref5, _excluded2);\n\n  let location = useLocation();\n  let path = useResolvedPath(to);\n  let locationPathname = location.pathname;\n  let toPathname = path.pathname;\n\n  if (!caseSensitive) {\n    locationPathname = locationPathname.toLowerCase();\n    toPathname = toPathname.toLowerCase();\n  }\n\n  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === \"/\";\n  let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n  let className;\n\n  if (typeof classNameProp === \"function\") {\n    className = classNameProp({\n      isActive\n    });\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].filter(Boolean).join(\" \");\n  }\n\n  let style = typeof styleProp === \"function\" ? styleProp({\n    isActive\n  }) : styleProp;\n  return /*#__PURE__*/createElement(Link, _extends({}, rest, {\n    \"aria-current\": ariaCurrent,\n    className: className,\n    ref: ref,\n    style: style,\n    to: to\n  }), typeof children === \"function\" ? children({\n    isActive\n  }) : children);\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n} ////////////////////////////////////////////////////////////////////////////////\n// HOOKS\n////////////////////////////////////////////////////////////////////////////////\n\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 */\n\n\nfunction useLinkClickHandler(to, _temp) {\n  let {\n    target,\n    replace: replaceProp,\n    state\n  } = _temp === void 0 ? {} : _temp;\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to);\n  return useCallback(event => {\n    if (event.button === 0 && ( // Ignore everything but left clicks\n    !target || target === \"_self\") && // Let browser handle \"target=_blank\" etc.\n    !isModifiedEvent(event) // Ignore clicks with modifier keys\n    ) {\n      event.preventDefault(); // If the URL hasn't changed, a regular <a> will do a replace instead of\n      // a push, so do the same here.\n\n      let replace = !!replaceProp || createPath(location) === createPath(path);\n      navigate(to, {\n        replace,\n        state\n      });\n    }\n  }, [location, navigate, path, replaceProp, state, target, to]);\n}\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\n\nfunction useSearchParams(defaultInit) {\n  process.env.NODE_ENV !== \"production\" ? 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\\n\\n\" + \"If you're unsure how to load polyfills, we recommend you check out \" + \"https://polyfill.io/v3/ which provides some recommendations about how \" + \"to load polyfills only for users that need them, instead of for every \" + \"user.\") : void 0;\n  let defaultSearchParamsRef = useRef(createSearchParams(defaultInit));\n  let location = useLocation();\n  let searchParams = useMemo(() => {\n    let searchParams = createSearchParams(location.search);\n\n    for (let key of defaultSearchParamsRef.current.keys()) {\n      if (!searchParams.has(key)) {\n        defaultSearchParamsRef.current.getAll(key).forEach(value => {\n          searchParams.append(key, value);\n        });\n      }\n    }\n\n    return searchParams;\n  }, [location.search]);\n  let navigate = useNavigate();\n  let setSearchParams = useCallback((nextInit, navigateOptions) => {\n    navigate(\"?\" + createSearchParams(nextInit), navigateOptions);\n  }, [navigate]);\n  return [searchParams, setSearchParams];\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\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}\n\nexport { BrowserRouter, HashRouter, Link, NavLink, createSearchParams, HistoryRouter as unstable_HistoryRouter, useLinkClickHandler, useSearchParams };\n//# sourceMappingURL=index.js.map\n","/**\n * React Router v6.3.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 { parsePath, createMemoryHistory, Action } from 'history';\nexport { Action as NavigationType, createPath, parsePath } from 'history';\nimport { createContext, useContext, useMemo, useRef, useEffect, useCallback, createElement, useState, useLayoutEffect, Children, isValidElement, Fragment } from 'react';\n\nconst NavigationContext = /*#__PURE__*/createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\n\nconst LocationContext = /*#__PURE__*/createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\n\nconst RouteContext = /*#__PURE__*/createContext({\n  outlet: null,\n  matches: []\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\n\nfunction invariant(cond, message) {\n  if (!cond) throw new Error(message);\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\n    try {\n      // Welcome to debugging React Router!\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\nconst alreadyWarned = {};\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? warning(false, message) : void 0;\n  }\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/api#generatepath\n */\nfunction generatePath(path, params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return path.replace(/:(\\w+)/g, (_, key) => {\n    !(params[key] != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Missing \\\":\" + key + \"\\\" param\") : invariant(false) : void 0;\n    return params[key];\n  }).replace(/\\/*\\*$/, _ => params[\"*\"] == null ? \"\" : params[\"*\"].replace(/^\\/*/, \"/\"));\n}\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchroutes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n\n  if (pathname == null) {\n    return null;\n  }\n\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i], pathname);\n  }\n\n  return matches;\n}\n\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n\n  routes.forEach((route, index) => {\n    let meta = {\n      relativePath: route.path || \"\",\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n\n    if (meta.relativePath.startsWith(\"/\")) {\n      !meta.relativePath.startsWith(parentPath) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"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.\") : invariant(false) : void 0;\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta); // 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\n    if (route.children && route.children.length > 0) {\n      !(route.index !== true) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\")) : invariant(false) : void 0;\n      flattenRoutes(route.children, branches, routesMeta, path);\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\n\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  });\n  return branches;\n}\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}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\n\nconst isSplat = s => s === \"*\";\n\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\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 ? // 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] : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\n\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n\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    if (!match) return null;\n    Object.assign(matchedParams, match.params);\n    let route = meta.route;\n    matches.push({\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\n\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchpath\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n\n  let [matcher, paramNames] = 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 = paramNames.reduce((memo, paramName, index) => {\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\n    memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || \"\", paramName);\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\n\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n\n  if (end === void 0) {\n    end = true;\n  }\n\n  process.env.NODE_ENV !== \"production\" ? 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(/\\*$/, \"/*\") + \"\\\".\")) : void 0;\n  let paramNames = [];\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) => {\n    paramNames.push(paramName);\n    return \"([^\\\\/]+)\";\n  });\n\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else {\n    regexpSource += end ? \"\\\\/*$\" // When matching to the end, ignore trailing slashes\n    : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts\n    // parent routes to matching only their own words and nothing more, e.g. parent\n    // route \"/home\" should not match \"/home2\".\n    // Additionally, allow paths starting with `.`, `-`, `~`, and url-encoded entities,\n    // but do not consume the character in the matched path so they can match against\n    // nested paths.\n    \"(?:(?=[.~-]|%[0-9A-F]{2})|\\\\b|\\\\/|$)\";\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, paramNames];\n}\n\nfunction safelyDecodeURIComponent(value, paramName) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    process.env.NODE_ENV !== \"production\" ? warning(false, \"The value for the URL param \\\"\" + paramName + \"\\\" will not be decoded because\" + (\" the string \\\"\" + value + \"\\\" is a malformed URL segment. This is probably\") + (\" due to a bad percent encoding (\" + error + \").\")) : void 0;\n    return value;\n  }\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/api#resolvepath\n */\n\n\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\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}\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}\n\nfunction resolveTo(toArg, routePathnames, locationPathname) {\n  let to = typeof toArg === \"string\" ? parsePath(toArg) : toArg;\n  let toPathname = toArg === \"\" || to.pathname === \"\" ? \"/\" : to.pathname; // 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\n  let from;\n\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\"); // Each leading .. segment means \"go up one route\" instead of \"go up one\n      // URL segment\".  This is a key difference from how <a href> works and a\n      // major reason we call this a \"to\" value instead of a \"href\".\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    } // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n\n\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from); // Ensure the pathname has a trailing slash if the original to value had one.\n\n  if (toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\") && !path.pathname.endsWith(\"/\")) {\n    path.pathname += \"/\";\n  }\n\n  return path;\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}\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  let nextChar = pathname.charAt(basename.length);\n\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(basename.length) || \"/\";\n}\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\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/docs/en/v6/api#usehref\n */\n\nfunction useHref(to) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = useContext(NavigationContext);\n  let {\n    hash,\n    pathname,\n    search\n  } = useResolvedPath(to);\n  let joinedPathname = pathname;\n\n  if (basename !== \"/\") {\n    let toPathname = getToPathname(to);\n    let endsWithSlash = toPathname != null && toPathname.endsWith(\"/\");\n    joinedPathname = pathname === \"/\" ? basename + (endsWithSlash ? \"/\" : \"\") : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\n}\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useinroutercontext\n */\n\nfunction useInRouterContext() {\n  return useContext(LocationContext) != null;\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/docs/en/v6/api#uselocation\n */\n\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  return useContext(LocationContext).location;\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/docs/en/v6/api#usenavigationtype\n */\n\nfunction useNavigationType() {\n  return useContext(LocationContext).navigationType;\n}\n/**\n * Returns true if the URL for the given \"to\" value 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/docs/en/v6/api#usematch\n */\n\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);\n}\n/**\n * The interface for the navigate() function returned from useNavigate().\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/docs/en/v6/api#usenavigate\n */\nfunction useNavigate() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = useContext(NavigationContext);\n  let {\n    matches\n  } = useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(matches.map(match => match.pathnameBase));\n  let activeRef = useRef(false);\n  useEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(activeRef.current, \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\") : void 0;\n    if (!activeRef.current) return;\n\n    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname);\n\n    if (basename !== \"/\") {\n      path.pathname = joinPaths([basename, path.pathname]);\n    }\n\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state);\n  }, [basename, navigator, routePathnamesJson, locationPathname]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/createContext(null);\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/docs/en/v6/api#useoutletcontext\n */\n\nfunction useOutletContext() {\n  return useContext(OutletContext);\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/docs/en/v6/api#useoutlet\n */\n\nfunction useOutlet(context) {\n  let outlet = useContext(RouteContext).outlet;\n\n  if (outlet) {\n    return /*#__PURE__*/createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\n  }\n\n  return outlet;\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/docs/en/v6/api#useparams\n */\n\nfunction useParams() {\n  let {\n    matches\n  } = useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? routeMatch.params : {};\n}\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/api#useresolvedpath\n */\n\nfunction useResolvedPath(to) {\n  let {\n    matches\n  } = useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(matches.map(match => match.pathnameBase));\n  return useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname), [to, routePathnamesJson, locationPathname]);\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/docs/en/v6/api#useroutes\n */\n\nfunction useRoutes(routes, locationArg) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let {\n    matches: parentMatches\n  } = 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\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\n  let locationFromContext = useLocation();\n  let location;\n\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n\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\" ? 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.\")) : invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n  let remainingPathname = parentPathnameBase === \"/\" ? pathname : pathname.slice(parentPathnameBase.length) || \"/\";\n  let matches = matchRoutes(routes, {\n    pathname: remainingPathname\n  });\n\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(matches == null || matches[matches.length - 1].route.element !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" does not have an element. \" + \"This means it will render an <Outlet /> with a null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n\n  return _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase, match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])\n  })), parentMatches);\n}\nfunction _renderMatches(matches, parentMatches) {\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n\n  if (matches == null) return null;\n  return matches.reduceRight((outlet, match, index) => {\n    return /*#__PURE__*/createElement(RouteContext.Provider, {\n      children: match.route.element !== undefined ? match.route.element : outlet,\n      value: {\n        outlet,\n        matches: parentMatches.concat(matches.slice(0, index + 1))\n      }\n    });\n  }, null);\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/docs/en/v6/api#memoryrouter\n */\nfunction MemoryRouter(_ref) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex\n  } = _ref;\n  let historyRef = useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = useState({\n    action: history.action,\n    location: history.location\n  });\n  useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\n  });\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/docs/en/v6/api#navigate\n */\nfunction Navigate(_ref2) {\n  let {\n    to,\n    replace,\n    state\n  } = _ref2;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  process.env.NODE_ENV !== \"production\" ? warning(!useContext(NavigationContext).static, \"<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 navigate = useNavigate();\n  useEffect(() => {\n    navigate(to, {\n      replace,\n      state\n    });\n  });\n  return null;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/docs/en/v6/api#outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#route\n */\nfunction Route(_props) {\n   process.env.NODE_ENV !== \"production\" ? 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>.\") : invariant(false) ;\n}\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/docs/en/v6/api#router\n */\nfunction Router(_ref3) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false\n  } = _ref3;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : invariant(false) : void 0;\n  let basename = normalizePathname(basenameProp);\n  let navigationContext = useMemo(() => ({\n    basename,\n    navigator,\n    static: staticProp\n  }), [basename, navigator, staticProp]);\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let location = useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      pathname: trailingPathname,\n      search,\n      hash,\n      state,\n      key\n    };\n  }, [basename, pathname, search, hash, state, key]);\n  process.env.NODE_ENV !== \"production\" ? warning(location != 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\n  if (location == null) {\n    return null;\n  }\n\n  return /*#__PURE__*/createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/createElement(LocationContext.Provider, {\n    children: children,\n    value: {\n      location,\n      navigationType\n    }\n  }));\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/docs/en/v6/api#routes\n */\nfunction Routes(_ref4) {\n  let {\n    children,\n    location\n  } = _ref4;\n  return useRoutes(createRoutesFromChildren(children), location);\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/docs/en/v6/api#createroutesfromchildren\n */\n\nfunction createRoutesFromChildren(children) {\n  let routes = [];\n  Children.forEach(children, element => {\n    if (! /*#__PURE__*/isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n\n    if (element.type === Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children));\n      return;\n    }\n\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? 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>\") : invariant(false) : void 0;\n    let route = {\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      index: element.props.index,\n      path: element.props.path\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children);\n    }\n\n    routes.push(route);\n  });\n  return routes;\n}\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\n\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n\nexport { MemoryRouter, Navigate, Outlet, Route, Router, Routes, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, createRoutesFromChildren, generatePath, matchPath, matchRoutes, renderMatches, resolvePath, useHref, useInRouterContext, useLocation, useMatch, useNavigate, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRoutes };\n//# sourceMappingURL=index.js.map\n"],"names":["Action","BeforeUnloadEventType","PopStateEventType","createBrowserHistory","options","_options$window","window","document","defaultView","globalHistory","history","getIndexAndLocation","_window$location","location","pathname","search","hash","state","idx","usr","key","blockedPopTx","addEventListener","blockers","call","nextAction","Pop","_getIndexAndLocation","nextIndex","nextLocation","length","delta","index","action","retry","go","applyTx","_getIndexAndLocation2","listeners","createEvents","createHref","to","createPath","getNextLocation","parsePath","createKey","getHistoryStateAndUrl","allowTx","_getIndexAndLocation3","replaceState","push","Push","_getHistoryStateAndUr","historyState","url","pushState","error","assign","replace","Replace","_getHistoryStateAndUr2","back","forward","listen","listener","block","blocker","unblock","promptBeforeUnload","removeEventListener","createHashHistory","_options2$window","_parsePath","substr","_parsePath$pathname","_parsePath$search","_parsePath$hash","handlePop","_getIndexAndLocation4","_getIndexAndLocation6","base","querySelector","href","getAttribute","hashIndex","indexOf","slice","getBaseHref","_getIndexAndLocation7","_getHistoryStateAndUr3","_getHistoryStateAndUr4","event","preventDefault","returnValue","handlers","fn","filter","handler","arg","forEach","Math","random","toString","_ref","_ref$pathname","_ref$search","_ref$hash","charAt","path","parsedPath","searchIndex","BrowserRouter","basename","children","historyRef","useRef","current","setState","useState","useLayoutEffect","createElement","navigationType","navigator","HashRouter","_ref2","NavigationContext","createContext","LocationContext","RouteContext","outlet","matches","invariant","cond","message","Error","matchRoutes","routes","locationArg","stripBasename","branches","flattenRoutes","sort","a","b","score","every","n","i","compareIndexes","routesMeta","map","meta","childrenIndex","rankRouteBranches","matchRouteBranch","parentsMeta","parentPath","route","relativePath","caseSensitive","startsWith","joinPaths","concat","computeScore","paramRe","isSplat","s","segments","split","initialScore","some","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","match","matchPath","Object","params","pathnameBase","normalizePathname","pattern","matcher","paramNames","regexpSource","_","paramName","endsWith","RegExp","undefined","compilePath","captureGroups","memo","splatValue","value","decodeURIComponent","safelyDecodeURIComponent","toLowerCase","nextChar","paths","join","normalizeSearch","normalizeHash","useInRouterContext","useContext","useLocation","useNavigate","locationPathname","routePathnamesJson","JSON","stringify","activeRef","useEffect","useCallback","toArg","routePathnames","from","toPathname","routePathnameIndex","toSegments","shift","fromPathname","pop","resolvePathname","resolvePath","resolveTo","parse","Navigate","navigate","Route","_props","Router","_ref3","basenameProp","locationProp","static","staticProp","navigationContext","useMemo","trailingPathname","Provider","Routes","_ref4","parentMatches","routeMatch","parentParams","parentPathnameBase","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","reduceRight","element","_renderMatches","useRoutes","createRoutesFromChildren","Children","isValidElement","type","Fragment","apply","props"],"sourceRoot":""}