@poveste/vendors 0.14.0 → 0.15.0

package/dist/client/b-vue-router.js

@@ -1,16 +1,12 @@
-import { P as onUnmounted, Q as onDeactivated, R as onActivated, O as getCurrentInstance, z as inject, B as watch, L as computed, C as unref, S as watchEffect, d as defineComponent, M as reactive, x as h, T as provide, u as ref, U as shallowRef, b as nextTick, V as shallowReactive } from './vue.runtime.esm-bundler.js';
-import { s as setupDevtoolsPlugin } from './index.js';
+import { defineDiagnostics, createConsoleReporter } from './index.js';
+import { inject, onUnmounted, onDeactivated, onActivated, getCurrentInstance, watch, computed, unref, watchEffect, defineComponent, reactive, h, provide, ref, shallowRef, nextTick, shallowReactive } from './vue.runtime.esm-bundler.js';
+import { setupDevToolsPlugin } from './devtools-api.js';
 
 /*!
- * vue-router v4.6.4
- * (c) 2025 Eduardo San Martin Morote
- * @license MIT
- */
-
-//#region src/utils/env.ts
-const isBrowser = typeof document !== "undefined";
-
-//#endregion
+* vue-router v5.3.1
+* (c) 2026 Eduardo San Martin Morote
+* @license MIT
+*/
 //#region src/utils/index.ts
 /**
 * Identity function that returns the value as is.
@@ -21,6 +17,14 @@ const isBrowser = typeof document !== "undefined";
 */
 const identityFn = (v) => v;
 /**
+* Checks if a path is absolute, meaning it starts with a `/`.
+*
+* @param path - path to check
+*
+* @internal
+*/
+const isAbsolutePath = (path) => path.startsWith("/");
+/**
 * Allows differentiating lazy components from functional components and vue-class-component
 * @internal
 *
@@ -54,14 +58,398 @@ function mergeOptions(defaults, partialOptions) {
 	for (const key in defaults) options[key] = key in partialOptions ? partialOptions[key] : defaults[key];
 	return options;
 }
-
 //#endregion
-//#region src/warning.ts
-function warn$1(msg) {
-	const args = Array.from(arguments).slice(1);
-	console.warn.apply(console, ["[Vue Router warn]: " + msg].concat(args));
+//#region src/errors.ts
+const NavigationFailureSymbol = Symbol(process.env.NODE_ENV !== "production" ? "navigation failure" : "");
+/**
+* Enumeration with all possible types for navigation failures. Can be passed to
+* {@link isNavigationFailure} to check for specific failures.
+*/
+let NavigationFailureType = /* @__PURE__ */ function(NavigationFailureType) {
+	/**
+	* An aborted navigation is a navigation that failed because a navigation
+	* guard returned `false` or called `next(false)`
+	*/
+	NavigationFailureType[NavigationFailureType["aborted"] = 4] = "aborted";
+	/**
+	* A cancelled navigation is a navigation that failed because a more recent
+	* navigation finished started (not necessarily finished).
+	*/
+	NavigationFailureType[NavigationFailureType["cancelled"] = 8] = "cancelled";
+	/**
+	* A duplicated navigation is a navigation that failed because it was
+	* initiated while already being at the exact same location.
+	*/
+	NavigationFailureType[NavigationFailureType["duplicated"] = 16] = "duplicated";
+	return NavigationFailureType;
+}({});
+const ErrorTypeMessages = {
+	[1]({ location, currentLocation }) {
+		return `No match for\n ${JSON.stringify(location)}${currentLocation ? "\nwhile being at\n" + JSON.stringify(currentLocation) : ""}`;
+	},
+	[2]({ from, to }) {
+		return `Redirected from "${from.fullPath}" to "${stringifyRoute(to)}" via a navigation guard.`;
+	},
+	[4]({ from, to }) {
+		return `Navigation aborted from "${from.fullPath}" to "${to.fullPath}" via a navigation guard.`;
+	},
+	[8]({ from, to }) {
+		return `Navigation cancelled from "${from.fullPath}" to "${to.fullPath}" with a new navigation.`;
+	},
+	[16]({ from, to: _to }) {
+		return `Avoided redundant navigation to current location: "${from.fullPath}".`;
+	}
+};
+/**
+* Creates a typed NavigationFailure object.
+* @internal
+* @param type - NavigationFailureType
+* @param params - { from, to }
+*/
+function createRouterError(type, params) {
+	if (process.env.NODE_ENV !== "production" || false) return assign(new Error(ErrorTypeMessages[type](params)), {
+		type,
+		[NavigationFailureSymbol]: true
+	}, params);
+	else return assign(/* @__PURE__ */ new Error(), {
+		type,
+		[NavigationFailureSymbol]: true
+	}, params);
+}
+function isNavigationFailure(error, type) {
+	return error instanceof Error && NavigationFailureSymbol in error && (type == null || !!(error.type & type));
+}
+const propertiesToLog = [
+	"params",
+	"query",
+	"hash"
+];
+/**
+* Stringifies a raw location for display in dev warnings.
+*
+* @internal
+*/
+function stringifyRoute(to) {
+	if (!to || typeof to === "string") return to;
+	if (to.path != null) return to.path;
+	const location = {};
+	for (const key of propertiesToLog) if (key in to) location[key] = to[key];
+	return JSON.stringify(location, null, 2);
+}
+//#endregion
+//#region src/diagnostics.ts
+/**
+* Runtime diagnostics catalog for Vue Router.
+*
+* Every entry has a stable `VUE_ROUTER_R####` code, a `why` that states the problem
+* (the diagnosis only, never the remedy) and a `fix` that states the remedy
+* (only, never the diagnosis). They are complementary: the reporter prints
+* both, so neither repeats the other. The diagnosis substrings asserted by the
+* warning tests stay in `why`. All call sites stay behind the existing `__DEV__` (or
+* `process.env.NODE_ENV !== 'production'`) guards and remain bare expression
+* statements so they tree-shake out of production builds.
+*
+* Codes are permanent: never rename or reuse one.
+* - `VUE_ROUTER_R0###` core runtime warnings
+* - `VUE_ROUTER_R1###` experimental data-loaders
+*/
+const diagnostics = /*#__PURE__*/ defineDiagnostics({
+	reporters: [/*#__PURE__*/ createConsoleReporter()],
+	codes: {
+		VUE_ROUTER_R0001: {
+			why: (p) => `Parent route "${p.name}" not found when adding child route`,
+			fix: "Add the parent route before its children, or check the parent name for typos.",
+			docs: "https://router.vuejs.org/guide/advanced/dynamic-routing.html#Adding-nested-routes"
+		},
+		VUE_ROUTER_R0002: {
+			why: (p) => `Cannot remove non-existent route "${p.name}"`,
+			fix: "Check the route name; it may already have been removed or was never added.",
+			docs: "https://router.vuejs.org/guide/advanced/dynamic-routing.html#Removing-routes"
+		},
+		VUE_ROUTER_R0003: {
+			why: (p) => `Location "${stringifyRoute(p.location)}" resolved to "${p.href}". A resolved location cannot start with multiple slashes.`,
+			fix: "Remove the leading slashes from the location or fix the route configuration."
+		},
+		VUE_ROUTER_R0004: {
+			why: (p) => `No match found for location with path "${stringifyRoute(p.path)}"`,
+			fix: "Add a route matching this path or check for typos in the location.",
+			docs: "https://router.vuejs.org/guide/essentials/dynamic-matching.html#Catch-all-404-Not-found-Route"
+		},
+		VUE_ROUTER_R0005: {
+			why: (p) => `router.resolve() was passed an invalid location. This will fail in production.\nLocation: ${stringifyRoute(p.rawLocation)}`,
+			fix: "Pass a valid route location: a string path or an object with `path` or `name`."
+		},
+		VUE_ROUTER_R0006: {
+			why: (p) => `Path "${p.path}" was passed with params but they will be ignored because a "path" was passed.`,
+			fix: "Use a named route `{ name, params }` instead of `{ path, params }`.",
+			docs: "https://router.vuejs.org/guide/essentials/navigation.html#Navigate-to-a-different-location"
+		},
+		VUE_ROUTER_R0007: {
+			why: (p) => `A \`hash\` should always start with the character "#" but received "${p.hash}".`,
+			fix: (p) => `Prepend "#" to the hash in your route location: use "#${p.hash}".`
+		},
+		VUE_ROUTER_R0008: {
+			why: (p) => `Invalid redirect found:\n${p.target}\n when navigating to "${p.to}".\nThis will break in production.`,
+			fix: "A redirect must resolve to a location with a `name` or `path`; return one of those (or a string path) from `redirect`.",
+			docs: "https://router.vuejs.org/guide/essentials/redirect-and-alias.html#Redirect"
+		},
+		VUE_ROUTER_R0009: {
+			why: (p) => `Detected a possibly infinite redirection in a navigation guard when going from "${p.from}" to "${p.to}". Aborting to avoid a Stack Overflow. This might break in production if not fixed.`,
+			fix: "A guard is returning a new location on every call; make that return conditional so it only redirects when actually needed.",
+			docs: "https://router.vuejs.org/guide/advanced/navigation-guards.html#Global-Before-Guards"
+		},
+		VUE_ROUTER_R0010: {
+			why: "Uncaught error during route navigation",
+			fix: "Register an error handler with `router.onError()` to handle navigation errors."
+		},
+		VUE_ROUTER_R0011: {
+			why: "Unexpected error when starting the router:",
+			fix: "Inspect the actual cause; a navigation guard or async component likely threw during the initial navigation."
+		},
+		VUE_ROUTER_R0020: {
+			why: (p) => `No active route record was found when calling \`${p.fn}()\`. Maybe you called it inside of App.vue?`,
+			fix: "Call it from a component rendered inside <router-view> (a page component or one of its children), not from App.vue.",
+			docs: "https://router.vuejs.org/guide/advanced/composition-api.html#Navigation-Guards"
+		},
+		VUE_ROUTER_R0021: {
+			why: "No active route record was found when reactivating component with navigation guard. This is likely a bug in vue-router.",
+			fix: "Report with a minimal reproduction at https://github.com/vuejs/router/issues/new/choose."
+		},
+		VUE_ROUTER_R0022: {
+			why: (p) => `${p.fn}() was called outside of component setup but it must be called at the top of a setup function`,
+			fix: "Call it synchronously at the top of `setup()`, before any `await`.",
+			docs: "https://router.vuejs.org/guide/advanced/composition-api.html#Navigation-Guards"
+		},
+		VUE_ROUTER_R0023: {
+			why: (p) => `The "next" callback was never called inside of ${p.name ? `"${p.name}"` : ""}:\n${p.guard}`,
+			fix: "Make sure `next()` runs on every branch, including early returns and async paths, or drop the `next` parameter and return the value instead.",
+			docs: "https://router.vuejs.org/guide/advanced/navigation-guards.html#Optional-third-argument-next"
+		},
+		VUE_ROUTER_R0024: {
+			why: (p) => `The "next" callback was called more than once in one navigation guard when going from "${p.from}" to "${p.to}". This will fail in production.`,
+			fix: "Call `next()` exactly once per guard: remove the extra call, or migrate to returning the value you passed to `next()`.",
+			docs: "https://router.vuejs.org/guide/advanced/navigation-guards.html#Optional-third-argument-next"
+		},
+		VUE_ROUTER_R0025: {
+			why: "The `next()` callback in navigation guards is deprecated.",
+			fix: "Return the value instead: `next()` becomes `return`, `next(false)` becomes `return false`, `next(\"/path\")` becomes `return \"/path\"`.",
+			docs: "https://router.vuejs.org/guide/advanced/navigation-guards.html#Optional-third-argument-next"
+		},
+		VUE_ROUTER_R0026: {
+			why: (p) => `Record with path "${p.path}" is either missing a "component(s)" or "children" property.`,
+			fix: "Add a `component`, `components`, or `children` to the route record.",
+			docs: "https://router.vuejs.org/guide/essentials/nested-routes.html"
+		},
+		VUE_ROUTER_R0027: {
+			why: (p) => `Component "${p.name}" in record with path "${p.path}" is not a valid component. Received "${p.received}".`,
+			fix: "Pass a component or a function returning a Promise that resolves to one."
+		},
+		VUE_ROUTER_R0028: {
+			why: (p) => `Component "${p.name}" in record with path "${p.path}" is a Promise instead of a function that returns a Promise. This will break in production if not fixed.`,
+			fix: `Defer the import in an arrow function so it loads lazily: write "() => import('./MyPage.vue')", not "import('./MyPage.vue')".`,
+			docs: "https://router.vuejs.org/guide/advanced/lazy-loading.html"
+		},
+		VUE_ROUTER_R0029: {
+			why: (p) => `Component "${p.name}" in record with path "${p.path}" is defined using "defineAsyncComponent()".`,
+			fix: `Drop the wrapper and pass "() => import('./MyPage.vue')" directly; the router handles lazy components itself.`,
+			docs: "https://router.vuejs.org/guide/advanced/lazy-loading.html#Relationship-to-async-components"
+		},
+		VUE_ROUTER_R0030: {
+			why: (p) => `Component "${p.name}" in record with path "${p.path}" is a function that does not return a Promise. This will break in production if not fixed.`,
+			fix: "Return a dynamic import (`() => import(\"./MyPage.vue\")`) from the function, or add a `displayName` if it is a functional component.",
+			docs: "https://router.vuejs.org/guide/advanced/lazy-loading.html"
+		},
+		VUE_ROUTER_R0040: {
+			why: (p) => `Because "${p.el}" starts with "#", scrollBehavior resolves it as an element id via document.getElementById("${p.el.slice(1)}"), not as a CSS selector. No element has that id, but "${p.el}" does match an element with document.querySelector().`,
+			fix: (p) => `Resolve the element yourself and return the node: el: document.querySelector('${p.el}').`,
+			docs: "https://router.vuejs.org/guide/advanced/scroll-behavior.html"
+		},
+		VUE_ROUTER_R0041: {
+			why: (p) => `The selector "${p.el}" is invalid. See https://mathiasbynens.be/notes/css-escapes or CSS.escape (https://developer.mozilla.org/en-US/docs/Web/API/CSS/escape) for the escaping rules.`,
+			fix: "Build an id selector as `#${CSS.escape(id)}` so special characters in the id are escaped.",
+			docs: "https://router.vuejs.org/guide/advanced/scroll-behavior.html"
+		},
+		VUE_ROUTER_R0042: {
+			why: (p) => `Couldn't find element using selector "${p.el}" returned by scrollBehavior.`,
+			fix: "Return a selector that matches an existing element, or guard against missing elements.",
+			docs: "https://router.vuejs.org/guide/advanced/scroll-behavior.html"
+		},
+		VUE_ROUTER_R0050: {
+			why: (p) => {
+				let to;
+				try {
+					to = p.to === void 0 ? "undefined" : JSON.stringify(p.to);
+				} catch {
+					to = String(p.to);
+				}
+				return `Invalid value for prop "to" in useLink()\n- to: ${to}`;
+			},
+			fix: "Pass a valid route location (a string path or an object) to the \"to\" prop."
+		},
+		VUE_ROUTER_R0060: {
+			why: (p) => `<router-view> can no longer be used directly inside <${p.comp}>.`,
+			fix: (p) => `Wrap the slot's resolved component with <${p.comp}> instead of nesting <router-view> in it:\n\n<router-view v-slot="{ Component }">\n  <${p.comp}>\n    <component :is="Component" />\n  </${p.comp}>\n</router-view>`,
+			docs: "https://router.vuejs.org/guide/advanced/router-view-slot.html#KeepAlive-Transition"
+		},
+		VUE_ROUTER_R0070: {
+			why: (p) => `Cannot resolve a relative location without an absolute path. Trying to resolve "${p.to}" from "${p.from}".`,
+			fix: (p) => `Resolve from an absolute \`from\` path that starts with "/", e.g. "/${p.from}".`
+		},
+		VUE_ROUTER_R0080: {
+			why: (p) => `Error decoding "${p.text}". Using original value`,
+			fix: "Ensure the value is correctly percent-encoded."
+		},
+		VUE_ROUTER_R0090: {
+			why: (p) => `Found duplicated params with name "${p.name}" for path "${p.path}". Only the last one will be available on "$route.params".`,
+			fix: "Give each param a unique name within the path.",
+			docs: "https://router.vuejs.org/guide/essentials/route-matching-syntax.html"
+		},
+		VUE_ROUTER_R0100: {
+			why: (p) => `Discarded invalid param(s) "${p.params}" when navigating.` + p.inherited + ` See https://github.com/vuejs/router/commit/e887570 for more details.`,
+			fix: "Only pass params that exist on the target route."
+		},
+		VUE_ROUTER_R0101: {
+			why: (p) => `The Matcher cannot resolve relative paths but received "${p.path}". Unless you directly called \`matcher.resolve("${p.path}")\`, this is probably a bug in vue-router. Please open an issue at https://github.com/vuejs/router/issues/new/choose.`,
+			fix: "Pass an absolute path (starting with \"/\") to the matcher."
+		},
+		VUE_ROUTER_R0102: {
+			why: (p) => `Alias "${p.alias}" and the original record: "${p.original}" must have the exact same param named "${p.name}"`,
+			fix: "Use the same param names in the alias as in the original route.",
+			docs: "https://router.vuejs.org/guide/essentials/redirect-and-alias.html#Alias"
+		},
+		VUE_ROUTER_R0103: {
+			why: (p) => `The route named "${p.name}" has a child without a name, an empty path, and no children. Using that name won't render the empty path child, so this is probably a mistake.`,
+			fix: "Move the `name` onto the empty-path child; or, if intentional, give the child its own name to silence this.",
+			docs: "https://router.vuejs.org/guide/essentials/nested-routes.html#Nested-Named-Routes"
+		},
+		VUE_ROUTER_R0104: {
+			why: (p) => `Absolute path "${p.path}" must have the exact same param named "${p.name}" as its parent "${p.parent}".`,
+			fix: "Include the parent route params in the absolute child path.",
+			docs: "https://router.vuejs.org/guide/essentials/nested-routes.html"
+		},
+		VUE_ROUTER_R0105: {
+			why: (p) => `Finding ancestor route "${p.ancestor}" failed for "${p.record}"`,
+			fix: "Report a reproduction at https://github.com/vuejs/router/issues/new/choose."
+		},
+		VUE_ROUTER_R0110: {
+			why: `A hash base must end with a "#"`,
+			fix: (p) => `Append "#" to the "base" argument passed to "createWebHashHistory()": "${p.base}" should be "${p.suggestion}".`
+		},
+		VUE_ROUTER_R0120: {
+			why: "Error with push/replace State",
+			fix: "The browser rejected the history API call; check for cross-origin or rate-limit issues."
+		},
+		VUE_ROUTER_R0121: {
+			why: "history.state seems to have been manually replaced without preserving the necessary values.\nYou can find more information at https://router.vuejs.org/guide/migration/#Usage-of-history-state",
+			fix: "Merge the router's state into your own when calling it manually: `history.replaceState({ ...history.state, ...yourState }, '', url)`.",
+			docs: "https://router.vuejs.org/guide/migration.html#Usage-of-history-state"
+		},
+		VUE_ROUTER_R1001: {
+			why: (p) => `Data loader "${String(p.key)}" has a different parent than the current context. This shouldn't be happening.`,
+			fix: "Report a bug with a minimal reproduction at https://github.com/vuejs/router/."
+		},
+		VUE_ROUTER_R1002: {
+			why: "Returning a NavigationResult is deprecated.",
+			fix: "Replace `return new NavigationResult(to)` with `reroute(to)`, which throws internally to reroute.",
+			docs: "https://router.vuejs.org/data-loaders/navigation-aware.html#Controlling-the-navigation-with-reroute-"
+		},
+		VUE_ROUTER_R1003: {
+			why: (p) => `Loader "${p.key}"'s "commit()" was called but there is no staged data.`,
+			fix: "Ensure the loader resolved before calling `commit()`.",
+			docs: "https://router.vuejs.org/data-loaders/defining-loaders.html#Delaying-data-updates-with-commit"
+		},
+		VUE_ROUTER_R1004: {
+			why: (p) => "A loader returned a NavigationResult but is not registered on the route." + p.key,
+			fix: "Export the loader from the page component so it gets registered, e.g. `export const useUserData = defineLoader(...)`.",
+			docs: "https://router.vuejs.org/data-loaders/organization.html"
+		},
+		VUE_ROUTER_R1005: {
+			why: (p) => `Data loader "${p.key}" has itself as parent. This shouldn't be happening.`,
+			fix: "Report a bug with a minimal reproduction at https://github.com/vuejs/router/."
+		},
+		VUE_ROUTER_R1006: {
+			why: (p) => `A query was defined with the same key as the loader "[${p.key}]".\nSee https://pinia-colada.esm.dev/#TODO`,
+			fix: "If the key is meant to match, use the data loader directly; otherwise rename the `useQuery()` key so it no longer collides.",
+			docs: "https://router.vuejs.org/data-loaders/colada.html"
+		},
+		VUE_ROUTER_R1007: {
+			why: "Data Loader was setup twice.",
+			fix: "Register `DataLoaderPlugin` a single time via `app.use()`.",
+			docs: "https://router.vuejs.org/data-loaders.html#Installation"
+		},
+		VUE_ROUTER_R1008: {
+			why: "Data Loader is experimental and subject to breaking changes in the future.",
+			docs: "https://router.vuejs.org/data-loaders.html"
+		},
+		VUE_ROUTER_R1009: {
+			why: "Returning a NavigationResult from a loader is deprecated.",
+			fix: "Call `reroute(to)` inside the loader instead of returning `new NavigationResult(to)`; it throws internally to reroute.",
+			docs: "https://router.vuejs.org/data-loaders/navigation-aware.html#Controlling-the-navigation-with-reroute-"
+		}
+	}
+});
+//#endregion
+//#region src/injectionSymbols.ts
+/**
+* RouteRecord being rendered by the closest ancestor Router View. Used for
+* `onBeforeRouteUpdate` and `onBeforeRouteLeave`. rvlm stands for Router View
+* Location Matched
+*
+* @internal
+*/
+const matchedRouteKey = Symbol(process.env.NODE_ENV !== "production" ? "router view location matched" : "");
+/**
+* Allows overriding the router view depth to control which component in
+* `matched` is rendered. rvd stands for Router View Depth
+*
+* @internal
+*/
+const viewDepthKey = Symbol(process.env.NODE_ENV !== "production" ? "router view depth" : "");
+/**
+* Allows overriding the router instance returned by `useRouter` in tests. r
+* stands for router
+*
+* @internal
+*/
+const routerKey = Symbol(process.env.NODE_ENV !== "production" ? "router" : "");
+/**
+* Allows overriding the current route returned by `useRoute` in tests. rl
+* stands for route location
+*
+* @internal
+*/
+const routeLocationKey = Symbol(process.env.NODE_ENV !== "production" ? "route location" : "");
+/**
+* Allows overriding the current route used by router-view. Internally this is
+* used when the `route` prop is passed.
+*
+* @internal
+*/
+const routerViewLocationKey = Symbol(process.env.NODE_ENV !== "production" ? "router view location" : "");
+//#endregion
+//#region src/useApi.ts
+/**
+* Returns the router instance. Equivalent to using `$router` inside
+* templates.
+*/
+function useRouter() {
+	return inject(routerKey);
+}
+/**
+* Returns the current route location. Equivalent to using `$route` inside
+* templates.
+*/
+function useRoute(_name) {
+	return inject(routeLocationKey);
 }
 
