{"version":3,"sources":["jsdelivr-header.js","/npm/vue-router@4.0.14/dist/vue-router.global.js"],"names":[],"mappings":"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","file":"/npm/vue-router@4.0.14/dist/vue-router.global.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/vue-router@4.0.14/dist/vue-router.global.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*!\n  * vue-router v4.0.14\n  * (c) 2022 Eduardo San Martin Morote\n  * @license MIT\n  */\nvar VueRouter = (function (exports, vue) {\n  'use strict';\n\n  const hasSymbol = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\r\n  const PolySymbol = (name) => \r\n  // vr = vue router\r\n  hasSymbol\r\n      ? Symbol('[vue-router]: ' + name )\r\n      : ('[vue-router]: ' ) + name;\r\n  // rvlm = Router View Location Matched\r\n  /**\r\n   * RouteRecord being rendered by the closest ancestor Router View. Used for\r\n   * `onBeforeRouteUpdate` and `onBeforeRouteLeave`. rvlm stands for Router View\r\n   * Location Matched\r\n   *\r\n   * @internal\r\n   */\r\n  const matchedRouteKey = /*#__PURE__*/ PolySymbol('router view location matched' );\r\n  /**\r\n   * Allows overriding the router view depth to control which component in\r\n   * `matched` is rendered. rvd stands for Router View Depth\r\n   *\r\n   * @internal\r\n   */\r\n  const viewDepthKey = /*#__PURE__*/ PolySymbol('router view depth' );\r\n  /**\r\n   * Allows overriding the router instance returned by `useRouter` in tests. r\r\n   * stands for router\r\n   *\r\n   * @internal\r\n   */\r\n  const routerKey = /*#__PURE__*/ PolySymbol('router' );\r\n  /**\r\n   * Allows overriding the current route returned by `useRoute` in tests. rl\r\n   * stands for route location\r\n   *\r\n   * @internal\r\n   */\r\n  const routeLocationKey = /*#__PURE__*/ PolySymbol('route location' );\r\n  /**\r\n   * Allows overriding the current route used by router-view. Internally this is\r\n   * used when the `route` prop is passed.\r\n   *\r\n   * @internal\r\n   */\r\n  const routerViewLocationKey = /*#__PURE__*/ PolySymbol('router view location' );\n\n  const isBrowser = typeof window !== 'undefined';\n\n  function isESModule(obj) {\r\n      return obj.__esModule || (hasSymbol && obj[Symbol.toStringTag] === 'Module');\r\n  }\r\n  const assign = Object.assign;\r\n  function applyToParams(fn, params) {\r\n      const newParams = {};\r\n      for (const key in params) {\r\n          const value = params[key];\r\n          newParams[key] = Array.isArray(value) ? value.map(fn) : fn(value);\r\n      }\r\n      return newParams;\r\n  }\r\n  const noop = () => { };\n\n  function warn(msg) {\r\n      // avoid using ...args as it breaks in older Edge builds\r\n      const args = Array.from(arguments).slice(1);\r\n      console.warn.apply(console, ['[Vue Router warn]: ' + msg].concat(args));\r\n  }\n\n  const TRAILING_SLASH_RE = /\\/$/;\r\n  const removeTrailingSlash = (path) => path.replace(TRAILING_SLASH_RE, '');\r\n  /**\r\n   * Transforms an URI into a normalized history location\r\n   *\r\n   * @param parseQuery\r\n   * @param location - URI to normalize\r\n   * @param currentLocation - current absolute location. Allows resolving relative\r\n   * paths. Must start with `/`. Defaults to `/`\r\n   * @returns a normalized history location\r\n   */\r\n  function parseURL(parseQuery, location, currentLocation = '/') {\r\n      let path, query = {}, searchString = '', hash = '';\r\n      // Could use URL and URLSearchParams but IE 11 doesn't support it\r\n      const searchPos = location.indexOf('?');\r\n      const hashPos = location.indexOf('#', searchPos > -1 ? searchPos : 0);\r\n      if (searchPos > -1) {\r\n          path = location.slice(0, searchPos);\r\n          searchString = location.slice(searchPos + 1, hashPos > -1 ? hashPos : location.length);\r\n          query = parseQuery(searchString);\r\n      }\r\n      if (hashPos > -1) {\r\n          path = path || location.slice(0, hashPos);\r\n          // keep the # character\r\n          hash = location.slice(hashPos, location.length);\r\n      }\r\n      // no search and no query\r\n      path = resolveRelativePath(path != null ? path : location, currentLocation);\r\n      // empty path means a relative query or hash `?foo=f`, `#thing`\r\n      return {\r\n          fullPath: path + (searchString && '?') + searchString + hash,\r\n          path,\r\n          query,\r\n          hash,\r\n      };\r\n  }\r\n  /**\r\n   * Stringifies a URL object\r\n   *\r\n   * @param stringifyQuery\r\n   * @param location\r\n   */\r\n  function stringifyURL(stringifyQuery, location) {\r\n      const query = location.query ? stringifyQuery(location.query) : '';\r\n      return location.path + (query && '?') + query + (location.hash || '');\r\n  }\r\n  /**\r\n   * Strips off the base from the beginning of a location.pathname in a non\r\n   * case-sensitive way.\r\n   *\r\n   * @param pathname - location.pathname\r\n   * @param base - base to strip off\r\n   */\r\n  function stripBase(pathname, base) {\r\n      // no base or base is not found at the beginning\r\n      if (!base || !pathname.toLowerCase().startsWith(base.toLowerCase()))\r\n          return pathname;\r\n      return pathname.slice(base.length) || '/';\r\n  }\r\n  /**\r\n   * Checks if two RouteLocation are equal. This means that both locations are\r\n   * pointing towards the same {@link RouteRecord} and that all `params`, `query`\r\n   * parameters and `hash` are the same\r\n   *\r\n   * @param a - first {@link RouteLocation}\r\n   * @param b - second {@link RouteLocation}\r\n   */\r\n  function isSameRouteLocation(stringifyQuery, a, b) {\r\n      const aLastIndex = a.matched.length - 1;\r\n      const bLastIndex = b.matched.length - 1;\r\n      return (aLastIndex > -1 &&\r\n          aLastIndex === bLastIndex &&\r\n          isSameRouteRecord(a.matched[aLastIndex], b.matched[bLastIndex]) &&\r\n          isSameRouteLocationParams(a.params, b.params) &&\r\n          stringifyQuery(a.query) === stringifyQuery(b.query) &&\r\n          a.hash === b.hash);\r\n  }\r\n  /**\r\n   * Check if two `RouteRecords` are equal. Takes into account aliases: they are\r\n   * considered equal to the `RouteRecord` they are aliasing.\r\n   *\r\n   * @param a - first {@link RouteRecord}\r\n   * @param b - second {@link RouteRecord}\r\n   */\r\n  function isSameRouteRecord(a, b) {\r\n      // since the original record has an undefined value for aliasOf\r\n      // but all aliases point to the original record, this will always compare\r\n      // the original record\r\n      return (a.aliasOf || a) === (b.aliasOf || b);\r\n  }\r\n  function isSameRouteLocationParams(a, b) {\r\n      if (Object.keys(a).length !== Object.keys(b).length)\r\n          return false;\r\n      for (const key in a) {\r\n          if (!isSameRouteLocationParamsValue(a[key], b[key]))\r\n              return false;\r\n      }\r\n      return true;\r\n  }\r\n  function isSameRouteLocationParamsValue(a, b) {\r\n      return Array.isArray(a)\r\n          ? isEquivalentArray(a, b)\r\n          : Array.isArray(b)\r\n              ? isEquivalentArray(b, a)\r\n              : a === b;\r\n  }\r\n  /**\r\n   * Check if two arrays are the same or if an array with one single entry is the\r\n   * same as another primitive value. Used to check query and parameters\r\n   *\r\n   * @param a - array of values\r\n   * @param b - array of values or a single value\r\n   */\r\n  function isEquivalentArray(a, b) {\r\n      return Array.isArray(b)\r\n          ? a.length === b.length && a.every((value, i) => value === b[i])\r\n          : a.length === 1 && a[0] === b;\r\n  }\r\n  /**\r\n   * Resolves a relative path that starts with `.`.\r\n   *\r\n   * @param to - path location we are resolving\r\n   * @param from - currentLocation.path, should start with `/`\r\n   */\r\n  function resolveRelativePath(to, from) {\r\n      if (to.startsWith('/'))\r\n          return to;\r\n      if (!from.startsWith('/')) {\r\n          warn(`Cannot resolve a relative location without an absolute path. Trying to resolve \"${to}\" from \"${from}\". It should look like \"/${from}\".`);\r\n          return to;\r\n      }\r\n      if (!to)\r\n          return from;\r\n      const fromSegments = from.split('/');\r\n      const toSegments = to.split('/');\r\n      let position = fromSegments.length - 1;\r\n      let toPosition;\r\n      let segment;\r\n      for (toPosition = 0; toPosition < toSegments.length; toPosition++) {\r\n          segment = toSegments[toPosition];\r\n          // can't go below zero\r\n          if (position === 1 || segment === '.')\r\n              continue;\r\n          if (segment === '..')\r\n              position--;\r\n          // found something that is not relative path\r\n          else\r\n              break;\r\n      }\r\n      return (fromSegments.slice(0, position).join('/') +\r\n          '/' +\r\n          toSegments\r\n              .slice(toPosition - (toPosition === toSegments.length ? 1 : 0))\r\n              .join('/'));\r\n  }\n\n  var NavigationType;\r\n  (function (NavigationType) {\r\n      NavigationType[\"pop\"] = \"pop\";\r\n      NavigationType[\"push\"] = \"push\";\r\n  })(NavigationType || (NavigationType = {}));\r\n  var NavigationDirection;\r\n  (function (NavigationDirection) {\r\n      NavigationDirection[\"back\"] = \"back\";\r\n      NavigationDirection[\"forward\"] = \"forward\";\r\n      NavigationDirection[\"unknown\"] = \"\";\r\n  })(NavigationDirection || (NavigationDirection = {}));\r\n  /**\r\n   * Starting location for Histories\r\n   */\r\n  const START = '';\r\n  // Generic utils\r\n  /**\r\n   * Normalizes a base by removing any trailing slash and reading the base tag if\r\n   * present.\r\n   *\r\n   * @param base - base to normalize\r\n   */\r\n  function normalizeBase(base) {\r\n      if (!base) {\r\n          if (isBrowser) {\r\n              // respect <base> tag\r\n              const baseEl = document.querySelector('base');\r\n              base = (baseEl && baseEl.getAttribute('href')) || '/';\r\n              // strip full URL origin\r\n              base = base.replace(/^\\w+:\\/\\/[^\\/]+/, '');\r\n          }\r\n          else {\r\n              base = '/';\r\n          }\r\n      }\r\n      // ensure leading slash when it was removed by the regex above avoid leading\r\n      // slash with hash because the file could be read from the disk like file://\r\n      // and the leading slash would cause problems\r\n      if (base[0] !== '/' && base[0] !== '#')\r\n          base = '/' + base;\r\n      // remove the trailing slash so all other method can just do `base + fullPath`\r\n      // to build an href\r\n      return removeTrailingSlash(base);\r\n  }\r\n  // remove any character before the hash\r\n  const BEFORE_HASH_RE = /^[^#]+#/;\r\n  function createHref(base, location) {\r\n      return base.replace(BEFORE_HASH_RE, '#') + location;\r\n  }\n\n  function getElementPosition(el, offset) {\r\n      const docRect = document.documentElement.getBoundingClientRect();\r\n      const elRect = el.getBoundingClientRect();\r\n      return {\r\n          behavior: offset.behavior,\r\n          left: elRect.left - docRect.left - (offset.left || 0),\r\n          top: elRect.top - docRect.top - (offset.top || 0),\r\n      };\r\n  }\r\n  const computeScrollPosition = () => ({\r\n      left: window.pageXOffset,\r\n      top: window.pageYOffset,\r\n  });\r\n  function scrollToPosition(position) {\r\n      let scrollToOptions;\r\n      if ('el' in position) {\r\n          const positionEl = position.el;\r\n          const isIdSelector = typeof positionEl === 'string' && positionEl.startsWith('#');\r\n          /**\r\n           * `id`s can accept pretty much any characters, including CSS combinators\r\n           * like `>` or `~`. It's still possible to retrieve elements using\r\n           * `document.getElementById('~')` but it needs to be escaped when using\r\n           * `document.querySelector('#\\\\~')` for it to be valid. The only\r\n           * requirements for `id`s are them to be unique on the page and to not be\r\n           * empty (`id=\"\"`). Because of that, when passing an id selector, it should\r\n           * be properly escaped for it to work with `querySelector`. We could check\r\n           * for the id selector to be simple (no CSS combinators `+ >~`) but that\r\n           * would make things inconsistent since they are valid characters for an\r\n           * `id` but would need to be escaped when using `querySelector`, breaking\r\n           * their usage and ending up in no selector returned. Selectors need to be\r\n           * escaped:\r\n           *\r\n           * - `#1-thing` becomes `#\\31 -thing`\r\n           * - `#with~symbols` becomes `#with\\\\~symbols`\r\n           *\r\n           * - More information about  the topic can be found at\r\n           *   https://mathiasbynens.be/notes/html5-id-class.\r\n           * - Practical example: https://mathiasbynens.be/demo/html5-id\r\n           */\r\n          if (typeof position.el === 'string') {\r\n              if (!isIdSelector || !document.getElementById(position.el.slice(1))) {\r\n                  try {\r\n                      const foundEl = document.querySelector(position.el);\r\n                      if (isIdSelector && foundEl) {\r\n                          warn(`The selector \"${position.el}\" should be passed as \"el: document.querySelector('${position.el}')\" because it starts with \"#\".`);\r\n                          // return to avoid other warnings\r\n                          return;\r\n                      }\r\n                  }\r\n                  catch (err) {\r\n                      warn(`The selector \"${position.el}\" is invalid. If you are using an id selector, make sure to escape it. You can find more information about escaping characters in selectors at https://mathiasbynens.be/notes/css-escapes or use CSS.escape (https://developer.mozilla.org/en-US/docs/Web/API/CSS/escape).`);\r\n                      // return to avoid other warnings\r\n                      return;\r\n                  }\r\n              }\r\n          }\r\n          const el = typeof positionEl === 'string'\r\n              ? isIdSelector\r\n                  ? document.getElementById(positionEl.slice(1))\r\n                  : document.querySelector(positionEl)\r\n              : positionEl;\r\n          if (!el) {\r\n              warn(`Couldn't find element using selector \"${position.el}\" returned by scrollBehavior.`);\r\n              return;\r\n          }\r\n          scrollToOptions = getElementPosition(el, position);\r\n      }\r\n      else {\r\n          scrollToOptions = position;\r\n      }\r\n      if ('scrollBehavior' in document.documentElement.style)\r\n          window.scrollTo(scrollToOptions);\r\n      else {\r\n          window.scrollTo(scrollToOptions.left != null ? scrollToOptions.left : window.pageXOffset, scrollToOptions.top != null ? scrollToOptions.top : window.pageYOffset);\r\n      }\r\n  }\r\n  function getScrollKey(path, delta) {\r\n      const position = history.state ? history.state.position - delta : -1;\r\n      return position + path;\r\n  }\r\n  const scrollPositions = new Map();\r\n  function saveScrollPosition(key, scrollPosition) {\r\n      scrollPositions.set(key, scrollPosition);\r\n  }\r\n  function getSavedScrollPosition(key) {\r\n      const scroll = scrollPositions.get(key);\r\n      // consume it so it's not used again\r\n      scrollPositions.delete(key);\r\n      return scroll;\r\n  }\r\n  // TODO: RFC about how to save scroll position\r\n  /**\r\n   * ScrollBehavior instance used by the router to compute and restore the scroll\r\n   * position when navigating.\r\n   */\r\n  // export interface ScrollHandler<ScrollPositionEntry extends HistoryStateValue, ScrollPosition extends ScrollPositionEntry> {\r\n  //   // returns a scroll position that can be saved in history\r\n  //   compute(): ScrollPositionEntry\r\n  //   // can take an extended ScrollPositionEntry\r\n  //   scroll(position: ScrollPosition): void\r\n  // }\r\n  // export const scrollHandler: ScrollHandler<ScrollPosition> = {\r\n  //   compute: computeScroll,\r\n  //   scroll: scrollToPosition,\r\n  // }\n\n  let createBaseLocation = () => location.protocol + '//' + location.host;\r\n  /**\r\n   * Creates a normalized history location from a window.location object\r\n   * @param location -\r\n   */\r\n  function createCurrentLocation(base, location) {\r\n      const { pathname, search, hash } = location;\r\n      // allows hash bases like #, /#, #/, #!, #!/, /#!/, or even /folder#end\r\n      const hashPos = base.indexOf('#');\r\n      if (hashPos > -1) {\r\n          let slicePos = hash.includes(base.slice(hashPos))\r\n              ? base.slice(hashPos).length\r\n              : 1;\r\n          let pathFromHash = hash.slice(slicePos);\r\n          // prepend the starting slash to hash so the url starts with /#\r\n          if (pathFromHash[0] !== '/')\r\n              pathFromHash = '/' + pathFromHash;\r\n          return stripBase(pathFromHash, '');\r\n      }\r\n      const path = stripBase(pathname, base);\r\n      return path + search + hash;\r\n  }\r\n  function useHistoryListeners(base, historyState, currentLocation, replace) {\r\n      let listeners = [];\r\n      let teardowns = [];\r\n      // TODO: should it be a stack? a Dict. Check if the popstate listener\r\n      // can trigger twice\r\n      let pauseState = null;\r\n      const popStateHandler = ({ state, }) => {\r\n          const to = createCurrentLocation(base, location);\r\n          const from = currentLocation.value;\r\n          const fromState = historyState.value;\r\n          let delta = 0;\r\n          if (state) {\r\n              currentLocation.value = to;\r\n              historyState.value = state;\r\n              // ignore the popstate and reset the pauseState\r\n              if (pauseState && pauseState === from) {\r\n                  pauseState = null;\r\n                  return;\r\n              }\r\n              delta = fromState ? state.position - fromState.position : 0;\r\n          }\r\n          else {\r\n              replace(to);\r\n          }\r\n          // console.log({ deltaFromCurrent })\r\n          // Here we could also revert the navigation by calling history.go(-delta)\r\n          // this listener will have to be adapted to not trigger again and to wait for the url\r\n          // to be updated before triggering the listeners. Some kind of validation function would also\r\n          // need to be passed to the listeners so the navigation can be accepted\r\n          // call all listeners\r\n          listeners.forEach(listener => {\r\n              listener(currentLocation.value, from, {\r\n                  delta,\r\n                  type: NavigationType.pop,\r\n                  direction: delta\r\n                      ? delta > 0\r\n                          ? NavigationDirection.forward\r\n                          : NavigationDirection.back\r\n                      : NavigationDirection.unknown,\r\n              });\r\n          });\r\n      };\r\n      function pauseListeners() {\r\n          pauseState = currentLocation.value;\r\n      }\r\n      function listen(callback) {\r\n          // setup the listener and prepare teardown callbacks\r\n          listeners.push(callback);\r\n          const teardown = () => {\r\n              const index = listeners.indexOf(callback);\r\n              if (index > -1)\r\n                  listeners.splice(index, 1);\r\n          };\r\n          teardowns.push(teardown);\r\n          return teardown;\r\n      }\r\n      function beforeUnloadListener() {\r\n          const { history } = window;\r\n          if (!history.state)\r\n              return;\r\n          history.replaceState(assign({}, history.state, { scroll: computeScrollPosition() }), '');\r\n      }\r\n      function destroy() {\r\n          for (const teardown of teardowns)\r\n              teardown();\r\n          teardowns = [];\r\n          window.removeEventListener('popstate', popStateHandler);\r\n          window.removeEventListener('beforeunload', beforeUnloadListener);\r\n      }\r\n      // setup the listeners and prepare teardown callbacks\r\n      window.addEventListener('popstate', popStateHandler);\r\n      window.addEventListener('beforeunload', beforeUnloadListener);\r\n      return {\r\n          pauseListeners,\r\n          listen,\r\n          destroy,\r\n      };\r\n  }\r\n  /**\r\n   * Creates a state object\r\n   */\r\n  function buildState(back, current, forward, replaced = false, computeScroll = false) {\r\n      return {\r\n          back,\r\n          current,\r\n          forward,\r\n          replaced,\r\n          position: window.history.length,\r\n          scroll: computeScroll ? computeScrollPosition() : null,\r\n      };\r\n  }\r\n  function useHistoryStateNavigation(base) {\r\n      const { history, location } = window;\r\n      // private variables\r\n      const currentLocation = {\r\n          value: createCurrentLocation(base, location),\r\n      };\r\n      const historyState = { value: history.state };\r\n      // build current history entry as this is a fresh navigation\r\n      if (!historyState.value) {\r\n          changeLocation(currentLocation.value, {\r\n              back: null,\r\n              current: currentLocation.value,\r\n              forward: null,\r\n              // the length is off by one, we need to decrease it\r\n              position: history.length - 1,\r\n              replaced: true,\r\n              // don't add a scroll as the user may have an anchor and we want\r\n              // scrollBehavior to be triggered without a saved position\r\n              scroll: null,\r\n          }, true);\r\n      }\r\n      function changeLocation(to, state, replace) {\r\n          /**\r\n           * if a base tag is provided and we are on a normal domain, we have to\r\n           * respect the provided `base` attribute because pushState() will use it and\r\n           * potentially erase anything before the `#` like at\r\n           * https://github.com/vuejs/router/issues/685 where a base of\r\n           * `/folder/#` but a base of `/` would erase the `/folder/` section. If\r\n           * there is no host, the `<base>` tag makes no sense and if there isn't a\r\n           * base tag we can just use everything after the `#`.\r\n           */\r\n          const hashIndex = base.indexOf('#');\r\n          const url = hashIndex > -1\r\n              ? (location.host && document.querySelector('base')\r\n                  ? base\r\n                  : base.slice(hashIndex)) + to\r\n              : createBaseLocation() + base + to;\r\n          try {\r\n              // BROWSER QUIRK\r\n              // NOTE: Safari throws a SecurityError when calling this function 100 times in 30 seconds\r\n              history[replace ? 'replaceState' : 'pushState'](state, '', url);\r\n              historyState.value = state;\r\n          }\r\n          catch (err) {\r\n              {\r\n                  warn('Error with push/replace State', err);\r\n              }\r\n              // Force the navigation, this also resets the call count\r\n              location[replace ? 'replace' : 'assign'](url);\r\n          }\r\n      }\r\n      function replace(to, data) {\r\n          const state = assign({}, history.state, buildState(historyState.value.back, \r\n          // keep back and forward entries but override current position\r\n          to, historyState.value.forward, true), data, { position: historyState.value.position });\r\n          changeLocation(to, state, true);\r\n          currentLocation.value = to;\r\n      }\r\n      function push(to, data) {\r\n          // Add to current entry the information of where we are going\r\n          // as well as saving the current position\r\n          const currentState = assign({}, \r\n          // use current history state to gracefully handle a wrong call to\r\n          // history.replaceState\r\n          // https://github.com/vuejs/router/issues/366\r\n          historyState.value, history.state, {\r\n              forward: to,\r\n              scroll: computeScrollPosition(),\r\n          });\r\n          if (!history.state) {\r\n              warn(`history.state seems to have been manually replaced without preserving the necessary values. Make sure to preserve existing history state if you are manually calling history.replaceState:\\n\\n` +\r\n                  `history.replaceState(history.state, '', url)\\n\\n` +\r\n                  `You can find more information at https://next.router.vuejs.org/guide/migration/#usage-of-history-state.`);\r\n          }\r\n          changeLocation(currentState.current, currentState, true);\r\n          const state = assign({}, buildState(currentLocation.value, to, null), { position: currentState.position + 1 }, data);\r\n          changeLocation(to, state, false);\r\n          currentLocation.value = to;\r\n      }\r\n      return {\r\n          location: currentLocation,\r\n          state: historyState,\r\n          push,\r\n          replace,\r\n      };\r\n  }\r\n  /**\r\n   * Creates an HTML5 history. Most common history for single page applications.\r\n   *\r\n   * @param base -\r\n   */\r\n  function createWebHistory(base) {\r\n      base = normalizeBase(base);\r\n      const historyNavigation = useHistoryStateNavigation(base);\r\n      const historyListeners = useHistoryListeners(base, historyNavigation.state, historyNavigation.location, historyNavigation.replace);\r\n      function go(delta, triggerListeners = true) {\r\n          if (!triggerListeners)\r\n              historyListeners.pauseListeners();\r\n          history.go(delta);\r\n      }\r\n      const routerHistory = assign({\r\n          // it's overridden right after\r\n          location: '',\r\n          base,\r\n          go,\r\n          createHref: createHref.bind(null, base),\r\n      }, historyNavigation, historyListeners);\r\n      Object.defineProperty(routerHistory, 'location', {\r\n          enumerable: true,\r\n          get: () => historyNavigation.location.value,\r\n      });\r\n      Object.defineProperty(routerHistory, 'state', {\r\n          enumerable: true,\r\n          get: () => historyNavigation.state.value,\r\n      });\r\n      return routerHistory;\r\n  }\n\n  /**\r\n   * Creates a in-memory based history. The main purpose of this history is to handle SSR. It starts in a special location that is nowhere.\r\n   * It's up to the user to replace that location with the starter location by either calling `router.push` or `router.replace`.\r\n   *\r\n   * @param base - Base applied to all urls, defaults to '/'\r\n   * @returns a history object that can be passed to the router constructor\r\n   */\r\n  function createMemoryHistory(base = '') {\r\n      let listeners = [];\r\n      let queue = [START];\r\n      let position = 0;\r\n      base = normalizeBase(base);\r\n      function setLocation(location) {\r\n          position++;\r\n          if (position === queue.length) {\r\n              // we are at the end, we can simply append a new entry\r\n              queue.push(location);\r\n          }\r\n          else {\r\n              // we are in the middle, we remove everything from here in the queue\r\n              queue.splice(position);\r\n              queue.push(location);\r\n          }\r\n      }\r\n      function triggerListeners(to, from, { direction, delta }) {\r\n          const info = {\r\n              direction,\r\n              delta,\r\n              type: NavigationType.pop,\r\n          };\r\n          for (const callback of listeners) {\r\n              callback(to, from, info);\r\n          }\r\n      }\r\n      const routerHistory = {\r\n          // rewritten by Object.defineProperty\r\n          location: START,\r\n          // TODO: should be kept in queue\r\n          state: {},\r\n          base,\r\n          createHref: createHref.bind(null, base),\r\n          replace(to) {\r\n              // remove current entry and decrement position\r\n              queue.splice(position--, 1);\r\n              setLocation(to);\r\n          },\r\n          push(to, data) {\r\n              setLocation(to);\r\n          },\r\n          listen(callback) {\r\n              listeners.push(callback);\r\n              return () => {\r\n                  const index = listeners.indexOf(callback);\r\n                  if (index > -1)\r\n                      listeners.splice(index, 1);\r\n              };\r\n          },\r\n          destroy() {\r\n              listeners = [];\r\n              queue = [START];\r\n              position = 0;\r\n          },\r\n          go(delta, shouldTrigger = true) {\r\n              const from = this.location;\r\n              const direction = \r\n              // we are considering delta === 0 going forward, but in abstract mode\r\n              // using 0 for the delta doesn't make sense like it does in html5 where\r\n              // it reloads the page\r\n              delta < 0 ? NavigationDirection.back : NavigationDirection.forward;\r\n              position = Math.max(0, Math.min(position + delta, queue.length - 1));\r\n              if (shouldTrigger) {\r\n                  triggerListeners(this.location, from, {\r\n                      direction,\r\n                      delta,\r\n                  });\r\n              }\r\n          },\r\n      };\r\n      Object.defineProperty(routerHistory, 'location', {\r\n          enumerable: true,\r\n          get: () => queue[position],\r\n      });\r\n      return routerHistory;\r\n  }\n\n  /**\r\n   * Creates a hash history. Useful for web applications with no host (e.g.\r\n   * `file://`) or when configuring a server to handle any URL is not possible.\r\n   *\r\n   * @param base - optional base to provide. Defaults to `location.pathname +\r\n   * location.search` If there is a `<base>` tag in the `head`, its value will be\r\n   * ignored in favor of this parameter **but note it affects all the\r\n   * history.pushState() calls**, meaning that if you use a `<base>` tag, it's\r\n   * `href` value **has to match this parameter** (ignoring anything after the\r\n   * `#`).\r\n   *\r\n   * @example\r\n   * ```js\r\n   * // at https://example.com/folder\r\n   * createWebHashHistory() // gives a url of `https://example.com/folder#`\r\n   * createWebHashHistory('/folder/') // gives a url of `https://example.com/folder/#`\r\n   * // if the `#` is provided in the base, it won't be added by `createWebHashHistory`\r\n   * createWebHashHistory('/folder/#/app/') // gives a url of `https://example.com/folder/#/app/`\r\n   * // you should avoid doing this because it changes the original url and breaks copying urls\r\n   * createWebHashHistory('/other-folder/') // gives a url of `https://example.com/other-folder/#`\r\n   *\r\n   * // at file:///usr/etc/folder/index.html\r\n   * // for locations with no `host`, the base is ignored\r\n   * createWebHashHistory('/iAmIgnored') // gives a url of `file:///usr/etc/folder/index.html#`\r\n   * ```\r\n   */\r\n  function createWebHashHistory(base) {\r\n      // Make sure this implementation is fine in terms of encoding, specially for IE11\r\n      // for `file://`, directly use the pathname and ignore the base\r\n      // location.pathname contains an initial `/` even at the root: `https://example.com`\r\n      base = location.host ? base || location.pathname + location.search : '';\r\n      // allow the user to provide a `#` in the middle: `/base/#/app`\r\n      if (!base.includes('#'))\r\n          base += '#';\r\n      if (!base.endsWith('#/') && !base.endsWith('#')) {\r\n          warn(`A hash base must end with a \"#\":\\n\"${base}\" should be \"${base.replace(/#.*$/, '#')}\".`);\r\n      }\r\n      return createWebHistory(base);\r\n  }\n\n  function isRouteLocation(route) {\r\n      return typeof route === 'string' || (route && typeof route === 'object');\r\n  }\r\n  function isRouteName(name) {\r\n      return typeof name === 'string' || typeof name === 'symbol';\r\n  }\n\n  /**\r\n   * Initial route location where the router is. Can be used in navigation guards\r\n   * to differentiate the initial navigation.\r\n   *\r\n   * @example\r\n   * ```js\r\n   * import { START_LOCATION } from 'vue-router'\r\n   *\r\n   * router.beforeEach((to, from) => {\r\n   *   if (from === START_LOCATION) {\r\n   *     // initial navigation\r\n   *   }\r\n   * })\r\n   * ```\r\n   */\r\n  const START_LOCATION_NORMALIZED = {\r\n      path: '/',\r\n      name: undefined,\r\n      params: {},\r\n      query: {},\r\n      hash: '',\r\n      fullPath: '/',\r\n      matched: [],\r\n      meta: {},\r\n      redirectedFrom: undefined,\r\n  };\n\n  const NavigationFailureSymbol = /*#__PURE__*/ PolySymbol('navigation failure' );\r\n  /**\r\n   * Enumeration with all possible types for navigation failures. Can be passed to\r\n   * {@link isNavigationFailure} to check for specific failures.\r\n   */\r\n  exports.NavigationFailureType = void 0;\r\n  (function (NavigationFailureType) {\r\n      /**\r\n       * An aborted navigation is a navigation that failed because a navigation\r\n       * guard returned `false` or called `next(false)`\r\n       */\r\n      NavigationFailureType[NavigationFailureType[\"aborted\"] = 4] = \"aborted\";\r\n      /**\r\n       * A cancelled navigation is a navigation that failed because a more recent\r\n       * navigation finished started (not necessarily finished).\r\n       */\r\n      NavigationFailureType[NavigationFailureType[\"cancelled\"] = 8] = \"cancelled\";\r\n      /**\r\n       * A duplicated navigation is a navigation that failed because it was\r\n       * initiated while already being at the exact same location.\r\n       */\r\n      NavigationFailureType[NavigationFailureType[\"duplicated\"] = 16] = \"duplicated\";\r\n  })(exports.NavigationFailureType || (exports.NavigationFailureType = {}));\r\n  // DEV only debug messages\r\n  const ErrorTypeMessages = {\r\n      [1 /* MATCHER_NOT_FOUND */]({ location, currentLocation }) {\r\n          return `No match for\\n ${JSON.stringify(location)}${currentLocation\r\n            ? '\\nwhile being at\\n' + JSON.stringify(currentLocation)\r\n            : ''}`;\r\n      },\r\n      [2 /* NAVIGATION_GUARD_REDIRECT */]({ from, to, }) {\r\n          return `Redirected from \"${from.fullPath}\" to \"${stringifyRoute(to)}\" via a navigation guard.`;\r\n      },\r\n      [4 /* NAVIGATION_ABORTED */]({ from, to }) {\r\n          return `Navigation aborted from \"${from.fullPath}\" to \"${to.fullPath}\" via a navigation guard.`;\r\n      },\r\n      [8 /* NAVIGATION_CANCELLED */]({ from, to }) {\r\n          return `Navigation cancelled from \"${from.fullPath}\" to \"${to.fullPath}\" with a new navigation.`;\r\n      },\r\n      [16 /* NAVIGATION_DUPLICATED */]({ from, to }) {\r\n          return `Avoided redundant navigation to current location: \"${from.fullPath}\".`;\r\n      },\r\n  };\r\n  function createRouterError(type, params) {\r\n      // keep full error messages in cjs versions\r\n      {\r\n          return assign(new Error(ErrorTypeMessages[type](params)), {\r\n              type,\r\n              [NavigationFailureSymbol]: true,\r\n          }, params);\r\n      }\r\n  }\r\n  function isNavigationFailure(error, type) {\r\n      return (error instanceof Error &&\r\n          NavigationFailureSymbol in error &&\r\n          (type == null || !!(error.type & type)));\r\n  }\r\n  const propertiesToLog = ['params', 'query', 'hash'];\r\n  function stringifyRoute(to) {\r\n      if (typeof to === 'string')\r\n          return to;\r\n      if ('path' in to)\r\n          return to.path;\r\n      const location = {};\r\n      for (const key of propertiesToLog) {\r\n          if (key in to)\r\n              location[key] = to[key];\r\n      }\r\n      return JSON.stringify(location, null, 2);\r\n  }\n\n  // default pattern for a param: non greedy everything but /\r\n  const BASE_PARAM_PATTERN = '[^/]+?';\r\n  const BASE_PATH_PARSER_OPTIONS = {\r\n      sensitive: false,\r\n      strict: false,\r\n      start: true,\r\n      end: true,\r\n  };\r\n  // Special Regex characters that must be escaped in static tokens\r\n  const REGEX_CHARS_RE = /[.+*?^${}()[\\]/\\\\]/g;\r\n  /**\r\n   * Creates a path parser from an array of Segments (a segment is an array of Tokens)\r\n   *\r\n   * @param segments - array of segments returned by tokenizePath\r\n   * @param extraOptions - optional options for the regexp\r\n   * @returns a PathParser\r\n   */\r\n  function tokensToParser(segments, extraOptions) {\r\n      const options = assign({}, BASE_PATH_PARSER_OPTIONS, extraOptions);\r\n      // the amount of scores is the same as the length of segments except for the root segment \"/\"\r\n      const score = [];\r\n      // the regexp as a string\r\n      let pattern = options.start ? '^' : '';\r\n      // extracted keys\r\n      const keys = [];\r\n      for (const segment of segments) {\r\n          // the root segment needs special treatment\r\n          const segmentScores = segment.length ? [] : [90 /* Root */];\r\n          // allow trailing slash\r\n          if (options.strict && !segment.length)\r\n              pattern += '/';\r\n          for (let tokenIndex = 0; tokenIndex < segment.length; tokenIndex++) {\r\n              const token = segment[tokenIndex];\r\n              // resets the score if we are inside a sub segment /:a-other-:b\r\n              let subSegmentScore = 40 /* Segment */ +\r\n                  (options.sensitive ? 0.25 /* BonusCaseSensitive */ : 0);\r\n              if (token.type === 0 /* Static */) {\r\n                  // prepend the slash if we are starting a new segment\r\n                  if (!tokenIndex)\r\n                      pattern += '/';\r\n                  pattern += token.value.replace(REGEX_CHARS_RE, '\\\\$&');\r\n                  subSegmentScore += 40 /* Static */;\r\n              }\r\n              else if (token.type === 1 /* Param */) {\r\n                  const { value, repeatable, optional, regexp } = token;\r\n                  keys.push({\r\n                      name: value,\r\n                      repeatable,\r\n                      optional,\r\n                  });\r\n                  const re = regexp ? regexp : BASE_PARAM_PATTERN;\r\n                  // the user provided a custom regexp /:id(\\\\d+)\r\n                  if (re !== BASE_PARAM_PATTERN) {\r\n                      subSegmentScore += 10 /* BonusCustomRegExp */;\r\n                      // make sure the regexp is valid before using it\r\n                      try {\r\n                          new RegExp(`(${re})`);\r\n                      }\r\n                      catch (err) {\r\n                          throw new Error(`Invalid custom RegExp for param \"${value}\" (${re}): ` +\r\n                              err.message);\r\n                      }\r\n                  }\r\n                  // when we repeat we must take care of the repeating leading slash\r\n                  let subPattern = repeatable ? `((?:${re})(?:/(?:${re}))*)` : `(${re})`;\r\n                  // prepend the slash if we are starting a new segment\r\n                  if (!tokenIndex)\r\n                      subPattern =\r\n                          // avoid an optional / if there are more segments e.g. /:p?-static\r\n                          // or /:p?-:p2\r\n                          optional && segment.length < 2\r\n                              ? `(?:/${subPattern})`\r\n                              : '/' + subPattern;\r\n                  if (optional)\r\n                      subPattern += '?';\r\n                  pattern += subPattern;\r\n                  subSegmentScore += 20 /* Dynamic */;\r\n                  if (optional)\r\n                      subSegmentScore += -8 /* BonusOptional */;\r\n                  if (repeatable)\r\n                      subSegmentScore += -20 /* BonusRepeatable */;\r\n                  if (re === '.*')\r\n                      subSegmentScore += -50 /* BonusWildcard */;\r\n              }\r\n              segmentScores.push(subSegmentScore);\r\n          }\r\n          // an empty array like /home/ -> [[{home}], []]\r\n          // if (!segment.length) pattern += '/'\r\n          score.push(segmentScores);\r\n      }\r\n      // only apply the strict bonus to the last score\r\n      if (options.strict && options.end) {\r\n          const i = score.length - 1;\r\n          score[i][score[i].length - 1] += 0.7000000000000001 /* BonusStrict */;\r\n      }\r\n      // TODO: dev only warn double trailing slash\r\n      if (!options.strict)\r\n          pattern += '/?';\r\n      if (options.end)\r\n          pattern += '$';\r\n      // allow paths like /dynamic to only match dynamic or dynamic/... but not dynamic_something_else\r\n      else if (options.strict)\r\n          pattern += '(?:/|$)';\r\n      const re = new RegExp(pattern, options.sensitive ? '' : 'i');\r\n      function parse(path) {\r\n          const match = path.match(re);\r\n          const params = {};\r\n          if (!match)\r\n              return null;\r\n          for (let i = 1; i < match.length; i++) {\r\n              const value = match[i] || '';\r\n              const key = keys[i - 1];\r\n              params[key.name] = value && key.repeatable ? value.split('/') : value;\r\n          }\r\n          return params;\r\n      }\r\n      function stringify(params) {\r\n          let path = '';\r\n          // for optional parameters to allow to be empty\r\n          let avoidDuplicatedSlash = false;\r\n          for (const segment of segments) {\r\n              if (!avoidDuplicatedSlash || !path.endsWith('/'))\r\n                  path += '/';\r\n              avoidDuplicatedSlash = false;\r\n              for (const token of segment) {\r\n                  if (token.type === 0 /* Static */) {\r\n                      path += token.value;\r\n                  }\r\n                  else if (token.type === 1 /* Param */) {\r\n                      const { value, repeatable, optional } = token;\r\n                      const param = value in params ? params[value] : '';\r\n                      if (Array.isArray(param) && !repeatable)\r\n                          throw new Error(`Provided param \"${value}\" is an array but it is not repeatable (* or + modifiers)`);\r\n                      const text = Array.isArray(param) ? param.join('/') : param;\r\n                      if (!text) {\r\n                          if (optional) {\r\n                              // if we have more than one optional param like /:a?-static we\r\n                              // don't need to care about the optional param\r\n                              if (segment.length < 2) {\r\n                                  // remove the last slash as we could be at the end\r\n                                  if (path.endsWith('/'))\r\n                                      path = path.slice(0, -1);\r\n                                  // do not append a slash on the next iteration\r\n                                  else\r\n                                      avoidDuplicatedSlash = true;\r\n                              }\r\n                          }\r\n                          else\r\n                              throw new Error(`Missing required param \"${value}\"`);\r\n                      }\r\n                      path += text;\r\n                  }\r\n              }\r\n          }\r\n          return path;\r\n      }\r\n      return {\r\n          re,\r\n          score,\r\n          keys,\r\n          parse,\r\n          stringify,\r\n      };\r\n  }\r\n  /**\r\n   * Compares an array of numbers as used in PathParser.score and returns a\r\n   * number. This function can be used to `sort` an array\r\n   *\r\n   * @param a - first array of numbers\r\n   * @param b - second array of numbers\r\n   * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b\r\n   * should be sorted first\r\n   */\r\n  function compareScoreArray(a, b) {\r\n      let i = 0;\r\n      while (i < a.length && i < b.length) {\r\n          const diff = b[i] - a[i];\r\n          // only keep going if diff === 0\r\n          if (diff)\r\n              return diff;\r\n          i++;\r\n      }\r\n      // if the last subsegment was Static, the shorter segments should be sorted first\r\n      // otherwise sort the longest segment first\r\n      if (a.length < b.length) {\r\n          return a.length === 1 && a[0] === 40 /* Static */ + 40 /* Segment */\r\n              ? -1\r\n              : 1;\r\n      }\r\n      else if (a.length > b.length) {\r\n          return b.length === 1 && b[0] === 40 /* Static */ + 40 /* Segment */\r\n              ? 1\r\n              : -1;\r\n      }\r\n      return 0;\r\n  }\r\n  /**\r\n   * Compare function that can be used with `sort` to sort an array of PathParser\r\n   *\r\n   * @param a - first PathParser\r\n   * @param b - second PathParser\r\n   * @returns 0 if both are equal, < 0 if a should be sorted first, > 0 if b\r\n   */\r\n  function comparePathParserScore(a, b) {\r\n      let i = 0;\r\n      const aScore = a.score;\r\n      const bScore = b.score;\r\n      while (i < aScore.length && i < bScore.length) {\r\n          const comp = compareScoreArray(aScore[i], bScore[i]);\r\n          // do not return if both are equal\r\n          if (comp)\r\n              return comp;\r\n          i++;\r\n      }\r\n      // if a and b share the same score entries but b has more, sort b first\r\n      return bScore.length - aScore.length;\r\n      // this is the ternary version\r\n      // return aScore.length < bScore.length\r\n      //   ? 1\r\n      //   : aScore.length > bScore.length\r\n      //   ? -1\r\n      //   : 0\r\n  }\n\n  const ROOT_TOKEN = {\r\n      type: 0 /* Static */,\r\n      value: '',\r\n  };\r\n  const VALID_PARAM_RE = /[a-zA-Z0-9_]/;\r\n  // After some profiling, the cache seems to be unnecessary because tokenizePath\r\n  // (the slowest part of adding a route) is very fast\r\n  // const tokenCache = new Map<string, Token[][]>()\r\n  function tokenizePath(path) {\r\n      if (!path)\r\n          return [[]];\r\n      if (path === '/')\r\n          return [[ROOT_TOKEN]];\r\n      if (!path.startsWith('/')) {\r\n          throw new Error(`Route paths should start with a \"/\": \"${path}\" should be \"/${path}\".`\r\n              );\r\n      }\r\n      // if (tokenCache.has(path)) return tokenCache.get(path)!\r\n      function crash(message) {\r\n          throw new Error(`ERR (${state})/\"${buffer}\": ${message}`);\r\n      }\r\n      let state = 0 /* Static */;\r\n      let previousState = state;\r\n      const tokens = [];\r\n      // the segment will always be valid because we get into the initial state\r\n      // with the leading /\r\n      let segment;\r\n      function finalizeSegment() {\r\n          if (segment)\r\n              tokens.push(segment);\r\n          segment = [];\r\n      }\r\n      // index on the path\r\n      let i = 0;\r\n      // char at index\r\n      let char;\r\n      // buffer of the value read\r\n      let buffer = '';\r\n      // custom regexp for a param\r\n      let customRe = '';\r\n      function consumeBuffer() {\r\n          if (!buffer)\r\n              return;\r\n          if (state === 0 /* Static */) {\r\n              segment.push({\r\n                  type: 0 /* Static */,\r\n                  value: buffer,\r\n              });\r\n          }\r\n          else if (state === 1 /* Param */ ||\r\n              state === 2 /* ParamRegExp */ ||\r\n              state === 3 /* ParamRegExpEnd */) {\r\n              if (segment.length > 1 && (char === '*' || char === '+'))\r\n                  crash(`A repeatable param (${buffer}) must be alone in its segment. eg: '/:ids+.`);\r\n              segment.push({\r\n                  type: 1 /* Param */,\r\n                  value: buffer,\r\n                  regexp: customRe,\r\n                  repeatable: char === '*' || char === '+',\r\n                  optional: char === '*' || char === '?',\r\n              });\r\n          }\r\n          else {\r\n              crash('Invalid state to consume buffer');\r\n          }\r\n          buffer = '';\r\n      }\r\n      function addCharToBuffer() {\r\n          buffer += char;\r\n      }\r\n      while (i < path.length) {\r\n          char = path[i++];\r\n          if (char === '\\\\' && state !== 2 /* ParamRegExp */) {\r\n              previousState = state;\r\n              state = 4 /* EscapeNext */;\r\n              continue;\r\n          }\r\n          switch (state) {\r\n              case 0 /* Static */:\r\n                  if (char === '/') {\r\n                      if (buffer) {\r\n                          consumeBuffer();\r\n                      }\r\n                      finalizeSegment();\r\n                  }\r\n                  else if (char === ':') {\r\n                      consumeBuffer();\r\n                      state = 1 /* Param */;\r\n                  }\r\n                  else {\r\n                      addCharToBuffer();\r\n                  }\r\n                  break;\r\n              case 4 /* EscapeNext */:\r\n                  addCharToBuffer();\r\n                  state = previousState;\r\n                  break;\r\n              case 1 /* Param */:\r\n                  if (char === '(') {\r\n                      state = 2 /* ParamRegExp */;\r\n                  }\r\n                  else if (VALID_PARAM_RE.test(char)) {\r\n                      addCharToBuffer();\r\n                  }\r\n                  else {\r\n                      consumeBuffer();\r\n                      state = 0 /* Static */;\r\n                      // go back one character if we were not modifying\r\n                      if (char !== '*' && char !== '?' && char !== '+')\r\n                          i--;\r\n                  }\r\n                  break;\r\n              case 2 /* ParamRegExp */:\r\n                  // TODO: is it worth handling nested regexp? like :p(?:prefix_([^/]+)_suffix)\r\n                  // it already works by escaping the closing )\r\n                  // https://paths.esm.dev/?p=AAMeJbiAwQEcDKbAoAAkP60PG2R6QAvgNaA6AFACM2ABuQBB#\r\n                  // is this really something people need since you can also write\r\n                  // /prefix_:p()_suffix\r\n                  if (char === ')') {\r\n                      // handle the escaped )\r\n                      if (customRe[customRe.length - 1] == '\\\\')\r\n                          customRe = customRe.slice(0, -1) + char;\r\n                      else\r\n                          state = 3 /* ParamRegExpEnd */;\r\n                  }\r\n                  else {\r\n                      customRe += char;\r\n                  }\r\n                  break;\r\n              case 3 /* ParamRegExpEnd */:\r\n                  // same as finalizing a param\r\n                  consumeBuffer();\r\n                  state = 0 /* Static */;\r\n                  // go back one character if we were not modifying\r\n                  if (char !== '*' && char !== '?' && char !== '+')\r\n                      i--;\r\n                  customRe = '';\r\n                  break;\r\n              default:\r\n                  crash('Unknown state');\r\n                  break;\r\n          }\r\n      }\r\n      if (state === 2 /* ParamRegExp */)\r\n          crash(`Unfinished custom RegExp for param \"${buffer}\"`);\r\n      consumeBuffer();\r\n      finalizeSegment();\r\n      // tokenCache.set(path, tokens)\r\n      return tokens;\r\n  }\n\n  function createRouteRecordMatcher(record, parent, options) {\r\n      const parser = tokensToParser(tokenizePath(record.path), options);\r\n      // warn against params with the same name\r\n      {\r\n          const existingKeys = new Set();\r\n          for (const key of parser.keys) {\r\n              if (existingKeys.has(key.name))\r\n                  warn(`Found duplicated params with name \"${key.name}\" for path \"${record.path}\". Only the last one will be available on \"$route.params\".`);\r\n              existingKeys.add(key.name);\r\n          }\r\n      }\r\n      const matcher = assign(parser, {\r\n          record,\r\n          parent,\r\n          // these needs to be populated by the parent\r\n          children: [],\r\n          alias: [],\r\n      });\r\n      if (parent) {\r\n          // both are aliases or both are not aliases\r\n          // we don't want to mix them because the order is used when\r\n          // passing originalRecord in Matcher.addRoute\r\n          if (!matcher.record.aliasOf === !parent.record.aliasOf)\r\n              parent.children.push(matcher);\r\n      }\r\n      return matcher;\r\n  }\n\n  /**\r\n   * Creates a Router Matcher.\r\n   *\r\n   * @internal\r\n   * @param routes - array of initial routes\r\n   * @param globalOptions - global route options\r\n   */\r\n  function createRouterMatcher(routes, globalOptions) {\r\n      // normalized ordered array of matchers\r\n      const matchers = [];\r\n      const matcherMap = new Map();\r\n      globalOptions = mergeOptions({ strict: false, end: true, sensitive: false }, globalOptions);\r\n      function getRecordMatcher(name) {\r\n          return matcherMap.get(name);\r\n      }\r\n      function addRoute(record, parent, originalRecord) {\r\n          // used later on to remove by name\r\n          const isRootAdd = !originalRecord;\r\n          const mainNormalizedRecord = normalizeRouteRecord(record);\r\n          // we might be the child of an alias\r\n          mainNormalizedRecord.aliasOf = originalRecord && originalRecord.record;\r\n          const options = mergeOptions(globalOptions, record);\r\n          // generate an array of records to correctly handle aliases\r\n          const normalizedRecords = [\r\n              mainNormalizedRecord,\r\n          ];\r\n          if ('alias' in record) {\r\n              const aliases = typeof record.alias === 'string' ? [record.alias] : record.alias;\r\n              for (const alias of aliases) {\r\n                  normalizedRecords.push(assign({}, mainNormalizedRecord, {\r\n                      // this allows us to hold a copy of the `components` option\r\n                      // so that async components cache is hold on the original record\r\n                      components: originalRecord\r\n                          ? originalRecord.record.components\r\n                          : mainNormalizedRecord.components,\r\n                      path: alias,\r\n                      // we might be the child of an alias\r\n                      aliasOf: originalRecord\r\n                          ? originalRecord.record\r\n                          : mainNormalizedRecord,\r\n                      // the aliases are always of the same kind as the original since they\r\n                      // are defined on the same record\r\n                  }));\r\n              }\r\n          }\r\n          let matcher;\r\n          let originalMatcher;\r\n          for (const normalizedRecord of normalizedRecords) {\r\n              const { path } = normalizedRecord;\r\n              // Build up the path for nested routes if the child isn't an absolute\r\n              // route. Only add the / delimiter if the child path isn't empty and if the\r\n              // parent path doesn't have a trailing slash\r\n              if (parent && path[0] !== '/') {\r\n                  const parentPath = parent.record.path;\r\n                  const connectingSlash = parentPath[parentPath.length - 1] === '/' ? '' : '/';\r\n                  normalizedRecord.path =\r\n                      parent.record.path + (path && connectingSlash + path);\r\n              }\r\n              if (normalizedRecord.path === '*') {\r\n                  throw new Error('Catch all routes (\"*\") must now be defined using a param with a custom regexp.\\n' +\r\n                      'See more at https://next.router.vuejs.org/guide/migration/#removed-star-or-catch-all-routes.');\r\n              }\r\n              // create the object before hand so it can be passed to children\r\n              matcher = createRouteRecordMatcher(normalizedRecord, parent, options);\r\n              if (parent && path[0] === '/')\r\n                  checkMissingParamsInAbsolutePath(matcher, parent);\r\n              // if we are an alias we must tell the original record that we exist\r\n              // so we can be removed\r\n              if (originalRecord) {\r\n                  originalRecord.alias.push(matcher);\r\n                  {\r\n                      checkSameParams(originalRecord, matcher);\r\n                  }\r\n              }\r\n              else {\r\n                  // otherwise, the first record is the original and others are aliases\r\n                  originalMatcher = originalMatcher || matcher;\r\n                  if (originalMatcher !== matcher)\r\n                      originalMatcher.alias.push(matcher);\r\n                  // remove the route if named and only for the top record (avoid in nested calls)\r\n                  // this works because the original record is the first one\r\n                  if (isRootAdd && record.name && !isAliasRecord(matcher))\r\n                      removeRoute(record.name);\r\n              }\r\n              if ('children' in mainNormalizedRecord) {\r\n                  const children = mainNormalizedRecord.children;\r\n                  for (let i = 0; i < children.length; i++) {\r\n                      addRoute(children[i], matcher, originalRecord && originalRecord.children[i]);\r\n                  }\r\n              }\r\n              // if there was no original record, then the first one was not an alias and all\r\n              // other alias (if any) need to reference this record when adding children\r\n              originalRecord = originalRecord || matcher;\r\n              // TODO: add normalized records for more flexibility\r\n              // if (parent && isAliasRecord(originalRecord)) {\r\n              //   parent.children.push(originalRecord)\r\n              // }\r\n              insertMatcher(matcher);\r\n          }\r\n          return originalMatcher\r\n              ? () => {\r\n                  // since other matchers are aliases, they should be removed by the original matcher\r\n                  removeRoute(originalMatcher);\r\n              }\r\n              : noop;\r\n      }\r\n      function removeRoute(matcherRef) {\r\n          if (isRouteName(matcherRef)) {\r\n              const matcher = matcherMap.get(matcherRef);\r\n              if (matcher) {\r\n                  matcherMap.delete(matcherRef);\r\n                  matchers.splice(matchers.indexOf(matcher), 1);\r\n                  matcher.children.forEach(removeRoute);\r\n                  matcher.alias.forEach(removeRoute);\r\n              }\r\n          }\r\n          else {\r\n              const index = matchers.indexOf(matcherRef);\r\n              if (index > -1) {\r\n                  matchers.splice(index, 1);\r\n                  if (matcherRef.record.name)\r\n                      matcherMap.delete(matcherRef.record.name);\r\n                  matcherRef.children.forEach(removeRoute);\r\n                  matcherRef.alias.forEach(removeRoute);\r\n              }\r\n          }\r\n      }\r\n      function getRoutes() {\r\n          return matchers;\r\n      }\r\n      function insertMatcher(matcher) {\r\n          let i = 0;\r\n          while (i < matchers.length &&\r\n              comparePathParserScore(matcher, matchers[i]) >= 0 &&\r\n              // Adding children with empty path should still appear before the parent\r\n              // https://github.com/vuejs/router/issues/1124\r\n              (matcher.record.path !== matchers[i].record.path ||\r\n                  !isRecordChildOf(matcher, matchers[i])))\r\n              i++;\r\n          matchers.splice(i, 0, matcher);\r\n          // only add the original record to the name map\r\n          if (matcher.record.name && !isAliasRecord(matcher))\r\n              matcherMap.set(matcher.record.name, matcher);\r\n      }\r\n      function resolve(location, currentLocation) {\r\n          let matcher;\r\n          let params = {};\r\n          let path;\r\n          let name;\r\n          if ('name' in location && location.name) {\r\n              matcher = matcherMap.get(location.name);\r\n              if (!matcher)\r\n                  throw createRouterError(1 /* MATCHER_NOT_FOUND */, {\r\n                      location,\r\n                  });\r\n              name = matcher.record.name;\r\n              params = assign(\r\n              // paramsFromLocation is a new object\r\n              paramsFromLocation(currentLocation.params, \r\n              // only keep params that exist in the resolved location\r\n              // TODO: only keep optional params coming from a parent record\r\n              matcher.keys.filter(k => !k.optional).map(k => k.name)), location.params);\r\n              // throws if cannot be stringified\r\n              path = matcher.stringify(params);\r\n          }\r\n          else if ('path' in location) {\r\n              // no need to resolve the path with the matcher as it was provided\r\n              // this also allows the user to control the encoding\r\n              path = location.path;\r\n              if (!path.startsWith('/')) {\r\n                  warn(`The Matcher cannot resolve relative paths but received \"${path}\". Unless you directly called \\`matcher.resolve(\"${path}\")\\`, this is probably a bug in vue-router. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/router.`);\r\n              }\r\n              matcher = matchers.find(m => m.re.test(path));\r\n              // matcher should have a value after the loop\r\n              if (matcher) {\r\n                  // TODO: dev warning of unused params if provided\r\n                  // we know the matcher works because we tested the regexp\r\n                  params = matcher.parse(path);\r\n                  name = matcher.record.name;\r\n              }\r\n              // location is a relative path\r\n          }\r\n          else {\r\n              // match by name or path of current route\r\n              matcher = currentLocation.name\r\n                  ? matcherMap.get(currentLocation.name)\r\n                  : matchers.find(m => m.re.test(currentLocation.path));\r\n              if (!matcher)\r\n                  throw createRouterError(1 /* MATCHER_NOT_FOUND */, {\r\n                      location,\r\n                      currentLocation,\r\n                  });\r\n              name = matcher.record.name;\r\n              // since we are navigating to the same location, we don't need to pick the\r\n              // params like when `name` is provided\r\n              params = assign({}, currentLocation.params, location.params);\r\n              path = matcher.stringify(params);\r\n          }\r\n          const matched = [];\r\n          let parentMatcher = matcher;\r\n          while (parentMatcher) {\r\n              // reversed order so parents are at the beginning\r\n              matched.unshift(parentMatcher.record);\r\n              parentMatcher = parentMatcher.parent;\r\n          }\r\n          return {\r\n              name,\r\n              path,\r\n              params,\r\n              matched,\r\n              meta: mergeMetaFields(matched),\r\n          };\r\n      }\r\n      // add initial routes\r\n      routes.forEach(route => addRoute(route));\r\n      return { addRoute, resolve, removeRoute, getRoutes, getRecordMatcher };\r\n  }\r\n  function paramsFromLocation(params, keys) {\r\n      const newParams = {};\r\n      for (const key of keys) {\r\n          if (key in params)\r\n              newParams[key] = params[key];\r\n      }\r\n      return newParams;\r\n  }\r\n  /**\r\n   * Normalizes a RouteRecordRaw. Creates a copy\r\n   *\r\n   * @param record\r\n   * @returns the normalized version\r\n   */\r\n  function normalizeRouteRecord(record) {\r\n      return {\r\n          path: record.path,\r\n          redirect: record.redirect,\r\n          name: record.name,\r\n          meta: record.meta || {},\r\n          aliasOf: undefined,\r\n          beforeEnter: record.beforeEnter,\r\n          props: normalizeRecordProps(record),\r\n          children: record.children || [],\r\n          instances: {},\r\n          leaveGuards: new Set(),\r\n          updateGuards: new Set(),\r\n          enterCallbacks: {},\r\n          components: 'components' in record\r\n              ? record.components || {}\r\n              : { default: record.component },\r\n      };\r\n  }\r\n  /**\r\n   * Normalize the optional `props` in a record to always be an object similar to\r\n   * components. Also accept a boolean for components.\r\n   * @param record\r\n   */\r\n  function normalizeRecordProps(record) {\r\n      const propsObject = {};\r\n      // props does not exist on redirect records but we can set false directly\r\n      const props = record.props || false;\r\n      if ('component' in record) {\r\n          propsObject.default = props;\r\n      }\r\n      else {\r\n          // NOTE: we could also allow a function to be applied to every component.\r\n          // Would need user feedback for use cases\r\n          for (const name in record.components)\r\n              propsObject[name] = typeof props === 'boolean' ? props : props[name];\r\n      }\r\n      return propsObject;\r\n  }\r\n  /**\r\n   * Checks if a record or any of its parent is an alias\r\n   * @param record\r\n   */\r\n  function isAliasRecord(record) {\r\n      while (record) {\r\n          if (record.record.aliasOf)\r\n              return true;\r\n          record = record.parent;\r\n      }\r\n      return false;\r\n  }\r\n  /**\r\n   * Merge meta fields of an array of records\r\n   *\r\n   * @param matched - array of matched records\r\n   */\r\n  function mergeMetaFields(matched) {\r\n      return matched.reduce((meta, record) => assign(meta, record.meta), {});\r\n  }\r\n  function mergeOptions(defaults, partialOptions) {\r\n      const options = {};\r\n      for (const key in defaults) {\r\n          options[key] = key in partialOptions ? partialOptions[key] : defaults[key];\r\n      }\r\n      return options;\r\n  }\r\n  function isSameParam(a, b) {\r\n      return (a.name === b.name &&\r\n          a.optional === b.optional &&\r\n          a.repeatable === b.repeatable);\r\n  }\r\n  /**\r\n   * Check if a path and its alias have the same required params\r\n   *\r\n   * @param a - original record\r\n   * @param b - alias record\r\n   */\r\n  function checkSameParams(a, b) {\r\n      for (const key of a.keys) {\r\n          if (!key.optional && !b.keys.find(isSameParam.bind(null, key)))\r\n              return warn(`Alias \"${b.record.path}\" and the original record: \"${a.record.path}\" should have the exact same param named \"${key.name}\"`);\r\n      }\r\n      for (const key of b.keys) {\r\n          if (!key.optional && !a.keys.find(isSameParam.bind(null, key)))\r\n              return warn(`Alias \"${b.record.path}\" and the original record: \"${a.record.path}\" should have the exact same param named \"${key.name}\"`);\r\n      }\r\n  }\r\n  function checkMissingParamsInAbsolutePath(record, parent) {\r\n      for (const key of parent.keys) {\r\n          if (!record.keys.find(isSameParam.bind(null, key)))\r\n              return warn(`Absolute path \"${record.record.path}\" should have the exact same param named \"${key.name}\" as its parent \"${parent.record.path}\".`);\r\n      }\r\n  }\r\n  function isRecordChildOf(record, parent) {\r\n      return parent.children.some(child => child === record || isRecordChildOf(record, child));\r\n  }\n\n  /**\r\n   * Encoding Rules ␣ = Space Path: ␣ \" < > # ? { } Query: ␣ \" < > # & = Hash: ␣ \"\r\n   * < > `\r\n   *\r\n   * On top of that, the RFC3986 (https://tools.ietf.org/html/rfc3986#section-2.2)\r\n   * defines some extra characters to be encoded. Most browsers do not encode them\r\n   * in encodeURI https://github.com/whatwg/url/issues/369, so it may be safer to\r\n   * also encode `!'()*`. Leaving unencoded only ASCII alphanumeric(`a-zA-Z0-9`)\r\n   * plus `-._~`. This extra safety should be applied to query by patching the\r\n   * string returned by encodeURIComponent encodeURI also encodes `[\\]^`. `\\`\r\n   * should be encoded to avoid ambiguity. Browsers (IE, FF, C) transform a `\\`\r\n   * into a `/` if directly typed in. The _backtick_ (`````) should also be\r\n   * encoded everywhere because some browsers like FF encode it when directly\r\n   * written while others don't. Safari and IE don't encode ``\"<>{}``` in hash.\r\n   */\r\n  // const EXTRA_RESERVED_RE = /[!'()*]/g\r\n  // const encodeReservedReplacer = (c: string) => '%' + c.charCodeAt(0).toString(16)\r\n  const HASH_RE = /#/g; // %23\r\n  const AMPERSAND_RE = /&/g; // %26\r\n  const SLASH_RE = /\\//g; // %2F\r\n  const EQUAL_RE = /=/g; // %3D\r\n  const IM_RE = /\\?/g; // %3F\r\n  const PLUS_RE = /\\+/g; // %2B\r\n  /**\r\n   * NOTE: It's not clear to me if we should encode the + symbol in queries, it\r\n   * seems to be less flexible than not doing so and I can't find out the legacy\r\n   * systems requiring this for regular requests like text/html. In the standard,\r\n   * the encoding of the plus character is only mentioned for\r\n   * application/x-www-form-urlencoded\r\n   * (https://url.spec.whatwg.org/#urlencoded-parsing) and most browsers seems lo\r\n   * leave the plus character as is in queries. To be more flexible, we allow the\r\n   * plus character on the query but it can also be manually encoded by the user.\r\n   *\r\n   * Resources:\r\n   * - https://url.spec.whatwg.org/#urlencoded-parsing\r\n   * - https://stackoverflow.com/questions/1634271/url-encoding-the-space-character-or-20\r\n   */\r\n  const ENC_BRACKET_OPEN_RE = /%5B/g; // [\r\n  const ENC_BRACKET_CLOSE_RE = /%5D/g; // ]\r\n  const ENC_CARET_RE = /%5E/g; // ^\r\n  const ENC_BACKTICK_RE = /%60/g; // `\r\n  const ENC_CURLY_OPEN_RE = /%7B/g; // {\r\n  const ENC_PIPE_RE = /%7C/g; // |\r\n  const ENC_CURLY_CLOSE_RE = /%7D/g; // }\r\n  const ENC_SPACE_RE = /%20/g; // }\r\n  /**\r\n   * Encode characters that need to be encoded on the path, search and hash\r\n   * sections of the URL.\r\n   *\r\n   * @internal\r\n   * @param text - string to encode\r\n   * @returns encoded string\r\n   */\r\n  function commonEncode(text) {\r\n      return encodeURI('' + text)\r\n          .replace(ENC_PIPE_RE, '|')\r\n          .replace(ENC_BRACKET_OPEN_RE, '[')\r\n          .replace(ENC_BRACKET_CLOSE_RE, ']');\r\n  }\r\n  /**\r\n   * Encode characters that need to be encoded on the hash section of the URL.\r\n   *\r\n   * @param text - string to encode\r\n   * @returns encoded string\r\n   */\r\n  function encodeHash(text) {\r\n      return commonEncode(text)\r\n          .replace(ENC_CURLY_OPEN_RE, '{')\r\n          .replace(ENC_CURLY_CLOSE_RE, '}')\r\n          .replace(ENC_CARET_RE, '^');\r\n  }\r\n  /**\r\n   * Encode characters that need to be encoded query values on the query\r\n   * section of the URL.\r\n   *\r\n   * @param text - string to encode\r\n   * @returns encoded string\r\n   */\r\n  function encodeQueryValue(text) {\r\n      return (commonEncode(text)\r\n          // Encode the space as +, encode the + to differentiate it from the space\r\n          .replace(PLUS_RE, '%2B')\r\n          .replace(ENC_SPACE_RE, '+')\r\n          .replace(HASH_RE, '%23')\r\n          .replace(AMPERSAND_RE, '%26')\r\n          .replace(ENC_BACKTICK_RE, '`')\r\n          .replace(ENC_CURLY_OPEN_RE, '{')\r\n          .replace(ENC_CURLY_CLOSE_RE, '}')\r\n          .replace(ENC_CARET_RE, '^'));\r\n  }\r\n  /**\r\n   * Like `encodeQueryValue` but also encodes the `=` character.\r\n   *\r\n   * @param text - string to encode\r\n   */\r\n  function encodeQueryKey(text) {\r\n      return encodeQueryValue(text).replace(EQUAL_RE, '%3D');\r\n  }\r\n  /**\r\n   * Encode characters that need to be encoded on the path section of the URL.\r\n   *\r\n   * @param text - string to encode\r\n   * @returns encoded string\r\n   */\r\n  function encodePath(text) {\r\n      return commonEncode(text).replace(HASH_RE, '%23').replace(IM_RE, '%3F');\r\n  }\r\n  /**\r\n   * Encode characters that need to be encoded on the path section of the URL as a\r\n   * param. This function encodes everything {@link encodePath} does plus the\r\n   * slash (`/`) character. If `text` is `null` or `undefined`, returns an empty\r\n   * string instead.\r\n   *\r\n   * @param text - string to encode\r\n   * @returns encoded string\r\n   */\r\n  function encodeParam(text) {\r\n      return text == null ? '' : encodePath(text).replace(SLASH_RE, '%2F');\r\n  }\r\n  /**\r\n   * Decode text using `decodeURIComponent`. Returns the original text if it\r\n   * fails.\r\n   *\r\n   * @param text - string to decode\r\n   * @returns decoded string\r\n   */\r\n  function decode(text) {\r\n      try {\r\n          return decodeURIComponent('' + text);\r\n      }\r\n      catch (err) {\r\n          warn(`Error decoding \"${text}\". Using original value`);\r\n      }\r\n      return '' + text;\r\n  }\n\n  /**\r\n   * Transforms a queryString into a {@link LocationQuery} object. Accept both, a\r\n   * version with the leading `?` and without Should work as URLSearchParams\r\n\n   * @internal\r\n   *\r\n   * @param search - search string to parse\r\n   * @returns a query object\r\n   */\r\n  function parseQuery(search) {\r\n      const query = {};\r\n      // avoid creating an object with an empty key and empty value\r\n      // because of split('&')\r\n      if (search === '' || search === '?')\r\n          return query;\r\n      const hasLeadingIM = search[0] === '?';\r\n      const searchParams = (hasLeadingIM ? search.slice(1) : search).split('&');\r\n      for (let i = 0; i < searchParams.length; ++i) {\r\n          // pre decode the + into space\r\n          const searchParam = searchParams[i].replace(PLUS_RE, ' ');\r\n          // allow the = character\r\n          const eqPos = searchParam.indexOf('=');\r\n          const key = decode(eqPos < 0 ? searchParam : searchParam.slice(0, eqPos));\r\n          const value = eqPos < 0 ? null : decode(searchParam.slice(eqPos + 1));\r\n          if (key in query) {\r\n              // an extra variable for ts types\r\n              let currentValue = query[key];\r\n              if (!Array.isArray(currentValue)) {\r\n                  currentValue = query[key] = [currentValue];\r\n              }\r\n              currentValue.push(value);\r\n          }\r\n          else {\r\n              query[key] = value;\r\n          }\r\n      }\r\n      return query;\r\n  }\r\n  /**\r\n   * Stringifies a {@link LocationQueryRaw} object. Like `URLSearchParams`, it\r\n   * doesn't prepend a `?`\r\n   *\r\n   * @internal\r\n   *\r\n   * @param query - query object to stringify\r\n   * @returns string version of the query without the leading `?`\r\n   */\r\n  function stringifyQuery(query) {\r\n      let search = '';\r\n      for (let key in query) {\r\n          const value = query[key];\r\n          key = encodeQueryKey(key);\r\n          if (value == null) {\r\n              // only null adds the value\r\n              if (value !== undefined) {\r\n                  search += (search.length ? '&' : '') + key;\r\n              }\r\n              continue;\r\n          }\r\n          // keep null values\r\n          const values = Array.isArray(value)\r\n              ? value.map(v => v && encodeQueryValue(v))\r\n              : [value && encodeQueryValue(value)];\r\n          values.forEach(value => {\r\n              // skip undefined values in arrays as if they were not present\r\n              // smaller code than using filter\r\n              if (value !== undefined) {\r\n                  // only append & with non-empty search\r\n                  search += (search.length ? '&' : '') + key;\r\n                  if (value != null)\r\n                      search += '=' + value;\r\n              }\r\n          });\r\n      }\r\n      return search;\r\n  }\r\n  /**\r\n   * Transforms a {@link LocationQueryRaw} into a {@link LocationQuery} by casting\r\n   * numbers into strings, removing keys with an undefined value and replacing\r\n   * undefined with null in arrays\r\n   *\r\n   * @param query - query object to normalize\r\n   * @returns a normalized query object\r\n   */\r\n  function normalizeQuery(query) {\r\n      const normalizedQuery = {};\r\n      for (const key in query) {\r\n          const value = query[key];\r\n          if (value !== undefined) {\r\n              normalizedQuery[key] = Array.isArray(value)\r\n                  ? value.map(v => (v == null ? null : '' + v))\r\n                  : value == null\r\n                      ? value\r\n                      : '' + value;\r\n          }\r\n      }\r\n      return normalizedQuery;\r\n  }\n\n  /**\r\n   * Create a list of callbacks that can be reset. Used to create before and after navigation guards list\r\n   */\r\n  function useCallbacks() {\r\n      let handlers = [];\r\n      function add(handler) {\r\n          handlers.push(handler);\r\n          return () => {\r\n              const i = handlers.indexOf(handler);\r\n              if (i > -1)\r\n                  handlers.splice(i, 1);\r\n          };\r\n      }\r\n      function reset() {\r\n          handlers = [];\r\n      }\r\n      return {\r\n          add,\r\n          list: () => handlers,\r\n          reset,\r\n      };\r\n  }\n\n  function registerGuard(record, name, guard) {\r\n      const removeFromList = () => {\r\n          record[name].delete(guard);\r\n      };\r\n      vue.onUnmounted(removeFromList);\r\n      vue.onDeactivated(removeFromList);\r\n      vue.onActivated(() => {\r\n          record[name].add(guard);\r\n      });\r\n      record[name].add(guard);\r\n  }\r\n  /**\r\n   * Add a navigation guard that triggers whenever the component for the current\r\n   * location is about to be left. Similar to {@link beforeRouteLeave} but can be\r\n   * used in any component. The guard is removed when the component is unmounted.\r\n   *\r\n   * @param leaveGuard - {@link NavigationGuard}\r\n   */\r\n  function onBeforeRouteLeave(leaveGuard) {\r\n      if (!vue.getCurrentInstance()) {\r\n          warn('getCurrentInstance() returned null. onBeforeRouteLeave() must be called at the top of a setup function');\r\n          return;\r\n      }\r\n      const activeRecord = vue.inject(matchedRouteKey, \r\n      // to avoid warning\r\n      {}).value;\r\n      if (!activeRecord) {\r\n          warn('No active route record was found when calling `onBeforeRouteLeave()`. Make sure you call this function inside of a component child of <router-view>. Maybe you called it inside of App.vue?');\r\n          return;\r\n      }\r\n      registerGuard(activeRecord, 'leaveGuards', leaveGuard);\r\n  }\r\n  /**\r\n   * Add a navigation guard that triggers whenever the current location is about\r\n   * to be updated. Similar to {@link beforeRouteUpdate} but can be used in any\r\n   * component. The guard is removed when the component is unmounted.\r\n   *\r\n   * @param updateGuard - {@link NavigationGuard}\r\n   */\r\n  function onBeforeRouteUpdate(updateGuard) {\r\n      if (!vue.getCurrentInstance()) {\r\n          warn('getCurrentInstance() returned null. onBeforeRouteUpdate() must be called at the top of a setup function');\r\n          return;\r\n      }\r\n      const activeRecord = vue.inject(matchedRouteKey, \r\n      // to avoid warning\r\n      {}).value;\r\n      if (!activeRecord) {\r\n          warn('No active route record was found when calling `onBeforeRouteUpdate()`. Make sure you call this function inside of a component child of <router-view>. Maybe you called it inside of App.vue?');\r\n          return;\r\n      }\r\n      registerGuard(activeRecord, 'updateGuards', updateGuard);\r\n  }\r\n  function guardToPromiseFn(guard, to, from, record, name) {\r\n      // keep a reference to the enterCallbackArray to prevent pushing callbacks if a new navigation took place\r\n      const enterCallbackArray = record &&\r\n          // name is defined if record is because of the function overload\r\n          (record.enterCallbacks[name] = record.enterCallbacks[name] || []);\r\n      return () => new Promise((resolve, reject) => {\r\n          const next = (valid) => {\r\n              if (valid === false)\r\n                  reject(createRouterError(4 /* NAVIGATION_ABORTED */, {\r\n                      from,\r\n                      to,\r\n                  }));\r\n              else if (valid instanceof Error) {\r\n                  reject(valid);\r\n              }\r\n              else if (isRouteLocation(valid)) {\r\n                  reject(createRouterError(2 /* NAVIGATION_GUARD_REDIRECT */, {\r\n                      from: to,\r\n                      to: valid,\r\n                  }));\r\n              }\r\n              else {\r\n                  if (enterCallbackArray &&\r\n                      // since enterCallbackArray is truthy, both record and name also are\r\n                      record.enterCallbacks[name] === enterCallbackArray &&\r\n                      typeof valid === 'function')\r\n                      enterCallbackArray.push(valid);\r\n                  resolve();\r\n              }\r\n          };\r\n          // wrapping with Promise.resolve allows it to work with both async and sync guards\r\n          const guardReturn = guard.call(record && record.instances[name], to, from, canOnlyBeCalledOnce(next, to, from) );\r\n          let guardCall = Promise.resolve(guardReturn);\r\n          if (guard.length < 3)\r\n              guardCall = guardCall.then(next);\r\n          if (guard.length > 2) {\r\n              const message = `The \"next\" callback was never called inside of ${guard.name ? '\"' + guard.name + '\"' : ''}:\\n${guard.toString()}\\n. If you are returning a value instead of calling \"next\", make sure to remove the \"next\" parameter from your function.`;\r\n              if (typeof guardReturn === 'object' && 'then' in guardReturn) {\r\n                  guardCall = guardCall.then(resolvedValue => {\r\n                      // @ts-expect-error: _called is added at canOnlyBeCalledOnce\r\n                      if (!next._called) {\r\n                          warn(message);\r\n                          return Promise.reject(new Error('Invalid navigation guard'));\r\n                      }\r\n                      return resolvedValue;\r\n                  });\r\n                  // TODO: test me!\r\n              }\r\n              else if (guardReturn !== undefined) {\r\n                  // @ts-expect-error: _called is added at canOnlyBeCalledOnce\r\n                  if (!next._called) {\r\n                      warn(message);\r\n                      reject(new Error('Invalid navigation guard'));\r\n                      return;\r\n                  }\r\n              }\r\n          }\r\n          guardCall.catch(err => reject(err));\r\n      });\r\n  }\r\n  function canOnlyBeCalledOnce(next, to, from) {\r\n      let called = 0;\r\n      return function () {\r\n          if (called++ === 1)\r\n              warn(`The \"next\" callback was called more than once in one navigation guard when going from \"${from.fullPath}\" to \"${to.fullPath}\". It should be called exactly one time in each navigation guard. This will fail in production.`);\r\n          // @ts-expect-error: we put it in the original one because it's easier to check\r\n          next._called = true;\r\n          if (called === 1)\r\n              next.apply(null, arguments);\r\n      };\r\n  }\r\n  function extractComponentsGuards(matched, guardType, to, from) {\r\n      const guards = [];\r\n      for (const record of matched) {\r\n          for (const name in record.components) {\r\n              let rawComponent = record.components[name];\r\n              {\r\n                  if (!rawComponent ||\r\n                      (typeof rawComponent !== 'object' &&\r\n                          typeof rawComponent !== 'function')) {\r\n                      warn(`Component \"${name}\" in record with path \"${record.path}\" is not` +\r\n                          ` a valid component. Received \"${String(rawComponent)}\".`);\r\n                      // throw to ensure we stop here but warn to ensure the message isn't\r\n                      // missed by the user\r\n                      throw new Error('Invalid route component');\r\n                  }\r\n                  else if ('then' in rawComponent) {\r\n                      // warn if user wrote import('/component.vue') instead of () =>\r\n                      // import('./component.vue')\r\n                      warn(`Component \"${name}\" in record with path \"${record.path}\" is a ` +\r\n                          `Promise instead of a function that returns a Promise. Did you ` +\r\n                          `write \"import('./MyPage.vue')\" instead of ` +\r\n                          `\"() => import('./MyPage.vue')\" ? This will break in ` +\r\n                          `production if not fixed.`);\r\n                      const promise = rawComponent;\r\n                      rawComponent = () => promise;\r\n                  }\r\n                  else if (rawComponent.__asyncLoader &&\r\n                      // warn only once per component\r\n                      !rawComponent.__warnedDefineAsync) {\r\n                      rawComponent.__warnedDefineAsync = true;\r\n                      warn(`Component \"${name}\" in record with path \"${record.path}\" is defined ` +\r\n                          `using \"defineAsyncComponent()\". ` +\r\n                          `Write \"() => import('./MyPage.vue')\" instead of ` +\r\n                          `\"defineAsyncComponent(() => import('./MyPage.vue'))\".`);\r\n                  }\r\n              }\r\n              // skip update and leave guards if the route component is not mounted\r\n              if (guardType !== 'beforeRouteEnter' && !record.instances[name])\r\n                  continue;\r\n              if (isRouteComponent(rawComponent)) {\r\n                  // __vccOpts is added by vue-class-component and contain the regular options\r\n                  const options = rawComponent.__vccOpts || rawComponent;\r\n                  const guard = options[guardType];\r\n                  guard && guards.push(guardToPromiseFn(guard, to, from, record, name));\r\n              }\r\n              else {\r\n                  // start requesting the chunk already\r\n                  let componentPromise = rawComponent();\r\n                  if (!('catch' in componentPromise)) {\r\n                      warn(`Component \"${name}\" in record with path \"${record.path}\" is a function that does not return a Promise. If you were passing a functional component, make sure to add a \"displayName\" to the component. This will break in production if not fixed.`);\r\n                      componentPromise = Promise.resolve(componentPromise);\r\n                  }\r\n                  guards.push(() => componentPromise.then(resolved => {\r\n                      if (!resolved)\r\n                          return Promise.reject(new Error(`Couldn't resolve component \"${name}\" at \"${record.path}\"`));\r\n                      const resolvedComponent = isESModule(resolved)\r\n                          ? resolved.default\r\n                          : resolved;\r\n                      // replace the function with the resolved component\r\n                      record.components[name] = resolvedComponent;\r\n                      // __vccOpts is added by vue-class-component and contain the regular options\r\n                      const options = resolvedComponent.__vccOpts || resolvedComponent;\r\n                      const guard = options[guardType];\r\n                      return guard && guardToPromiseFn(guard, to, from, record, name)();\r\n                  }));\r\n              }\r\n          }\r\n      }\r\n      return guards;\r\n  }\r\n  /**\r\n   * Allows differentiating lazy components from functional components and vue-class-component\r\n   *\r\n   * @param component\r\n   */\r\n  function isRouteComponent(component) {\r\n      return (typeof component === 'object' ||\r\n          'displayName' in component ||\r\n          'props' in component ||\r\n          '__vccOpts' in component);\r\n  }\n\n  // TODO: we could allow currentRoute as a prop to expose `isActive` and\r\n  // `isExactActive` behavior should go through an RFC\r\n  function useLink(props) {\r\n      const router = vue.inject(routerKey);\r\n      const currentRoute = vue.inject(routeLocationKey);\r\n      const route = vue.computed(() => router.resolve(vue.unref(props.to)));\r\n      const activeRecordIndex = vue.computed(() => {\r\n          const { matched } = route.value;\r\n          const { length } = matched;\r\n          const routeMatched = matched[length - 1];\r\n          const currentMatched = currentRoute.matched;\r\n          if (!routeMatched || !currentMatched.length)\r\n              return -1;\r\n          const index = currentMatched.findIndex(isSameRouteRecord.bind(null, routeMatched));\r\n          if (index > -1)\r\n              return index;\r\n          // possible parent record\r\n          const parentRecordPath = getOriginalPath(matched[length - 2]);\r\n          return (\r\n          // we are dealing with nested routes\r\n          length > 1 &&\r\n              // if the parent and matched route have the same path, this link is\r\n              // referring to the empty child. Or we currently are on a different\r\n              // child of the same parent\r\n              getOriginalPath(routeMatched) === parentRecordPath &&\r\n              // avoid comparing the child with its parent\r\n              currentMatched[currentMatched.length - 1].path !== parentRecordPath\r\n              ? currentMatched.findIndex(isSameRouteRecord.bind(null, matched[length - 2]))\r\n              : index);\r\n      });\r\n      const isActive = vue.computed(() => activeRecordIndex.value > -1 &&\r\n          includesParams(currentRoute.params, route.value.params));\r\n      const isExactActive = vue.computed(() => activeRecordIndex.value > -1 &&\r\n          activeRecordIndex.value === currentRoute.matched.length - 1 &&\r\n          isSameRouteLocationParams(currentRoute.params, route.value.params));\r\n      function navigate(e = {}) {\r\n          if (guardEvent(e)) {\r\n              return router[vue.unref(props.replace) ? 'replace' : 'push'](vue.unref(props.to)\r\n              // avoid uncaught errors are they are logged anyway\r\n              ).catch(noop);\r\n          }\r\n          return Promise.resolve();\r\n      }\r\n      // devtools only\r\n      if (isBrowser) {\r\n          const instance = vue.getCurrentInstance();\r\n          if (instance) {\r\n              const linkContextDevtools = {\r\n                  route: route.value,\r\n                  isActive: isActive.value,\r\n                  isExactActive: isExactActive.value,\r\n              };\r\n              // @ts-expect-error: this is internal\r\n              instance.__vrl_devtools = instance.__vrl_devtools || [];\r\n              // @ts-expect-error: this is internal\r\n              instance.__vrl_devtools.push(linkContextDevtools);\r\n              vue.watchEffect(() => {\r\n                  linkContextDevtools.route = route.value;\r\n                  linkContextDevtools.isActive = isActive.value;\r\n                  linkContextDevtools.isExactActive = isExactActive.value;\r\n              }, { flush: 'post' });\r\n          }\r\n      }\r\n      return {\r\n          route,\r\n          href: vue.computed(() => route.value.href),\r\n          isActive,\r\n          isExactActive,\r\n          navigate,\r\n      };\r\n  }\r\n  const RouterLinkImpl = /*#__PURE__*/ vue.defineComponent({\r\n      name: 'RouterLink',\r\n      props: {\r\n          to: {\r\n              type: [String, Object],\r\n              required: true,\r\n          },\r\n          replace: Boolean,\r\n          activeClass: String,\r\n          // inactiveClass: String,\r\n          exactActiveClass: String,\r\n          custom: Boolean,\r\n          ariaCurrentValue: {\r\n              type: String,\r\n              default: 'page',\r\n          },\r\n      },\r\n      useLink,\r\n      setup(props, { slots }) {\r\n          const link = vue.reactive(useLink(props));\r\n          const { options } = vue.inject(routerKey);\r\n          const elClass = vue.computed(() => ({\r\n              [getLinkClass(props.activeClass, options.linkActiveClass, 'router-link-active')]: link.isActive,\r\n              // [getLinkClass(\r\n              //   props.inactiveClass,\r\n              //   options.linkInactiveClass,\r\n              //   'router-link-inactive'\r\n              // )]: !link.isExactActive,\r\n              [getLinkClass(props.exactActiveClass, options.linkExactActiveClass, 'router-link-exact-active')]: link.isExactActive,\r\n          }));\r\n          return () => {\r\n              const children = slots.default && slots.default(link);\r\n              return props.custom\r\n                  ? children\r\n                  : vue.h('a', {\r\n                      'aria-current': link.isExactActive\r\n                          ? props.ariaCurrentValue\r\n                          : null,\r\n                      href: link.href,\r\n                      // this would override user added attrs but Vue will still add\r\n                      // the listener so we end up triggering both\r\n                      onClick: link.navigate,\r\n                      class: elClass.value,\r\n                  }, children);\r\n          };\r\n      },\r\n  });\r\n  // export the public type for h/tsx inference\r\n  // also to avoid inline import() in generated d.ts files\r\n  /**\r\n   * Component to render a link that triggers a navigation on click.\r\n   */\r\n  const RouterLink = RouterLinkImpl;\r\n  function guardEvent(e) {\r\n      // don't redirect with control keys\r\n      if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)\r\n          return;\r\n      // don't redirect when preventDefault called\r\n      if (e.defaultPrevented)\r\n          return;\r\n      // don't redirect on right click\r\n      if (e.button !== undefined && e.button !== 0)\r\n          return;\r\n      // don't redirect if `target=\"_blank\"`\r\n      // @ts-expect-error getAttribute does exist\r\n      if (e.currentTarget && e.currentTarget.getAttribute) {\r\n          // @ts-expect-error getAttribute exists\r\n          const target = e.currentTarget.getAttribute('target');\r\n          if (/\\b_blank\\b/i.test(target))\r\n              return;\r\n      }\r\n      // this may be a Weex event which doesn't have this method\r\n      if (e.preventDefault)\r\n          e.preventDefault();\r\n      return true;\r\n  }\r\n  function includesParams(outer, inner) {\r\n      for (const key in inner) {\r\n          const innerValue = inner[key];\r\n          const outerValue = outer[key];\r\n          if (typeof innerValue === 'string') {\r\n              if (innerValue !== outerValue)\r\n                  return false;\r\n          }\r\n          else {\r\n              if (!Array.isArray(outerValue) ||\r\n                  outerValue.length !== innerValue.length ||\r\n                  innerValue.some((value, i) => value !== outerValue[i]))\r\n                  return false;\r\n          }\r\n      }\r\n      return true;\r\n  }\r\n  /**\r\n   * Get the original path value of a record by following its aliasOf\r\n   * @param record\r\n   */\r\n  function getOriginalPath(record) {\r\n      return record ? (record.aliasOf ? record.aliasOf.path : record.path) : '';\r\n  }\r\n  /**\r\n   * Utility class to get the active class based on defaults.\r\n   * @param propClass\r\n   * @param globalClass\r\n   * @param defaultClass\r\n   */\r\n  const getLinkClass = (propClass, globalClass, defaultClass) => propClass != null\r\n      ? propClass\r\n      : globalClass != null\r\n          ? globalClass\r\n          : defaultClass;\n\n  const RouterViewImpl = /*#__PURE__*/ vue.defineComponent({\r\n      name: 'RouterView',\r\n      // #674 we manually inherit them\r\n      inheritAttrs: false,\r\n      props: {\r\n          name: {\r\n              type: String,\r\n              default: 'default',\r\n          },\r\n          route: Object,\r\n      },\r\n      setup(props, { attrs, slots }) {\r\n          warnDeprecatedUsage();\r\n          const injectedRoute = vue.inject(routerViewLocationKey);\r\n          const routeToDisplay = vue.computed(() => props.route || injectedRoute.value);\r\n          const depth = vue.inject(viewDepthKey, 0);\r\n          const matchedRouteRef = vue.computed(() => routeToDisplay.value.matched[depth]);\r\n          vue.provide(viewDepthKey, depth + 1);\r\n          vue.provide(matchedRouteKey, matchedRouteRef);\r\n          vue.provide(routerViewLocationKey, routeToDisplay);\r\n          const viewRef = vue.ref();\r\n          // watch at the same time the component instance, the route record we are\r\n          // rendering, and the name\r\n          vue.watch(() => [viewRef.value, matchedRouteRef.value, props.name], ([instance, to, name], [oldInstance, from, oldName]) => {\r\n              // copy reused instances\r\n              if (to) {\r\n                  // this will update the instance for new instances as well as reused\r\n                  // instances when navigating to a new route\r\n                  to.instances[name] = instance;\r\n                  // the component instance is reused for a different route or name so\r\n                  // we copy any saved update or leave guards. With async setup, the\r\n                  // mounting component will mount before the matchedRoute changes,\r\n                  // making instance === oldInstance, so we check if guards have been\r\n                  // added before. This works because we remove guards when\r\n                  // unmounting/deactivating components\r\n                  if (from && from !== to && instance && instance === oldInstance) {\r\n                      if (!to.leaveGuards.size) {\r\n                          to.leaveGuards = from.leaveGuards;\r\n                      }\r\n                      if (!to.updateGuards.size) {\r\n                          to.updateGuards = from.updateGuards;\r\n                      }\r\n                  }\r\n              }\r\n              // trigger beforeRouteEnter next callbacks\r\n              if (instance &&\r\n                  to &&\r\n                  // if there is no instance but to and from are the same this might be\r\n                  // the first visit\r\n                  (!from || !isSameRouteRecord(to, from) || !oldInstance)) {\r\n                  (to.enterCallbacks[name] || []).forEach(callback => callback(instance));\r\n              }\r\n          }, { flush: 'post' });\r\n          return () => {\r\n              const route = routeToDisplay.value;\r\n              const matchedRoute = matchedRouteRef.value;\r\n              const ViewComponent = matchedRoute && matchedRoute.components[props.name];\r\n              // we need the value at the time we render because when we unmount, we\r\n              // navigated to a different location so the value is different\r\n              const currentName = props.name;\r\n              if (!ViewComponent) {\r\n                  return normalizeSlot(slots.default, { Component: ViewComponent, route });\r\n              }\r\n              // props from route configuration\r\n              const routePropsOption = matchedRoute.props[props.name];\r\n              const routeProps = routePropsOption\r\n                  ? routePropsOption === true\r\n                      ? route.params\r\n                      : typeof routePropsOption === 'function'\r\n                          ? routePropsOption(route)\r\n                          : routePropsOption\r\n                  : null;\r\n              const onVnodeUnmounted = vnode => {\r\n                  // remove the instance reference to prevent leak\r\n                  if (vnode.component.isUnmounted) {\r\n                      matchedRoute.instances[currentName] = null;\r\n                  }\r\n              };\r\n              const component = vue.h(ViewComponent, assign({}, routeProps, attrs, {\r\n                  onVnodeUnmounted,\r\n                  ref: viewRef,\r\n              }));\r\n              if (isBrowser &&\r\n                  component.ref) {\r\n                  // TODO: can display if it's an alias, its props\r\n                  const info = {\r\n                      depth,\r\n                      name: matchedRoute.name,\r\n                      path: matchedRoute.path,\r\n                      meta: matchedRoute.meta,\r\n                  };\r\n                  const internalInstances = Array.isArray(component.ref)\r\n                      ? component.ref.map(r => r.i)\r\n                      : [component.ref.i];\r\n                  internalInstances.forEach(instance => {\r\n                      // @ts-expect-error\r\n                      instance.__vrv_devtools = info;\r\n                  });\r\n              }\r\n              return (\r\n              // pass the vnode to the slot as a prop.\r\n              // h and <component :is=\"...\"> both accept vnodes\r\n              normalizeSlot(slots.default, { Component: component, route }) ||\r\n                  component);\r\n          };\r\n      },\r\n  });\r\n  function normalizeSlot(slot, data) {\r\n      if (!slot)\r\n          return null;\r\n      const slotContent = slot(data);\r\n      return slotContent.length === 1 ? slotContent[0] : slotContent;\r\n  }\r\n  // export the public type for h/tsx inference\r\n  // also to avoid inline import() in generated d.ts files\r\n  /**\r\n   * Component to display the current route the user is at.\r\n   */\r\n  const RouterView = RouterViewImpl;\r\n  // warn against deprecated usage with <transition> & <keep-alive>\r\n  // due to functional component being no longer eager in Vue 3\r\n  function warnDeprecatedUsage() {\r\n      const instance = vue.getCurrentInstance();\r\n      const parentName = instance.parent && instance.parent.type.name;\r\n      if (parentName &&\r\n          (parentName === 'KeepAlive' || parentName.includes('Transition'))) {\r\n          const comp = parentName === 'KeepAlive' ? 'keep-alive' : 'transition';\r\n          warn(`<router-view> can no longer be used directly inside <transition> or <keep-alive>.\\n` +\r\n              `Use slot props instead:\\n\\n` +\r\n              `<router-view v-slot=\"{ Component }\">\\n` +\r\n              `  <${comp}>\\n` +\r\n              `    <component :is=\"Component\" />\\n` +\r\n              `  </${comp}>\\n` +\r\n              `</router-view>`);\r\n      }\r\n  }\n\n  function getDevtoolsGlobalHook() {\n      return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;\n  }\n  function getTarget() {\n      // @ts-ignore\n      return (typeof navigator !== 'undefined' && typeof window !== 'undefined')\n          ? window\n          : typeof global !== 'undefined'\n              ? global\n              : {};\n  }\n  const isProxyAvailable = typeof Proxy === 'function';\n\n  const HOOK_SETUP = 'devtools-plugin:setup';\n  const HOOK_PLUGIN_SETTINGS_SET = 'plugin:settings:set';\n\n  class ApiProxy {\n      constructor(plugin, hook) {\n          this.target = null;\n          this.targetQueue = [];\n          this.onQueue = [];\n          this.plugin = plugin;\n          this.hook = hook;\n          const defaultSettings = {};\n          if (plugin.settings) {\n              for (const id in plugin.settings) {\n                  const item = plugin.settings[id];\n                  defaultSettings[id] = item.defaultValue;\n              }\n          }\n          const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;\n          let currentSettings = Object.assign({}, defaultSettings);\n          try {\n              const raw = localStorage.getItem(localSettingsSaveId);\n              const data = JSON.parse(raw);\n              Object.assign(currentSettings, data);\n          }\n          catch (e) {\n              // noop\n          }\n          this.fallbacks = {\n              getSettings() {\n                  return currentSettings;\n              },\n              setSettings(value) {\n                  try {\n                      localStorage.setItem(localSettingsSaveId, JSON.stringify(value));\n                  }\n                  catch (e) {\n                      // noop\n                  }\n                  currentSettings = value;\n              },\n          };\n          if (hook) {\n              hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {\n                  if (pluginId === this.plugin.id) {\n                      this.fallbacks.setSettings(value);\n                  }\n              });\n          }\n          this.proxiedOn = new Proxy({}, {\n              get: (_target, prop) => {\n                  if (this.target) {\n                      return this.target.on[prop];\n                  }\n                  else {\n                      return (...args) => {\n                          this.onQueue.push({\n                              method: prop,\n                              args,\n                          });\n                      };\n                  }\n              },\n          });\n          this.proxiedTarget = new Proxy({}, {\n              get: (_target, prop) => {\n                  if (this.target) {\n                      return this.target[prop];\n                  }\n                  else if (prop === 'on') {\n                      return this.proxiedOn;\n                  }\n                  else if (Object.keys(this.fallbacks).includes(prop)) {\n                      return (...args) => {\n                          this.targetQueue.push({\n                              method: prop,\n                              args,\n                              resolve: () => { },\n                          });\n                          return this.fallbacks[prop](...args);\n                      };\n                  }\n                  else {\n                      return (...args) => {\n                          return new Promise(resolve => {\n                              this.targetQueue.push({\n                                  method: prop,\n                                  args,\n                                  resolve,\n                              });\n                          });\n                      };\n                  }\n              },\n          });\n      }\n      async setRealTarget(target) {\n          this.target = target;\n          for (const item of this.onQueue) {\n              this.target.on[item.method](...item.args);\n          }\n          for (const item of this.targetQueue) {\n              item.resolve(await this.target[item.method](...item.args));\n          }\n      }\n  }\n\n  function setupDevtoolsPlugin(pluginDescriptor, setupFn) {\n      const descriptor = pluginDescriptor;\n      const target = getTarget();\n      const hook = getDevtoolsGlobalHook();\n      const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;\n      if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {\n          hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);\n      }\n      else {\n          const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;\n          const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];\n          list.push({\n              pluginDescriptor: descriptor,\n              setupFn,\n              proxy,\n          });\n          if (proxy)\n              setupFn(proxy.proxiedTarget);\n      }\n  }\n\n  function formatRouteLocation(routeLocation, tooltip) {\r\n      const copy = assign({}, routeLocation, {\r\n          // remove variables that can contain vue instances\r\n          matched: routeLocation.matched.map(matched => omit(matched, ['instances', 'children', 'aliasOf'])),\r\n      });\r\n      return {\r\n          _custom: {\r\n              type: null,\r\n              readOnly: true,\r\n              display: routeLocation.fullPath,\r\n              tooltip,\r\n              value: copy,\r\n          },\r\n      };\r\n  }\r\n  function formatDisplay(display) {\r\n      return {\r\n          _custom: {\r\n              display,\r\n          },\r\n      };\r\n  }\r\n  // to support multiple router instances\r\n  let routerId = 0;\r\n  function addDevtools(app, router, matcher) {\r\n      // Take over router.beforeEach and afterEach\r\n      // make sure we are not registering the devtool twice\r\n      if (router.__hasDevtools)\r\n          return;\r\n      router.__hasDevtools = true;\r\n      // increment to support multiple router instances\r\n      const id = routerId++;\r\n      setupDevtoolsPlugin({\r\n          id: 'org.vuejs.router' + (id ? '.' + id : ''),\r\n          label: 'Vue Router',\r\n          packageName: 'vue-router',\r\n          homepage: 'https://router.vuejs.org',\r\n          logo: 'https://router.vuejs.org/logo.png',\r\n          componentStateTypes: ['Routing'],\r\n          app,\r\n      }, api => {\r\n          // display state added by the router\r\n          api.on.inspectComponent((payload, ctx) => {\r\n              if (payload.instanceData) {\r\n                  payload.instanceData.state.push({\r\n                      type: 'Routing',\r\n                      key: '$route',\r\n                      editable: false,\r\n                      value: formatRouteLocation(router.currentRoute.value, 'Current Route'),\r\n                  });\r\n              }\r\n          });\r\n          // mark router-link as active and display tags on router views\r\n          api.on.visitComponentTree(({ treeNode: node, componentInstance }) => {\r\n              if (componentInstance.__vrv_devtools) {\r\n                  const info = componentInstance.__vrv_devtools;\r\n                  node.tags.push({\r\n                      label: (info.name ? `${info.name.toString()}: ` : '') + info.path,\r\n                      textColor: 0,\r\n                      tooltip: 'This component is rendered by &lt;router-view&gt;',\r\n                      backgroundColor: PINK_500,\r\n                  });\r\n              }\r\n              // if multiple useLink are used\r\n              if (Array.isArray(componentInstance.__vrl_devtools)) {\r\n                  componentInstance.__devtoolsApi = api;\r\n                  componentInstance.__vrl_devtools.forEach(devtoolsData => {\r\n                      let backgroundColor = ORANGE_400;\r\n                      let tooltip = '';\r\n                      if (devtoolsData.isExactActive) {\r\n                          backgroundColor = LIME_500;\r\n                          tooltip = 'This is exactly active';\r\n                      }\r\n                      else if (devtoolsData.isActive) {\r\n                          backgroundColor = BLUE_600;\r\n                          tooltip = 'This link is active';\r\n                      }\r\n                      node.tags.push({\r\n                          label: devtoolsData.route.path,\r\n                          textColor: 0,\r\n                          tooltip,\r\n                          backgroundColor,\r\n                      });\r\n                  });\r\n              }\r\n          });\r\n          vue.watch(router.currentRoute, () => {\r\n              // refresh active state\r\n              refreshRoutesView();\r\n              api.notifyComponentUpdate();\r\n              api.sendInspectorTree(routerInspectorId);\r\n              api.sendInspectorState(routerInspectorId);\r\n          });\r\n          const navigationsLayerId = 'router:navigations:' + id;\r\n          api.addTimelineLayer({\r\n              id: navigationsLayerId,\r\n              label: `Router${id ? ' ' + id : ''} Navigations`,\r\n              color: 0x40a8c4,\r\n          });\r\n          // const errorsLayerId = 'router:errors'\r\n          // api.addTimelineLayer({\r\n          //   id: errorsLayerId,\r\n          //   label: 'Router Errors',\r\n          //   color: 0xea5455,\r\n          // })\r\n          router.onError((error, to) => {\r\n              api.addTimelineEvent({\r\n                  layerId: navigationsLayerId,\r\n                  event: {\r\n                      title: 'Error during Navigation',\r\n                      subtitle: to.fullPath,\r\n                      logType: 'error',\r\n                      time: api.now(),\r\n                      data: { error },\r\n                      groupId: to.meta.__navigationId,\r\n                  },\r\n              });\r\n          });\r\n          // attached to `meta` and used to group events\r\n          let navigationId = 0;\r\n          router.beforeEach((to, from) => {\r\n              const data = {\r\n                  guard: formatDisplay('beforeEach'),\r\n                  from: formatRouteLocation(from, 'Current Location during this navigation'),\r\n                  to: formatRouteLocation(to, 'Target location'),\r\n              };\r\n              // Used to group navigations together, hide from devtools\r\n              Object.defineProperty(to.meta, '__navigationId', {\r\n                  value: navigationId++,\r\n              });\r\n              api.addTimelineEvent({\r\n                  layerId: navigationsLayerId,\r\n                  event: {\r\n                      time: api.now(),\r\n                      title: 'Start of navigation',\r\n                      subtitle: to.fullPath,\r\n                      data,\r\n                      groupId: to.meta.__navigationId,\r\n                  },\r\n              });\r\n          });\r\n          router.afterEach((to, from, failure) => {\r\n              const data = {\r\n                  guard: formatDisplay('afterEach'),\r\n              };\r\n              if (failure) {\r\n                  data.failure = {\r\n                      _custom: {\r\n                          type: Error,\r\n                          readOnly: true,\r\n                          display: failure ? failure.message : '',\r\n                          tooltip: 'Navigation Failure',\r\n                          value: failure,\r\n                      },\r\n                  };\r\n                  data.status = formatDisplay('❌');\r\n              }\r\n              else {\r\n                  data.status = formatDisplay('✅');\r\n              }\r\n              // we set here to have the right order\r\n              data.from = formatRouteLocation(from, 'Current Location during this navigation');\r\n              data.to = formatRouteLocation(to, 'Target location');\r\n              api.addTimelineEvent({\r\n                  layerId: navigationsLayerId,\r\n                  event: {\r\n                      title: 'End of navigation',\r\n                      subtitle: to.fullPath,\r\n                      time: api.now(),\r\n                      data,\r\n                      logType: failure ? 'warning' : 'default',\r\n                      groupId: to.meta.__navigationId,\r\n                  },\r\n              });\r\n          });\r\n          /**\r\n           * Inspector of Existing routes\r\n           */\r\n          const routerInspectorId = 'router-inspector:' + id;\r\n          api.addInspector({\r\n              id: routerInspectorId,\r\n              label: 'Routes' + (id ? ' ' + id : ''),\r\n              icon: 'book',\r\n              treeFilterPlaceholder: 'Search routes',\r\n          });\r\n          function refreshRoutesView() {\r\n              // the routes view isn't active\r\n              if (!activeRoutesPayload)\r\n                  return;\r\n              const payload = activeRoutesPayload;\r\n              // children routes will appear as nested\r\n              let routes = matcher.getRoutes().filter(route => !route.parent);\r\n              // reset match state to false\r\n              routes.forEach(resetMatchStateOnRouteRecord);\r\n              // apply a match state if there is a payload\r\n              if (payload.filter) {\r\n                  routes = routes.filter(route => \r\n                  // save matches state based on the payload\r\n                  isRouteMatching(route, payload.filter.toLowerCase()));\r\n              }\r\n              // mark active routes\r\n              routes.forEach(route => markRouteRecordActive(route, router.currentRoute.value));\r\n              payload.rootNodes = routes.map(formatRouteRecordForInspector);\r\n          }\r\n          let activeRoutesPayload;\r\n          api.on.getInspectorTree(payload => {\r\n              activeRoutesPayload = payload;\r\n              if (payload.app === app && payload.inspectorId === routerInspectorId) {\r\n                  refreshRoutesView();\r\n              }\r\n          });\r\n          /**\r\n           * Display information about the currently selected route record\r\n           */\r\n          api.on.getInspectorState(payload => {\r\n              if (payload.app === app && payload.inspectorId === routerInspectorId) {\r\n                  const routes = matcher.getRoutes();\r\n                  const route = routes.find(route => route.record.__vd_id === payload.nodeId);\r\n                  if (route) {\r\n                      payload.state = {\r\n                          options: formatRouteRecordMatcherForStateInspector(route),\r\n                      };\r\n                  }\r\n              }\r\n          });\r\n          api.sendInspectorTree(routerInspectorId);\r\n          api.sendInspectorState(routerInspectorId);\r\n      });\r\n  }\r\n  function modifierForKey(key) {\r\n      if (key.optional) {\r\n          return key.repeatable ? '*' : '?';\r\n      }\r\n      else {\r\n          return key.repeatable ? '+' : '';\r\n      }\r\n  }\r\n  function formatRouteRecordMatcherForStateInspector(route) {\r\n      const { record } = route;\r\n      const fields = [\r\n          { editable: false, key: 'path', value: record.path },\r\n      ];\r\n      if (record.name != null) {\r\n          fields.push({\r\n              editable: false,\r\n              key: 'name',\r\n              value: record.name,\r\n          });\r\n      }\r\n      fields.push({ editable: false, key: 'regexp', value: route.re });\r\n      if (route.keys.length) {\r\n          fields.push({\r\n              editable: false,\r\n              key: 'keys',\r\n              value: {\r\n                  _custom: {\r\n                      type: null,\r\n                      readOnly: true,\r\n                      display: route.keys\r\n                          .map(key => `${key.name}${modifierForKey(key)}`)\r\n                          .join(' '),\r\n                      tooltip: 'Param keys',\r\n                      value: route.keys,\r\n                  },\r\n              },\r\n          });\r\n      }\r\n      if (record.redirect != null) {\r\n          fields.push({\r\n              editable: false,\r\n              key: 'redirect',\r\n              value: record.redirect,\r\n          });\r\n      }\r\n      if (route.alias.length) {\r\n          fields.push({\r\n              editable: false,\r\n              key: 'aliases',\r\n              value: route.alias.map(alias => alias.record.path),\r\n          });\r\n      }\r\n      fields.push({\r\n          key: 'score',\r\n          editable: false,\r\n          value: {\r\n              _custom: {\r\n                  type: null,\r\n                  readOnly: true,\r\n                  display: route.score.map(score => score.join(', ')).join(' | '),\r\n                  tooltip: 'Score used to sort routes',\r\n                  value: route.score,\r\n              },\r\n          },\r\n      });\r\n      return fields;\r\n  }\r\n  /**\r\n   * Extracted from tailwind palette\r\n   */\r\n  const PINK_500 = 0xec4899;\r\n  const BLUE_600 = 0x2563eb;\r\n  const LIME_500 = 0x84cc16;\r\n  const CYAN_400 = 0x22d3ee;\r\n  const ORANGE_400 = 0xfb923c;\r\n  // const GRAY_100 = 0xf4f4f5\r\n  const DARK = 0x666666;\r\n  function formatRouteRecordForInspector(route) {\r\n      const tags = [];\r\n      const { record } = route;\r\n      if (record.name != null) {\r\n          tags.push({\r\n              label: String(record.name),\r\n              textColor: 0,\r\n              backgroundColor: CYAN_400,\r\n          });\r\n      }\r\n      if (record.aliasOf) {\r\n          tags.push({\r\n              label: 'alias',\r\n              textColor: 0,\r\n              backgroundColor: ORANGE_400,\r\n          });\r\n      }\r\n      if (route.__vd_match) {\r\n          tags.push({\r\n              label: 'matches',\r\n              textColor: 0,\r\n              backgroundColor: PINK_500,\r\n          });\r\n      }\r\n      if (route.__vd_exactActive) {\r\n          tags.push({\r\n              label: 'exact',\r\n              textColor: 0,\r\n              backgroundColor: LIME_500,\r\n          });\r\n      }\r\n      if (route.__vd_active) {\r\n          tags.push({\r\n              label: 'active',\r\n              textColor: 0,\r\n              backgroundColor: BLUE_600,\r\n          });\r\n      }\r\n      if (record.redirect) {\r\n          tags.push({\r\n              label: 'redirect: ' +\r\n                  (typeof record.redirect === 'string' ? record.redirect : 'Object'),\r\n              textColor: 0xffffff,\r\n              backgroundColor: DARK,\r\n          });\r\n      }\r\n      // add an id to be able to select it. Using the `path` is not possible because\r\n      // empty path children would collide with their parents\r\n      let id = record.__vd_id;\r\n      if (id == null) {\r\n          id = String(routeRecordId++);\r\n          record.__vd_id = id;\r\n      }\r\n      return {\r\n          id,\r\n          label: record.path,\r\n          tags,\r\n          children: route.children.map(formatRouteRecordForInspector),\r\n      };\r\n  }\r\n  //  incremental id for route records and inspector state\r\n  let routeRecordId = 0;\r\n  const EXTRACT_REGEXP_RE = /^\\/(.*)\\/([a-z]*)$/;\r\n  function markRouteRecordActive(route, currentRoute) {\r\n      // no route will be active if matched is empty\r\n      // reset the matching state\r\n      const isExactActive = currentRoute.matched.length &&\r\n          isSameRouteRecord(currentRoute.matched[currentRoute.matched.length - 1], route.record);\r\n      route.__vd_exactActive = route.__vd_active = isExactActive;\r\n      if (!isExactActive) {\r\n          route.__vd_active = currentRoute.matched.some(match => isSameRouteRecord(match, route.record));\r\n      }\r\n      route.children.forEach(childRoute => markRouteRecordActive(childRoute, currentRoute));\r\n  }\r\n  function resetMatchStateOnRouteRecord(route) {\r\n      route.__vd_match = false;\r\n      route.children.forEach(resetMatchStateOnRouteRecord);\r\n  }\r\n  function isRouteMatching(route, filter) {\r\n      const found = String(route.re).match(EXTRACT_REGEXP_RE);\r\n      route.__vd_match = false;\r\n      if (!found || found.length < 3) {\r\n          return false;\r\n      }\r\n      // use a regexp without $ at the end to match nested routes better\r\n      const nonEndingRE = new RegExp(found[1].replace(/\\$$/, ''), found[2]);\r\n      if (nonEndingRE.test(filter)) {\r\n          // mark children as matches\r\n          route.children.forEach(child => isRouteMatching(child, filter));\r\n          // exception case: `/`\r\n          if (route.record.path !== '/' || filter === '/') {\r\n              route.__vd_match = route.re.test(filter);\r\n              return true;\r\n          }\r\n          // hide the / route\r\n          return false;\r\n      }\r\n      const path = route.record.path.toLowerCase();\r\n      const decodedPath = decode(path);\r\n      // also allow partial matching on the path\r\n      if (!filter.startsWith('/') &&\r\n          (decodedPath.includes(filter) || path.includes(filter)))\r\n          return true;\r\n      if (decodedPath.startsWith(filter) || path.startsWith(filter))\r\n          return true;\r\n      if (route.record.name && String(route.record.name).includes(filter))\r\n          return true;\r\n      return route.children.some(child => isRouteMatching(child, filter));\r\n  }\r\n  function omit(obj, keys) {\r\n      const ret = {};\r\n      for (const key in obj) {\r\n          if (!keys.includes(key)) {\r\n              // @ts-expect-error\r\n              ret[key] = obj[key];\r\n          }\r\n      }\r\n      return ret;\r\n  }\n\n  /**\r\n   * Creates a Router instance that can be used by a Vue app.\r\n   *\r\n   * @param options - {@link RouterOptions}\r\n   */\r\n  function createRouter(options) {\r\n      const matcher = createRouterMatcher(options.routes, options);\r\n      const parseQuery$1 = options.parseQuery || parseQuery;\r\n      const stringifyQuery$1 = options.stringifyQuery || stringifyQuery;\r\n      const routerHistory = options.history;\r\n      if (!routerHistory)\r\n          throw new Error('Provide the \"history\" option when calling \"createRouter()\":' +\r\n              ' https://next.router.vuejs.org/api/#history.');\r\n      const beforeGuards = useCallbacks();\r\n      const beforeResolveGuards = useCallbacks();\r\n      const afterGuards = useCallbacks();\r\n      const currentRoute = vue.shallowRef(START_LOCATION_NORMALIZED);\r\n      let pendingLocation = START_LOCATION_NORMALIZED;\r\n      // leave the scrollRestoration if no scrollBehavior is provided\r\n      if (isBrowser && options.scrollBehavior && 'scrollRestoration' in history) {\r\n          history.scrollRestoration = 'manual';\r\n      }\r\n      const normalizeParams = applyToParams.bind(null, paramValue => '' + paramValue);\r\n      const encodeParams = applyToParams.bind(null, encodeParam);\r\n      const decodeParams = \r\n      // @ts-expect-error: intentionally avoid the type check\r\n      applyToParams.bind(null, decode);\r\n      function addRoute(parentOrRoute, route) {\r\n          let parent;\r\n          let record;\r\n          if (isRouteName(parentOrRoute)) {\r\n              parent = matcher.getRecordMatcher(parentOrRoute);\r\n              record = route;\r\n          }\r\n          else {\r\n              record = parentOrRoute;\r\n          }\r\n          return matcher.addRoute(record, parent);\r\n      }\r\n      function removeRoute(name) {\r\n          const recordMatcher = matcher.getRecordMatcher(name);\r\n          if (recordMatcher) {\r\n              matcher.removeRoute(recordMatcher);\r\n          }\r\n          else {\r\n              warn(`Cannot remove non-existent route \"${String(name)}\"`);\r\n          }\r\n      }\r\n      function getRoutes() {\r\n          return matcher.getRoutes().map(routeMatcher => routeMatcher.record);\r\n      }\r\n      function hasRoute(name) {\r\n          return !!matcher.getRecordMatcher(name);\r\n      }\r\n      function resolve(rawLocation, currentLocation) {\r\n          // const objectLocation = routerLocationAsObject(rawLocation)\r\n          // we create a copy to modify it later\r\n          currentLocation = assign({}, currentLocation || currentRoute.value);\r\n          if (typeof rawLocation === 'string') {\r\n              const locationNormalized = parseURL(parseQuery$1, rawLocation, currentLocation.path);\r\n              const matchedRoute = matcher.resolve({ path: locationNormalized.path }, currentLocation);\r\n              const href = routerHistory.createHref(locationNormalized.fullPath);\r\n              {\r\n                  if (href.startsWith('//'))\r\n                      warn(`Location \"${rawLocation}\" resolved to \"${href}\". A resolved location cannot start with multiple slashes.`);\r\n                  else if (!matchedRoute.matched.length) {\r\n                      warn(`No match found for location with path \"${rawLocation}\"`);\r\n                  }\r\n              }\r\n              // locationNormalized is always a new object\r\n              return assign(locationNormalized, matchedRoute, {\r\n                  params: decodeParams(matchedRoute.params),\r\n                  hash: decode(locationNormalized.hash),\r\n                  redirectedFrom: undefined,\r\n                  href,\r\n              });\r\n          }\r\n          let matcherLocation;\r\n          // path could be relative in object as well\r\n          if ('path' in rawLocation) {\r\n              if ('params' in rawLocation &&\r\n                  !('name' in rawLocation) &&\r\n                  // @ts-expect-error: the type is never\r\n                  Object.keys(rawLocation.params).length) {\r\n                  warn(`Path \"${\r\n                // @ts-expect-error: the type is never\r\n                rawLocation.path}\" was passed with params but they will be ignored. Use a named route alongside params instead.`);\r\n              }\r\n              matcherLocation = assign({}, rawLocation, {\r\n                  path: parseURL(parseQuery$1, rawLocation.path, currentLocation.path).path,\r\n              });\r\n          }\r\n          else {\r\n              // remove any nullish param\r\n              const targetParams = assign({}, rawLocation.params);\r\n              for (const key in targetParams) {\r\n                  if (targetParams[key] == null) {\r\n                      delete targetParams[key];\r\n                  }\r\n              }\r\n              // pass encoded values to the matcher so it can produce encoded path and fullPath\r\n              matcherLocation = assign({}, rawLocation, {\r\n                  params: encodeParams(rawLocation.params),\r\n              });\r\n              // current location params are decoded, we need to encode them in case the\r\n              // matcher merges the params\r\n              currentLocation.params = encodeParams(currentLocation.params);\r\n          }\r\n          const matchedRoute = matcher.resolve(matcherLocation, currentLocation);\r\n          const hash = rawLocation.hash || '';\r\n          if (hash && !hash.startsWith('#')) {\r\n              warn(`A \\`hash\\` should always start with the character \"#\". Replace \"${hash}\" with \"#${hash}\".`);\r\n          }\r\n          // decoding them) the matcher might have merged current location params so\r\n          // we need to run the decoding again\r\n          matchedRoute.params = normalizeParams(decodeParams(matchedRoute.params));\r\n          const fullPath = stringifyURL(stringifyQuery$1, assign({}, rawLocation, {\r\n              hash: encodeHash(hash),\r\n              path: matchedRoute.path,\r\n          }));\r\n          const href = routerHistory.createHref(fullPath);\r\n          {\r\n              if (href.startsWith('//')) {\r\n                  warn(`Location \"${rawLocation}\" resolved to \"${href}\". A resolved location cannot start with multiple slashes.`);\r\n              }\r\n              else if (!matchedRoute.matched.length) {\r\n                  warn(`No match found for location with path \"${'path' in rawLocation ? rawLocation.path : rawLocation}\"`);\r\n              }\r\n          }\r\n          return assign({\r\n              fullPath,\r\n              // keep the hash encoded so fullPath is effectively path + encodedQuery +\r\n              // hash\r\n              hash,\r\n              query: \r\n              // if the user is using a custom query lib like qs, we might have\r\n              // nested objects, so we keep the query as is, meaning it can contain\r\n              // numbers at `$route.query`, but at the point, the user will have to\r\n              // use their own type anyway.\r\n              // https://github.com/vuejs/router/issues/328#issuecomment-649481567\r\n              stringifyQuery$1 === stringifyQuery\r\n                  ? normalizeQuery(rawLocation.query)\r\n                  : (rawLocation.query || {}),\r\n          }, matchedRoute, {\r\n              redirectedFrom: undefined,\r\n              href,\r\n          });\r\n      }\r\n      function locationAsObject(to) {\r\n          return typeof to === 'string'\r\n              ? parseURL(parseQuery$1, to, currentRoute.value.path)\r\n              : assign({}, to);\r\n      }\r\n      function checkCanceledNavigation(to, from) {\r\n          if (pendingLocation !== to) {\r\n              return createRouterError(8 /* NAVIGATION_CANCELLED */, {\r\n                  from,\r\n                  to,\r\n              });\r\n          }\r\n      }\r\n      function push(to) {\r\n          return pushWithRedirect(to);\r\n      }\r\n      function replace(to) {\r\n          return push(assign(locationAsObject(to), { replace: true }));\r\n      }\r\n      function handleRedirectRecord(to) {\r\n          const lastMatched = to.matched[to.matched.length - 1];\r\n          if (lastMatched && lastMatched.redirect) {\r\n              const { redirect } = lastMatched;\r\n              let newTargetLocation = typeof redirect === 'function' ? redirect(to) : redirect;\r\n              if (typeof newTargetLocation === 'string') {\r\n                  newTargetLocation =\r\n                      newTargetLocation.includes('?') || newTargetLocation.includes('#')\r\n                          ? (newTargetLocation = locationAsObject(newTargetLocation))\r\n                          : // force empty params\r\n                              { path: newTargetLocation };\r\n                  // @ts-expect-error: force empty params when a string is passed to let\r\n                  // the router parse them again\r\n                  newTargetLocation.params = {};\r\n              }\r\n              if (!('path' in newTargetLocation) &&\r\n                  !('name' in newTargetLocation)) {\r\n                  warn(`Invalid redirect found:\\n${JSON.stringify(newTargetLocation, null, 2)}\\n when navigating to \"${to.fullPath}\". A redirect must contain a name or path. This will break in production.`);\r\n                  throw new Error('Invalid redirect');\r\n              }\r\n              return assign({\r\n                  query: to.query,\r\n                  hash: to.hash,\r\n                  params: to.params,\r\n              }, newTargetLocation);\r\n          }\r\n      }\r\n      function pushWithRedirect(to, redirectedFrom) {\r\n          const targetLocation = (pendingLocation = resolve(to));\r\n          const from = currentRoute.value;\r\n          const data = to.state;\r\n          const force = to.force;\r\n          // to could be a string where `replace` is a function\r\n          const replace = to.replace === true;\r\n          const shouldRedirect = handleRedirectRecord(targetLocation);\r\n          if (shouldRedirect)\r\n              return pushWithRedirect(assign(locationAsObject(shouldRedirect), {\r\n                  state: data,\r\n                  force,\r\n                  replace,\r\n              }), \r\n              // keep original redirectedFrom if it exists\r\n              redirectedFrom || targetLocation);\r\n          // if it was a redirect we already called `pushWithRedirect` above\r\n          const toLocation = targetLocation;\r\n          toLocation.redirectedFrom = redirectedFrom;\r\n          let failure;\r\n          if (!force && isSameRouteLocation(stringifyQuery$1, from, targetLocation)) {\r\n              failure = createRouterError(16 /* NAVIGATION_DUPLICATED */, { to: toLocation, from });\r\n              // trigger scroll to allow scrolling to the same anchor\r\n              handleScroll(from, from, \r\n              // this is a push, the only way for it to be triggered from a\r\n              // history.listen is with a redirect, which makes it become a push\r\n              true, \r\n              // This cannot be the first navigation because the initial location\r\n              // cannot be manually navigated to\r\n              false);\r\n          }\r\n          return (failure ? Promise.resolve(failure) : navigate(toLocation, from))\r\n              .catch((error) => isNavigationFailure(error)\r\n              ? // navigation redirects still mark the router as ready\r\n                  isNavigationFailure(error, 2 /* NAVIGATION_GUARD_REDIRECT */)\r\n                      ? error\r\n                      : markAsReady(error) // also returns the error\r\n              : // reject any unknown error\r\n                  triggerError(error, toLocation, from))\r\n              .then((failure) => {\r\n              if (failure) {\r\n                  if (isNavigationFailure(failure, 2 /* NAVIGATION_GUARD_REDIRECT */)) {\r\n                      if (// we are redirecting to the same location we were already at\r\n                          isSameRouteLocation(stringifyQuery$1, resolve(failure.to), toLocation) &&\r\n                          // and we have done it a couple of times\r\n                          redirectedFrom &&\r\n                          // @ts-expect-error: added only in dev\r\n                          (redirectedFrom._count = redirectedFrom._count\r\n                              ? // @ts-expect-error\r\n                                  redirectedFrom._count + 1\r\n                              : 1) > 10) {\r\n                          warn(`Detected an infinite redirection in a navigation guard when going from \"${from.fullPath}\" to \"${toLocation.fullPath}\". Aborting to avoid a Stack Overflow. This will break in production if not fixed.`);\r\n                          return Promise.reject(new Error('Infinite redirect in navigation guard'));\r\n                      }\r\n                      return pushWithRedirect(\r\n                      // keep options\r\n                      assign(locationAsObject(failure.to), {\r\n                          state: data,\r\n                          force,\r\n                          replace,\r\n                      }), \r\n                      // preserve the original redirectedFrom if any\r\n                      redirectedFrom || toLocation);\r\n                  }\r\n              }\r\n              else {\r\n                  // if we fail we don't finalize the navigation\r\n                  failure = finalizeNavigation(toLocation, from, true, replace, data);\r\n              }\r\n              triggerAfterEach(toLocation, from, failure);\r\n              return failure;\r\n          });\r\n      }\r\n      /**\r\n       * Helper to reject and skip all navigation guards if a new navigation happened\r\n       * @param to\r\n       * @param from\r\n       */\r\n      function checkCanceledNavigationAndReject(to, from) {\r\n          const error = checkCanceledNavigation(to, from);\r\n          return error ? Promise.reject(error) : Promise.resolve();\r\n      }\r\n      // TODO: refactor the whole before guards by internally using router.beforeEach\r\n      function navigate(to, from) {\r\n          let guards;\r\n          const [leavingRecords, updatingRecords, enteringRecords] = extractChangingRecords(to, from);\r\n          // all components here have been resolved once because we are leaving\r\n          guards = extractComponentsGuards(leavingRecords.reverse(), 'beforeRouteLeave', to, from);\r\n          // leavingRecords is already reversed\r\n          for (const record of leavingRecords) {\r\n              record.leaveGuards.forEach(guard => {\r\n                  guards.push(guardToPromiseFn(guard, to, from));\r\n              });\r\n          }\r\n          const canceledNavigationCheck = checkCanceledNavigationAndReject.bind(null, to, from);\r\n          guards.push(canceledNavigationCheck);\r\n          // run the queue of per route beforeRouteLeave guards\r\n          return (runGuardQueue(guards)\r\n              .then(() => {\r\n              // check global guards beforeEach\r\n              guards = [];\r\n              for (const guard of beforeGuards.list()) {\r\n                  guards.push(guardToPromiseFn(guard, to, from));\r\n              }\r\n              guards.push(canceledNavigationCheck);\r\n              return runGuardQueue(guards);\r\n          })\r\n              .then(() => {\r\n              // check in components beforeRouteUpdate\r\n              guards = extractComponentsGuards(updatingRecords, 'beforeRouteUpdate', to, from);\r\n              for (const record of updatingRecords) {\r\n                  record.updateGuards.forEach(guard => {\r\n                      guards.push(guardToPromiseFn(guard, to, from));\r\n                  });\r\n              }\r\n              guards.push(canceledNavigationCheck);\r\n              // run the queue of per route beforeEnter guards\r\n              return runGuardQueue(guards);\r\n          })\r\n              .then(() => {\r\n              // check the route beforeEnter\r\n              guards = [];\r\n              for (const record of to.matched) {\r\n                  // do not trigger beforeEnter on reused views\r\n                  if (record.beforeEnter && !from.matched.includes(record)) {\r\n                      if (Array.isArray(record.beforeEnter)) {\r\n                          for (const beforeEnter of record.beforeEnter)\r\n                              guards.push(guardToPromiseFn(beforeEnter, to, from));\r\n                      }\r\n                      else {\r\n                          guards.push(guardToPromiseFn(record.beforeEnter, to, from));\r\n                      }\r\n                  }\r\n              }\r\n              guards.push(canceledNavigationCheck);\r\n              // run the queue of per route beforeEnter guards\r\n              return runGuardQueue(guards);\r\n          })\r\n              .then(() => {\r\n              // NOTE: at this point to.matched is normalized and does not contain any () => Promise<Component>\r\n              // clear existing enterCallbacks, these are added by extractComponentsGuards\r\n              to.matched.forEach(record => (record.enterCallbacks = {}));\r\n              // check in-component beforeRouteEnter\r\n              guards = extractComponentsGuards(enteringRecords, 'beforeRouteEnter', to, from);\r\n              guards.push(canceledNavigationCheck);\r\n              // run the queue of per route beforeEnter guards\r\n              return runGuardQueue(guards);\r\n          })\r\n              .then(() => {\r\n              // check global guards beforeResolve\r\n              guards = [];\r\n              for (const guard of beforeResolveGuards.list()) {\r\n                  guards.push(guardToPromiseFn(guard, to, from));\r\n              }\r\n              guards.push(canceledNavigationCheck);\r\n              return runGuardQueue(guards);\r\n          })\r\n              // catch any navigation canceled\r\n              .catch(err => isNavigationFailure(err, 8 /* NAVIGATION_CANCELLED */)\r\n              ? err\r\n              : Promise.reject(err)));\r\n      }\r\n      function triggerAfterEach(to, from, failure) {\r\n          // navigation is confirmed, call afterGuards\r\n          // TODO: wrap with error handlers\r\n          for (const guard of afterGuards.list())\r\n              guard(to, from, failure);\r\n      }\r\n      /**\r\n       * - Cleans up any navigation guards\r\n       * - Changes the url if necessary\r\n       * - Calls the scrollBehavior\r\n       */\r\n      function finalizeNavigation(toLocation, from, isPush, replace, data) {\r\n          // a more recent navigation took place\r\n          const error = checkCanceledNavigation(toLocation, from);\r\n          if (error)\r\n              return error;\r\n          // only consider as push if it's not the first navigation\r\n          const isFirstNavigation = from === START_LOCATION_NORMALIZED;\r\n          const state = !isBrowser ? {} : history.state;\r\n          // change URL only if the user did a push/replace and if it's not the initial navigation because\r\n          // it's just reflecting the url\r\n          if (isPush) {\r\n              // on the initial navigation, we want to reuse the scroll position from\r\n              // history state if it exists\r\n              if (replace || isFirstNavigation)\r\n                  routerHistory.replace(toLocation.fullPath, assign({\r\n                      scroll: isFirstNavigation && state && state.scroll,\r\n                  }, data));\r\n              else\r\n                  routerHistory.push(toLocation.fullPath, data);\r\n          }\r\n          // accept current navigation\r\n          currentRoute.value = toLocation;\r\n          handleScroll(toLocation, from, isPush, isFirstNavigation);\r\n          markAsReady();\r\n      }\r\n      let removeHistoryListener;\r\n      // attach listener to history to trigger navigations\r\n      function setupListeners() {\r\n          removeHistoryListener = routerHistory.listen((to, _from, info) => {\r\n              // cannot be a redirect route because it was in history\r\n              const toLocation = resolve(to);\r\n              // due to dynamic routing, and to hash history with manual navigation\r\n              // (manually changing the url or calling history.hash = '#/somewhere'),\r\n              // there could be a redirect record in history\r\n              const shouldRedirect = handleRedirectRecord(toLocation);\r\n              if (shouldRedirect) {\r\n                  pushWithRedirect(assign(shouldRedirect, { replace: true }), toLocation).catch(noop);\r\n                  return;\r\n              }\r\n              pendingLocation = toLocation;\r\n              const from = currentRoute.value;\r\n              // TODO: should be moved to web history?\r\n              if (isBrowser) {\r\n                  saveScrollPosition(getScrollKey(from.fullPath, info.delta), computeScrollPosition());\r\n              }\r\n              navigate(toLocation, from)\r\n                  .catch((error) => {\r\n                  if (isNavigationFailure(error, 4 /* NAVIGATION_ABORTED */ | 8 /* NAVIGATION_CANCELLED */)) {\r\n                      return error;\r\n                  }\r\n                  if (isNavigationFailure(error, 2 /* NAVIGATION_GUARD_REDIRECT */)) {\r\n                      // Here we could call if (info.delta) routerHistory.go(-info.delta,\r\n                      // false) but this is bug prone as we have no way to wait the\r\n                      // navigation to be finished before calling pushWithRedirect. Using\r\n                      // a setTimeout of 16ms seems to work but there is not guarantee for\r\n                      // it to work on every browser. So Instead we do not restore the\r\n                      // history entry and trigger a new navigation as requested by the\r\n                      // navigation guard.\r\n                      // the error is already handled by router.push we just want to avoid\r\n                      // logging the error\r\n                      pushWithRedirect(error.to, toLocation\r\n                      // avoid an uncaught rejection, let push call triggerError\r\n                      )\r\n                          .then(failure => {\r\n                          // manual change in hash history #916 ending up in the URL not\r\n                          // changing but it was changed by the manual url change, so we\r\n                          // need to manually change it ourselves\r\n                          if (isNavigationFailure(failure, 4 /* NAVIGATION_ABORTED */ |\r\n                              16 /* NAVIGATION_DUPLICATED */) &&\r\n                              !info.delta &&\r\n                              info.type === NavigationType.pop) {\r\n                              routerHistory.go(-1, false);\r\n                          }\r\n                      })\r\n                          .catch(noop);\r\n                      // avoid the then branch\r\n                      return Promise.reject();\r\n                  }\r\n                  // do not restore history on unknown direction\r\n                  if (info.delta)\r\n                      routerHistory.go(-info.delta, false);\r\n                  // unrecognized error, transfer to the global handler\r\n                  return triggerError(error, toLocation, from);\r\n              })\r\n                  .then((failure) => {\r\n                  failure =\r\n                      failure ||\r\n                          finalizeNavigation(\r\n                          // after navigation, all matched components are resolved\r\n                          toLocation, from, false);\r\n                  // revert the navigation\r\n                  if (failure) {\r\n                      if (info.delta) {\r\n                          routerHistory.go(-info.delta, false);\r\n                      }\r\n                      else if (info.type === NavigationType.pop &&\r\n                          isNavigationFailure(failure, 4 /* NAVIGATION_ABORTED */ | 16 /* NAVIGATION_DUPLICATED */)) {\r\n                          // manual change in hash history #916\r\n                          // it's like a push but lacks the information of the direction\r\n                          routerHistory.go(-1, false);\r\n                      }\r\n                  }\r\n                  triggerAfterEach(toLocation, from, failure);\r\n              })\r\n                  .catch(noop);\r\n          });\r\n      }\r\n      // Initialization and Errors\r\n      let readyHandlers = useCallbacks();\r\n      let errorHandlers = useCallbacks();\r\n      let ready;\r\n      /**\r\n       * Trigger errorHandlers added via onError and throws the error as well\r\n       *\r\n       * @param error - error to throw\r\n       * @param to - location we were navigating to when the error happened\r\n       * @param from - location we were navigating from when the error happened\r\n       * @returns the error as a rejected promise\r\n       */\r\n      function triggerError(error, to, from) {\r\n          markAsReady(error);\r\n          const list = errorHandlers.list();\r\n          if (list.length) {\r\n              list.forEach(handler => handler(error, to, from));\r\n          }\r\n          else {\r\n              {\r\n                  warn('uncaught error during route navigation:');\r\n              }\r\n              console.error(error);\r\n          }\r\n          return Promise.reject(error);\r\n      }\r\n      function isReady() {\r\n          if (ready && currentRoute.value !== START_LOCATION_NORMALIZED)\r\n              return Promise.resolve();\r\n          return new Promise((resolve, reject) => {\r\n              readyHandlers.add([resolve, reject]);\r\n          });\r\n      }\r\n      function markAsReady(err) {\r\n          if (!ready) {\r\n              // still not ready if an error happened\r\n              ready = !err;\r\n              setupListeners();\r\n              readyHandlers\r\n                  .list()\r\n                  .forEach(([resolve, reject]) => (err ? reject(err) : resolve()));\r\n              readyHandlers.reset();\r\n          }\r\n          return err;\r\n      }\r\n      // Scroll behavior\r\n      function handleScroll(to, from, isPush, isFirstNavigation) {\r\n          const { scrollBehavior } = options;\r\n          if (!isBrowser || !scrollBehavior)\r\n              return Promise.resolve();\r\n          const scrollPosition = (!isPush && getSavedScrollPosition(getScrollKey(to.fullPath, 0))) ||\r\n              ((isFirstNavigation || !isPush) &&\r\n                  history.state &&\r\n                  history.state.scroll) ||\r\n              null;\r\n          return vue.nextTick()\r\n              .then(() => scrollBehavior(to, from, scrollPosition))\r\n              .then(position => position && scrollToPosition(position))\r\n              .catch(err => triggerError(err, to, from));\r\n      }\r\n      const go = (delta) => routerHistory.go(delta);\r\n      let started;\r\n      const installedApps = new Set();\r\n      const router = {\r\n          currentRoute,\r\n          addRoute,\r\n          removeRoute,\r\n          hasRoute,\r\n          getRoutes,\r\n          resolve,\r\n          options,\r\n          push,\r\n          replace,\r\n          go,\r\n          back: () => go(-1),\r\n          forward: () => go(1),\r\n          beforeEach: beforeGuards.add,\r\n          beforeResolve: beforeResolveGuards.add,\r\n          afterEach: afterGuards.add,\r\n          onError: errorHandlers.add,\r\n          isReady,\r\n          install(app) {\r\n              const router = this;\r\n              app.component('RouterLink', RouterLink);\r\n              app.component('RouterView', RouterView);\r\n              app.config.globalProperties.$router = router;\r\n              Object.defineProperty(app.config.globalProperties, '$route', {\r\n                  enumerable: true,\r\n                  get: () => vue.unref(currentRoute),\r\n              });\r\n              // this initial navigation is only necessary on client, on server it doesn't\r\n              // make sense because it will create an extra unnecessary navigation and could\r\n              // lead to problems\r\n              if (isBrowser &&\r\n                  // used for the initial navigation client side to avoid pushing\r\n                  // multiple times when the router is used in multiple apps\r\n                  !started &&\r\n                  currentRoute.value === START_LOCATION_NORMALIZED) {\r\n                  // see above\r\n                  started = true;\r\n                  push(routerHistory.location).catch(err => {\r\n                      warn('Unexpected error when starting the router:', err);\r\n                  });\r\n              }\r\n              const reactiveRoute = {};\r\n              for (const key in START_LOCATION_NORMALIZED) {\r\n                  // @ts-expect-error: the key matches\r\n                  reactiveRoute[key] = vue.computed(() => currentRoute.value[key]);\r\n              }\r\n              app.provide(routerKey, router);\r\n              app.provide(routeLocationKey, vue.reactive(reactiveRoute));\r\n              app.provide(routerViewLocationKey, currentRoute);\r\n              const unmountApp = app.unmount;\r\n              installedApps.add(app);\r\n              app.unmount = function () {\r\n                  installedApps.delete(app);\r\n                  // the router is not attached to an app anymore\r\n                  if (installedApps.size < 1) {\r\n                      // invalidate the current navigation\r\n                      pendingLocation = START_LOCATION_NORMALIZED;\r\n                      removeHistoryListener && removeHistoryListener();\r\n                      currentRoute.value = START_LOCATION_NORMALIZED;\r\n                      started = false;\r\n                      ready = false;\r\n                  }\r\n                  unmountApp();\r\n              };\r\n              if (isBrowser) {\r\n                  addDevtools(app, router, matcher);\r\n              }\r\n          },\r\n      };\r\n      return router;\r\n  }\r\n  function runGuardQueue(guards) {\r\n      return guards.reduce((promise, guard) => promise.then(() => guard()), Promise.resolve());\r\n  }\r\n  function extractChangingRecords(to, from) {\r\n      const leavingRecords = [];\r\n      const updatingRecords = [];\r\n      const enteringRecords = [];\r\n      const len = Math.max(from.matched.length, to.matched.length);\r\n      for (let i = 0; i < len; i++) {\r\n          const recordFrom = from.matched[i];\r\n          if (recordFrom) {\r\n              if (to.matched.find(record => isSameRouteRecord(record, recordFrom)))\r\n                  updatingRecords.push(recordFrom);\r\n              else\r\n                  leavingRecords.push(recordFrom);\r\n          }\r\n          const recordTo = to.matched[i];\r\n          if (recordTo) {\r\n              // the type doesn't matter because we are comparing per reference\r\n              if (!from.matched.find(record => isSameRouteRecord(record, recordTo))) {\r\n                  enteringRecords.push(recordTo);\r\n              }\r\n          }\r\n      }\r\n      return [leavingRecords, updatingRecords, enteringRecords];\r\n  }\n\n  /**\r\n   * Returns the router instance. Equivalent to using `$router` inside\r\n   * templates.\r\n   */\r\n  function useRouter() {\r\n      return vue.inject(routerKey);\r\n  }\r\n  /**\r\n   * Returns the current route location. Equivalent to using `$route` inside\r\n   * templates.\r\n   */\r\n  function useRoute() {\r\n      return vue.inject(routeLocationKey);\r\n  }\n\n  exports.RouterLink = RouterLink;\n  exports.RouterView = RouterView;\n  exports.START_LOCATION = START_LOCATION_NORMALIZED;\n  exports.createMemoryHistory = createMemoryHistory;\n  exports.createRouter = createRouter;\n  exports.createRouterMatcher = createRouterMatcher;\n  exports.createWebHashHistory = createWebHashHistory;\n  exports.createWebHistory = createWebHistory;\n  exports.isNavigationFailure = isNavigationFailure;\n  exports.matchedRouteKey = matchedRouteKey;\n  exports.onBeforeRouteLeave = onBeforeRouteLeave;\n  exports.onBeforeRouteUpdate = onBeforeRouteUpdate;\n  exports.parseQuery = parseQuery;\n  exports.routeLocationKey = routeLocationKey;\n  exports.routerKey = routerKey;\n  exports.routerViewLocationKey = routerViewLocationKey;\n  exports.stringifyQuery = stringifyQuery;\n  exports.useLink = useLink;\n  exports.useRoute = useRoute;\n  exports.useRouter = useRouter;\n  exports.viewDepthKey = viewDepthKey;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n  return exports;\n\n})({}, Vue);\n"]}