wevu 6.7.2 → 6.7.4

package/dist/router.mjs

@@ -0,0 +1,1412 @@
+import { d as reactive } from "./ref-BeA_Is-2.mjs";
+import { L as readonly, S as onShow, j as getCurrentSetupContext, l as onLoad, n as useNativeRouter$1, t as useNativePageRouter$1, v as onRouteDone } from "./router-5qgy8oOS.mjs";
+//#region src/routerInternal/path.ts
+function normalizePathSegments(path) {
+	const segments = [];
+	for (const segment of path.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (segments.length > 0) segments.pop();
+			continue;
+		}
+		segments.push(segment);
+	}
+	return segments;
+}
+function resolvePath(path, currentPath) {
+	if (!path) return normalizePathSegments(currentPath).join("/");
+	if (path.startsWith("/")) return normalizePathSegments(path).join("/");
+	if (path.startsWith("./") || path.startsWith("../")) {
+		const baseSegments = normalizePathSegments(currentPath);
+		if (baseSegments.length > 0) baseSegments.pop();
+		for (const segment of path.split("/")) {
+			if (!segment || segment === ".") continue;
+			if (segment === "..") {
+				if (baseSegments.length > 0) baseSegments.pop();
+				continue;
+			}
+			baseSegments.push(segment);
+		}
+		return baseSegments.join("/");
+	}
+	return normalizePathSegments(path).join("/");
+}
+function createAbsoluteRoutePath(path) {
+	return path ? `/${path}` : "/";
+}
+function isDynamicRoutePath(path) {
+	return /(?:^|\/):/.test(path);
+}
+//#endregion
+//#region src/routerInternal/query.ts
+function decodeQuerySegment(value) {
+	return decodeURIComponent(value.replace(/\+/g, " "));
+}
+function encodeQuerySegment(value) {
+	return encodeURIComponent(value);
+}
+function pushQueryValue(target, key, value) {
+	const previous = target[key];
+	if (previous === void 0) {
+		target[key] = value;
+		return;
+	}
+	if (Array.isArray(previous)) {
+		previous.push(value);
+		return;
+	}
+	target[key] = [previous, value];
+}
+function pushRouteParamValue(target, key, value) {
+	const previous = target[key];
+	if (previous === void 0) {
+		target[key] = value;
+		return;
+	}
+	if (Array.isArray(previous)) {
+		previous.push(value);
+		return;
+	}
+	target[key] = [previous, value];
+}
+function normalizeQueryValue(value) {
+	if (value === void 0) return;
+	if (value === null) return null;
+	return String(value);
+}
+function normalizeQuery(query) {
+	const normalized = {};
+	for (const key of Object.keys(query)) {
+		const rawValue = query[key];
+		if (Array.isArray(rawValue)) {
+			for (const item of rawValue) {
+				const next = normalizeQueryValue(item);
+				if (next !== void 0) pushQueryValue(normalized, key, next);
+			}
+			continue;
+		}
+		const next = normalizeQueryValue(rawValue);
+		if (next !== void 0) pushQueryValue(normalized, key, next);
+	}
+	return normalized;
+}
+function normalizeRouteParamValue(value) {
+	if (value === void 0 || value === null) return;
+	return String(value);
+}
+function normalizeRouteParams(params) {
+	const normalized = {};
+	for (const key of Object.keys(params)) {
+		const rawValue = params[key];
+		if (Array.isArray(rawValue)) {
+			for (const item of rawValue) {
+				const next = normalizeRouteParamValue(item);
+				if (next !== void 0) pushRouteParamValue(normalized, key, next);
+			}
+			continue;
+		}
+		const next = normalizeRouteParamValue(rawValue);
+		if (next !== void 0) pushRouteParamValue(normalized, key, next);
+	}
+	return normalized;
+}
+function normalizeHash(rawHash) {
+	if (!rawHash) return "";
+	return rawHash.startsWith("#") ? rawHash : `#${rawHash}`;
+}
+function parseQuery(search) {
+	const normalizedSearch = search.startsWith("?") ? search.slice(1) : search;
+	const query = {};
+	if (!normalizedSearch) return query;
+	for (const segment of normalizedSearch.split("&")) {
+		if (!segment) continue;
+		const equalIndex = segment.indexOf("=");
+		const rawKey = equalIndex >= 0 ? segment.slice(0, equalIndex) : segment;
+		if (!rawKey) continue;
+		pushQueryValue(query, decodeQuerySegment(rawKey), equalIndex >= 0 ? decodeQuerySegment(segment.slice(equalIndex + 1)) : null);
+	}
+	return query;
+}
+function stringifyQuery(query = {}) {
+	const normalizedQuery = normalizeQuery(query);
+	const segments = [];
+	for (const key of Object.keys(normalizedQuery)) {
+		const encodedKey = encodeQuerySegment(key);
+		const rawValue = normalizedQuery[key];
+		if (Array.isArray(rawValue)) {
+			for (const item of rawValue) if (item === null) segments.push(encodedKey);
+			else segments.push(`${encodedKey}=${encodeQuerySegment(item)}`);
+			continue;
+		}
+		if (rawValue === null) {
+			segments.push(encodedKey);
+			continue;
+		}
+		segments.push(`${encodedKey}=${encodeQuerySegment(rawValue)}`);
+	}
+	return segments.join("&");
+}
+//#endregion
+//#region src/routerInternal/location.ts
+const DEFAULT_ROUTE_RESOLVE_CODEC$1 = {
+	parseQuery,
+	stringifyQuery
+};
+function parsePathInput(input, codec = DEFAULT_ROUTE_RESOLVE_CODEC$1) {
+	const hashIndex = input.indexOf("#");
+	const withoutHash = hashIndex >= 0 ? input.slice(0, hashIndex) : input;
+	const hash = hashIndex >= 0 ? normalizeHash(input.slice(hashIndex + 1)) : "";
+	const queryIndex = withoutHash.indexOf("?");
+	if (queryIndex < 0) return {
+		path: withoutHash,
+		query: {},
+		hash
+	};
+	return {
+		path: withoutHash.slice(0, queryIndex),
+		query: normalizeQuery(codec.parseQuery(withoutHash.slice(queryIndex + 1))),
+		hash
+	};
+}
+function createRouteLocation(path, query, hash = "", name, params = {}, queryStringifier = stringifyQuery) {
+	const normalizedPath = resolvePath(path, "");
+	const queryString = queryStringifier(query);
+	const fullPathBase = createAbsoluteRoutePath(normalizedPath);
+	const normalizedHash = normalizeHash(hash);
+	const fullPath = queryString ? `${fullPathBase}?${queryString}` : fullPathBase;
+	const location = {
+		path: normalizedPath,
+		fullPath: normalizedHash ? `${fullPath}${normalizedHash}` : fullPath,
+		query,
+		hash: normalizedHash,
+		params
+	};
+	if (name !== void 0) location.name = name;
+	return location;
+}
+function getCurrentMiniProgramPage() {
+	const getCurrentPagesFn = globalThis.getCurrentPages;
+	if (typeof getCurrentPagesFn !== "function") return;
+	try {
+		const pages = getCurrentPagesFn();
+		if (!Array.isArray(pages) || pages.length === 0) return;
+		return pages[pages.length - 1];
+	} catch (_unused) {
+		return;
+	}
+}
+function resolveCurrentRoute(queryOverride) {
+	var _currentPage$options;
+	const currentPage = getCurrentMiniProgramPage();
+	if (!currentPage) return createRouteLocation("", {});
+	return createRouteLocation(typeof currentPage.route === "string" ? currentPage.route : typeof currentPage.__route__ === "string" ? currentPage.__route__ : "", normalizeQuery(queryOverride !== null && queryOverride !== void 0 ? queryOverride : (_currentPage$options = currentPage.options) !== null && _currentPage$options !== void 0 ? _currentPage$options : {}), "", void 0, {});
+}
+//#endregion
+//#region src/routerInternal/params.ts
+function parsePathParamToken(segment) {
+	var _match$;
+	const match = /^:(\w+)(?:\([^)]*\))?([+*?])?$/.exec(segment);
+	if (!match) return;
+	return {
+		key: match[1],
+		modifier: (_match$ = match[2]) !== null && _match$ !== void 0 ? _match$ : ""
+	};
+}
+function normalizePathParamValues(value) {
+	if (value === void 0) return [];
+	if (Array.isArray(value)) return value;
+	return [value];
+}
+function stringifyPathParamSegment(value) {
+	return encodeURIComponent(value);
+}
+function decodeRouteParamSegment(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch (_unused) {
+		return value;
+	}
+}
+function resolveNamedRoutePath(pathTemplate, params, routeName) {
+	const resolvedSegments = [];
+	const consumedKeys = /* @__PURE__ */ new Set();
+	for (const rawSegment of pathTemplate.split("/")) {
+		if (!rawSegment) continue;
+		const token = parsePathParamToken(rawSegment);
+		if (!token) {
+			resolvedSegments.push(rawSegment);
+			continue;
+		}
+		const values = normalizePathParamValues(params[token.key]);
+		if (token.modifier === "") {
+			if (values.length !== 1) throw new Error(`Missing required param "${token.key}" for named route "${routeName}"`);
+			consumedKeys.add(token.key);
+			resolvedSegments.push(stringifyPathParamSegment(values[0]));
+			continue;
+		}
+		if (token.modifier === "?") {
+			if (values.length === 0) continue;
+			if (values.length > 1) throw new Error(`Param "${token.key}" for named route "${routeName}" must be a single value`);
+			consumedKeys.add(token.key);
+			resolvedSegments.push(stringifyPathParamSegment(values[0]));
+			continue;
+		}
+		if (token.modifier === "+") {
+			if (values.length === 0) throw new Error(`Missing required repeatable param "${token.key}" for named route "${routeName}"`);
+			consumedKeys.add(token.key);
+			for (const value of values) resolvedSegments.push(stringifyPathParamSegment(value));
+			continue;
+		}
+		if (values.length > 0) consumedKeys.add(token.key);
+		for (const value of values) resolvedSegments.push(stringifyPathParamSegment(value));
+	}
+	return {
+		path: resolvedSegments.join("/"),
+		consumedKeys
+	};
+}
+function hasNonEmptyRouteParamValue(value) {
+	if (value === void 0) return false;
+	if (Array.isArray(value)) return value.length > 0;
+	return true;
+}
+function assertNoUnexpectedNamedRouteParams(params, consumedKeys, routeName) {
+	const unexpectedKeys = Object.keys(params).filter((key) => !consumedKeys.has(key)).filter((key) => hasNonEmptyRouteParamValue(params[key]));
+	if (unexpectedKeys.length === 0) return;
+	throw new Error(`Unexpected params for named route "${routeName}": ${unexpectedKeys.join(", ")}`);
+}
+function resolveNamedRouteLocation(to, lookup, paramsMode) {
+	const routeName = to.name;
+	if (typeof routeName !== "string" || !routeName) return to;
+	if (to.path !== void 0 || to.fullPath !== void 0) return to;
+	const routeRecord = lookup.recordByName.get(routeName);
+	if (!routeRecord) throw new Error(`Named route "${routeName}" is not defined in useRouter({ routes | namedRoutes })`);
+	const params = to.params ? normalizeRouteParams(to.params) : {};
+	const resolvedResult = resolveNamedRoutePath(routeRecord.path, params, routeName);
+	if (paramsMode === "strict") assertNoUnexpectedNamedRouteParams(params, resolvedResult.consumedKeys, routeName);
+	return {
+		...to,
+		path: resolvedResult.path ? `/${resolvedResult.path}` : "/",
+		params
+	};
+}
+//#endregion
+//#region src/routerInternal/matching.ts
+function splitRoutePathSegments(path) {
+	return path.split("/").filter(Boolean);
+}
+function listRouteRecordMatchPaths(record) {
+	return [record.path, ...record.aliasPaths];
+}
+function resolveMatchedRouteRecordChain(record, lookup) {
+	const matchedRecords = [];
+	const visitedNames = /* @__PURE__ */ new Set();
+	let currentRecord = record;
+	while (currentRecord) {
+		if (visitedNames.has(currentRecord.name)) break;
+		visitedNames.add(currentRecord.name);
+		matchedRecords.unshift(currentRecord);
+		if (!currentRecord.parentName) break;
+		currentRecord = lookup.recordByName.get(currentRecord.parentName);
+	}
+	return matchedRecords;
+}
+function mergeMatchedRouteMeta(matchedRecords) {
+	let mergedRouteMeta;
+	for (const matchedRecord of matchedRecords) {
+		if (!matchedRecord.meta) continue;
+		if (!mergedRouteMeta) mergedRouteMeta = {};
+		Object.assign(mergedRouteMeta, matchedRecord.meta);
+	}
+	return mergedRouteMeta;
+}
+function collectRouteNamesForRemoval(routeName, recordByName) {
+	const namesToRemove = /* @__PURE__ */ new Set();
+	if (!recordByName.has(routeName)) return namesToRemove;
+	namesToRemove.add(routeName);
+	let expanded = true;
+	while (expanded) {
+		expanded = false;
+		for (const [name, record] of recordByName.entries()) {
+			if (!record.parentName || namesToRemove.has(name)) continue;
+			if (namesToRemove.has(record.parentName)) {
+				namesToRemove.add(name);
+				expanded = true;
+			}
+		}
+	}
+	return namesToRemove;
+}
+function buildRouteParamsFromMatch(matchValues) {
+	const params = {};
+	for (const [key, values] of matchValues.entries()) {
+		if (values.length === 0) continue;
+		params[key] = values.length === 1 ? values[0] : values;
+	}
+	return params;
+}
+function matchRoutePathParams(pathTemplate, targetPath) {
+	const templateSegments = splitRoutePathSegments(pathTemplate);
+	const targetSegments = splitRoutePathSegments(targetPath);
+	const matchedValues = /* @__PURE__ */ new Map();
+	const pushValue = (key, value) => {
+		const previous = matchedValues.get(key);
+		if (previous) {
+			previous.push(value);
+			return;
+		}
+		matchedValues.set(key, [value]);
+	};
+	const popValue = (key) => {
+		const previous = matchedValues.get(key);
+		if (!previous || previous.length === 0) return;
+		previous.pop();
+		if (previous.length === 0) matchedValues.delete(key);
+	};
+	const consumeRepeatableToken = (key, startIndex, count) => {
+		for (let index = 0; index < count; index += 1) pushValue(key, decodeRouteParamSegment(targetSegments[startIndex + index]));
+		return () => {
+			for (let index = 0; index < count; index += 1) popValue(key);
+		};
+	};
+	const matchRecursively = (templateIndex, targetIndex) => {
+		if (templateIndex >= templateSegments.length) return targetIndex >= targetSegments.length;
+		const templateSegment = templateSegments[templateIndex];
+		const token = parsePathParamToken(templateSegment);
+		if (!token) {
+			if (targetIndex >= targetSegments.length || templateSegment !== targetSegments[targetIndex]) return false;
+			return matchRecursively(templateIndex + 1, targetIndex + 1);
+		}
+		if (token.modifier === "") {
+			if (targetIndex >= targetSegments.length) return false;
+			pushValue(token.key, decodeRouteParamSegment(targetSegments[targetIndex]));
+			const matched = matchRecursively(templateIndex + 1, targetIndex + 1);
+			if (!matched) popValue(token.key);
+			return matched;
+		}
+		if (token.modifier === "?") {
+			if (targetIndex < targetSegments.length) {
+				pushValue(token.key, decodeRouteParamSegment(targetSegments[targetIndex]));
+				if (matchRecursively(templateIndex + 1, targetIndex + 1)) return true;
+				popValue(token.key);
+			}
+			return matchRecursively(templateIndex + 1, targetIndex);
+		}
+		const minimumCount = token.modifier === "+" ? 1 : 0;
+		const maximumCount = targetSegments.length - targetIndex;
+		for (let count = maximumCount; count >= minimumCount; count -= 1) {
+			const rollback = consumeRepeatableToken(token.key, targetIndex, count);
+			if (matchRecursively(templateIndex + 1, targetIndex + count)) return true;
+			rollback();
+		}
+		return false;
+	};
+	if (!matchRecursively(0, 0)) return;
+	return buildRouteParamsFromMatch(matchedValues);
+}
+function resolveMatchedRouteRecord(target, lookup) {
+	if (target.name) {
+		const byName = lookup.recordByName.get(target.name);
+		if (byName) return {
+			record: byName,
+			matchedRecords: resolveMatchedRouteRecordChain(byName, lookup)
+		};
+	}
+	const staticNamedRoute = lookup.nameByStaticPath.get(target.path);
+	if (staticNamedRoute) {
+		const record = lookup.recordByName.get(staticNamedRoute);
+		if (record) return {
+			record,
+			matchedRecords: resolveMatchedRouteRecordChain(record, lookup),
+			matchedPath: target.path
+		};
+	}
+	for (const record of lookup.recordByName.values()) for (const routePath of listRouteRecordMatchPaths(record)) {
+		if (!isDynamicRoutePath(routePath)) continue;
+		const matchedParams = matchRoutePathParams(routePath, target.path);
+		if (!matchedParams) continue;
+		return {
+			record,
+			matchedRecords: resolveMatchedRouteRecordChain(record, lookup),
+			matchedPath: routePath,
+			params: matchedParams
+		};
+	}
+}
+//#endregion
+//#region src/routerInternal/recordsWarnings.ts
+function warnRouteConfig(message) {
+	if (typeof console === "undefined" || typeof console.warn !== "function") return;
+	console.warn(`[wevu/router] ${message}`);
+}
+function formatRoutePathForWarning(path) {
+	const normalizedPath = resolvePath(path, "");
+	if (!normalizedPath) return "/";
+	return createAbsoluteRoutePath(normalizedPath);
+}
+function hasCircularChildrenReference(routeRecord, ancestorRecords = /* @__PURE__ */ new Set()) {
+	if (ancestorRecords.has(routeRecord)) return true;
+	if (!Array.isArray(routeRecord.children) || routeRecord.children.length === 0) return false;
+	const nextAncestorRecords = new Set(ancestorRecords);
+	nextAncestorRecords.add(routeRecord);
+	for (const childRecord of routeRecord.children) if (hasCircularChildrenReference(childRecord, nextAncestorRecords)) return true;
+	return false;
+}
+function assertValidAddRouteInput(routeRecord) {
+	const routeName = typeof routeRecord.name === "string" ? routeRecord.name.trim() : "";
+	if (!routeName) throw new Error("Route name is required when adding a named route");
+	if (typeof routeRecord.path !== "string" || !routeRecord.path) throw new Error(`Route path is required when adding named route "${routeName}"`);
+	if (hasCircularChildrenReference(routeRecord)) throw new Error(`Circular children reference detected when adding named route "${routeName}"`);
+}
+function warnDuplicateRouteEntries(routeEntries) {
+	const latestRouteInfoByName = /* @__PURE__ */ new Map();
+	const duplicateMessages = [];
+	for (const routeEntry of routeEntries) {
+		var _routeEntry$source;
+		const routeName = routeEntry.route.name.trim();
+		if (!routeName) continue;
+		const currentSource = (_routeEntry$source = routeEntry.source) !== null && _routeEntry$source !== void 0 ? _routeEntry$source : "namedRoutes";
+		const currentPath = formatRoutePathForWarning(routeEntry.route.path);
+		const previousInfo = latestRouteInfoByName.get(routeName);
+		if (previousInfo) duplicateMessages.push(`"${routeName}" (${previousInfo.source}:${previousInfo.path} -> ${currentSource}:${currentPath})`);
+		latestRouteInfoByName.set(routeName, {
+			source: currentSource,
+			path: currentPath
+		});
+	}
+	if (duplicateMessages.length === 0) return;
+	warnRouteConfig(`duplicate route names detected, later entries override earlier ones: ${duplicateMessages.join(", ")}`);
+}
+//#endregion
+//#region src/routerInternal/records.ts
+function normalizeBeforeEnterGuards(beforeEnter) {
+	if (!beforeEnter) return [];
+	if (Array.isArray(beforeEnter)) return beforeEnter;
+	return [beforeEnter];
+}
+function normalizeRouteRecordRaw(route, parentName) {
+	const routeName = route.name.trim();
+	if (!routeName) return;
+	const normalizedPath = resolvePath(route.path, "");
+	if (!normalizedPath) return;
+	return {
+		name: routeName,
+		path: normalizedPath,
+		aliasPaths: normalizeRouteRecordAliasPaths(route.alias, normalizedPath),
+		parentName,
+		meta: route.meta,
+		beforeEnterGuards: normalizeBeforeEnterGuards(route.beforeEnter),
+		redirect: route.redirect
+	};
+}
+function normalizeRouteRecordAliasPaths(alias, normalizedPath) {
+	if (!alias) return [];
+	const aliasList = Array.isArray(alias) ? alias : [alias];
+	const normalizedAliasPaths = [];
+	for (const aliasPath of aliasList) {
+		if (typeof aliasPath !== "string") continue;
+		const normalizedAliasPath = resolvePath(aliasPath, "");
+		if (!normalizedAliasPath || normalizedAliasPath === normalizedPath) continue;
+		if (!normalizedAliasPaths.includes(normalizedAliasPath)) normalizedAliasPaths.push(normalizedAliasPath);
+	}
+	return normalizedAliasPaths;
+}
+function normalizeNamedRouteEntries(namedRoutes, source = "namedRoutes") {
+	if (!namedRoutes) return [];
+	if (Array.isArray(namedRoutes)) return flattenNamedRouteRecords(namedRoutes, void 0, void 0, [], source, source);
+	const normalizedEntries = [];
+	for (const [rawName, rawPath] of Object.entries(namedRoutes)) {
+		const routeName = typeof rawName === "string" ? rawName.trim() : "";
+		if (!routeName) {
+			warnRouteConfig(`ignored route record at ${source}: route name is required`);
+			continue;
+		}
+		if (typeof rawPath !== "string" || !rawPath) {
+			warnRouteConfig(`ignored route record "${routeName}" at ${source}: route path is required`);
+			continue;
+		}
+		normalizedEntries.push({
+			route: {
+				name: routeName,
+				path: rawPath
+			},
+			source
+		});
+	}
+	return normalizedEntries;
+}
+function resolveRouteOptionEntries(options) {
+	return [...normalizeNamedRouteEntries(options.routes, "routes"), ...normalizeNamedRouteEntries(options.namedRoutes, "namedRoutes")];
+}
+function normalizeNestedRoutePath(path, parentPath) {
+	if (!parentPath || path.startsWith("/")) return resolvePath(path, "");
+	return resolvePath(`${createAbsoluteRoutePath(parentPath)}/${path}`, "");
+}
+function normalizeAliasInputList(alias) {
+	if (!alias) return [];
+	if (Array.isArray(alias)) return alias.filter((item) => typeof item === "string" && item.length > 0);
+	return typeof alias === "string" && alias.length > 0 ? [alias] : [];
+}
+function mergeAliasPaths(aliasPaths) {
+	const mergedAliasPaths = [];
+	for (const aliasPath of aliasPaths) {
+		if (!aliasPath || mergedAliasPaths.includes(aliasPath)) continue;
+		mergedAliasPaths.push(aliasPath);
+	}
+	return mergedAliasPaths;
+}
+function createRouteRecordAliasValue(aliasPaths) {
+	if (aliasPaths.length === 0) return;
+	if (aliasPaths.length === 1) return createAbsoluteRoutePath(aliasPaths[0]);
+	return aliasPaths.map((aliasPath) => createAbsoluteRoutePath(aliasPath));
+}
+function flattenNamedRouteRecords(records, parentPath, parentName, parentAliasPaths = [], source, pathPrefix = "namedRoutes", ancestorRecords = /* @__PURE__ */ new Set()) {
+	const flattenedRecords = [];
+	for (const [index, record] of records.entries()) {
+		const routeConfigPath = `${pathPrefix}[${index}]`;
+		if (ancestorRecords.has(record)) {
+			warnRouteConfig(`ignored route record at ${routeConfigPath}: detected circular children reference`);
+			continue;
+		}
+		const routeName = typeof (record === null || record === void 0 ? void 0 : record.name) === "string" ? record.name.trim() : "";
+		if (!routeName) {
+			warnRouteConfig(`ignored route record at ${routeConfigPath}: route name is required`);
+			continue;
+		}
+		if (typeof record.path !== "string" || !record.path) {
+			warnRouteConfig(`ignored route record "${routeName}" at ${routeConfigPath}: route path is required`);
+			continue;
+		}
+		const normalizedPath = normalizeNestedRoutePath(record.path, parentPath);
+		const normalizedDirectAliasPaths = [];
+		const directAliasByNormalizedPath = /* @__PURE__ */ new Map();
+		for (const rawAliasPath of normalizeAliasInputList(record.alias)) {
+			const normalizedAliasPath = normalizeNestedRoutePath(rawAliasPath, parentPath);
+			if (!normalizedAliasPath) continue;
+			if (normalizedAliasPath === normalizedPath) {
+				warnRouteConfig(`ignored alias "${createAbsoluteRoutePath(normalizedAliasPath)}" for route "${routeName}" at ${routeConfigPath}: alias is same as route path`);
+				continue;
+			}
+			const duplicateAliasPath = directAliasByNormalizedPath.get(normalizedAliasPath);
+			if (duplicateAliasPath) {
+				warnRouteConfig(`ignored duplicate alias "${createAbsoluteRoutePath(normalizedAliasPath)}" for route "${routeName}" at ${routeConfigPath}: already declared by "${duplicateAliasPath}"`);
+				continue;
+			}
+			directAliasByNormalizedPath.set(normalizedAliasPath, rawAliasPath);
+			normalizedDirectAliasPaths.push(normalizedAliasPath);
+		}
+		const normalizedInheritedAliasPaths = record.path.startsWith("/") ? [] : parentAliasPaths.map((parentAliasPath) => normalizeNestedRoutePath(record.path, parentAliasPath)).filter(Boolean).filter((aliasPath) => aliasPath !== normalizedPath);
+		const normalizedAliasPaths = mergeAliasPaths([...normalizedDirectAliasPaths, ...normalizedInheritedAliasPaths]);
+		const normalizedRecord = {
+			...record,
+			name: routeName,
+			path: normalizedPath ? createAbsoluteRoutePath(normalizedPath) : "/",
+			alias: createRouteRecordAliasValue(normalizedAliasPaths)
+		};
+		flattenedRecords.push({
+			route: normalizedRecord,
+			parentName,
+			source
+		});
+		if (Array.isArray(record.children) && record.children.length > 0) {
+			const nextAncestorRecords = new Set(ancestorRecords);
+			nextAncestorRecords.add(record);
+			flattenedRecords.push(...flattenNamedRouteRecords(record.children, normalizedPath, routeName, normalizedAliasPaths, source, `${routeConfigPath}.children`, nextAncestorRecords));
+		}
+	}
+	return flattenedRecords;
+}
+function createNamedRouteNameByStaticPath(recordByName) {
+	const nameByStaticPath = /* @__PURE__ */ new Map();
+	for (const [name, record] of recordByName.entries()) {
+		if (!isDynamicRoutePath(record.path) && !nameByStaticPath.has(record.path)) nameByStaticPath.set(record.path, name);
+		for (const aliasPath of record.aliasPaths) if (!isDynamicRoutePath(aliasPath) && !nameByStaticPath.has(aliasPath)) nameByStaticPath.set(aliasPath, name);
+	}
+	return nameByStaticPath;
+}
+function createNamedRouteLookup(routeEntries) {
+	const recordByName = /* @__PURE__ */ new Map();
+	for (const routeRecord of routeEntries) {
+		const normalizedRecord = normalizeRouteRecordRaw(routeRecord.route, routeRecord.parentName);
+		if (!normalizedRecord) continue;
+		recordByName.set(normalizedRecord.name, normalizedRecord);
+	}
+	return {
+		recordByName,
+		nameByStaticPath: createNamedRouteNameByStaticPath(recordByName)
+	};
+}
+//#endregion
+//#region src/routerInternal/snapshots.ts
+function cloneRouteMeta(meta) {
+	if (!meta) return;
+	return { ...meta };
+}
+function freezeRouteRecordRawSnapshot(routeRecord) {
+	const snapshot = {
+		name: routeRecord.name,
+		path: routeRecord.path
+	};
+	if (routeRecord.meta !== void 0) snapshot.meta = cloneRouteMeta(routeRecord.meta);
+	if (Array.isArray(routeRecord.alias)) snapshot.alias = Object.freeze(routeRecord.alias.slice());
+	else if (routeRecord.alias !== void 0) snapshot.alias = routeRecord.alias;
+	if (Array.isArray(routeRecord.beforeEnter)) snapshot.beforeEnter = Object.freeze(routeRecord.beforeEnter.slice());
+	else if (routeRecord.beforeEnter !== void 0) snapshot.beforeEnter = routeRecord.beforeEnter;
+	if (routeRecord.redirect !== void 0) snapshot.redirect = routeRecord.redirect;
+	return Object.freeze(snapshot);
+}
+function createRouterOptionsSnapshot(normalizedTabBarEntries, normalizedNamedRoutes, paramsMode, maxRedirects, routeResolveCodec, rejectOnError) {
+	const tabBarEntriesSnapshot = Object.freeze(normalizedTabBarEntries.map((path) => createAbsoluteRoutePath(path)));
+	const routesSnapshot = Object.freeze(normalizedNamedRoutes.map(freezeRouteRecordRawSnapshot));
+	return Object.freeze({
+		tabBarEntries: tabBarEntriesSnapshot,
+		routes: routesSnapshot,
+		namedRoutes: routesSnapshot,
+		paramsMode,
+		maxRedirects,
+		parseQuery: routeResolveCodec.parseQuery,
+		stringifyQuery: routeResolveCodec.stringifyQuery,
+		rejectOnError
+	});
+}
+function normalizeRouteRecordMatched(record, matchedPath) {
+	const matchedRecord = {
+		name: record.name,
+		path: createAbsoluteRoutePath(record.path)
+	};
+	const normalizedMatchedPath = typeof matchedPath === "string" && matchedPath ? createAbsoluteRoutePath(resolvePath(matchedPath, "")) : void 0;
+	if (normalizedMatchedPath && normalizedMatchedPath !== matchedRecord.path) matchedRecord.aliasPath = normalizedMatchedPath;
+	if (record.meta !== void 0) matchedRecord.meta = cloneRouteMeta(record.meta);
+	return matchedRecord;
+}
+function cloneRouteRecordMatchedList(matched) {
+	if (!matched) return;
+	return matched.map((record) => ({
+		name: record.name,
+		path: record.path,
+		aliasPath: record.aliasPath,
+		meta: cloneRouteMeta(record.meta)
+	}));
+}
+function cloneLocationQuery(query) {
+	const cloned = {};
+	for (const key of Object.keys(query)) {
+		const value = query[key];
+		cloned[key] = Array.isArray(value) ? value.slice() : value;
+	}
+	return cloned;
+}
+function cloneRouteParams(params) {
+	const cloned = {};
+	for (const key of Object.keys(params)) {
+		const value = params[key];
+		cloned[key] = Array.isArray(value) ? value.slice() : value;
+	}
+	return cloned;
+}
+function cloneRouteLocationRedirectedFrom(redirectedFrom) {
+	if (!redirectedFrom) return;
+	const cloned = {
+		path: redirectedFrom.path,
+		fullPath: redirectedFrom.fullPath,
+		query: cloneLocationQuery(redirectedFrom.query),
+		hash: redirectedFrom.hash,
+		params: cloneRouteParams(redirectedFrom.params)
+	};
+	if (redirectedFrom.name !== void 0) cloned.name = redirectedFrom.name;
+	if (redirectedFrom.meta !== void 0) cloned.meta = cloneRouteMeta(redirectedFrom.meta);
+	if (redirectedFrom.href !== void 0) cloned.href = redirectedFrom.href;
+	if (redirectedFrom.matched !== void 0) cloned.matched = cloneRouteRecordMatchedList(redirectedFrom.matched);
+	return cloned;
+}
+function createRedirectedFromSnapshot(route) {
+	const snapshot = {
+		path: route.path,
+		fullPath: route.fullPath,
+		query: cloneLocationQuery(route.query),
+		hash: route.hash,
+		params: cloneRouteParams(route.params)
+	};
+	if (route.name !== void 0) snapshot.name = route.name;
+	if (route.meta !== void 0) snapshot.meta = cloneRouteMeta(route.meta);
+	if (route.href !== void 0) snapshot.href = route.href;
+	if (route.matched !== void 0) snapshot.matched = cloneRouteRecordMatchedList(route.matched);
+	return snapshot;
+}
+function snapshotRouteLocation(route) {
+	const snapshot = {
+		path: route.path,
+		fullPath: route.fullPath,
+		query: cloneLocationQuery(route.query),
+		hash: route.hash,
+		params: cloneRouteParams(route.params)
+	};
+	if (route.meta !== void 0) snapshot.meta = cloneRouteMeta(route.meta);
+	if (route.href !== void 0) snapshot.href = route.href;
+	if (route.matched !== void 0) snapshot.matched = cloneRouteRecordMatchedList(route.matched);
+	if (route.redirectedFrom !== void 0) snapshot.redirectedFrom = cloneRouteLocationRedirectedFrom(route.redirectedFrom);
+	if (route.name !== void 0) snapshot.name = route.name;
+	return snapshot;
+}
+function createNativeRouteUrl(target, queryStringifier = stringifyQuery) {
+	const basePath = createAbsoluteRoutePath(target.path);
+	const queryString = queryStringifier(target.query);
+	return queryString ? `${basePath}?${queryString}` : basePath;
+}
+function hasLocationQuery(query) {
+	return Object.keys(query).length > 0;
+}
+//#endregion
+//#region src/router/types.ts
+const NavigationFailureType = {
+	unknown: 1,
+	aborted: 4,
+	cancelled: 8,
+	duplicated: 16
+};
+//#endregion
+//#region src/router/navigationCore.ts
+function normalizeNavigationErrorMessage(error) {
+	if (typeof error === "string") return error;
+	if (error && typeof error === "object") {
+		const message = error.errMsg;
+		if (typeof message === "string") return message;
+		if (error instanceof Error) return error.message;
+	}
+	return "";
+}
+function resolveNavigationFailureType(error) {
+	const normalizedMessage = normalizeNavigationErrorMessage(error).toLowerCase();
+	if (/already|same|duplicat|重复/.test(normalizedMessage)) return NavigationFailureType.duplicated;
+	if (/cancel|取消/.test(normalizedMessage)) return NavigationFailureType.cancelled;
+	if (/abort|interrupt|中断/.test(normalizedMessage)) return NavigationFailureType.aborted;
+	return NavigationFailureType.unknown;
+}
+function createNavigationFailure(type, to, from, cause) {
+	const message = normalizeNavigationErrorMessage(cause) || "Navigation failed";
+	const error = new Error(message);
+	error.__wevuNavigationFailure = true;
+	error.type = type;
+	error.to = to;
+	error.from = from;
+	error.cause = cause;
+	return error;
+}
+function isNavigationFailure(error, type) {
+	if (!error || typeof error !== "object") return false;
+	const navigationError = error;
+	if (navigationError.__wevuNavigationFailure !== true) return false;
+	if (type === void 0) return true;
+	return navigationError.type === type;
+}
+function isNavigationRedirectCandidate(value) {
+	if (!value || typeof value !== "object") return false;
+	return "to" in value;
+}
+function isRouteLocationRawCandidate(value) {
+	if (typeof value === "string") return true;
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return "path" in candidate || "fullPath" in candidate || "query" in candidate || "hash" in candidate || "name" in candidate || "params" in candidate;
+}
+async function runNavigationGuards(guards, context, resolveRoute) {
+	for (const guard of guards) try {
+		const result = await guard(context.to, context.from, context);
+		if (isNavigationFailure(result)) return {
+			status: "failure",
+			failure: result
+		};
+		if (result === false) return {
+			status: "failure",
+			failure: createNavigationFailure(NavigationFailureType.aborted, context.to, context.from, "Navigation aborted by guard")
+		};
+		if (isNavigationRedirectCandidate(result)) {
+			if (!context.to) return {
+				status: "failure",
+				failure: createNavigationFailure(NavigationFailureType.aborted, context.to, context.from, "Redirect is not supported in back navigation guards")
+			};
+			return {
+				status: "redirect",
+				target: resolveRoute(result.to, context.to.path),
+				replace: result.replace
+			};
+		}
+		if (isRouteLocationRawCandidate(result)) {
+			if (!context.to) return {
+				status: "failure",
+				failure: createNavigationFailure(NavigationFailureType.aborted, context.to, context.from, "Redirect is not supported in back navigation guards")
+			};
+			return {
+				status: "redirect",
+				target: resolveRoute(result, context.to.path)
+			};
+		}
+	} catch (error) {
+		return {
+			status: "failure",
+			failure: createNavigationFailure(NavigationFailureType.aborted, context.to, context.from, error)
+		};
+	}
+	return { status: "continue" };
+}
+function executeNavigationMethod(method, options, to, from) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const finalize = (result) => {
+			if (settled) return;
+			settled = true;
+			resolve(result);
+		};
+		try {
+			const maybePromise = method({
+				...options,
+				success: () => finalize(),
+				fail: (error) => {
+					finalize(createNavigationFailure(resolveNavigationFailureType(error), to, from, error));
+				}
+			});
+			if (maybePromise && typeof maybePromise.then === "function") maybePromise.then(() => finalize(), (error) => finalize(createNavigationFailure(resolveNavigationFailureType(error), to, from, error)));
+		} catch (error) {
+			finalize(createNavigationFailure(resolveNavigationFailureType(error), to, from, error));
+		}
+	});
+}
+async function runAfterEachHooks(hooks, context) {
+	for (const hook of hooks) try {
+		await hook(context.to, context.from, context.failure, context);
+	} catch (_unused) {}
+}
+async function runNavigationErrorHooks(handlers, error, context) {
+	for (const handler of handlers) try {
+		await handler(error, context);
+	} catch (_unused2) {}
+}
+function isNativeFailureLikeError(value) {
+	if (!value || typeof value !== "object") return false;
+	return typeof value.errMsg === "string";
+}
+function shouldEmitNavigationError(failure) {
+	if (failure.type === NavigationFailureType.unknown) return true;
+	if (failure.cause instanceof Error) return true;
+	if (failure.type === NavigationFailureType.aborted && failure.cause !== void 0) {
+		if (typeof failure.cause === "string") return false;
+		if (isNativeFailureLikeError(failure.cause)) return false;
+		return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/router/resolve.ts
+const DEFAULT_ROUTE_RESOLVE_CODEC = {
+	parseQuery,
+	stringifyQuery
+};
+function resolveRouteLocation(to, currentPath = "", codec = DEFAULT_ROUTE_RESOLVE_CODEC) {
+	var _ref, _to$path, _parsedFromFullPath$q, _to$hash;
+	if (typeof to === "string") {
+		const parsed = parsePathInput(to, codec);
+		return createRouteLocation(resolvePath(parsed.path, currentPath), parsed.query, parsed.hash, void 0, {}, codec.stringifyQuery);
+	}
+	const parsedFromFullPath = typeof to.fullPath === "string" ? parsePathInput(to.fullPath, codec) : void 0;
+	return createRouteLocation(resolvePath((_ref = (_to$path = to.path) !== null && _to$path !== void 0 ? _to$path : parsedFromFullPath === null || parsedFromFullPath === void 0 ? void 0 : parsedFromFullPath.path) !== null && _ref !== void 0 ? _ref : currentPath, currentPath), to.query ? normalizeQuery(to.query) : (_parsedFromFullPath$q = parsedFromFullPath === null || parsedFromFullPath === void 0 ? void 0 : parsedFromFullPath.query) !== null && _parsedFromFullPath$q !== void 0 ? _parsedFromFullPath$q : {}, normalizeHash((_to$hash = to.hash) !== null && _to$hash !== void 0 ? _to$hash : parsedFromFullPath === null || parsedFromFullPath === void 0 ? void 0 : parsedFromFullPath.hash), typeof to.name === "string" ? to.name : void 0, to.params ? normalizeRouteParams(to.params) : {}, codec.stringifyQuery);
+}
+//#endregion
+//#region src/router/useRoute.ts
+function useRoute() {
+	if (!getCurrentSetupContext()) throw new Error("useRoute() 必须在 setup() 的同步阶段调用");
+	const currentRoute = resolveCurrentRoute();
+	const routeState = reactive({
+		path: currentRoute.path,
+		fullPath: currentRoute.fullPath,
+		query: currentRoute.query,
+		hash: currentRoute.hash,
+		params: currentRoute.params,
+		name: currentRoute.name
+	});
+	if (currentRoute.meta !== void 0) routeState.meta = currentRoute.meta;
+	function syncRoute(queryOverride) {
+		const nextRoute = resolveCurrentRoute(queryOverride);
+		routeState.path = nextRoute.path;
+		routeState.fullPath = nextRoute.fullPath;
+		routeState.query = nextRoute.query;
+		routeState.hash = nextRoute.hash;
+		if (nextRoute.meta === void 0) delete routeState.meta;
+		else routeState.meta = nextRoute.meta;
+		routeState.params = nextRoute.params;
+		routeState.name = nextRoute.name;
+	}
+	onLoad((query) => {
+		syncRoute(query);
+	});
+	onShow(() => {
+		syncRoute();
+	});
+	onRouteDone(() => {
+		syncRoute();
+	});
+	return readonly(routeState);
+}
+/**
+* @description 获取当前组件路径语义的原生 Router
+*/
+function useNativeRouter() {
+	return useNativeRouter$1();
+}
+/**
+* @description 获取当前页面路径语义的原生 Page Router
+*/
+function useNativePageRouter() {
+	return useNativePageRouter$1();
+}
+//#endregion
+//#region src/router/navigationResult.ts
+function createNavigationRunResult(mode, from, to, failure) {
+	return {
+		mode,
+		from,
+		to,
+		failure
+	};
+}
+function createNavigationResultController(options) {
+	const { afterEachHooks, errorHandlers, nativeRouter, rejectOnError } = options;
+	async function emitNavigationAfterEach(result) {
+		await runAfterEachHooks(afterEachHooks, {
+			mode: result.mode,
+			to: result.to,
+			from: result.from,
+			nativeRouter,
+			failure: result.failure
+		});
+		if (result.failure && shouldEmitNavigationError(result.failure)) {
+			var _result$failure$cause;
+			await runNavigationErrorHooks(errorHandlers, (_result$failure$cause = result.failure.cause) !== null && _result$failure$cause !== void 0 ? _result$failure$cause : result.failure, {
+				mode: result.mode,
+				to: result.to,
+				from: result.from,
+				nativeRouter,
+				failure: result.failure
+			});
+		}
+	}
+	function shouldRejectNavigationFailure(failure) {
+		return rejectOnError && shouldEmitNavigationError(failure);
+	}
+	async function settleNavigationResult(result) {
+		await emitNavigationAfterEach(result);
+		if (result.failure && shouldRejectNavigationFailure(result.failure)) throw result.failure;
+		return result.failure;
+	}
+	return { settleNavigationResult };
+}
+//#endregion
+//#region src/router/navigationTargetHelpers.ts
+function createDuplicatedFailure(target, from) {
+	return createNavigationFailure(NavigationFailureType.duplicated, target, from, "Avoided redundant navigation to current location");
+}
+function createTabBarQueryFailure(target, from) {
+	return createNavigationFailure(NavigationFailureType.aborted, target, from, "switchTab does not support query parameters");
+}
+function createTooManyRedirectsFailure(target, from, maxRedirects) {
+	return createNavigationFailure(NavigationFailureType.aborted, target, from, `Navigation redirected more than ${maxRedirects} times`);
+}
+function createHashOnlyNavigationFailure(target, from) {
+	return createNavigationFailure(NavigationFailureType.aborted, target, from, "Hash-only navigation is not supported in mini-program router");
+}
+function createForwardNotSupportedFailure(from) {
+	return createNavigationFailure(NavigationFailureType.aborted, void 0, from, "Forward navigation is not supported in mini-program router");
+}
+function applyRedirectedFrom(redirectedTarget, currentTarget) {
+	redirectedTarget.redirectedFrom = currentTarget.redirectedFrom ? cloneRouteLocationRedirectedFrom(currentTarget.redirectedFrom) : createRedirectedFromSnapshot(currentTarget);
+}
+async function resolveRouteRecordRedirect(redirect, to, from, resolveWithCodec) {
+	const redirectResult = typeof redirect === "function" ? await redirect(to, from) : redirect;
+	if (isNavigationRedirectCandidate(redirectResult)) return {
+		target: resolveWithCodec(redirectResult.to, to.path),
+		replace: redirectResult.replace
+	};
+	return {
+		target: resolveWithCodec(redirectResult, to.path),
+		replace: true
+	};
+}
+//#endregion
+//#region src/router/navigationTarget.ts
+async function navigateWithTarget(options) {
+	const { mode, target, from, nativeRouter, routeResolveCodec, namedRouteLookup, beforeEachGuards, beforeResolveGuards, maxRedirects, tabBarPathSet, resolveWithCodec } = options;
+	let currentTarget = target;
+	let currentMode = mode;
+	let redirectCount = 0;
+	while (true) {
+		var _matchedRouteResult$m;
+		const tabBarTarget = tabBarPathSet.has(currentTarget.path);
+		if (createNativeRouteUrl(currentTarget, routeResolveCodec.stringifyQuery) === createNativeRouteUrl(from, routeResolveCodec.stringifyQuery) && currentTarget.hash !== from.hash) return createNavigationRunResult(currentMode, from, currentTarget, createHashOnlyNavigationFailure(currentTarget, from));
+		if (tabBarTarget ? currentTarget.path === from.path : currentTarget.fullPath === from.fullPath) return createNavigationRunResult(currentMode, from, currentTarget, createDuplicatedFailure(currentTarget, from));
+		if (tabBarTarget && hasLocationQuery(currentTarget.query)) return createNavigationRunResult(currentMode, from, currentTarget, createTabBarQueryFailure(currentTarget, from));
+		const beforeEachResult = await runNavigationGuards(beforeEachGuards, {
+			mode: currentMode,
+			to: currentTarget,
+			from,
+			nativeRouter
+		}, resolveWithCodec);
+		if (beforeEachResult.status === "failure") return createNavigationRunResult(currentMode, from, currentTarget, beforeEachResult.failure);
+		if (beforeEachResult.status === "redirect") {
+			const redirectedTarget = beforeEachResult.target;
+			const redirectedMode = beforeEachResult.replace === true ? "replace" : beforeEachResult.replace === false ? "push" : currentMode;
+			if (redirectedTarget.fullPath !== currentTarget.fullPath || redirectedMode !== currentMode) {
+				applyRedirectedFrom(redirectedTarget, currentTarget);
+				currentTarget = redirectedTarget;
+				currentMode = redirectedMode;
+				redirectCount += 1;
+				if (redirectCount > maxRedirects) return createNavigationRunResult(currentMode, from, currentTarget, createTooManyRedirectsFailure(currentTarget, from, maxRedirects));
+				continue;
+			}
+		}
+		const matchedRouteResult = resolveMatchedRouteRecord(currentTarget, namedRouteLookup);
+		const matchedRouteRecords = (_matchedRouteResult$m = matchedRouteResult === null || matchedRouteResult === void 0 ? void 0 : matchedRouteResult.matchedRecords) !== null && _matchedRouteResult$m !== void 0 ? _matchedRouteResult$m : [];
+		let redirectedByRouteRecord = false;
+		for (const matchedRouteRecord of matchedRouteRecords) {
+			if (matchedRouteRecord.redirect === void 0) continue;
+			let redirectedByRecord;
+			try {
+				redirectedByRecord = await resolveRouteRecordRedirect(matchedRouteRecord.redirect, currentTarget, from, resolveWithCodec);
+			} catch (error) {
+				return createNavigationRunResult(currentMode, from, currentTarget, createNavigationFailure(NavigationFailureType.aborted, currentTarget, from, error));
+			}
+			const redirectedMode = redirectedByRecord.replace === false ? "push" : "replace";
+			const redirectedTarget = redirectedByRecord.target;
+			if (redirectedTarget.fullPath !== currentTarget.fullPath || redirectedMode !== currentMode) {
+				applyRedirectedFrom(redirectedTarget, currentTarget);
+				currentTarget = redirectedTarget;
+				currentMode = redirectedMode;
+				redirectCount += 1;
+				if (redirectCount > maxRedirects) return createNavigationRunResult(currentMode, from, currentTarget, createTooManyRedirectsFailure(currentTarget, from, maxRedirects));
+				redirectedByRouteRecord = true;
+				break;
+			}
+		}
+		if (redirectedByRouteRecord) continue;
+		let redirectedByBeforeEnter = false;
+		for (const matchedRouteRecord of matchedRouteRecords) {
+			if (matchedRouteRecord.beforeEnterGuards.length === 0) continue;
+			const beforeEnterResult = await runNavigationGuards(new Set(matchedRouteRecord.beforeEnterGuards), {
+				mode: currentMode,
+				to: currentTarget,
+				from,
+				nativeRouter
+			}, resolveWithCodec);
+			if (beforeEnterResult.status === "failure") return createNavigationRunResult(currentMode, from, currentTarget, beforeEnterResult.failure);
+			if (beforeEnterResult.status === "redirect") {
+				const redirectedTarget = beforeEnterResult.target;
+				const redirectedMode = beforeEnterResult.replace === true ? "replace" : beforeEnterResult.replace === false ? "push" : currentMode;
+				if (redirectedTarget.fullPath !== currentTarget.fullPath || redirectedMode !== currentMode) {
+					applyRedirectedFrom(redirectedTarget, currentTarget);
+					currentTarget = redirectedTarget;
+					currentMode = redirectedMode;
+					redirectCount += 1;
+					if (redirectCount > maxRedirects) return createNavigationRunResult(currentMode, from, currentTarget, createTooManyRedirectsFailure(currentTarget, from, maxRedirects));
+					redirectedByBeforeEnter = true;
+					break;
+				}
+			}
+		}
+		if (redirectedByBeforeEnter) continue;
+		const beforeResolveResult = await runNavigationGuards(beforeResolveGuards, {
+			mode: currentMode,
+			to: currentTarget,
+			from,
+			nativeRouter
+		}, resolveWithCodec);
+		if (beforeResolveResult.status === "failure") return createNavigationRunResult(currentMode, from, currentTarget, beforeResolveResult.failure);
+		if (beforeResolveResult.status === "redirect") {
+			const redirectedTarget = beforeResolveResult.target;
+			const redirectedMode = beforeResolveResult.replace === true ? "replace" : beforeResolveResult.replace === false ? "push" : currentMode;
+			if (redirectedTarget.fullPath !== currentTarget.fullPath || redirectedMode !== currentMode) {
+				applyRedirectedFrom(redirectedTarget, currentTarget);
+				currentTarget = redirectedTarget;
+				currentMode = redirectedMode;
+				redirectCount += 1;
+				if (redirectCount > maxRedirects) return createNavigationRunResult(currentMode, from, currentTarget, createTooManyRedirectsFailure(currentTarget, from, maxRedirects));
+				continue;
+			}
+		}
+		if (tabBarTarget) {
+			const result = await executeNavigationMethod(nativeRouter.switchTab, { url: createAbsoluteRoutePath(currentTarget.path) }, currentTarget, from);
+			if (isNavigationFailure(result)) return createNavigationRunResult(currentMode, from, currentTarget, result);
+			return createNavigationRunResult(currentMode, from, currentTarget);
+		}
+		const result = await executeNavigationMethod(currentMode === "push" ? nativeRouter.navigateTo : nativeRouter.redirectTo, { url: createNativeRouteUrl(currentTarget, routeResolveCodec.stringifyQuery) }, currentTarget, from);
+		if (isNavigationFailure(result)) return createNavigationRunResult(currentMode, from, currentTarget, result);
+		return createNavigationRunResult(currentMode, from, currentTarget);
+	}
+}
+//#endregion
+//#region src/router/navigationApi.ts
+function createNavigationApi(options) {
+	const { nativeRouter, route, routeResolveCodec, namedRouteLookup, beforeEachGuards, beforeResolveGuards, maxRedirects, tabBarPathSet, resolveWithCodec, settleNavigationResult } = options;
+	async function push(to) {
+		const from = snapshotRouteLocation(route);
+		let target;
+		try {
+			target = resolveWithCodec(to, from.path);
+		} catch (error) {
+			return settleNavigationResult(createNavigationRunResult("push", from, void 0, createNavigationFailure(NavigationFailureType.unknown, void 0, from, error)));
+		}
+		return settleNavigationResult(await navigateWithTarget({
+			mode: "push",
+			target,
+			from,
+			nativeRouter,
+			routeResolveCodec,
+			namedRouteLookup,
+			beforeEachGuards,
+			beforeResolveGuards,
+			maxRedirects,
+			tabBarPathSet,
+			resolveWithCodec
+		}));
+	}
+	async function replace(to) {
+		const from = snapshotRouteLocation(route);
+		let target;
+		try {
+			target = resolveWithCodec(to, from.path);
+		} catch (error) {
+			return settleNavigationResult(createNavigationRunResult("replace", from, void 0, createNavigationFailure(NavigationFailureType.unknown, void 0, from, error)));
+		}
+		return settleNavigationResult(await navigateWithTarget({
+			mode: "replace",
+			target,
+			from,
+			nativeRouter,
+			routeResolveCodec,
+			namedRouteLookup,
+			beforeEachGuards,
+			beforeResolveGuards,
+			maxRedirects,
+			tabBarPathSet,
+			resolveWithCodec
+		}));
+	}
+	async function back(delta = 1) {
+		const from = snapshotRouteLocation(route);
+		const beforeEachResult = await runNavigationGuards(beforeEachGuards, {
+			mode: "back",
+			from,
+			nativeRouter
+		}, resolveWithCodec);
+		if (beforeEachResult.status === "failure") return settleNavigationResult(createNavigationRunResult("back", from, void 0, beforeEachResult.failure));
+		if (beforeEachResult.status === "redirect") return settleNavigationResult(createNavigationRunResult("back", from, void 0, createNavigationFailure(NavigationFailureType.aborted, void 0, from, "Redirect is not supported in back navigation guards")));
+		const beforeResolveResult = await runNavigationGuards(beforeResolveGuards, {
+			mode: "back",
+			from,
+			nativeRouter
+		}, resolveWithCodec);
+		if (beforeResolveResult.status === "failure") return settleNavigationResult(createNavigationRunResult("back", from, void 0, beforeResolveResult.failure));
+		if (beforeResolveResult.status === "redirect") return settleNavigationResult(createNavigationRunResult("back", from, void 0, createNavigationFailure(NavigationFailureType.aborted, void 0, from, "Redirect is not supported in back navigation guards")));
+		const result = await executeNavigationMethod(nativeRouter.navigateBack, { delta }, void 0, from);
+		return settleNavigationResult(isNavigationFailure(result) ? createNavigationRunResult("back", from, void 0, result) : createNavigationRunResult("back", from));
+	}
+	async function go(delta) {
+		if (delta < 0) return back(Math.abs(delta));
+		if (delta === 0) return;
+		const from = snapshotRouteLocation(route);
+		return settleNavigationResult(createNavigationRunResult("back", from, void 0, createForwardNotSupportedFailure(from)));
+	}
+	async function forward() {
+		return go(1);
+	}
+	return {
+		push,
+		replace,
+		back,
+		go,
+		forward
+	};
+}
+//#endregion
+//#region src/router/routeRegistry.ts
+function normalizeRouteRecordForOutput(record) {
+	const normalizedRoute = {
+		name: record.name,
+		path: record.path ? `/${record.path}` : "/"
+	};
+	if (record.meta !== void 0) normalizedRoute.meta = cloneRouteMeta(record.meta);
+	if (record.aliasPaths.length === 1) normalizedRoute.alias = createAbsoluteRoutePath(record.aliasPaths[0]);
+	else if (record.aliasPaths.length > 1) normalizedRoute.alias = record.aliasPaths.map((aliasPath) => createAbsoluteRoutePath(aliasPath));
+	if (record.beforeEnterGuards.length === 1) normalizedRoute.beforeEnter = record.beforeEnterGuards[0];
+	else if (record.beforeEnterGuards.length > 1) normalizedRoute.beforeEnter = record.beforeEnterGuards.slice();
+	if (record.redirect !== void 0) normalizedRoute.redirect = record.redirect;
+	return normalizedRoute;
+}
+function createRouteRegistry(namedRouteLookup) {
+	const hasRoute = (name) => namedRouteLookup.recordByName.has(name);
+	const getRoutes = () => Array.from(namedRouteLookup.recordByName.values()).map(normalizeRouteRecordForOutput);
+	const addRoute = ((parentNameOrRoute, maybeRoute) => {
+		const route = typeof parentNameOrRoute === "string" ? maybeRoute : parentNameOrRoute;
+		if (!route) throw new Error("Route record is required when adding a child route");
+		assertValidAddRouteInput(route);
+		const parentRouteName = typeof parentNameOrRoute === "string" ? parentNameOrRoute : void 0;
+		const parentRouteRecord = parentRouteName ? namedRouteLookup.recordByName.get(parentRouteName) : void 0;
+		if (parentRouteName && !parentRouteRecord) throw new Error(`Parent route "${parentRouteName}" is not defined in useRouter({ routes | namedRoutes })`);
+		const routeRecords = flattenNamedRouteRecords([route], parentRouteRecord === null || parentRouteRecord === void 0 ? void 0 : parentRouteRecord.path, parentRouteName, parentRouteRecord === null || parentRouteRecord === void 0 ? void 0 : parentRouteRecord.aliasPaths, void 0, "addRoute");
+		if (routeRecords.length === 0) throw new Error("Route name and path are required when adding a named route");
+		const addedRoutes = [];
+		for (const routeRecord of routeRecords) {
+			const normalizedRoute = normalizeRouteRecordRaw(routeRecord.route, routeRecord.parentName);
+			if (!normalizedRoute) continue;
+			const existingRoute = namedRouteLookup.recordByName.get(normalizedRoute.name);
+			if (existingRoute) {
+				const namesToRemove = collectRouteNamesForRemoval(existingRoute.name, namedRouteLookup.recordByName);
+				for (const routeName of namesToRemove) namedRouteLookup.recordByName.delete(routeName);
+				warnRouteConfig(`addRoute() replaced existing route "${normalizedRoute.name}" (${createAbsoluteRoutePath(existingRoute.path)} -> ${createAbsoluteRoutePath(normalizedRoute.path)}) and removed ${namesToRemove.size - 1} nested route(s)`);
+			}
+			namedRouteLookup.recordByName.set(normalizedRoute.name, normalizedRoute);
+			addedRoutes.push(normalizedRoute);
+		}
+		namedRouteLookup.nameByStaticPath = createNamedRouteNameByStaticPath(namedRouteLookup.recordByName);
+		return () => {
+			let changed = false;
+			for (const addedRoute of addedRoutes) if (namedRouteLookup.recordByName.get(addedRoute.name) === addedRoute) {
+				namedRouteLookup.recordByName.delete(addedRoute.name);
+				changed = true;
+			}
+			if (changed) namedRouteLookup.nameByStaticPath = createNamedRouteNameByStaticPath(namedRouteLookup.recordByName);
+		};
+	});
+	function removeRoute(name) {
+		const namesToRemove = collectRouteNamesForRemoval(name, namedRouteLookup.recordByName);
+		if (namesToRemove.size === 0) return;
+		let changed = false;
+		for (const routeName of namesToRemove) changed = namedRouteLookup.recordByName.delete(routeName) || changed;
+		if (changed) namedRouteLookup.nameByStaticPath = createNamedRouteNameByStaticPath(namedRouteLookup.recordByName);
+	}
+	function clearRoutes() {
+		namedRouteLookup.recordByName.clear();
+		namedRouteLookup.nameByStaticPath.clear();
+	}
+	return {
+		hasRoute,
+		getRoutes,
+		addRoute,
+		removeRoute,
+		clearRoutes
+	};
+}
+//#endregion
+//#region src/router/useRouter.ts
+/**
+* @description 获取高阶路由导航器（对齐 Vue Router 心智）
+*/
+function useRouter(options = {}) {
+	var _options$maxRedirects, _options$paramsMode, _options$rejectOnErro, _options$parseQuery, _options$stringifyQue, _options$tabBarEntrie;
+	const nativeRouter = useNativeRouter();
+	const route = useRoute();
+	const beforeEachGuards = /* @__PURE__ */ new Set();
+	const beforeResolveGuards = /* @__PURE__ */ new Set();
+	const afterEachHooks = /* @__PURE__ */ new Set();
+	const errorHandlers = /* @__PURE__ */ new Set();
+	const maxRedirects = (_options$maxRedirects = options.maxRedirects) !== null && _options$maxRedirects !== void 0 ? _options$maxRedirects : 10;
+	const paramsMode = (_options$paramsMode = options.paramsMode) !== null && _options$paramsMode !== void 0 ? _options$paramsMode : "loose";
+	const rejectOnError = (_options$rejectOnErro = options.rejectOnError) !== null && _options$rejectOnErro !== void 0 ? _options$rejectOnErro : true;
+	const routeResolveCodec = {
+		parseQuery: (_options$parseQuery = options.parseQuery) !== null && _options$parseQuery !== void 0 ? _options$parseQuery : parseQuery,
+		stringifyQuery: (_options$stringifyQue = options.stringifyQuery) !== null && _options$stringifyQue !== void 0 ? _options$stringifyQue : stringifyQuery
+	};
+	const readyPromise = Promise.resolve();
+	const routeEntries = resolveRouteOptionEntries(options);
+	warnDuplicateRouteEntries(routeEntries);
+	const namedRouteLookup = createNamedRouteLookup(routeEntries);
+	const normalizedTabBarEntries = ((_options$tabBarEntrie = options.tabBarEntries) !== null && _options$tabBarEntrie !== void 0 ? _options$tabBarEntrie : []).map((path) => resolvePath(path, "")).filter(Boolean);
+	const tabBarPathSet = new Set(normalizedTabBarEntries);
+	const routeRegistry = createRouteRegistry(namedRouteLookup);
+	const routerOptions = createRouterOptionsSnapshot(normalizedTabBarEntries, routeRegistry.getRoutes(), paramsMode, maxRedirects, routeResolveCodec, rejectOnError);
+	function resolveWithCodec(to, currentPath) {
+		const resolved = resolveRouteLocation(typeof to === "string" ? to : resolveNamedRouteLocation(to, namedRouteLookup, paramsMode), currentPath, routeResolveCodec);
+		resolved.href = resolved.fullPath;
+		const matchedResult = resolveMatchedRouteRecord(resolved, namedRouteLookup);
+		if (matchedResult) {
+			const matchedRecord = matchedResult.record;
+			if (resolved.name === void 0) resolved.name = matchedRecord.name;
+			const mergedRouteMeta = mergeMatchedRouteMeta(matchedResult.matchedRecords);
+			if (mergedRouteMeta !== void 0) resolved.meta = cloneRouteMeta(mergedRouteMeta);
+			if (matchedResult.params && Object.keys(resolved.params).length === 0) resolved.params = cloneRouteParams(matchedResult.params);
+			resolved.matched = matchedResult.matchedRecords.map((record, index, records) => {
+				return normalizeRouteRecordMatched(record, index === records.length - 1 ? matchedResult.matchedPath : void 0);
+			});
+		} else resolved.matched = [];
+		return resolved;
+	}
+	function resolve(to) {
+		return resolveWithCodec(to, route.path);
+	}
+	function install(_app) {}
+	function isReady() {
+		return readyPromise;
+	}
+	const navigationApi = createNavigationApi({
+		nativeRouter,
+		route,
+		routeResolveCodec,
+		namedRouteLookup,
+		beforeEachGuards,
+		beforeResolveGuards,
+		maxRedirects,
+		tabBarPathSet,
+		resolveWithCodec,
+		settleNavigationResult: createNavigationResultController({
+			afterEachHooks,
+			errorHandlers,
+			nativeRouter,
+			rejectOnError
+		}).settleNavigationResult
+	});
+	function beforeEach(guard) {
+		beforeEachGuards.add(guard);
+		return () => {
+			beforeEachGuards.delete(guard);
+		};
+	}
+	function beforeResolve(guard) {
+		beforeResolveGuards.add(guard);
+		return () => {
+			beforeResolveGuards.delete(guard);
+		};
+	}
+	function afterEach(hook) {
+		afterEachHooks.add(hook);
+		return () => {
+			afterEachHooks.delete(hook);
+		};
+	}
+	function onError(handler) {
+		errorHandlers.add(handler);
+		return () => {
+			errorHandlers.delete(handler);
+		};
+	}
+	return {
+		nativeRouter,
+		options: routerOptions,
+		currentRoute: route,
+		install,
+		resolve,
+		isReady,
+		push: navigationApi.push,
+		replace: navigationApi.replace,
+		back: navigationApi.back,
+		go: navigationApi.go,
+		forward: navigationApi.forward,
+		hasRoute: routeRegistry.hasRoute,
+		getRoutes: routeRegistry.getRoutes,
+		addRoute: routeRegistry.addRoute,
+		removeRoute: routeRegistry.removeRoute,
+		clearRoutes: routeRegistry.clearRoutes,
+		beforeEach,
+		beforeResolve,
+		afterEach,
+		onError
+	};
+}
+//#endregion
+export { NavigationFailureType, createNavigationFailure, isNavigationFailure, parseQuery, resolveRouteLocation, stringifyQuery, useNativePageRouter, useNativeRouter, useRoute, useRouter };