+/*!
+* vue-router v5.3.1
+* (c) 2026 Eduardo San Martin Morote
+* @license MIT
+*/
+//#region src/utils/env.ts
+const isBrowser = typeof document !== "undefined";
 //#endregion
 //#region src/encoding.ts
 /**
@@ -172,12 +560,11 @@ function decode(text) {
 	if (text == null) return null;
 	try {
 		return decodeURIComponent("" + text);
-	} catch (err) {
-		process.env.NODE_ENV !== "production" && warn$1(`Error decoding "${text}". Using original value`);
+	} catch {
+		process.env.NODE_ENV !== "production" && diagnostics.VUE_ROUTER_R0080({ text: "" + text });
 	}
 	return "" + text;
 }
-
 //#endregion
 //#region src/location.ts
 const TRAILING_SLASH_RE = /\/$/;
@@ -191,7 +578,7 @@ const removeTrailingSlash = (path) => path.replace(TRAILING_SLASH_RE, "");
 * paths. Must start with `/`. Defaults to `/`
 * @returns a normalized history location
 */
-function parseURL(parseQuery$1, location, currentLocation = "/") {
+function parseURL(parseQuery, location, currentLocation = "/") {
 	let path, query = {}, searchString = "", hash = "";
 	const hashPos = location.indexOf("#");
 	let searchPos = location.indexOf("?");
@@ -199,7 +586,7 @@ function parseURL(parseQuery$1, location, currentLocation = "/") {
 	if (searchPos >= 0) {
 		path = location.slice(0, searchPos);
 		searchString = location.slice(searchPos, hashPos > 0 ? hashPos : location.length);
-		query = parseQuery$1(searchString.slice(1));
+		query = parseQuery(searchString.slice(1));
 	}
 	if (hashPos >= 0) {
 		path = path || location.slice(0, hashPos);
@@ -213,8 +600,8 @@ function parseURL(parseQuery$1, location, currentLocation = "/") {
 		hash: decode(hash)
 	};
 }
-function NEW_stringifyURL(stringifyQuery$1, path, query, hash = "") {
-	const searchText = stringifyQuery$1(query);
+function NEW_stringifyURL(stringifyQuery, path, query, hash = "") {
+	const searchText = stringifyQuery(query);
 	return path + (searchText && "?") + searchText + encodeHash(hash);
 }
 /**
@@ -223,8 +610,8 @@ function NEW_stringifyURL(stringifyQuery$1, path, query, hash = "") {
 * @param stringifyQuery
 * @param location
 */
-function stringifyURL(stringifyQuery$1, location) {
-	const query = location.query ? stringifyQuery$1(location.query) : "";
+function stringifyURL(stringifyQuery, location) {
+	const query = location.query ? stringifyQuery(location.query) : "";
 	return location.path + (query && "?") + query + (location.hash || "");
 }
 /**
@@ -246,10 +633,10 @@ function stripBase(pathname, base) {
 * @param a - first {@link RouteLocation}
 * @param b - second {@link RouteLocation}
 */
-function isSameRouteLocation(stringifyQuery$1, a, b) {
+function isSameRouteLocation(stringifyQuery, a, b) {
 	const aLastIndex = a.matched.length - 1;
 	const bLastIndex = b.matched.length - 1;
-	return aLastIndex > -1 && aLastIndex === bLastIndex && isSameRouteRecord(a.matched[aLastIndex], b.matched[bLastIndex]) && isSameRouteLocationParams(a.params, b.params) && stringifyQuery$1(a.query) === stringifyQuery$1(b.query) && a.hash === b.hash;
+	return aLastIndex > -1 && aLastIndex === bLastIndex && isSameRouteRecord(a.matched[aLastIndex], b.matched[bLastIndex]) && isSameRouteLocationParams(a.params, b.params) && stringifyQuery(a.query) === stringifyQuery(b.query) && a.hash === b.hash;
 }
 /**
 * Check if two `RouteRecords` are equal. Takes into account aliases: they are
@@ -267,7 +654,7 @@ function isSameRouteLocationParams(a, b) {
 	return true;
 }
 function isSameRouteLocationParamsValue(a, b) {
-	return isArray(a) ? isEquivalentArray(a, b) : isArray(b) ? isEquivalentArray(b, a) : a?.valueOf() === b?.valueOf();
+	return isArray(a) ? isEquivalentArray(a, b) : isArray(b) ? isEquivalentArray(b, a) : (a && a.valueOf()) === (b && b.valueOf());
 }
 /**
 * Check if two arrays are the same or if an array with one single entry is the
@@ -286,9 +673,12 @@ function isEquivalentArray(a, b) {
 * @param from - currentLocation.path, should start with `/`
 */
 function resolveRelativePath(to, from) {
-	if (to.startsWith("/")) return to;
-	if (process.env.NODE_ENV !== "production" && !from.startsWith("/")) {
-		warn$1(`Cannot resolve a relative location without an absolute path. Trying to resolve "${to}" from "${from}". It should look like "/${from}".`);
+	if (isAbsolutePath(to)) return to;
+	if (process.env.NODE_ENV !== "production" && !isAbsolutePath(from)) {
+		diagnostics.VUE_ROUTER_R0070({
+			to,
+			from
+		});
 		return to;
 	}
 	if (!to) return from;
@@ -334,24 +724,8 @@ const START_LOCATION_NORMALIZED = {
 	meta: {},
 	redirectedFrom: void 0
 };
-
 //#endregion
 //#region src/history/common.ts
-let NavigationType = /* @__PURE__ */ function(NavigationType$1) {
-	NavigationType$1["pop"] = "pop";
-	NavigationType$1["push"] = "push";
-	return NavigationType$1;
-}({});
-let NavigationDirection = /* @__PURE__ */ function(NavigationDirection$1) {
-	NavigationDirection$1["back"] = "back";
-	NavigationDirection$1["forward"] = "forward";
-	NavigationDirection$1["unknown"] = "";
-	return NavigationDirection$1;
-}({});
-/**
-* Starting location for Histories
-*/
-const START = "";
 /**
 * Normalizes a base by removing any trailing slash and reading the base tag if
 * present.
@@ -359,11 +733,13 @@ const START = "";
 * @param base - base to normalize
 */
 function normalizeBase(base) {
-	if (!base) if (isBrowser) {
-		const baseEl = document.querySelector("base");
-		base = baseEl && baseEl.getAttribute("href") || "/";
-		base = base.replace(/^\w+:\/\/[^\/]+/, "");
-	} else base = "/";
+	if (!base) {
+		if (isBrowser) {
+			const baseEl = document.querySelector("base");
+			base = baseEl && baseEl.getAttribute("href") || "/";
+			base = base.replace(/^\w+:\/\/[^/]+/, "");
+		} else base = "/";
+	}
 	if (base[0] !== "/" && base[0] !== "#") base = "/" + base;
 	return removeTrailingSlash(base);
 }
@@ -371,7 +747,6 @@ const BEFORE_HASH_RE = /^[^#]+#/;
 function createHref(base, location) {
 	return base.replace(BEFORE_HASH_RE, "#") + location;
 }
-
 //#endregion
 //#region src/scrollBehavior.ts
 function getElementPosition(el, offset) {
@@ -383,10 +758,10 @@ function getElementPosition(el, offset) {
 		top: elRect.top - docRect.top - (offset.top || 0)
 	};
 }
-const computeScrollPosition = () => ({
+const computeScrollPosition = () => history.scrollRestoration === "manual" ? {
 	left: window.scrollX,
 	top: window.scrollY
-});
+} : null;
 function scrollToPosition(position) {
 	let scrollToOptions;
 	if ("el" in position) {
@@ -417,17 +792,17 @@ function scrollToPosition(position) {
 			if (!isIdSelector || !document.getElementById(position.el.slice(1))) try {
 				const foundEl = document.querySelector(position.el);
 				if (isIdSelector && foundEl) {
-					warn$1(`The selector "${position.el}" should be passed as "el: document.querySelector('${position.el}')" because it starts with "#".`);
+					diagnostics.VUE_ROUTER_R0040({ el: position.el });
 					return;
 				}
-			} catch (err) {
-				warn$1(`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).`);
+			} catch {
+				diagnostics.VUE_ROUTER_R0041({ el: position.el });
 				return;
 			}
 		}
 		const el = typeof positionEl === "string" ? isIdSelector ? document.getElementById(positionEl.slice(1)) : document.querySelector(positionEl) : positionEl;
 		if (!el) {
-			process.env.NODE_ENV !== "production" && warn$1(`Couldn't find element using selector "${position.el}" returned by scrollBehavior.`);
+			process.env.NODE_ENV !== "production" && diagnostics.VUE_ROUTER_R0042({ el: position.el });
 			return;
 		}
 		scrollToOptions = getElementPosition(el, position);
@@ -439,8 +814,8 @@ function getScrollKey(path, delta) {
 	return (history.state ? history.state.position - delta : -1) + path;
 }
 const scrollPositions = /* @__PURE__ */ new Map();
-function saveScrollPosition(key, scrollPosition) {
-	scrollPositions.set(key, scrollPosition);
+function saveScrollPosition(key) {
+	scrollPositions.set(key, computeScrollPosition());
 }
 function getSavedScrollPosition(key) {
 	const scroll = scrollPositions.get(key);
@@ -451,7 +826,6 @@ function getSavedScrollPosition(key) {
 * ScrollBehavior instance used by the router to compute and restore the scroll
 * position when navigating.
 */
-
 //#endregion
 //#region src/types/typeGuards.ts
 function isRouteLocation(route) {
@@ -460,95 +834,6 @@ function isRouteLocation(route) {
 function isRouteName(name) {
 	return typeof name === "string" || typeof name === "symbol";
 }
-
-//#endregion
-//#region src/errors.ts
-/**
-* Flags so we can combine them when checking for multiple errors. This is the internal version of
-* {@link NavigationFailureType}.
-*
-* @internal
-*/
-let ErrorTypes = /* @__PURE__ */ function(ErrorTypes$1) {
-	ErrorTypes$1[ErrorTypes$1["MATCHER_NOT_FOUND"] = 1] = "MATCHER_NOT_FOUND";
-	ErrorTypes$1[ErrorTypes$1["NAVIGATION_GUARD_REDIRECT"] = 2] = "NAVIGATION_GUARD_REDIRECT";
-	ErrorTypes$1[ErrorTypes$1["NAVIGATION_ABORTED"] = 4] = "NAVIGATION_ABORTED";
-	ErrorTypes$1[ErrorTypes$1["NAVIGATION_CANCELLED"] = 8] = "NAVIGATION_CANCELLED";
-	ErrorTypes$1[ErrorTypes$1["NAVIGATION_DUPLICATED"] = 16] = "NAVIGATION_DUPLICATED";
-	return ErrorTypes$1;
-}({});
-const NavigationFailureSymbol = Symbol(process.env.NODE_ENV !== "production" ? "navigation failure" : "");
-/**
-* Enumeration with all possible types for navigation failures. Can be passed to
-* {@link isNavigationFailure} to check for specific failures.
-*/
-let NavigationFailureType = /* @__PURE__ */ function(NavigationFailureType$1) {
-	/**
-	* An aborted navigation is a navigation that failed because a navigation
-	* guard returned `false` or called `next(false)`
-	*/
-	NavigationFailureType$1[NavigationFailureType$1["aborted"] = 4] = "aborted";
-	/**
-	* A cancelled navigation is a navigation that failed because a more recent
-	* navigation finished started (not necessarily finished).
-	*/
-	NavigationFailureType$1[NavigationFailureType$1["cancelled"] = 8] = "cancelled";
-	/**
-	* A duplicated navigation is a navigation that failed because it was
-	* initiated while already being at the exact same location.
-	*/
-	NavigationFailureType$1[NavigationFailureType$1["duplicated"] = 16] = "duplicated";
-	return NavigationFailureType$1;
-}({});
-const ErrorTypeMessages = {
-	[ErrorTypes.MATCHER_NOT_FOUND]({ location, currentLocation }) {
-		return `No match for\n ${JSON.stringify(location)}${currentLocation ? "\nwhile being at\n" + JSON.stringify(currentLocation) : ""}`;
-	},
-	[ErrorTypes.NAVIGATION_GUARD_REDIRECT]({ from, to }) {
-		return `Redirected from "${from.fullPath}" to "${stringifyRoute(to)}" via a navigation guard.`;
-	},
-	[ErrorTypes.NAVIGATION_ABORTED]({ from, to }) {
-		return `Navigation aborted from "${from.fullPath}" to "${to.fullPath}" via a navigation guard.`;
-	},
-	[ErrorTypes.NAVIGATION_CANCELLED]({ from, to }) {
-		return `Navigation cancelled from "${from.fullPath}" to "${to.fullPath}" with a new navigation.`;
-	},
-	[ErrorTypes.NAVIGATION_DUPLICATED]({ from, to }) {
-		return `Avoided redundant navigation to current location: "${from.fullPath}".`;
-	}
-};
-/**
-* Creates a typed NavigationFailure object.
-* @internal
-* @param type - NavigationFailureType
-* @param params - { from, to }
-*/
-function createRouterError(type, params) {
-	if (process.env.NODE_ENV !== "production" || false) return assign(new Error(ErrorTypeMessages[type](params)), {
-		type,
-		[NavigationFailureSymbol]: true
-	}, params);
-	else return assign(/* @__PURE__ */ new Error(), {
-		type,
-		[NavigationFailureSymbol]: true
-	}, params);
-}
-function isNavigationFailure(error, type) {
-	return error instanceof Error && NavigationFailureSymbol in error && (type == null || !!(error.type & type));
-}
-const propertiesToLog = [
-	"params",
-	"query",
-	"hash"
-];
-function stringifyRoute(to) {
-	if (typeof to === "string") return to;
-	if (to.path != null) return to.path;
-	const location = {};
-	for (const key of propertiesToLog) if (key in to) location[key] = to[key];
-	return JSON.stringify(location, null, 2);
-}
-
 //#endregion
 //#region src/query.ts
 /**
@@ -595,10 +880,10 @@ function stringifyQuery(query) {
 			if (value !== void 0) search += (search.length ? "&" : "") + key;
 			continue;
 		}
-		(isArray(value) ? value.map((v) => v && encodeQueryValue(v)) : [value && encodeQueryValue(value)]).forEach((value$1) => {
-			if (value$1 !== void 0) {
+		(isArray(value) ? value.map((v) => v && encodeQueryValue(v)) : [value && encodeQueryValue(value)]).forEach((value) => {
+			if (value !== void 0) {
 				search += (search.length ? "&" : "") + key;
-				if (value$1 != null) search += "=" + value$1;
+				if (value != null) search += "=" + value;
 			}
 		});
 	}
@@ -620,46 +905,6 @@ function normalizeQuery(query) {
 	}
 	return normalizedQuery;
 }
-
-//#endregion
-//#region src/injectionSymbols.ts
-/**
-* RouteRecord being rendered by the closest ancestor Router View. Used for
-* `onBeforeRouteUpdate` and `onBeforeRouteLeave`. rvlm stands for Router View
-* Location Matched
-*
-* @internal
-*/
-const matchedRouteKey = Symbol(process.env.NODE_ENV !== "production" ? "router view location matched" : "");
-/**
-* Allows overriding the router view depth to control which component in
-* `matched` is rendered. rvd stands for Router View Depth
-*
-* @internal
-*/
-const viewDepthKey = Symbol(process.env.NODE_ENV !== "production" ? "router view depth" : "");
-/**
-* Allows overriding the router instance returned by `useRouter` in tests. r
-* stands for router
-*
-* @internal
-*/
-const routerKey = Symbol(process.env.NODE_ENV !== "production" ? "router" : "");
-/**
-* Allows overriding the current route returned by `useRoute` in tests. rl
-* stands for route location
-*
-* @internal
-*/
-const routeLocationKey = Symbol(process.env.NODE_ENV !== "production" ? "route location" : "");
-/**
-* Allows overriding the current route used by router-view. Internally this is
-* used when the `route` prop is passed.
-*
-* @internal
-*/
-const routerViewLocationKey = Symbol(process.env.NODE_ENV !== "production" ? "router view location" : "");
-
 //#endregion
 //#region src/utils/callbacks.ts
 /**
@@ -683,19 +928,30 @@ function useCallbacks() {
 		reset
 	};
 }
-
 //#endregion
 //#region src/navigationGuards.ts
-function registerGuard(record, name, guard) {
+function registerGuard(activeRecordRef, name, guard) {
+	const record = activeRecordRef.value;
+	if (!record) {
+		if (process.env.NODE_ENV !== "production") {
+			const fnName = name === "updateGuards" ? "onBeforeRouteUpdate" : "onBeforeRouteLeave";
+			diagnostics.VUE_ROUTER_R0020({ fn: fnName });
+		}
+		return;
+	}
+	let currentRecord = record;
 	const removeFromList = () => {
-		record[name].delete(guard);
+		currentRecord[name].delete(guard);
 	};
 	onUnmounted(removeFromList);
 	onDeactivated(removeFromList);
 	onActivated(() => {
-		record[name].add(guard);
+		const newRecord = activeRecordRef.value;
+		if (process.env.NODE_ENV !== "production" && !newRecord) diagnostics.VUE_ROUTER_R0021();
+		if (newRecord) currentRecord = newRecord;
+		currentRecord[name].add(guard);
 	});
-	record[name].add(guard);
+	currentRecord[name].add(guard);
 }
 /**
 * Add a navigation guard that triggers whenever the component for the current
@@ -706,15 +962,10 @@ function registerGuard(record, name, guard) {
 */
 function onBeforeRouteLeave(leaveGuard) {
 	if (process.env.NODE_ENV !== "production" && !getCurrentInstance()) {
-		warn$1("getCurrentInstance() returned null. onBeforeRouteLeave() must be called at the top of a setup function");
+		diagnostics.VUE_ROUTER_R0022({ fn: "onBeforeRouteLeave" });
 		return;
 	}
-	const activeRecord = inject(matchedRouteKey, {}).value;
-	if (!activeRecord) {
-		process.env.NODE_ENV !== "production" && warn$1("No active route record was found when calling `onBeforeRouteLeave()`. Make sure you call this function inside a component child of <router-view>. Maybe you called it inside of App.vue?");
-		return;
-	}
-	registerGuard(activeRecord, "leaveGuards", leaveGuard);
+	registerGuard(inject(matchedRouteKey, {}), "leaveGuards", leaveGuard);
 }
 /**
 * Add a navigation guard that triggers whenever the current location is about
@@ -725,26 +976,21 @@ function onBeforeRouteLeave(leaveGuard) {
 */
 function onBeforeRouteUpdate(updateGuard) {
 	if (process.env.NODE_ENV !== "production" && !getCurrentInstance()) {
-		warn$1("getCurrentInstance() returned null. onBeforeRouteUpdate() must be called at the top of a setup function");
-		return;
-	}
-	const activeRecord = inject(matchedRouteKey, {}).value;
-	if (!activeRecord) {
-		process.env.NODE_ENV !== "production" && warn$1("No active route record was found when calling `onBeforeRouteUpdate()`. Make sure you call this function inside a component child of <router-view>. Maybe you called it inside of App.vue?");
+		diagnostics.VUE_ROUTER_R0022({ fn: "onBeforeRouteUpdate" });
 		return;
 	}
-	registerGuard(activeRecord, "updateGuards", updateGuard);
+	registerGuard(inject(matchedRouteKey, {}), "updateGuards", updateGuard);
 }
 function guardToPromiseFn(guard, to, from, record, name, runWithContext = (fn) => fn()) {
 	const enterCallbackArray = record && (record.enterCallbacks[name] = record.enterCallbacks[name] || []);
 	return () => new Promise((resolve, reject) => {
 		const next = (valid) => {
-			if (valid === false) reject(createRouterError(ErrorTypes.NAVIGATION_ABORTED, {
+			if (valid === false) reject(createRouterError(4, {
 				from,
 				to
 			}));
 			else if (valid instanceof Error) reject(valid);
-			else if (isRouteLocation(valid)) reject(createRouterError(ErrorTypes.NAVIGATION_GUARD_REDIRECT, {
+			else if (isRouteLocation(valid)) reject(createRouterError(2, {
 				from: to,
 				to: valid
 			}));
@@ -753,21 +999,24 @@ function guardToPromiseFn(guard, to, from, record, name, runWithContext = (fn) =
 				resolve();
 			}
 		};
-		const guardReturn = runWithContext(() => guard.call(record && record.instances[name], to, from, process.env.NODE_ENV !== "production" ? canOnlyBeCalledOnce(next, to, from) : next));
+		const guardReturn = runWithContext(() => guard.call(record && record.instances[name], to, from, process.env.NODE_ENV !== "production" ? withDeprecationWarning(canOnlyBeCalledOnce(next, to, from)) : next));
 		let guardCall = Promise.resolve(guardReturn);
 		if (guard.length < 3) guardCall = guardCall.then(next);
 		if (process.env.NODE_ENV !== "production" && guard.length > 2) {
-			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.`;
+			const guardInfo = {
+				name: guard.name,
+				guard: guard.toString()
+			};
 			if (typeof guardReturn === "object" && "then" in guardReturn) guardCall = guardCall.then((resolvedValue) => {
 				if (!next._called) {
-					warn$1(message);
+					diagnostics.VUE_ROUTER_R0023(guardInfo);
 					return Promise.reject(/* @__PURE__ */ new Error("Invalid navigation guard"));
 				}
 				return resolvedValue;
 			});
 			else if (guardReturn !== void 0) {
 				if (!next._called) {
-					warn$1(message);
+					diagnostics.VUE_ROUTER_R0023(guardInfo);
 					reject(/* @__PURE__ */ new Error("Invalid navigation guard"));
 					return;
 				}
@@ -776,10 +1025,30 @@ function guardToPromiseFn(guard, to, from, record, name, runWithContext = (fn) =
 		guardCall.catch((err) => reject(err));
 	});
 }
+/**
+* Wraps the next callback to warn when it is used. Dev-only: when __DEV__ is
+* false (production builds), this branch is dead code and is stripped from the
+* bundle.
+*
+* @internal
+*/
+function withDeprecationWarning(next) {
+	let warned = false;
+	return function() {
+		if (!warned) {
+			warned = true;
+			diagnostics.VUE_ROUTER_R0025();
+		}
+		return next.apply(this, arguments);
+	};
+}
 function canOnlyBeCalledOnce(next, to, from) {
 	let called = 0;
 	return function() {
-		if (called++ === 1) warn$1(`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.`);
+		if (called++ === 1) diagnostics.VUE_ROUTER_R0024({
+			from: from.fullPath,
+			to: to.fullPath
+		});
 		next._called = true;
 		if (called === 1) next.apply(null, arguments);
 	};
@@ -787,20 +1056,30 @@ function canOnlyBeCalledOnce(next, to, from) {
 function extractComponentsGuards(matched, guardType, to, from, runWithContext = (fn) => fn()) {
 	const guards = [];
 	for (const record of matched) {
-		if (process.env.NODE_ENV !== "production" && !record.components && record.children && !record.children.length) warn$1(`Record with path "${record.path}" is either missing a "component(s)" or "children" property.`);
+		if (process.env.NODE_ENV !== "production" && !record.components && record.children && !record.children.length) diagnostics.VUE_ROUTER_R0026({ path: record.path });
 		for (const name in record.components) {
 			let rawComponent = record.components[name];
 			if (process.env.NODE_ENV !== "production") {
 				if (!rawComponent || typeof rawComponent !== "object" && typeof rawComponent !== "function") {
-					warn$1(`Component "${name}" in record with path "${record.path}" is not a valid component. Received "${String(rawComponent)}".`);
+					diagnostics.VUE_ROUTER_R0027({
+						name,
+						path: record.path,
+						received: String(rawComponent)
+					});
 					throw new Error("Invalid route component");
 				} else if ("then" in rawComponent) {
-					warn$1(`Component "${name}" in record with path "${record.path}" is a Promise instead of a function that returns a Promise. Did you write "import('./MyPage.vue')" instead of "() => import('./MyPage.vue')" ? This will break in production if not fixed.`);
+					diagnostics.VUE_ROUTER_R0028({
+						name,
+						path: record.path
+					});
 					const promise = rawComponent;
 					rawComponent = () => promise;
 				} else if (rawComponent.__asyncLoader && !rawComponent.__warnedDefineAsync) {
 					rawComponent.__warnedDefineAsync = true;
-					warn$1(`Component "${name}" in record with path "${record.path}" is defined using "defineAsyncComponent()". Write "() => import('./MyPage.vue')" instead of "defineAsyncComponent(() => import('./MyPage.vue'))".`);
+					diagnostics.VUE_ROUTER_R0029({
+						name,
+						path: record.path
+					});
 				}
 			}
 			if (guardType !== "beforeRouteEnter" && !record.instances[name]) continue;
@@ -810,7 +1089,10 @@ function extractComponentsGuards(matched, guardType, to, from, runWithContext =
 			} else {
 				let componentPromise = rawComponent();
 				if (process.env.NODE_ENV !== "production" && !("catch" in componentPromise)) {
-					warn$1(`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.`);
+					diagnostics.VUE_ROUTER_R0030({
+						name,
+						path: record.path
+					});
 					componentPromise = Promise.resolve(componentPromise);
 				}
 				guards.push(() => componentPromise.then((resolved) => {
@@ -857,8 +1139,10 @@ function extractChangingRecords(to, from) {
 	const len = Math.max(from.matched.length, to.matched.length);
 	for (let i = 0; i < len; i++) {
 		const recordFrom = from.matched[i];
-		if (recordFrom) if (to.matched.find((record) => isSameRouteRecord(record, recordFrom))) updatingRecords.push(recordFrom);
-		else leavingRecords.push(recordFrom);
+		if (recordFrom) {
+			if (to.matched.find((record) => isSameRouteRecord(record, recordFrom))) updatingRecords.push(recordFrom);
+			else leavingRecords.push(recordFrom);
+		}
 		const recordTo = to.matched[i];
 		if (recordTo) {
 			if (!from.matched.find((record) => isSameRouteRecord(record, recordTo))) enteringRecords.push(recordTo);
@@ -870,7 +1154,6 @@ function extractChangingRecords(to, from) {
 		enteringRecords
 	];
 }
-
 //#endregion
 //#region src/devtools.ts
 /**
@@ -902,7 +1185,7 @@ function addDevtools(app, router, matcher) {
 	if (router.__hasDevtools) return;
 	router.__hasDevtools = true;
 	const id = routerId++;
-	setupDevtoolsPlugin({
+	setupDevToolsPlugin({
 		id: "org.vuejs.router" + (id ? "." + id : ""),
 		label: "Vue Router",
 		packageName: "vue-router",
@@ -911,8 +1194,7 @@ function addDevtools(app, router, matcher) {
 		componentStateTypes: ["Routing"],
 		app
 	}, (api) => {
-		if (typeof api.now !== "function") warn$1("[Vue Router]: You seem to be using an outdated version of Vue Devtools. Are you still using the Beta release instead of the stable one? You can find the links at https://devtools.vuejs.org/guide/installation.html.");
-		api.on.inspectComponent((payload, ctx) => {
+		api.on.inspectComponent((payload) => {
 			if (payload.instanceData) payload.instanceData.state.push({
 				type: "Routing",
 				key: "$route",
@@ -1056,7 +1338,7 @@ function addDevtools(app, router, matcher) {
 		*/
 		api.on.getInspectorState((payload) => {
 			if (payload.app === app && payload.inspectorId === routerInspectorId) {
-				const route = matcher.getRoutes().find((route$1) => route$1.record.__vd_id === payload.nodeId);
+				const route = matcher.getRoutes().find((route) => route.record.__vd_id === payload.nodeId);
 				if (route) payload.state = { options: formatRouteRecordMatcherForStateInspector(route) };
 			}
 		});
@@ -1206,7 +1488,7 @@ function isRouteMatching(route, filter) {
 	}
 	const path = route.record.path.toLowerCase();
 	const decodedPath = decode(path);
-	if (!filter.startsWith("/") && (decodedPath.includes(filter) || path.includes(filter))) return true;
+	if (!isAbsolutePath(filter) && (decodedPath.includes(filter) || path.includes(filter))) return true;
 	if (decodedPath.startsWith(filter) || path.startsWith(filter)) return true;
 	if (route.record.name && String(route.record.name).includes(filter)) return true;
 	return route.children.some((child) => isRouteMatching(child, filter));
@@ -1218,11 +1500,10 @@ function omit(obj, keys) {
 }
 
 /*!
- * vue-router v4.6.4
- * (c) 2025 Eduardo San Martin Morote
- * @license MIT
- */
-
+* vue-router v5.3.1
+* (c) 2026 Eduardo San Martin Morote
+* @license MIT
+*/
 //#region src/history/html5.ts
 let createBaseLocation = () => location.protocol + "//" + location.host;
 /**
@@ -1230,8 +1511,8 @@ let createBaseLocation = () => location.protocol + "//" + location.host;
 * @param base - The base path
 * @param location - The window.location object
 */
-function createCurrentLocation(base, location$1) {
-	const { pathname, search, hash } = location$1;
+function createCurrentLocation(base, location) {
+	const { pathname, search, hash } = location;
 	const hashPos = base.indexOf("#");
 	if (hashPos > -1) {
 		let slicePos = hash.includes(base.slice(hashPos)) ? base.slice(hashPos).length : 1;
@@ -1262,8 +1543,8 @@ function useHistoryListeners(base, historyState, currentLocation, replace) {
 		listeners.forEach((listener) => {
 			listener(currentLocation.value, from, {
 				delta,
-				type: NavigationType.pop,
-				direction: delta ? delta > 0 ? NavigationDirection.forward : NavigationDirection.back : NavigationDirection.unknown
+				type: "pop",
+				direction: delta ? delta > 0 ? "forward" : "back" : ""
 			});
 		});
 	};
@@ -1280,22 +1561,18 @@ function useHistoryListeners(base, historyState, currentLocation, replace) {
 		return teardown;
 	}
 	function beforeUnloadListener() {
-		if (document.visibilityState === "hidden") {
-			const { history: history$1 } = window;
-			if (!history$1.state) return;
-			history$1.replaceState(assign({}, history$1.state, { scroll: computeScrollPosition() }), "");
-		}
+		const { history } = window;
+		if (!history.state) return;
+		history.replaceState(assign({}, history.state, { scroll: computeScrollPosition() }), "");
 	}
 	function destroy() {
 		for (const teardown of teardowns) teardown();
 		teardowns = [];
 		window.removeEventListener("popstate", popStateHandler);
 		window.removeEventListener("pagehide", beforeUnloadListener);
-		document.removeEventListener("visibilitychange", beforeUnloadListener);
 	}
 	window.addEventListener("popstate", popStateHandler);
 	window.addEventListener("pagehide", beforeUnloadListener);
-	document.addEventListener("visibilitychange", beforeUnloadListener);
 	return {
 		pauseListeners,
 		listen,
@@ -1305,29 +1582,29 @@ function useHistoryListeners(base, historyState, currentLocation, replace) {
 /**
 * Creates a state object
 */
-function buildState(back, current, forward, replaced = false, computeScroll = false) {
+function buildState(back, current, forward, replaced = false) {
 	return {
 		back,
 		current,
 		forward,
 		replaced,
 		position: window.history.length,
-		scroll: computeScroll ? computeScrollPosition() : null
+		scroll: null
 	};
 }
 function useHistoryStateNavigation(base) {
-	const { history: history$1, location: location$1 } = window;
-	const currentLocation = { value: createCurrentLocation(base, location$1) };
-	const historyState = { value: history$1.state };
+	const { history, location } = window;
+	const currentLocation = { value: createCurrentLocation(base, location) };
+	const historyState = { value: history.state };
 	if (!historyState.value) changeLocation(currentLocation.value, {
 		back: null,
 		current: currentLocation.value,
 		forward: null,
-		position: history$1.length - 1,
+		position: history.length - 1,
 		replaced: true,
 		scroll: null
 	}, true);
-	function changeLocation(to, state, replace$1) {
+	function changeLocation(to, state, replace) {
 		/**
 		* if a base tag is provided, and we are on a normal domain, we have to
 		* respect the provided `base` attribute because pushState() will use it and
@@ -1338,26 +1615,26 @@ function useHistoryStateNavigation(base) {
 		* base tag we can just use everything after the `#`.
 		*/
 		const hashIndex = base.indexOf("#");
-		const url = hashIndex > -1 ? (location$1.host && document.querySelector("base") ? base : base.slice(hashIndex)) + to : createBaseLocation() + base + to;
+		const url = hashIndex > -1 ? (location.host && document.querySelector("base") ? base : base.slice(hashIndex)) + to : createBaseLocation() + base + to;
 		try {
-			history$1[replace$1 ? "replaceState" : "pushState"](state, "", url);
+			history[replace ? "replaceState" : "pushState"](state, "", url);
 			historyState.value = state;
 		} catch (err) {
-			if (process.env.NODE_ENV !== "production") warn$1("Error with push/replace State", err);
+			if (process.env.NODE_ENV !== "production") diagnostics.VUE_ROUTER_R0120({ cause: err });
 			else console.error(err);
-			location$1[replace$1 ? "replace" : "assign"](url);
+			location[replace ? "replace" : "assign"](url);
 		}
 	}
 	function replace(to, data) {
-		changeLocation(to, assign({}, history$1.state, buildState(historyState.value.back, to, historyState.value.forward, true), data, { position: historyState.value.position }), true);
+		changeLocation(to, assign({}, history.state, buildState(historyState.value.back, to, historyState.value.forward, true), data, { position: historyState.value.position }), true);
 		currentLocation.value = to;
 	}
 	function push(to, data) {
-		const currentState = assign({}, historyState.value, history$1.state, {
+		const currentState = assign({}, historyState.value, history.state, {
 			forward: to,
 			scroll: computeScrollPosition()
 		});
-		if (process.env.NODE_ENV !== "production" && !history$1.state) warn$1("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\nhistory.replaceState(history.state, '', url)\n\nYou can find more information at https://router.vuejs.org/guide/migration/#Usage-of-history-state");
+		if (process.env.NODE_ENV !== "production" && !history.state) diagnostics.VUE_ROUTER_R0121();
 		changeLocation(currentState.current, currentState, true);
 		changeLocation(to, assign({}, buildState(currentLocation.value, to, null), { position: currentState.position + 1 }, data), false);
 		currentLocation.value = to;
@@ -1398,7 +1675,41 @@ function createWebHistory(base) {
 	});
 	return routerHistory;
 }
-
+//#endregion
+//#region src/history/hash.ts
+/**
+* Creates a hash history. Useful for web applications with no host (e.g. `file://`) or when configuring a server to
+* handle any URL is not possible.
+*
+* @param base - optional base to provide. Defaults to `location.pathname + location.search` If there is a `<base>` tag
+* in the `head`, its value will be ignored in favor of this parameter **but note it affects all the history.pushState()
+* calls**, meaning that if you use a `<base>` tag, it's `href` value **has to match this parameter** (ignoring anything
+* after the `#`).
+*
+* @example
+* ```js
+* // at https://example.com/folder
+* createWebHashHistory() // gives a url of `https://example.com/folder#`
+* createWebHashHistory('/folder/') // gives a url of `https://example.com/folder/#`
+* // if the `#` is provided in the base, it won't be added by `createWebHashHistory`
+* createWebHashHistory('/folder/#/app/') // gives a url of `https://example.com/folder/#/app/`
+* // you should avoid doing this because it changes the original url and breaks copying urls
+* createWebHashHistory('/other-folder/') // gives a url of `https://example.com/other-folder/#`
+*
+* // at file:///usr/etc/folder/index.html
+* // for locations with no `host`, the base is ignored
+* createWebHashHistory('/iAmIgnored') // gives a url of `file:///usr/etc/folder/index.html#`
+* ```
+*/
+function createWebHashHistory(base) {
+	base = location.host ? base || location.pathname + location.search : "";
+	if (!base.includes("#")) base += "#";
+	if (process.env.NODE_ENV !== "production" && !base.endsWith("#/") && !base.endsWith("#")) diagnostics.VUE_ROUTER_R0110({
+		base,
+		suggestion: base.replace(/#.*$/, "#")
+	});
+	return createWebHistory(base);
+}
 //#endregion
 //#region src/history/memory.ts
 /**
@@ -1410,24 +1721,24 @@ function createWebHistory(base) {
 */
 function createMemoryHistory(base = "") {
 	let listeners = [];
-	let queue = [[START, {}]];
+	let queue = [["", {}]];
 	let position = 0;
 	base = normalizeBase(base);
-	function setLocation(location$1, state = {}) {
+	function setLocation(location, state = {}) {
 		position++;
 		if (position !== queue.length) queue.splice(position);
-		queue.push([location$1, state]);
+		queue.push([location, state]);
 	}
 	function triggerListeners(to, from, { direction, delta }) {
 		const info = {
 			direction,
 			delta,
-			type: NavigationType.pop
+			type: "pop"
 		};
 		for (const callback of listeners) callback(to, from, info);
 	}
 	const routerHistory = {
-		location: START,
+		location: "",
 		state: {},
 		base,
 		createHref: createHref.bind(null, base),
@@ -1447,12 +1758,12 @@ function createMemoryHistory(base = "") {
 		},
 		destroy() {
 			listeners = [];
-			queue = [[START, {}]];
+			queue = [["", {}]];
 			position = 0;
 		},
 		go(delta, shouldTrigger = true) {
 			const from = this.location;
-			const direction = delta < 0 ? NavigationDirection.back : NavigationDirection.forward;
+			const direction = delta < 0 ? "back" : "forward";
 			position = Math.max(0, Math.min(position + delta, queue.length - 1));
 			if (shouldTrigger) triggerListeners(this.location, from, {
 				direction,
@@ -1470,69 +1781,21 @@ function createMemoryHistory(base = "") {
 	});
 	return routerHistory;
 }
-
-//#endregion
-//#region src/history/hash.ts
-/**
-* Creates a hash history. Useful for web applications with no host (e.g. `file://`) or when configuring a server to
-* handle any URL is not possible.
-*
-* @param base - optional base to provide. Defaults to `location.pathname + location.search` If there is a `<base>` tag
-* in the `head`, its value will be ignored in favor of this parameter **but note it affects all the history.pushState()
-* calls**, meaning that if you use a `<base>` tag, it's `href` value **has to match this parameter** (ignoring anything
-* after the `#`).
-*
-* @example
-* ```js
-* // at https://example.com/folder
-* createWebHashHistory() // gives a url of `https://example.com/folder#`
-* createWebHashHistory('/folder/') // gives a url of `https://example.com/folder/#`
-* // if the `#` is provided in the base, it won't be added by `createWebHashHistory`
-* createWebHashHistory('/folder/#/app/') // gives a url of `https://example.com/folder/#/app/`
-* // you should avoid doing this because it changes the original url and breaks copying urls
-* createWebHashHistory('/other-folder/') // gives a url of `https://example.com/other-folder/#`
-*
-* // at file:///usr/etc/folder/index.html
-* // for locations with no `host`, the base is ignored
-* createWebHashHistory('/iAmIgnored') // gives a url of `file:///usr/etc/folder/index.html#`
-* ```
-*/
-function createWebHashHistory(base) {
-	base = location.host ? base || location.pathname + location.search : "";
-	if (!base.includes("#")) base += "#";
-	if (process.env.NODE_ENV !== "production" && !base.endsWith("#/") && !base.endsWith("#")) warn$1(`A hash base must end with a "#":\n"${base}" should be "${base.replace(/#.*$/, "#")}".`);
-	return createWebHistory(base);
-}
-
 //#endregion
 //#region src/matcher/pathTokenizer.ts
-let TokenType = /* @__PURE__ */ function(TokenType$1) {
-	TokenType$1[TokenType$1["Static"] = 0] = "Static";
-	TokenType$1[TokenType$1["Param"] = 1] = "Param";
-	TokenType$1[TokenType$1["Group"] = 2] = "Group";
-	return TokenType$1;
-}({});
-var TokenizerState = /* @__PURE__ */ function(TokenizerState$1) {
-	TokenizerState$1[TokenizerState$1["Static"] = 0] = "Static";
-	TokenizerState$1[TokenizerState$1["Param"] = 1] = "Param";
-	TokenizerState$1[TokenizerState$1["ParamRegExp"] = 2] = "ParamRegExp";
-	TokenizerState$1[TokenizerState$1["ParamRegExpEnd"] = 3] = "ParamRegExpEnd";
-	TokenizerState$1[TokenizerState$1["EscapeNext"] = 4] = "EscapeNext";
-	return TokenizerState$1;
-}(TokenizerState || {});
 const ROOT_TOKEN = {
-	type: TokenType.Static,
+	type: 0,
 	value: ""
 };
 const VALID_PARAM_RE = /[a-zA-Z0-9_]/;
 function tokenizePath(path) {
 	if (!path) return [[]];
 	if (path === "/") return [[ROOT_TOKEN]];
-	if (!path.startsWith("/")) throw new Error(process.env.NODE_ENV !== "production" ? `Route paths should start with a "/": "${path}" should be "/${path}".` : `Invalid path "${path}"`);
+	if (!isAbsolutePath(path)) throw new Error(process.env.NODE_ENV !== "production" ? `Route paths should start with a "/": "${path}" should be "/${path}".` : `Invalid path "${path}"`);
 	function crash(message) {
 		throw new Error(`ERR (${state})/"${buffer}": ${message}`);
 	}
-	let state = TokenizerState.Static;
+	let state = 0;
 	let previousState = state;
 	const tokens = [];
 	let segment;
@@ -1546,14 +1809,14 @@ function tokenizePath(path) {
 	let customRe = "";
 	function consumeBuffer() {
 		if (!buffer) return;
-		if (state === TokenizerState.Static) segment.push({
-			type: TokenType.Static,
+		if (state === 0) segment.push({
+			type: 0,
 			value: buffer
 		});
-		else if (state === TokenizerState.Param || state === TokenizerState.ParamRegExp || state === TokenizerState.ParamRegExpEnd) {
+		else if (state === 1 || state === 2 || state === 3) {
 			if (segment.length > 1 && (char === "*" || char === "+")) crash(`A repeatable param (${buffer}) must be alone in its segment. eg: '/:ids+.`);
 			segment.push({
-				type: TokenType.Param,
+				type: 1,
 				value: buffer,
 				regexp: customRe,
 				repeatable: char === "*" || char === "+",
@@ -1567,56 +1830,52 @@ function tokenizePath(path) {
 	}
 	while (i < path.length) {
 		char = path[i++];
-		if (char === "\\" && state !== TokenizerState.ParamRegExp) {
-			previousState = state;
-			state = TokenizerState.EscapeNext;
-			continue;
-		}
 		switch (state) {
-			case TokenizerState.Static:
-				if (char === "/") {
+			case 0:
+				if (char === "\\") {
+					previousState = state;
+					state = 4;
+				} else if (char === "/") {
 					if (buffer) consumeBuffer();
 					finalizeSegment();
 				} else if (char === ":") {
 					consumeBuffer();
-					state = TokenizerState.Param;
+					state = 1;
 				} else addCharToBuffer();
 				break;
-			case TokenizerState.EscapeNext:
+			case 4:
 				addCharToBuffer();
 				state = previousState;
 				break;
-			case TokenizerState.Param:
-				if (char === "(") state = TokenizerState.ParamRegExp;
+			case 1:
+				if (char === "(") state = 2;
 				else if (VALID_PARAM_RE.test(char)) addCharToBuffer();
 				else {
 					consumeBuffer();
-					state = TokenizerState.Static;
+					state = 0;
 					if (char !== "*" && char !== "?" && char !== "+") i--;
 				}
 				break;
-			case TokenizerState.ParamRegExp:
-				if (char === ")") if (customRe[customRe.length - 1] == "\\") customRe = customRe.slice(0, -1) + char;
-				else state = TokenizerState.ParamRegExpEnd;
-				else customRe += char;
+			case 2:
+				if (char === ")") {
+					if (customRe[customRe.length - 1] == "\\") customRe = customRe.slice(0, -1) + char;
+					else state = 3;
+				} else customRe += char;
 				break;
-			case TokenizerState.ParamRegExpEnd:
+			case 3:
 				consumeBuffer();
-				state = TokenizerState.Static;
+				state = 0;
 				if (char !== "*" && char !== "?" && char !== "+") i--;
 				customRe = "";
 				break;
-			default:
-				crash("Unknown state");
-				break;
+			default: crash("Unknown state");
 		}
 	}
-	if (state === TokenizerState.ParamRegExp) crash(`Unfinished custom RegExp for param "${buffer}"`);
+	if (state === 2) crash(`Unfinished custom RegExp for param "${buffer}"`);
 	consumeBuffer();
 	finalizeSegment();
 	return tokens;
 }
-
 //#endregion
 //#region src/matcher/pathParserRanker.ts
 const BASE_PARAM_PATTERN = "[^/]+?";
@@ -1626,21 +1885,6 @@ const BASE_PATH_PARSER_OPTIONS = {
 	start: true,
 	end: true
 };
-var PathScore = /* @__PURE__ */ function(PathScore$1) {
-	PathScore$1[PathScore$1["_multiplier"] = 10] = "_multiplier";
-	PathScore$1[PathScore$1["Root"] = 90] = "Root";
-	PathScore$1[PathScore$1["Segment"] = 40] = "Segment";
-	PathScore$1[PathScore$1["SubSegment"] = 30] = "SubSegment";
-	PathScore$1[PathScore$1["Static"] = 40] = "Static";
-	PathScore$1[PathScore$1["Dynamic"] = 20] = "Dynamic";
-	PathScore$1[PathScore$1["BonusCustomRegExp"] = 10] = "BonusCustomRegExp";
-	PathScore$1[PathScore$1["BonusWildcard"] = -50] = "BonusWildcard";
-	PathScore$1[PathScore$1["BonusRepeatable"] = -20] = "BonusRepeatable";
-	PathScore$1[PathScore$1["BonusOptional"] = -8] = "BonusOptional";
-	PathScore$1[PathScore$1["BonusStrict"] = .7000000000000001] = "BonusStrict";
-	PathScore$1[PathScore$1["BonusCaseSensitive"] = .25] = "BonusCaseSensitive";
-	return PathScore$1;
-}(PathScore || {});
 const REGEX_CHARS_RE = /[.+*?^${}()[\]/\\]/g;
 /**
 * Creates a path parser from an array of Segments (a segment is an array of Tokens)
@@ -1655,39 +1899,39 @@ function tokensToParser(segments, extraOptions) {
 	let pattern = options.start ? "^" : "";
 	const keys = [];
 	for (const segment of segments) {
-		const segmentScores = segment.length ? [] : [PathScore.Root];
+		const segmentScores = segment.length ? [] : [90];
 		if (options.strict && !segment.length) pattern += "/";
 		for (let tokenIndex = 0; tokenIndex < segment.length; tokenIndex++) {
 			const token = segment[tokenIndex];
-			let subSegmentScore = PathScore.Segment + (options.sensitive ? PathScore.BonusCaseSensitive : 0);
-			if (token.type === TokenType.Static) {
+			let subSegmentScore = 40 + (options.sensitive ? .25 : 0);
+			if (token.type === 0) {
 				if (!tokenIndex) pattern += "/";
 				pattern += token.value.replace(REGEX_CHARS_RE, "\\$&");
-				subSegmentScore += PathScore.Static;
-			} else if (token.type === TokenType.Param) {
+				subSegmentScore += 40;
+			} else if (token.type === 1) {
 				const { value, repeatable, optional, regexp } = token;
 				keys.push({
 					name: value,
 					repeatable,
 					optional
 				});
-				const re$1 = regexp ? regexp : BASE_PARAM_PATTERN;
-				if (re$1 !== BASE_PARAM_PATTERN) {
-					subSegmentScore += PathScore.BonusCustomRegExp;
+				const re = regexp ? regexp : BASE_PARAM_PATTERN;
+				if (re !== BASE_PARAM_PATTERN) {
+					subSegmentScore += 10;
 					try {
-						`${re$1}`;
+						new RegExp(`(${re})`);
 					} catch (err) {
-						throw new Error(`Invalid custom RegExp for param "${value}" (${re$1}): ` + err.message);
+						throw new Error(`Invalid custom RegExp for param "${value}" (${re}): ` + err.message);
 					}
 				}
-				let subPattern = repeatable ? `((?:${re$1})(?:/(?:${re$1}))*)` : `(${re$1})`;
+				let subPattern = repeatable ? `((?:${re})(?:/(?:${re}))*)` : `(${re})`;
 				if (!tokenIndex) subPattern = optional && segment.length < 2 ? `(?:/${subPattern})` : "/" + subPattern;
 				if (optional) subPattern += "?";
 				pattern += subPattern;
-				subSegmentScore += PathScore.Dynamic;
-				if (optional) subSegmentScore += PathScore.BonusOptional;
-				if (repeatable) subSegmentScore += PathScore.BonusRepeatable;
-				if (re$1 === ".*") subSegmentScore += PathScore.BonusWildcard;
+				subSegmentScore += 20;
+				if (optional) subSegmentScore += -8;
+				if (repeatable) subSegmentScore += -20;
+				if (re === ".*") subSegmentScore += -50;
 			}
 			segmentScores.push(subSegmentScore);
 		}
@@ -1695,7 +1939,7 @@ function tokensToParser(segments, extraOptions) {
 	}
 	if (options.strict && options.end) {
 		const i = score.length - 1;
-		score[i][score[i].length - 1] += PathScore.BonusStrict;
+		score[i][score[i].length - 1] += .7000000000000001;
 	}
 	if (!options.strict) pattern += "/?";
 	if (options.end) pattern += "$";
@@ -1718,16 +1962,20 @@ function tokensToParser(segments, extraOptions) {
 		for (const segment of segments) {
 			if (!avoidDuplicatedSlash || !path.endsWith("/")) path += "/";
 			avoidDuplicatedSlash = false;
-			for (const token of segment) if (token.type === TokenType.Static) path += token.value;
-			else if (token.type === TokenType.Param) {
+			for (const token of segment) if (token.type === 0) path += token.value;
+			else if (token.type === 1) {
 				const { value, repeatable, optional } = token;
 				const param = value in params ? params[value] : "";
 				if (isArray(param) && !repeatable) throw new Error(`Provided param "${value}" is an array but it is not repeatable (* or + modifiers)`);
 				const text = isArray(param) ? param.join("/") : param;
-				if (!text) if (optional) {
-					if (segment.length < 2) if (path.endsWith("/")) path = path.slice(0, -1);
-					else avoidDuplicatedSlash = true;
-				} else throw new Error(`Missing required param "${value}"`);
+				if (!text) {
+					if (optional) {
+						if (segment.length < 2) {
+							if (path.endsWith("/")) path = path.slice(0, -1);
+							else avoidDuplicatedSlash = true;
+						}
+					} else throw new Error(`Missing required param "${value}"`);
+				}
 				path += text;
 			}
 		}
@@ -1757,8 +2005,8 @@ function compareScoreArray(a, b) {
 		if (diff) return diff;
 		i++;
 	}
-	if (a.length < b.length) return a.length === 1 && a[0] === PathScore.Static + PathScore.Segment ? -1 : 1;
-	else if (a.length > b.length) return b.length === 1 && b[0] === PathScore.Static + PathScore.Segment ? 1 : -1;
+	if (a.length < b.length) return a.length === 1 && a[0] === 80 ? -1 : 1;
+	else if (a.length > b.length) return b.length === 1 && b[0] === 80 ? 1 : -1;
 	return 0;
 }
 /**
@@ -1798,7 +2046,6 @@ const PATH_PARSER_OPTIONS_DEFAULTS = {
 	end: true,
 	sensitive: false
 };
-
 //#endregion
 //#region src/matcher/pathMatcher.ts
 function createRouteRecordMatcher(record, parent, options) {
@@ -1806,7 +2053,10 @@ function createRouteRecordMatcher(record, parent, options) {
 	if (process.env.NODE_ENV !== "production") {
 		const existingKeys = /* @__PURE__ */ new Set();
 		for (const key of parser.keys) {
-			if (existingKeys.has(key.name)) warn$1(`Found duplicated params with name "${key.name}" for path "${record.path}". Only the last one will be available on "$route.params".`);
+			if (existingKeys.has(key.name)) diagnostics.VUE_ROUTER_R0090({
+				name: key.name,
+				path: record.path
+			});
 			existingKeys.add(key.name);
 		}
 	}
@@ -1821,7 +2071,6 @@ function createRouteRecordMatcher(record, parent, options) {
 	}
 	return matcher;
 }
-
 //#endregion
 //#region src/matcher/index.ts
 /**
@@ -1857,14 +2106,14 @@ function createRouterMatcher(routes, globalOptions) {
 		let originalMatcher;
 		for (const normalizedRecord of normalizedRecords) {
 			const { path } = normalizedRecord;
-			if (parent && path[0] !== "/") {
+			if (parent && !isAbsolutePath(path)) {
 				const parentPath = parent.record.path;
 				const connectingSlash = parentPath[parentPath.length - 1] === "/" ? "" : "/";
 				normalizedRecord.path = parent.record.path + (path && connectingSlash + path);
 			}
 			if (process.env.NODE_ENV !== "production" && normalizedRecord.path === "*") throw new Error("Catch all routes (\"*\") must now be defined using a param with a custom regexp.\nSee more at https://router.vuejs.org/guide/migration/#Removed-star-or-catch-all-routes.");
 			matcher = createRouteRecordMatcher(normalizedRecord, parent, options);
-			if (process.env.NODE_ENV !== "production" && parent && path[0] === "/") checkMissingParamsInAbsolutePath(matcher, parent);
+			if (process.env.NODE_ENV !== "production" && parent && isAbsolutePath(path)) checkMissingParamsInAbsolutePath(matcher, parent);
 			if (originalRecord) {
 				originalRecord.alias.push(matcher);
 				if (process.env.NODE_ENV !== "production") checkSameParams(originalRecord, matcher);
@@ -1914,37 +2163,46 @@ function createRouterMatcher(routes, globalOptions) {
 		matchers.splice(index, 0, matcher);
 		if (matcher.record.name && !isAliasRecord(matcher)) matcherMap.set(matcher.record.name, matcher);
 	}
-	function resolve(location$1, currentLocation) {
+	function resolve(location, currentLocation) {
 		let matcher;
 		let params = {};
 		let path;
 		let name;
-		if ("name" in location$1 && location$1.name) {
-			matcher = matcherMap.get(location$1.name);
-			if (!matcher) throw createRouterError(ErrorTypes.MATCHER_NOT_FOUND, { location: location$1 });
+		if ("name" in location && location.name) {
+			matcher = matcherMap.get(location.name);
+			if (!matcher) throw createRouterError(1, { location });
 			if (process.env.NODE_ENV !== "production") {
-				const invalidParams = Object.keys(location$1.params || {}).filter((paramName) => !matcher.keys.find((k) => k.name === paramName));
-				if (invalidParams.length) warn$1(`Discarded invalid param(s) "${invalidParams.join("\", \"")}" when navigating. See https://github.com/vuejs/router/blob/main/packages/router/CHANGELOG.md#414-2022-08-22 for more details.`);
+				const invalidParams = Object.keys(location.params || {}).filter((paramName) => !matcher.keys.find((k) => k.name === paramName));
+				if (invalidParams.length) {
+					const isInherited = !matcher.keys.length && invalidParams.some((name) => name in currentLocation.params);
+					diagnostics.VUE_ROUTER_R0100({
+						params: invalidParams.join("\", \""),
+						inherited: isInherited ? ` If you are using a catch-all route with a named redirect, pass an empty \`params\` object: \`redirect: { name: '...', params: {} }\`.` : ""
+					});
+				}
 			}
 			name = matcher.record.name;
-			params = assign(pickParams(currentLocation.params, matcher.keys.filter((k) => !k.optional).concat(matcher.parent ? matcher.parent.keys.filter((k) => k.optional) : []).map((k) => k.name)), location$1.params && pickParams(location$1.params, matcher.keys.map((k) => k.name)));
+			params = assign(pickParams(currentLocation.params, matcher.keys.filter((k) => !k.optional).concat(matcher.parent ? matcher.parent.keys.filter((k) => k.optional) : []).map((k) => k.name)), location.params && pickParams(location.params, matcher.keys.map((k) => k.name)));
 			path = matcher.stringify(params);
-		} else if (location$1.path != null) {
-			path = location$1.path;
-			if (process.env.NODE_ENV !== "production" && !path.startsWith("/")) warn$1(`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://github.com/vuejs/router/issues/new/choose.`);
+		} else if (location.path != null) {
+			path = location.path;
+			if (process.env.NODE_ENV !== "production" && !isAbsolutePath(path)) diagnostics.VUE_ROUTER_R0101({ path });
 			matcher = matchers.find((m) => m.re.test(path));
 			if (matcher) {
 				params = matcher.parse(path);
 				name = matcher.record.name;
+				matcher.keys.forEach((key) => {
+					if (key.optional && !params[key.name]) delete params[key.name];
+				});
 			}
 		} else {
 			matcher = currentLocation.name ? matcherMap.get(currentLocation.name) : matchers.find((m) => m.re.test(currentLocation.path));
-			if (!matcher) throw createRouterError(ErrorTypes.MATCHER_NOT_FOUND, {
-				location: location$1,
+			if (!matcher) throw createRouterError(1, {
+				location,
 				currentLocation
 			});
 			name = matcher.record.name;
-			params = assign({}, currentLocation.params, location$1.params);
+			params = assign({}, currentLocation.params, location.params);
 			path = matcher.stringify(params);
 		}
 		const matched = [];
@@ -2052,8 +2310,22 @@ function isSameParam(a, b) {
 * @param b - alias record
 */
 function checkSameParams(a, b) {
-	for (const key of a.keys) if (!key.optional && !b.keys.find(isSameParam.bind(null, key))) return warn$1(`Alias "${b.record.path}" and the original record: "${a.record.path}" must have the exact same param named "${key.name}"`);
-	for (const key of b.keys) if (!key.optional && !a.keys.find(isSameParam.bind(null, key))) return warn$1(`Alias "${b.record.path}" and the original record: "${a.record.path}" must have the exact same param named "${key.name}"`);
+	for (const key of a.keys) if (!key.optional && !b.keys.find(isSameParam.bind(null, key))) {
+		diagnostics.VUE_ROUTER_R0102({
+			alias: b.record.path,
+			original: a.record.path,
+			name: key.name
+		});
+		return;
+	}
+	for (const key of b.keys) if (!key.optional && !a.keys.find(isSameParam.bind(null, key))) {
+		diagnostics.VUE_ROUTER_R0102({
+			alias: b.record.path,
+			original: a.record.path,
+			name: key.name
+		});
+		return;
+	}
 }
 /**
 * A route with a name and a child with an empty path without a name should warn when adding the route
@@ -2062,13 +2334,20 @@ function checkSameParams(a, b) {
 * @param parent - RouteRecordMatcher
 */
 function checkChildMissingNameWithEmptyPath(mainNormalizedRecord, parent) {
-	if (parent && parent.record.name && !mainNormalizedRecord.name && !mainNormalizedRecord.path) warn$1(`The route named "${String(parent.record.name)}" has a child without a name and an empty path. Using that name won't render the empty path child so you probably want to move the name to the child instead. If this is intentional, add a name to the child route to remove the warning.`);
+	if (parent && parent.record.name && !mainNormalizedRecord.name && !mainNormalizedRecord.path && mainNormalizedRecord.children.length === 0) diagnostics.VUE_ROUTER_R0103({ name: String(parent.record.name) });
 }
 function checkSameNameAsAncestor(record, parent) {
 	for (let ancestor = parent; ancestor; ancestor = ancestor.parent) if (ancestor.record.name === record.name) throw new Error(`A route named "${String(record.name)}" has been added as a ${parent === ancestor ? "child" : "descendant"} of a route with the same name. Route names must be unique and a nested route cannot use the same name as an ancestor.`);
 }
 function checkMissingParamsInAbsolutePath(record, parent) {
-	for (const key of parent.keys) if (!record.keys.find(isSameParam.bind(null, key))) return warn$1(`Absolute path "${record.record.path}" must have the exact same param named "${key.name}" as its parent "${parent.record.path}".`);
+	for (const key of parent.keys) if (!record.keys.find(isSameParam.bind(null, key))) {
+		diagnostics.VUE_ROUTER_R0104({
+			path: record.record.path,
+			name: key.name,
+			parent: parent.record.path
+		});
+		return;
+	}
 }
 /**
 * Performs a binary search to find the correct insertion index for a new matcher.
@@ -2090,7 +2369,10 @@ function findInsertionIndex(matcher, matchers) {
 	const insertionAncestor = getInsertionAncestor(matcher);
 	if (insertionAncestor) {
 		upper = matchers.lastIndexOf(insertionAncestor, upper - 1);
-		if (process.env.NODE_ENV !== "production" && upper < 0) warn$1(`Finding ancestor route "${insertionAncestor.record.path}" failed for "${matcher.record.path}"`);
+		if (process.env.NODE_ENV !== "production" && upper < 0) diagnostics.VUE_ROUTER_R0105({
+			ancestor: insertionAncestor.record.path,
+			record: matcher.record.path
+		});
 	}
 	return upper;
 }
@@ -2108,7 +2390,6 @@ function getInsertionAncestor(matcher) {
 function isMatchable({ record }) {
 	return !!(record.name || record.components && Object.keys(record.components).length || record.redirect);
 }
-
 //#endregion
 //#region src/RouterLink.ts
 /**
@@ -2124,8 +2405,7 @@ function useLink(props) {
 	const route = computed(() => {
 		const to = unref(props.to);
 		if (process.env.NODE_ENV !== "production" && (!hasPrevious || to !== previousTo)) {
-			if (!isRouteLocation(to)) if (hasPrevious) warn$1(`Invalid value for prop "to" in useLink()\n- to:`, to, `\n- previous to:`, previousTo, `\n- props:`, props);
-			else warn$1(`Invalid value for prop "to" in useLink()\n- to:`, to, `\n- props:`, props);
+			if (!isRouteLocation(to)) diagnostics.VUE_ROUTER_R0050({ to });
 			previousTo = to;
 			hasPrevious = true;
 		}
@@ -2185,7 +2465,10 @@ function useLink(props) {
 function preferSingleVNode(vnodes) {
 	return vnodes.length === 1 ? vnodes[0] : vnodes;
 }
-const RouterLinkImpl = /* @__PURE__ */ defineComponent({
+/**
+* Component to render a link that triggers a navigation on click.
+*/
+const RouterLink = /* @__PURE__ */ defineComponent({
 	name: "RouterLink",
 	compatConfig: { MODE: 3 },
 	props: {
@@ -2222,10 +2505,6 @@ const RouterLinkImpl = /* @__PURE__ */ defineComponent({
 		};
 	}
 });
-/**
-* Component to render a link that triggers a navigation on click.
-*/
-const RouterLink = RouterLinkImpl;
 function guardEvent(e) {
 	if (e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return;
 	if (e.defaultPrevented) return;
@@ -2241,9 +2520,9 @@ function includesParams(outer, inner) {
 	for (const key in inner) {
 		const innerValue = inner[key];
 		const outerValue = outer[key];
-		if (typeof innerValue === "string") {
-			if (innerValue !== outerValue) return false;
-		} else if (!isArray(outerValue) || outerValue.length !== innerValue.length || innerValue.some((value, i) => value.valueOf() !== outerValue[i].valueOf())) return false;
+		if (isArray(innerValue)) {
+			if (!isArray(outerValue) || outerValue.length !== innerValue.length || innerValue.some((value, i) => value.valueOf() !== outerValue[i].valueOf())) return false;
+		} else if (innerValue !== outerValue) return false;
 	}
 	return true;
 }
@@ -2261,10 +2540,9 @@ function getOriginalPath(record) {
 * @param defaultClass
 */
 const getLinkClass = (propClass, globalClass, defaultClass) => propClass != null ? propClass : globalClass != null ? globalClass : defaultClass;
-
 //#endregion
 //#region src/RouterView.ts
-const RouterViewImpl = /* @__PURE__ */ defineComponent({
+const RouterViewImpl = /*#__PURE__*/ defineComponent({
 	name: "RouterView",
 	inheritAttrs: false,
 	props: {
@@ -2296,7 +2574,7 @@ const RouterViewImpl = /* @__PURE__ */ defineComponent({
 			viewRef.value,
 			matchedRouteRef.value,
 			props.name
-		], ([instance, to, name], [oldInstance, from, oldName]) => {
+		], ([instance, to, name], [oldInstance, from, _oldName]) => {
 			if (to) {
 				to.instances[name] = instance;
 				if (from && from !== to && instance && instance === oldInstance) {
@@ -2332,7 +2610,7 @@ const RouterViewImpl = /* @__PURE__ */ defineComponent({
 					meta: matchedRoute.meta
 				};
 				(isArray(component.ref) ? component.ref.map((r) => r.i) : [component.ref.i]).forEach((instance) => {
-					instance.__vrv_devtools = info;
+					if (instance) instance.__vrv_devtools = info;
 				});
 			}
 			return normalizeSlot(slots.default, {
@@ -2357,14 +2635,9 @@ function warnDeprecatedUsage() {
 	const parentSubTreeType = instance.parent && instance.parent.subTree && instance.parent.subTree.type;
 	if (parentName && (parentName === "KeepAlive" || parentName.includes("Transition")) && typeof parentSubTreeType === "object" && parentSubTreeType.name === "RouterView") {
 		const comp = parentName === "KeepAlive" ? "keep-alive" : "transition";
-		warn$1(`<router-view> can no longer be used directly inside <transition> or <keep-alive>.
-Use slot props instead:
-
-<router-view v-slot="{ Component }">
-  <${comp}>\n    <component :is="Component" />\n  </${comp}>\n</router-view>`);
+		diagnostics.VUE_ROUTER_R0060({ comp });
 	}
 }
-
 //#endregion
 //#region src/router.ts
 /**
@@ -2382,6 +2655,7 @@ function createRouter(options) {
 	const beforeResolveGuards = useCallbacks();
 	const afterGuards = useCallbacks();
 	const currentRoute = shallowRef(START_LOCATION_NORMALIZED);
+	const routesVersion = shallowRef(0);
 	let pendingLocation = START_LOCATION_NORMALIZED;
 	if (isBrowser && options.scrollBehavior && "scrollRestoration" in history) history.scrollRestoration = "manual";
 	const normalizeParams = applyToParams.bind(null, (paramValue) => "" + paramValue);
@@ -2392,15 +2666,26 @@ function createRouter(options) {
 		let record;
 		if (isRouteName(parentOrRoute)) {
 			parent = matcher.getRecordMatcher(parentOrRoute);
-			if (process.env.NODE_ENV !== "production" && !parent) warn$1(`Parent route "${String(parentOrRoute)}" not found when adding child route`, route);
+			if (process.env.NODE_ENV !== "production" && !parent) diagnostics.VUE_ROUTER_R0001({ name: String(parentOrRoute) });
 			record = route;
 		} else record = parentOrRoute;
-		return matcher.addRoute(record, parent);
+		const removeRoute = matcher.addRoute(record, parent);
+		routesVersion.value++;
+		return () => {
+			removeRoute();
+			routesVersion.value++;
+		};
 	}
 	function removeRoute(name) {
 		const recordMatcher = matcher.getRecordMatcher(name);
-		if (recordMatcher) matcher.removeRoute(recordMatcher);
-		else if (process.env.NODE_ENV !== "production") warn$1(`Cannot remove non-existent route "${String(name)}"`);
+		if (recordMatcher) {
+			matcher.removeRoute(recordMatcher);
+			routesVersion.value++;
+		} else if (process.env.NODE_ENV !== "production") diagnostics.VUE_ROUTER_R0002({ name: String(name) });
+	}
+	function clearRoutes() {
+		matcher.clearRoutes();
+		routesVersion.value++;
 	}
 	function getRoutes() {
 		return matcher.getRoutes().map((routeMatcher) => routeMatcher.record);
@@ -2409,29 +2694,33 @@ function createRouter(options) {
 		return !!matcher.getRecordMatcher(name);
 	}
 	function resolve(rawLocation, currentLocation) {
-		currentLocation = assign({}, currentLocation || currentRoute.value);
+		routesVersion.value;
 		if (typeof rawLocation === "string") {
+			currentLocation = currentLocation || (rawLocation.startsWith("/") ? START_LOCATION_NORMALIZED : currentRoute.value);
 			const locationNormalized = parseURL(parseQuery$1, rawLocation, currentLocation.path);
-			const matchedRoute$1 = matcher.resolve({ path: locationNormalized.path }, currentLocation);
-			const href$1 = routerHistory.createHref(locationNormalized.fullPath);
+			const matchedRoute = matcher.resolve({ path: locationNormalized.path }, currentLocation);
+			const href = routerHistory.createHref(locationNormalized.fullPath);
 			if (process.env.NODE_ENV !== "production") {
-				if (href$1.startsWith("//")) warn$1(`Location "${rawLocation}" resolved to "${href$1}". A resolved location cannot start with multiple slashes.`);
-				else if (!matchedRoute$1.matched.length) warn$1(`No match found for location with path "${rawLocation}"`);
+				if (href.startsWith("//")) diagnostics.VUE_ROUTER_R0003({
+					location: rawLocation,
+					href
+				});
+				else if (!matchedRoute.matched.length) diagnostics.VUE_ROUTER_R0004({ path: rawLocation });
 			}
-			return assign(locationNormalized, matchedRoute$1, {
-				params: decodeParams(matchedRoute$1.params),
-				hash: decode(locationNormalized.hash),
+			return assign(locationNormalized, matchedRoute, {
+				params: decodeParams(matchedRoute.params),
 				redirectedFrom: void 0,
-				href: href$1
+				href
 			});
 		}
 		if (process.env.NODE_ENV !== "production" && !isRouteLocation(rawLocation)) {
-			warn$1(`router.resolve() was passed an invalid location. This will fail in production.\n- Location:`, rawLocation);
+			diagnostics.VUE_ROUTER_R0005({ rawLocation });
 			return resolve({});
 		}
+		currentLocation = assign({}, currentLocation || (rawLocation.path != null && rawLocation.path.startsWith("/") && !("name" in rawLocation && rawLocation.name) ? START_LOCATION_NORMALIZED : currentRoute.value));
 		let matcherLocation;
 		if (rawLocation.path != null) {
-			if (process.env.NODE_ENV !== "production" && "params" in rawLocation && !("name" in rawLocation) && Object.keys(rawLocation.params).length) warn$1(`Path "${rawLocation.path}" was passed with params but they will be ignored. Use a named route alongside params instead.`);
+			if (process.env.NODE_ENV !== "production" && "params" in rawLocation && !("name" in rawLocation) && Object.keys(rawLocation.params).length) diagnostics.VUE_ROUTER_R0006({ path: rawLocation.path });
 			matcherLocation = assign({}, rawLocation, { path: parseURL(parseQuery$1, rawLocation.path, currentLocation.path).path });
 		} else {
 			const targetParams = assign({}, rawLocation.params);
@@ -2441,7 +2730,7 @@ function createRouter(options) {
 		}
 		const matchedRoute = matcher.resolve(matcherLocation, currentLocation);
 		const hash = rawLocation.hash || "";
-		if (process.env.NODE_ENV !== "production" && hash && !hash.startsWith("#")) warn$1(`A \`hash\` should always start with the character "#". Replace "${hash}" with "#${hash}".`);
+		if (process.env.NODE_ENV !== "production" && hash && !hash.startsWith("#")) diagnostics.VUE_ROUTER_R0007({ hash });
 		matchedRoute.params = normalizeParams(decodeParams(matchedRoute.params));
 		const fullPath = stringifyURL(stringifyQuery$1, assign({}, rawLocation, {
 			hash: encodeHash(hash),
@@ -2449,8 +2738,11 @@ function createRouter(options) {
 		}));
 		const href = routerHistory.createHref(fullPath);
 		if (process.env.NODE_ENV !== "production") {
-			if (href.startsWith("//")) warn$1(`Location "${rawLocation}" resolved to "${href}". A resolved location cannot start with multiple slashes.`);
-			else if (!matchedRoute.matched.length) warn$1(`No match found for location with path "${rawLocation.path != null ? rawLocation.path : rawLocation}"`);
+			if (href.startsWith("//")) diagnostics.VUE_ROUTER_R0003({
+				location: rawLocation,
+				href
+			});
+			else if (!matchedRoute.matched.length) diagnostics.VUE_ROUTER_R0004({ path: rawLocation.path != null ? rawLocation.path : rawLocation });
 		}
 		return assign({
 			fullPath,
@@ -2465,7 +2757,7 @@ function createRouter(options) {
 		return typeof to === "string" ? parseURL(parseQuery$1, to, currentRoute.value.path) : assign({}, to);
 	}
 	function checkCanceledNavigation(to, from) {
-		if (pendingLocation !== to) return createRouterError(ErrorTypes.NAVIGATION_CANCELLED, {
+		if (pendingLocation !== to) return createRouterError(8, {
 			from,
 			to
 		});
@@ -2486,7 +2778,10 @@ function createRouter(options) {
 				newTargetLocation.params = {};
 			}
 			if (process.env.NODE_ENV !== "production" && newTargetLocation.path == null && !("name" in newTargetLocation)) {
-				warn$1(`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.`);
+				diagnostics.VUE_ROUTER_R0008({
+					target: JSON.stringify(newTargetLocation, null, 2),
+					to: to.fullPath
+				});
 				throw new Error("Invalid redirect");
 			}
 			return assign({
@@ -2501,38 +2796,41 @@ function createRouter(options) {
 		const from = currentRoute.value;
 		const data = to.state;
 		const force = to.force;
-		const replace$1 = to.replace === true;
+		const replace = to.replace === true;
 		const shouldRedirect = handleRedirectRecord(targetLocation, from);
 		if (shouldRedirect) return pushWithRedirect(assign(locationAsObject(shouldRedirect), {
 			state: typeof shouldRedirect === "object" ? assign({}, data, shouldRedirect.state) : data,
 			force,
-			replace: replace$1
+			replace
 		}), redirectedFrom || targetLocation);
 		const toLocation = targetLocation;
 		toLocation.redirectedFrom = redirectedFrom;
 		let failure;
 		if (!force && isSameRouteLocation(stringifyQuery$1, from, targetLocation)) {
-			failure = createRouterError(ErrorTypes.NAVIGATION_DUPLICATED, {
+			failure = createRouterError(16, {
 				to: toLocation,
 				from
 			});
 			handleScroll(from, from, true, false);
 		}
-		return (failure ? Promise.resolve(failure) : navigate(toLocation, from)).catch((error) => isNavigationFailure(error) ? isNavigationFailure(error, ErrorTypes.NAVIGATION_GUARD_REDIRECT) ? error : markAsReady(error) : triggerError(error, toLocation, from)).then((failure$1) => {
-			if (failure$1) {
-				if (isNavigationFailure(failure$1, ErrorTypes.NAVIGATION_GUARD_REDIRECT)) {
-					if (process.env.NODE_ENV !== "production" && isSameRouteLocation(stringifyQuery$1, resolve(failure$1.to), toLocation) && redirectedFrom && (redirectedFrom._count = redirectedFrom._count ? redirectedFrom._count + 1 : 1) > 30) {
-						warn$1(`Detected a possibly infinite redirection in a navigation guard when going from "${from.fullPath}" to "${toLocation.fullPath}". Aborting to avoid a Stack Overflow.\n Are you always returning a new location within a navigation guard? That would lead to this error. Only return when redirecting or aborting, that should fix this. This might break in production if not fixed.`);
+		return (failure ? Promise.resolve(failure) : navigate(toLocation, from)).catch((error) => isNavigationFailure(error) ? isNavigationFailure(error, 2) ? error : markAsReady(error) : triggerError(error, toLocation, from)).then((failure) => {
+			if (failure) {
+				if (isNavigationFailure(failure, 2)) {
+					if (process.env.NODE_ENV !== "production" && isSameRouteLocation(stringifyQuery$1, resolve(failure.to), toLocation) && redirectedFrom && (redirectedFrom._count = redirectedFrom._count ? redirectedFrom._count + 1 : 1) > 30) {
+						diagnostics.VUE_ROUTER_R0009({
+							from: from.fullPath,
+							to: toLocation.fullPath
+						});
 						return Promise.reject(/* @__PURE__ */ new Error("Infinite redirect in navigation guard"));
 					}
-					return pushWithRedirect(assign({ replace: replace$1 }, locationAsObject(failure$1.to), {
-						state: typeof failure$1.to === "object" ? assign({}, data, failure$1.to.state) : data,
+					return pushWithRedirect(assign({ replace }, locationAsObject(failure.to), {
+						state: typeof failure.to === "object" ? assign({}, data, failure.to.state) : data,
 						force
 					}), redirectedFrom || toLocation);
 				}
-			} else failure$1 = finalizeNavigation(toLocation, from, true, replace$1, data);
-			triggerAfterEach(toLocation, from, failure$1);
-			return failure$1;
+			} else failure = finalizeNavigation(toLocation, from, true, replace, data);
+			triggerAfterEach(toLocation, from, failure);
+			return failure;
 		});
 	}
 	/**
@@ -2571,8 +2869,10 @@ function createRouter(options) {
 			return runGuardQueue(guards);
 		}).then(() => {
 			guards = [];
-			for (const record of enteringRecords) if (record.beforeEnter) if (isArray(record.beforeEnter)) for (const beforeEnter of record.beforeEnter) guards.push(guardToPromiseFn(beforeEnter, to, from));
-			else guards.push(guardToPromiseFn(record.beforeEnter, to, from));
+			for (const record of enteringRecords) if (record.beforeEnter) {
+				if (isArray(record.beforeEnter)) for (const beforeEnter of record.beforeEnter) guards.push(guardToPromiseFn(beforeEnter, to, from));
+				else guards.push(guardToPromiseFn(record.beforeEnter, to, from));
+			}
 			guards.push(canceledNavigationCheck);
 			return runGuardQueue(guards);
 		}).then(() => {
@@ -2585,7 +2885,7 @@ function createRouter(options) {
 			for (const guard of beforeResolveGuards.list()) guards.push(guardToPromiseFn(guard, to, from));
 			guards.push(canceledNavigationCheck);
 			return runGuardQueue(guards);
-		}).catch((err) => isNavigationFailure(err, ErrorTypes.NAVIGATION_CANCELLED) ? err : Promise.reject(err));
+		}).catch((err) => isNavigationFailure(err, 8) ? err : Promise.reject(err));
 	}
 	function triggerAfterEach(to, from, failure) {
 		afterGuards.list().forEach((guard) => runWithContext(() => guard(to, from, failure)));
@@ -2595,13 +2895,15 @@ function createRouter(options) {
 	* - Changes the url if necessary
 	* - Calls the scrollBehavior
 	*/
-	function finalizeNavigation(toLocation, from, isPush, replace$1, data) {
+	function finalizeNavigation(toLocation, from, isPush, replace, data) {
 		const error = checkCanceledNavigation(toLocation, from);
 		if (error) return error;
 		const isFirstNavigation = from === START_LOCATION_NORMALIZED;
 		const state = !isBrowser ? {} : history.state;
-		if (isPush) if (replace$1 || isFirstNavigation) routerHistory.replace(toLocation.fullPath, assign({ scroll: isFirstNavigation && state && state.scroll }, data));
-		else routerHistory.push(toLocation.fullPath, data);
+		if (isPush) {
+			if (replace || isFirstNavigation) routerHistory.replace(toLocation.fullPath, assign({ scroll: isFirstNavigation && state && state.scroll }, data));
+			else routerHistory.push(toLocation.fullPath, data);
+		}
 		currentRoute.value = toLocation;
 		handleScroll(toLocation, from, isPush, isFirstNavigation);
 		markAsReady();
@@ -2622,12 +2924,12 @@ function createRouter(options) {
 			}
 			pendingLocation = toLocation;
 			const from = currentRoute.value;
-			if (isBrowser) saveScrollPosition(getScrollKey(from.fullPath, info.delta), computeScrollPosition());
+			if (isBrowser && info.delta) saveScrollPosition(getScrollKey(from.fullPath, info.delta));
 			navigate(toLocation, from).catch((error) => {
-				if (isNavigationFailure(error, ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_CANCELLED)) return error;
-				if (isNavigationFailure(error, ErrorTypes.NAVIGATION_GUARD_REDIRECT)) {
+				if (isNavigationFailure(error, 12)) return error;
+				if (isNavigationFailure(error, 2)) {
 					pushWithRedirect(assign(locationAsObject(error.to), { force: true }), toLocation).then((failure) => {
-						if (isNavigationFailure(failure, ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_DUPLICATED) && !info.delta && info.type === NavigationType.pop) routerHistory.go(-1, false);
+						if (isNavigationFailure(failure, 20) && !info.delta && info.type === "pop") routerHistory.go(-1, false);
 					}).catch(noop);
 					return Promise.reject();
 				}
@@ -2636,8 +2938,8 @@ function createRouter(options) {
 			}).then((failure) => {
 				failure = failure || finalizeNavigation(toLocation, from, false);
 				if (failure) {
-					if (info.delta && !isNavigationFailure(failure, ErrorTypes.NAVIGATION_CANCELLED)) routerHistory.go(-info.delta, false);
-					else if (info.type === NavigationType.pop && isNavigationFailure(failure, ErrorTypes.NAVIGATION_ABORTED | ErrorTypes.NAVIGATION_DUPLICATED)) routerHistory.go(-1, false);
+					if (info.delta && !isNavigationFailure(failure, 8)) routerHistory.go(-info.delta, false);
+					else if (info.type === "pop" && isNavigationFailure(failure, 20)) routerHistory.go(-1, false);
 				}
 				triggerAfterEach(toLocation, from, failure);
 			}).catch(noop);
@@ -2659,22 +2961,22 @@ function createRouter(options) {
 		const list = errorListeners.list();
 		if (list.length) list.forEach((handler) => handler(error, to, from));
 		else {
-			if (process.env.NODE_ENV !== "production") warn$1("uncaught error during route navigation:");
+			if (process.env.NODE_ENV !== "production") diagnostics.VUE_ROUTER_R0010();
 			console.error(error);
 		}
 		return Promise.reject(error);
 	}
 	function isReady() {
 		if (ready && currentRoute.value !== START_LOCATION_NORMALIZED) return Promise.resolve();
-		return new Promise((resolve$1, reject) => {
-			readyHandlers.add([resolve$1, reject]);
+		return new Promise((resolve, reject) => {
+			readyHandlers.add([resolve, reject]);
 		});
 	}
 	function markAsReady(err) {
 		if (!ready) {
 			ready = !err;
 			setupListeners();
-			readyHandlers.list().forEach(([resolve$1, reject]) => err ? reject(err) : resolve$1());
+			readyHandlers.list().forEach(([resolve, reject]) => err ? reject(err) : resolve());
 			readyHandlers.reset();
 		}
 		return err;
@@ -2683,7 +2985,7 @@ function createRouter(options) {
 		const { scrollBehavior } = options;
 		if (!isBrowser || !scrollBehavior) return Promise.resolve();
 		const scrollPosition = !isPush && getSavedScrollPosition(getScrollKey(to.fullPath, 0)) || (isFirstNavigation || !isPush) && history.state && history.state.scroll || null;
-		return nextTick().then(() => scrollBehavior(to, from, scrollPosition)).then((position) => position && scrollToPosition(position)).catch((err) => triggerError(err, to, from));
+		return nextTick().then(() => scrollBehavior(to, from, scrollPosition)).then((position) => to === currentRoute.value && position && scrollToPosition(position)).catch((err) => to === currentRoute.value && triggerError(err, to, from));
 	}
 	const go = (delta) => routerHistory.go(delta);
 	let started;
@@ -2693,7 +2995,7 @@ function createRouter(options) {
 		listening: true,
 		addRoute,
 		removeRoute,
-		clearRoutes: matcher.clearRoutes,
+		clearRoutes,
 		hasRoute,
 		getRoutes,
 		resolve,
@@ -2719,7 +3021,7 @@ function createRouter(options) {
 			if (isBrowser && !started && currentRoute.value === START_LOCATION_NORMALIZED) {
 				started = true;
 				push(routerHistory.location).catch((err) => {
-					if (process.env.NODE_ENV !== "production") warn$1("Unexpected error when starting the router:", err);
+					if (process.env.NODE_ENV !== "production") diagnostics.VUE_ROUTER_R0011({ cause: err });
 				});
 			}
 			const reactiveRoute = {};
@@ -2744,7 +3046,7 @@ function createRouter(options) {
 				}
 				unmountApp();
 			};
-			if ((process.env.NODE_ENV !== "production" || __VUE_PROD_DEVTOOLS__) && isBrowser) addDevtools(app, router, matcher);
+			if ((process.env.NODE_ENV !== "production" || __VUE_PROD_DEVTOOLS__) && isBrowser && true) addDevtools(app, router, matcher);
 		}
 	};
 	function runGuardQueue(guards) {
@@ -2753,21 +3055,4 @@ function createRouter(options) {
 	return router;
 }
 
-//#endregion
-//#region src/useApi.ts
-/**
-* Returns the router instance. Equivalent to using `$router` inside
-* templates.
-*/
-function useRouter() {
-	return inject(routerKey);
-}
-/**
-* Returns the current route location. Equivalent to using `$route` inside
-* templates.
-*/
-function useRoute(_name) {
-	return inject(routeLocationKey);
-}
-
 export { NavigationFailureType, RouterLink, RouterView, START_LOCATION_NORMALIZED as START_LOCATION, createMemoryHistory, createRouter, createRouterMatcher, createWebHashHistory, createWebHistory, isNavigationFailure, loadRouteLocation, matchedRouteKey, onBeforeRouteLeave, onBeforeRouteUpdate, parseQuery, routeLocationKey, routerKey, routerViewLocationKey, stringifyQuery, useLink, useRoute, useRouter, viewDepthKey };