@askrjs/askr 0.3.0 → 0.4.0

package/dist/route-matching-CUzZ31gT.js

@@ -1,551 +0,0 @@
-import { d as getCurrentAppRenderRuntime } from "./scope-Cq_iYbTR.js";
-import { n as getActiveRenderContext } from "./render-context-B7ohlh6t.js";
-//#region src/router/match.ts
-function splitPathSegments(path) {
-	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-	if (!normalized || normalized === "/") return [];
-	const withoutLeadingSlash = normalized.startsWith("/") ? normalized.slice(1) : normalized;
-	return withoutLeadingSlash.length === 0 ? [] : withoutLeadingSlash.split("/");
-}
-function normalizeRouteSegmentName(value) {
-	return value.trim();
-}
-/**
-* Parse a route template path into typed segments.
-*
-* @example
-* parseSegments('/users/{id}')  // [{kind:'static',value:'users'},{kind:'param',value:'id'}]
-* parseSegments('/*')           // [{kind:'catchall',value:'*'}]
-* parseSegments('/posts/*')     // [{kind:'static',value:'posts'},{kind:'wildcard',value:'*'}]
-* parseSegments('/files/{*path}') // [{kind:'static',value:'files'},{kind:'splat',value:'path'}]
-*/
-function parseSegments(path) {
-	const parts = (path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path).split("/").filter(Boolean);
-	if (parts.length === 1 && parts[0] === "*") return [{
-		kind: "catchall",
-		value: "*"
-	}];
-	return parts.map((segment) => {
-		if (segment.startsWith("{") && segment.endsWith("}")) {
-			const value = normalizeRouteSegmentName(segment.slice(1, -1));
-			if (value.startsWith("*")) return {
-				kind: "splat",
-				value: normalizeRouteSegmentName(value.slice(1))
-			};
-			return {
-				kind: "param",
-				value
-			};
-		}
-		if (segment === "*") return {
-			kind: "wildcard",
-			value: "*"
-		};
-		return {
-			kind: "static",
-			value: segment
-		};
-	});
-}
-/**
-* Compute a numeric specificity rank from a parsed segment list.
-*
-* Scoring: static = 3, param = 2, wildcard = 1, catchall = 0.
-* Higher rank wins when multiple routes match the same path.
-*/
-function computeRank(segments) {
-	if (segments.length === 1 && segments[0].kind === "catchall") return -1;
-	let score = 0;
-	for (const seg of segments) if (seg.kind === "static") score += 3;
-	else if (seg.kind === "param") score += 2;
-	else if (seg.kind === "wildcard") score += 1;
-	else if (seg.kind === "splat") score -= .5;
-	return score;
-}
-/** Reused frozen empty params object — returned for purely-static (no-capture) routes. */
-const emptyParams = Object.freeze(Object.create(null));
-Object.freeze({
-	matched: false,
-	params: emptyParams
-});
-function decodeRouteParam(part) {
-	if (!part.includes("%")) return part;
-	try {
-		return decodeURIComponent(part);
-	} catch {
-		return part;
-	}
-}
-/**
-* Match pre-split URL parts against pre-parsed route segments.
-*
-* This is the hot-path matcher used by `resolveRoute` and
-* `resolveRouteFromRoutes`. Callers split the URL path **once** and reuse
-* `urlParts` across all route comparisons in a single resolution call.
-*
-* - Returns a params object (possibly the shared `{}`) on match.
-* - Returns `null` on no match.
-* - Params are allocated lazily — purely-static routes return the frozen
-*   empty sentinel without any heap allocation.
-*/
-function matchSegments(urlParts, segments) {
-	if (segments.length === 1 && segments[0].kind === "catchall") return { "*": urlParts.length === 0 ? "/" : urlParts.length === 1 ? urlParts[0] : "/" + urlParts.join("/") };
-	const splatIndex = segments.findIndex((segment) => segment.kind === "splat");
-	if (splatIndex !== -1) {
-		if (splatIndex !== segments.length - 1) return null;
-		if (urlParts.length < splatIndex) return null;
-	} else if (urlParts.length !== segments.length) return null;
-	let params = null;
-	const normalizeCapturedSplatParts = (parts) => {
-		let start = 0;
-		while (start < parts.length && parts[start] === "") start += 1;
-		return start === 0 ? parts : parts.slice(start);
-	};
-	for (let i = 0; i < segments.length; i++) {
-		const seg = segments[i];
-		const part = urlParts[i];
-		if (seg.kind === "static") {
-			if (seg.value !== part) return null;
-		} else if (seg.kind === "splat") {
-			if (params === null) params = {};
-			params[seg.value] = normalizeCapturedSplatParts(urlParts.slice(i).map(decodeRouteParam)).join("/");
-			return params;
-		} else {
-			if (params === null) params = {};
-			if (seg.kind === "param") params[seg.value] = decodeRouteParam(part);
-			else params["*"] = part;
-		}
-	}
-	return params ?? emptyParams;
-}
-//#endregion
-//#region src/router/store.ts
-function createRouteTable() {
-	return {
-		routes: [],
-		records: [],
-		namespaces: /* @__PURE__ */ new Set(),
-		routesByDepth: /* @__PURE__ */ new Map(),
-		registrationScopeStack: [],
-		registrationLocked: false,
-		defaultRouteAuthOptions: void 0,
-		activeClientRouteAuthOptions: void 0,
-		defaultRouteBasePath: ""
-	};
-}
-let activeTable = createRouteTable();
-/** Run `fn` with `table` as the registration target, then restore the previous one. */
-function withRouteTable(table, fn) {
-	const previous = activeTable;
-	activeTable = table;
-	try {
-		return fn();
-	} finally {
-		activeTable = previous;
-	}
-}
-function getDepth(path) {
-	const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-	return normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
-}
-function getRouteRecords() {
-	return activeTable.records;
-}
-function isRouteStoreRoutes(routeList) {
-	return routeList === activeTable.routes;
-}
-function insertRecordSorted(record) {
-	let lo = 0;
-	let hi = activeTable.records.length;
-	while (lo < hi) {
-		const mid = lo + hi >>> 1;
-		if (activeTable.records[mid].rank >= record.rank) lo = mid + 1;
-		else hi = mid;
-	}
-	activeTable.records.splice(lo, 0, record);
-}
-function addRouteToStores(routeObj) {
-	activeTable.routes.push(routeObj);
-	const depth = getDepth(routeObj.path);
-	let depthRoutes = activeTable.routesByDepth.get(depth);
-	if (!depthRoutes) {
-		depthRoutes = [];
-		activeTable.routesByDepth.set(depth, depthRoutes);
-	}
-	depthRoutes.push(routeObj);
-	if (routeObj.namespace) activeTable.namespaces.add(routeObj.namespace);
-}
-function getActiveRoutes() {
-	return getActiveRenderContext()?.routes ?? getCurrentAppRenderRuntime()?.routeRegistry?.routes ?? activeTable.routes;
-}
-function getActiveRouteAuthOptions(override) {
-	if (override !== void 0) return override;
-	const renderContext = getActiveRenderContext();
-	if (renderContext) return renderContext.routeAuth;
-	const appRuntime = getCurrentAppRenderRuntime();
-	if (appRuntime) return appRuntime.routeAuth;
-	return activeTable.activeClientRouteAuthOptions ?? activeTable.defaultRouteAuthOptions;
-}
-function _setActiveRouteAuthOptions(auth) {
-	activeTable.activeClientRouteAuthOptions = auth;
-}
-function getDefaultRouteAuthOptions() {
-	return activeTable.defaultRouteAuthOptions;
-}
-function setDefaultRouteAuthOptions(auth) {
-	activeTable.defaultRouteAuthOptions = auth;
-}
-function getDefaultRouteBasePath() {
-	return activeTable.defaultRouteBasePath;
-}
-function setDefaultRouteBasePath(basePath) {
-	activeTable.defaultRouteBasePath = basePath;
-}
-function getActiveRouteBasePath() {
-	const renderContext = getActiveRenderContext();
-	if (renderContext?.basePath !== void 0) return renderContext.basePath;
-	const appRegistry = getCurrentAppRenderRuntime()?.routeRegistry;
-	if (appRegistry) return appRegistry.manifest.basePath ?? "";
-	return activeTable.defaultRouteBasePath;
-}
-function getCurrentLayoutChain() {
-	const layoutChain = [];
-	for (const scope of activeTable.registrationScopeStack) if (scope.layout) layoutChain.push({ component: scope.layout });
-	return layoutChain;
-}
-function getCurrentPageChain() {
-	const pageChain = [];
-	for (const scope of activeTable.registrationScopeStack) if (scope.page) pageChain.push({ component: scope.page });
-	return pageChain;
-}
-function hasActivePageScope() {
-	return activeTable.registrationScopeStack.some((scope) => !!scope.page);
-}
-function getCurrentPageScope() {
-	for (let index = activeTable.registrationScopeStack.length - 1; index >= 0; index -= 1) {
-		const scope = activeTable.registrationScopeStack[index];
-		if (scope.kind === "page") return scope;
-	}
-	return null;
-}
-function getCurrentScopeKind() {
-	return activeTable.registrationScopeStack[activeTable.registrationScopeStack.length - 1]?.kind ?? null;
-}
-function getCurrentPathPrefix() {
-	return activeTable.registrationScopeStack[activeTable.registrationScopeStack.length - 1]?.pathPrefix ?? "";
-}
-function getCurrentInheritedPolicies() {
-	const policies = [];
-	for (const scope of activeTable.registrationScopeStack) if (scope.policies.length > 0) policies.push(...scope.policies);
-	return policies;
-}
-function getCurrentInheritedAuthRequirements() {
-	return activeTable.registrationScopeStack.flatMap((scope) => scope.auth ? [scope.auth] : []);
-}
-function getCurrentInheritedMeta() {
-	return activeTable.registrationScopeStack.flatMap((scope) => scope.meta ? [scope.meta] : []);
-}
-function pushRegistrationScope(scope, fn) {
-	activeTable.registrationScopeStack.push(scope);
-	try {
-		fn();
-	} finally {
-		activeTable.registrationScopeStack.pop();
-	}
-}
-function lockRouteRegistration() {
-	activeTable.registrationLocked = true;
-}
-function assertRouteRegistrationUnlocked() {
-	if (activeTable.registrationLocked) throw new Error("Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR.");
-}
-function getRouteList() {
-	return [...activeTable.routes];
-}
-function hasRegisteredRoutes() {
-	return activeTable.routes.length > 0 || activeTable.records.length > 0;
-}
-function clearRouteState() {
-	activeTable.routes.length = 0;
-	activeTable.records.length = 0;
-	activeTable.namespaces.clear();
-	activeTable.routesByDepth.clear();
-	activeTable.registrationScopeStack.length = 0;
-	activeTable.registrationLocked = false;
-	activeTable.defaultRouteAuthOptions = void 0;
-	activeTable.activeClientRouteAuthOptions = void 0;
-	activeTable.defaultRouteBasePath = "";
-}
-//#endregion
-//#region src/router/route-context.ts
-function parseLocation(url) {
-	try {
-		const parsedUrl = new URL(url, "http://localhost");
-		return {
-			pathname: parsedUrl.pathname,
-			search: parsedUrl.search,
-			hash: parsedUrl.hash
-		};
-	} catch {
-		return {
-			pathname: "/",
-			search: "",
-			hash: ""
-		};
-	}
-}
-function deepFreeze(obj) {
-	if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
-		Object.freeze(obj);
-		for (const key of Object.keys(obj)) {
-			const value = obj[key];
-			if (value && typeof value === "object") deepFreeze(value);
-		}
-	}
-	return obj;
-}
-function makeQuery(search) {
-	const searchParams = new URLSearchParams(search || "");
-	const mapping = /* @__PURE__ */ new Map();
-	for (const [key, value] of searchParams.entries()) {
-		const existing = mapping.get(key);
-		if (existing) existing.push(value);
-		else mapping.set(key, [value]);
-	}
-	return deepFreeze({
-		get(key) {
-			const values = mapping.get(key);
-			return values ? values[0] : null;
-		},
-		getAll(key) {
-			const values = mapping.get(key);
-			return values ? [...values] : [];
-		},
-		has(key) {
-			return mapping.has(key);
-		},
-		toJSON() {
-			const output = {};
-			for (const [key, values] of mapping.entries()) output[key] = values.length > 1 ? [...values] : values[0];
-			return output;
-		}
-	});
-}
-function buildRouteContextBase(target, params, options) {
-	const parsed = parseLocation(target);
-	const href = `${parsed.pathname}${parsed.search}${parsed.hash}`;
-	return {
-		mode: options.mode,
-		params,
-		pathname: parsed.pathname,
-		search: parsed.search,
-		hash: parsed.hash,
-		href,
-		signal: options.signal
-	};
-}
-function buildRouteContext(target, params, options) {
-	return {
-		...buildRouteContextBase(target, params, options),
-		auth: options.authContext
-	};
-}
-//#endregion
-//#region src/router/base-path.ts
-/** Normalize the public mount point used by one route registry. */
-function normalizeRouteBasePath(value) {
-	if (value === void 0 || value === "" || value === "/") return "";
-	if (!value.startsWith("/") || /\/{2,}/.test(value) || value.includes("?") || value.includes("#") || value.includes("\\")) throw new TypeError(`Route basePath must be an absolute pathname without a query or hash. Received: ${JSON.stringify(value)}`);
-	const normalized = value.endsWith("/") ? value.slice(0, -1) : value;
-	if (normalized.split("/").some((segment) => segment === "." || segment === "..")) throw new TypeError("Route basePath must not contain dot segments.");
-	return normalized;
-}
-function parsedTarget(target) {
-	return new URL(target, "http://askr.invalid");
-}
-/** Add a registry mount point to one logical root-relative route target. */
-function addRouteBasePath(target, basePath) {
-	if (!basePath || !target.startsWith("/") || target.startsWith("//")) return target;
-	const parsed = parsedTarget(target);
-	if (parsed.origin !== "http://askr.invalid" || parsed.pathname === basePath || parsed.pathname.startsWith(`${basePath}/`)) return target;
-	return `${basePath}${parsed.pathname}${parsed.search}${parsed.hash}`;
-}
-/** Remove a registry mount point and retain query/hash for logical matching. */
-function removeRouteBasePath(target, basePath) {
-	const parsed = parsedTarget(target);
-	if (!basePath) return `${parsed.pathname}${parsed.search}${parsed.hash}`;
-	if (parsed.pathname === basePath || parsed.pathname === `${basePath}/`) return `/${parsed.search}${parsed.hash}`;
-	if (!parsed.pathname.startsWith(`${basePath}/`)) return void 0;
-	return `${parsed.pathname.slice(basePath.length)}${parsed.search}${parsed.hash}`;
-}
-//#endregion
-//#region src/router/route-matching.ts
-const routeSegsCache = /* @__PURE__ */ new WeakMap();
-const routeRankCache = /* @__PURE__ */ new WeakMap();
-const sortedListCache = /* @__PURE__ */ new WeakMap();
-function cachedSegs(route) {
-	let segments = routeSegsCache.get(route);
-	if (!segments) {
-		segments = parseSegments(route.path);
-		routeSegsCache.set(route, segments);
-	}
-	return segments;
-}
-function cachedRank(route) {
-	let rank = routeRankCache.get(route);
-	if (rank === void 0) {
-		rank = computeRank(cachedSegs(route));
-		routeRankCache.set(route, rank);
-	}
-	return rank;
-}
-function cachedSortedList(routeList) {
-	let sorted = sortedListCache.get(routeList);
-	if (!sorted) {
-		sorted = [...routeList].sort((a, b) => cachedRank(b) - cachedRank(a));
-		sortedListCache.set(routeList, sorted);
-	}
-	return sorted;
-}
-function matchFallbackPrefix(pathname, fallbackPrefix) {
-	const normalizedPath = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const normalizedPrefix = fallbackPrefix.endsWith("/") && fallbackPrefix !== "/" ? fallbackPrefix.slice(0, -1) : fallbackPrefix;
-	if (normalizedPrefix === "/") {
-		const urlParts = splitPathSegments(normalizedPath);
-		return { "*": urlParts.length === 0 ? "/" : urlParts.length === 1 ? urlParts[0] : "/" + urlParts.join("/") };
-	}
-	if (normalizedPath !== normalizedPrefix && !normalizedPath.startsWith(`${normalizedPrefix}/`)) return null;
-	const remainderParts = splitPathSegments(normalizedPath === normalizedPrefix ? "/" : normalizedPath.slice(normalizedPrefix.length));
-	return { "*": remainderParts.length === 0 ? "/" : remainderParts.length === 1 ? remainderParts[0] : "/" + remainderParts.join("/") };
-}
-function findBestResolvedRouteFromRoutes(pathname, routeList) {
-	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const urlParts = splitPathSegments(normalized);
-	const sorted = cachedSortedList(routeList);
-	let bestRoute = null;
-	let bestParams = {};
-	let bestRank = -Infinity;
-	for (const route of sorted) {
-		if (route.fallbackPrefix) continue;
-		const rank = cachedRank(route);
-		if (rank < bestRank) break;
-		if (bestRoute !== null && rank === bestRank) continue;
-		const params = matchSegments(urlParts, cachedSegs(route));
-		if (params !== null) {
-			bestRoute = route;
-			bestParams = params;
-			bestRank = rank;
-		}
-	}
-	if (bestRoute !== null) return {
-		route: bestRoute,
-		params: bestParams
-	};
-	let bestFallback = null;
-	let bestFallbackParams = null;
-	let bestPrefixLength = -1;
-	for (const route of routeList) {
-		const internalRoute = route;
-		if (!internalRoute.fallbackPrefix) continue;
-		const params = matchFallbackPrefix(normalized, internalRoute.fallbackPrefix);
-		if (params === null) continue;
-		if (internalRoute.fallbackPrefix.length > bestPrefixLength) {
-			bestFallback = internalRoute;
-			bestFallbackParams = params;
-			bestPrefixLength = internalRoute.fallbackPrefix.length;
-		}
-	}
-	return bestFallback && bestFallbackParams ? {
-		route: bestFallback,
-		params: bestFallbackParams
-	} : null;
-}
-function findBestScopedFallbackRecord(pathname, routeRecords) {
-	let bestRecord = null;
-	let bestParams = null;
-	let bestPrefixLength = -1;
-	for (const routeRecord of routeRecords) {
-		const record = routeRecord;
-		if (!record.fallbackPrefix) continue;
-		const params = matchFallbackPrefix(pathname, record.fallbackPrefix);
-		if (params === null) continue;
-		if (record.fallbackPrefix.length > bestPrefixLength) {
-			bestRecord = record;
-			bestParams = params;
-			bestPrefixLength = record.fallbackPrefix.length;
-		}
-	}
-	return bestRecord && bestParams ? {
-		record: bestRecord,
-		params: bestParams
-	} : null;
-}
-function getMatchingRouteRecord(target, routeRecords) {
-	const location = parseLocation(target);
-	const normalized = location.pathname.endsWith("/") && location.pathname !== "/" ? location.pathname.slice(0, -1) : location.pathname;
-	const urlParts = splitPathSegments(normalized);
-	for (const record of routeRecords) {
-		if (record.fallbackPrefix) continue;
-		const params = matchSegments(urlParts, record.segments);
-		if (params !== null) return {
-			record,
-			params
-		};
-	}
-	return findBestScopedFallbackRecord(normalized, routeRecords);
-}
-function computeMatchesFromRoutes(pathname, routesList) {
-	const bestMatch = isRouteStoreRoutes(routesList) ? getMatchingRouteRecord(pathname, getRouteRecords()) : findBestResolvedRouteFromRoutes(pathname, routesList);
-	if (!bestMatch) return [];
-	return [{
-		path: "route" in bestMatch ? bestMatch.route.path : bestMatch.record.path,
-		params: deepFreeze({ ...bestMatch.params }),
-		name: "route" in bestMatch ? bestMatch.route.name : void 0,
-		namespace: "route" in bestMatch ? bestMatch.route.namespace : bestMatch.record.options.namespace
-	}];
-}
-function computeMatchesFromRouteRecords(pathname, routeRecords) {
-	const bestMatch = getMatchingRouteRecord(pathname, routeRecords);
-	if (!bestMatch) return [];
-	return [{
-		path: bestMatch.record.path,
-		params: deepFreeze({ ...bestMatch.params }),
-		namespace: bestMatch.record.options.namespace
-	}];
-}
-function computeRouteActivityMatches(pathname, options) {
-	const logicalPath = removeRouteBasePath(pathname, normalizeRouteBasePath(options.registry.manifest.basePath));
-	if (logicalPath === void 0) return [];
-	return computeMatchesFromRouteRecords(logicalPath, options.registry.manifest.records);
-}
-function resolveRoute(pathname) {
-	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const urlParts = splitPathSegments(normalized);
-	const records = getRouteRecords();
-	for (const record of records) {
-		if (record.fallbackPrefix) continue;
-		const params = matchSegments(urlParts, record.segments);
-		if (params !== null) return {
-			handler: record.handler,
-			params
-		};
-	}
-	const fallbackMatch = findBestScopedFallbackRecord(normalized, records);
-	return fallbackMatch ? {
-		handler: fallbackMatch.record.handler,
-		params: fallbackMatch.params
-	} : null;
-}
-function resolveRouteFromRoutes(pathname, routeList) {
-	if (isRouteStoreRoutes(routeList)) return resolveRoute(pathname);
-	const match = findBestResolvedRouteFromRoutes(pathname, routeList);
-	return match ? {
-		handler: match.route.handler,
-		params: match.params
-	} : null;
-}
-function _resolveRouteMatchFromRoutes(pathname, routeList) {
-	return findBestResolvedRouteFromRoutes(pathname, routeList);
-}
-//#endregion
-export { getDefaultRouteAuthOptions as A, setDefaultRouteBasePath as B, getCurrentInheritedMeta as C, getCurrentPageScope as D, getCurrentPageChain as E, hasRegisteredRoutes as F, computeRank as H, insertRecordSorted as I, lockRouteRegistration as L, getRouteList as M, getRouteRecords as N, getCurrentPathPrefix as O, hasActivePageScope as P, pushRegistrationScope as R, getCurrentInheritedAuthRequirements as S, getCurrentLayoutChain as T, normalizeRouteSegmentName as U, withRouteTable as V, parseSegments as W, clearRouteState as _, resolveRouteFromRoutes as a, getActiveRouteBasePath as b, removeRouteBasePath as c, deepFreeze as d, makeQuery as f, assertRouteRegistrationUnlocked as g, addRouteToStores as h, getMatchingRouteRecord as i, getDefaultRouteBasePath as j, getCurrentScopeKind as k, buildRouteContext as l, _setActiveRouteAuthOptions as m, computeMatchesFromRoutes as n, addRouteBasePath as o, parseLocation as p, computeRouteActivityMatches as r, normalizeRouteBasePath as s, _resolveRouteMatchFromRoutes as t, buildRouteContextBase as u, createRouteTable as v, getCurrentInheritedPolicies as w, getActiveRoutes as x, getActiveRouteAuthOptions as y, setDefaultRouteAuthOptions as z };

package/dist/router-internal-7nuNEHfG.js

@@ -1,36 +0,0 @@
-//#region src/common/url.ts
-const SAFE_URL_SCHEMES = /* @__PURE__ */ new Set([
-	"http",
-	"https",
-	"mailto",
-	"sms",
-	"tel"
-]);
-const URL_SCHEME_RE = /^([a-z][a-z0-9+.-]*):/i;
-function isSafeHref(value) {
-	const compact = value.trim().replace(/[\u0000-\u0020\u007f-\u009f]/g, "");
-	const scheme = URL_SCHEME_RE.exec(compact)?.[1]?.toLowerCase();
-	return scheme === void 0 || SAFE_URL_SCHEMES.has(scheme);
-}
-/**
-* Attribute names (lowercased) that can carry a browser-navigable/executable
-* URL and must be checked against isSafeHref. Shared between the client
-* renderer (renderer/attributes.ts) and SSR (ssr/attrs.ts) so their unsafe-
-* URL handling can't drift. Deliberately excludes `src`: it covers a much
-* wider range of legitimate non-navigable values (data: image URIs, blob:
-* URLs, etc.) where the same scheme allowlist would be overly aggressive.
-*/
-const UNSAFE_URL_SCHEME_ATTRIBUTES = /* @__PURE__ */ new Set([
-	"href",
-	"formaction",
-	"action",
-	"xlink:href"
-]);
-function isUnsafeUrlAttribute(key, value) {
-	return UNSAFE_URL_SCHEME_ATTRIBUTES.has(key.toLowerCase()) && !isSafeHref(String(value));
-}
-//#endregion
-//#region src/common/router-internal.ts
-const ROUTE_ROOT_COMPONENT = Symbol.for("askr.route-root-component");
-//#endregion
-export { isSafeHref as n, isUnsafeUrlAttribute as r, ROUTE_ROOT_COMPONENT as t };