@askrjs/askr 0.3.0 → 0.4.0

package/dist/resolution-3DskUkjG.js

@@ -1,577 +0,0 @@
-import { P as isPromiseLike, m as defineScope, v as readScope } from "./instance-VAFYVJOa.js";
-import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-DRS-qjiN.js";
-import { S as withPageFramework, b as replacePageRoute, n as getActiveRenderContext } from "./render-context-B7ohlh6t.js";
-import { t as ROUTE_ROOT_COMPONENT } from "./router-internal-7nuNEHfG.js";
-import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-LrYpQsDJ.js";
-import { c as removeRouteBasePath, i as getMatchingRouteRecord, l as buildRouteContext, o as addRouteBasePath, s as normalizeRouteBasePath, u as buildRouteContextBase, y as getActiveRouteAuthOptions } from "./route-matching-CUzZ31gT.js";
-//#region src/common/deferred-value.ts
-const DEFERRED_VALUE = Symbol.for("@askrjs/askr/deferred-value");
-const DEFERRED_BOUNDARY = Symbol.for("@askrjs/askr/deferred-boundary");
-/** Wrap a promise as a {@link Deferred} value that tracks its settled state and result. */
-function defer(promise) {
-	let state = "pending";
-	let value;
-	let error;
-	const normalized = Promise.resolve(promise);
-	normalized.then((resolved) => {
-		state = "fulfilled";
-		value = resolved;
-	}, (reason) => {
-		state = "rejected";
-		error = reason;
-	});
-	return Object.freeze(Object.defineProperties({}, {
-		state: {
-			enumerable: true,
-			get: () => state
-		},
-		value: {
-			enumerable: true,
-			get: () => value
-		},
-		error: {
-			enumerable: true,
-			get: () => error
-		},
-		promise: { value: normalized },
-		[DEFERRED_VALUE]: { value: true }
-	}));
-}
-/** Check whether `value` is a {@link Deferred} produced by {@link defer}. */
-function isDeferred(value) {
-	if (!value || typeof value !== "object") return false;
-	const marker = Object.getOwnPropertyDescriptor(value, DEFERRED_VALUE);
-	return Boolean(marker && "value" in marker && marker.value === true);
-}
-/** @internal Reconstruct settled server data without importing deferred rendering. */
-function reviveDeferredValue(state, value, error) {
-	const promise = state === "fulfilled" ? Promise.resolve(value) : Promise.reject(error);
-	if (state === "rejected") promise.catch(() => void 0);
-	return Object.freeze(Object.defineProperties({}, {
-		state: {
-			enumerable: true,
-			value: state
-		},
-		value: {
-			enumerable: true,
-			value
-		},
-		error: {
-			enumerable: true,
-			value: error
-		},
-		promise: { value: promise },
-		[DEFERRED_VALUE]: { value: true }
-	}));
-}
-//#endregion
-//#region src/router/route-hydration.ts
-function isDeferredHydrationValue(value) {
-	return isDeferred(value);
-}
-const omissionGuards = /* @__PURE__ */ new WeakMap();
-function propertyPath(parent, key) {
-	if (/^(?:0|[1-9]\d*)$/.test(key)) return `${parent}[${key}]`;
-	if (/^[A-Za-z_$][\w$]*$/.test(key)) return `${parent}.${key}`;
-	return `${parent}[${JSON.stringify(key)}]`;
-}
-function invalid(route, path, reason) {
-	throw new TypeError(`[Askr] Route hydration data for "${route}" at "${path}" is not JSON transport-safe: ${reason}. Return JSON-compatible data or use route(..., { dehydrate(data) { ... } }) to omit server-only values.`);
-}
-function objectLabel(value) {
-	if (value instanceof Date) return "Date";
-	if (value instanceof Map) return "Map";
-	if (value instanceof Set) return "Set";
-	const constructor = value.constructor;
-	return typeof constructor === "function" && constructor.name ? constructor.name : "class instance";
-}
-/** Validate the exact value that will enter the route hydration envelope. */
-function validateRouteHydrationData(value, route, path = "$", ancestors = /* @__PURE__ */ new Set()) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) invalid(route, path, "non-finite numbers are not supported");
-		return;
-	}
-	if (typeof value === "undefined") invalid(route, path, "undefined is not supported");
-	if (typeof value === "bigint") invalid(route, path, "bigint is not supported");
-	if (typeof value === "symbol") invalid(route, path, "symbols are not supported");
-	if (typeof value === "function") invalid(route, path, "functions are not supported");
-	const object = value;
-	if (isDeferredHydrationValue(object)) {
-		if (object.state === "fulfilled") validateRouteHydrationData(object.value, route, `${path}.value`, ancestors);
-		return;
-	}
-	if (ancestors.has(object)) invalid(route, path, "cyclic references are not supported");
-	ancestors.add(object);
-	try {
-		if (Array.isArray(object)) {
-			for (let index = 0; index < object.length; index += 1) if (!Object.prototype.hasOwnProperty.call(object, index)) invalid(route, `${path}[${index}]`, "sparse arrays are not supported");
-			for (const key of Reflect.ownKeys(object)) {
-				if (key === "length") continue;
-				if (typeof key === "symbol") invalid(route, path, "symbol-keyed properties are not supported");
-				const descriptor = Object.getOwnPropertyDescriptor(object, key);
-				if (!descriptor.enumerable) invalid(route, propertyPath(path, key), "non-enumerable properties are not supported");
-				if (!("value" in descriptor)) invalid(route, propertyPath(path, key), "accessors are not supported");
-				if (!/^(?:0|[1-9]\d*)$/.test(key) || Number(key) >= object.length) invalid(route, propertyPath(path, key), "named array properties are not supported");
-				validateRouteHydrationData(descriptor.value, route, propertyPath(path, key), ancestors);
-			}
-			return;
-		}
-		const prototype = Object.getPrototypeOf(object);
-		if (prototype !== Object.prototype && prototype !== null) invalid(route, path, `${objectLabel(object)} instances are not supported; use a plain object`);
-		for (const key of Reflect.ownKeys(object)) {
-			if (typeof key === "symbol") invalid(route, path, "symbol-keyed properties are not supported");
-			const descriptor = Object.getOwnPropertyDescriptor(object, key);
-			const childPath = propertyPath(path, key);
-			if (!descriptor.enumerable) invalid(route, childPath, "non-enumerable properties are not supported");
-			if (!("value" in descriptor)) invalid(route, childPath, "accessors are not supported");
-			validateRouteHydrationData(descriptor.value, route, childPath, ancestors);
-		}
-	} finally {
-		ancestors.delete(object);
-	}
-}
-function omissionMap(complete, selected, ancestors = /* @__PURE__ */ new Set()) {
-	if (!complete || typeof complete !== "object" || isDeferredHydrationValue(complete)) return void 0;
-	if (ancestors.has(complete)) return void 0;
-	ancestors.add(complete);
-	const selectedObject = selected && typeof selected === "object" ? selected : void 0;
-	const output = Object.create(null);
-	try {
-		for (const key of Object.keys(complete)) {
-			if (!selectedObject || !Object.prototype.hasOwnProperty.call(selectedObject, key)) {
-				output[key] = 1;
-				continue;
-			}
-			const completeDescriptor = Object.getOwnPropertyDescriptor(complete, key);
-			const selectedDescriptor = Object.getOwnPropertyDescriptor(selectedObject, key);
-			if (!completeDescriptor || !selectedDescriptor) continue;
-			if (!("value" in completeDescriptor) || !("value" in selectedDescriptor)) continue;
-			const nested = omissionMap(completeDescriptor.value, selectedDescriptor.value, ancestors);
-			if (nested) output[key] = nested;
-		}
-	} finally {
-		ancestors.delete(complete);
-	}
-	return Object.keys(output).length > 0 ? Object.freeze(output) : void 0;
-}
-function prepareRouteHydrationData(complete, dehydrate, context, route = context.href || context.pathname) {
-	const selected = dehydrate ? dehydrate(complete, context) : complete;
-	if (isPromiseLike(selected)) throw new TypeError(`[Askr] Route dehydrate() for "${route}" returned a Promise. dehydrate(data, context) must be synchronous.`);
-	validateRouteHydrationData(selected, route);
-	return {
-		data: selected,
-		metadata: Object.freeze({
-			r: route,
-			...dehydrate ? { o: omissionMap(complete, selected) } : {}
-		})
-	};
-}
-function readMetadata(framework) {
-	const value = framework["rh"];
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	const metadata = value;
-	return typeof metadata.r === "string" ? metadata : void 0;
-}
-function omittedRead(route, path) {
-	throw new Error(`[Askr] routeData() read "${path}" on the initial hydration of "${route}", but that branch was intentionally omitted by dehydrate(). Keep initial hydrated rendering within the selected data, or wait for a client navigation that reruns the loader with the complete result.`);
-}
-function guardOmissions(value, omissions, route, path = "$") {
-	if (!omissions || !value || typeof value !== "object" || isDeferredHydrationValue(value)) return value;
-	let guards = omissionGuards.get(value);
-	if (!guards) {
-		guards = /* @__PURE__ */ new WeakMap();
-		omissionGuards.set(value, guards);
-	}
-	const cached = guards.get(omissions);
-	if (cached) return cached;
-	const guarded = new Proxy(value, { get(target, property, receiver) {
-		if (typeof property === "string") {
-			const omitted = omissions[property];
-			if (omitted && !Object.prototype.hasOwnProperty.call(target, property)) omittedRead(route, propertyPath(path, property));
-			const child = Reflect.get(target, property, receiver);
-			return omitted === 1 ? child : guardOmissions(child, omitted, route, propertyPath(path, property));
-		}
-		return Reflect.get(target, property, receiver);
-	} });
-	guards.set(omissions, guarded);
-	return guarded;
-}
-function guardHydratedRouteData(value, framework) {
-	const metadata = readMetadata(framework);
-	return metadata ? guardOmissions(value, metadata.o, metadata.r) : value;
-}
-function getRouteHydrationMetadata(framework) {
-	return readMetadata(framework);
-}
-/** @internal Remove initial-only omission guards after a client loader reruns. */
-function withoutRouteHydrationMetadata(framework) {
-	if (!framework || !("rh" in framework)) return framework;
-	const next = { ...framework };
-	delete next["rh"];
-	return next;
-}
-//#endregion
-//#region src/router/route-data-loader.ts
-/** Thrown when a route's `loader` rejects; wraps the original `cause`. */
-var RouteDataLoadError = class extends Error {
-	constructor(route, phase, cause) {
-		const detail = cause instanceof Error ? cause.message : String(cause);
-		super("[Askr] Route data loader failed for \"" + route + "\" during " + phase + " loading: " + detail);
-		this.name = "RouteDataLoadError";
-		this.route = route;
-		this.phase = phase;
-		this.cause = cause;
-	}
-};
-function isAbortError(error) {
-	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
-}
-function loadPhase(mode) {
-	if (mode === "spa") return "client";
-	if (mode === "ssg") return "ssg";
-	return "server";
-}
-/** @internal Add route context to failures from lazyRouteData(). */
-function _wrapRouteDataLoadError(error, context) {
-	if (error instanceof RouteDataLoadError || isAbortError(error)) throw error;
-	throw new RouteDataLoadError(context.href || context.pathname, loadPhase(context.mode), error);
-}
-//#endregion
-//#region src/router/lazy.ts
-const pendingLazy = /* @__PURE__ */ new Set();
-const lazyStates = /* @__PURE__ */ new WeakMap();
-const handlerLazyComponents = /* @__PURE__ */ new WeakMap();
-function startLazyLoad(state) {
-	if (state.promise) return state.promise;
-	let promise;
-	promise = Promise.resolve().then(state.factory).then((mod) => {
-		state.resolved = typeof mod === "function" ? mod : mod.default;
-		state.loadError = null;
-		state.hasLoadError = false;
-	}, (err) => {
-		state.loadError = err;
-		state.hasLoadError = true;
-	}).finally(() => {
-		if (state.hasLoadError) state.promise = null;
-		pendingLazy.delete(promise);
-	});
-	state.promise = promise;
-	pendingLazy.add(promise);
-	return promise;
-}
-/** Wrap a dynamic-import factory as a {@link LazyRouteComponent}, loaded on first use. */
-function lazy(factory) {
-	const state = {
-		factory,
-		promise: null,
-		resolved: null,
-		loadError: null,
-		hasLoadError: false
-	};
-	const component = ((params) => {
-		if (state.hasLoadError) throw state.loadError;
-		if (!state.resolved) throw new Error("lazy() component used before it was resolved. Matched routes load automatically; call component.preload() for explicit preloading.");
-		return state.resolved(params);
-	});
-	Object.defineProperty(component, "preload", { value: () => startLazyLoad(state) });
-	lazyStates.set(component, state);
-	return component;
-}
-/**
-* Create a cached route loader backed by a dynamic import. The module is only
-* requested when the owning route matches, unless preload() is called.
-*/
-function lazyRouteData(factory, select) {
-	let imported = null;
-	const load = () => {
-		if (imported) return imported;
-		imported = Promise.resolve().then(factory).catch((error) => {
-			imported = null;
-			throw error;
-		});
-		return imported;
-	};
-	const loader = ((context) => load().then((module) => select ? select(module, context) : module).catch((error) => _wrapRouteDataLoadError(error, context)));
-	Object.defineProperty(loader, "preload", { value: () => load().then(() => void 0) });
-	return loader;
-}
-function _preloadRouteRecord(record) {
-	const imports = [
-		record.component,
-		...record.pageChain.map((scope) => scope.component),
-		...record.layoutChain.map((scope) => scope.component)
-	].flatMap((component) => {
-		const state = lazyStates.get(component);
-		return state ? [startLazyLoad(state)] : [];
-	});
-	return imports.length > 0 ? Promise.all(imports).then(() => void 0) : null;
-}
-function _associateLazyHandler(handler, components) {
-	handlerLazyComponents.set(handler, components);
-}
-function _preloadRouteHandler(handler) {
-	const imports = (handlerLazyComponents.get(handler) ?? []).flatMap((component) => {
-		const state = lazyStates.get(component);
-		return state ? [startLazyLoad(state)] : [];
-	});
-	return imports.length > 0 ? Promise.all(imports).then(() => void 0) : null;
-}
-//#endregion
-//#region src/router/rendering.ts
-const outletScope = defineScope(null);
-/** Renders the nested route content for the enclosing layout or page scope. */
-function Outlet() {
-	return {
-		$$typeof: ELEMENT_TYPE,
-		type: Fragment,
-		props: { children: readScope(outletScope) },
-		key: null
-	};
-}
-function applyPageChain(pageChain, params, content, deferComponents = false) {
-	let nextContent = content;
-	for (let i = pageChain.length - 1; i >= 0; i--) nextContent = outletScope({
-		value: nextContent,
-		children: deferComponents ? createRouteComponentVNode(pageChain[i].component, params) : pageChain[i].component(params)
-	});
-	return nextContent;
-}
-function createRouteComponentVNode(component, params, routeRoot = false) {
-	return {
-		$$typeof: ELEMENT_TYPE,
-		type: component,
-		props: params,
-		key: null,
-		...routeRoot ? { [ROUTE_ROOT_COMPONENT]: true } : {}
-	};
-}
-function createRouteHandler(component, pageChain, layoutChain, deferComponents = false) {
-	const handler = (params) => {
-		let content = deferComponents ? createRouteComponentVNode(component, params, true) : component(params);
-		content = applyPageChain(pageChain, params, content, deferComponents);
-		for (let i = layoutChain.length - 1; i >= 0; i--) {
-			const layout = layoutChain[i].component;
-			content = layout({ children: content });
-		}
-		return content;
-	};
-	_associateLazyHandler(handler, [
-		component,
-		...pageChain.map((scope) => scope.component),
-		...layoutChain.map((scope) => scope.component)
-	]);
-	return handler;
-}
-function getRenderHandler(record) {
-	return record.renderHandler ?? createRouteHandler(record.component, record.pageChain, record.layoutChain, true);
-}
-let clientAuth = Object.freeze({
-	authenticated: false,
-	principal: null,
-	session: null,
-	tenant: null
-});
-/** Return the identity resolved for the route currently being rendered. */
-function currentAuth() {
-	return getActiveRenderContext()?.authContext ?? clientAuth;
-}
-/** @internal Updated atomically with route resolution. */
-function setCurrentAuth(context) {
-	clientAuth = context;
-	const render = getActiveRenderContext();
-	if (render) render.authContext = context;
-}
-//#endregion
-//#region src/router/resolution.ts
-const anonymous = () => ({
-	authenticated: false,
-	principal: null,
-	session: null,
-	tenant: null
-});
-const routeRenderContexts = /* @__PURE__ */ new WeakMap();
-const routeRenderData = /* @__PURE__ */ new WeakMap();
-function getRouteRenderContext(result) {
-	return routeRenderContexts.get(result);
-}
-function getRouteRenderData(result) {
-	return routeRenderData.get(result);
-}
-/** Router-owned inspection of the record selected by request resolution. */
-function resolvedRouteHasLoader(result) {
-	return typeof result.record?.options?.loader === "function";
-}
-function createRouteRenderResult(record, params, context, handler) {
-	const result = {
-		kind: "render",
-		handler,
-		params
-	};
-	Object.defineProperty(result, "record", {
-		value: record,
-		enumerable: false
-	});
-	routeRenderContexts.set(result, context);
-	return result;
-}
-function getDefaultRouteMode() {
-	return typeof window !== "undefined" ? "spa" : "ssr";
-}
-function withoutInitialRouteHydrationMetadata(envelope) {
-	return withPageFramework(envelope, withoutRouteHydrationMetadata(envelope.framework) ?? {});
-}
-/** @internal Bind resolved loader output to one route subtree and its hydration envelope. */
-function bindResolvedRouteData(handler, data, hydration) {
-	return (params, context) => {
-		const renderContext = getActiveRenderContext();
-		if (renderContext) {
-			const envelope = replacePageRoute(renderContext.renderData, data);
-			renderContext.renderData = hydration ? envelope : withoutInitialRouteHydrationMetadata(envelope);
-			const hydrationEnvelope = replacePageRoute(renderContext.hydrationData, hydration?.data ?? data);
-			renderContext.hydrationData = hydration ? withPageFramework(hydrationEnvelope, {
-				...hydrationEnvelope.framework,
-				["rh"]: hydration.metadata
-			}) : withoutInitialRouteHydrationMetadata(hydrationEnvelope);
-		}
-		return handler(params, context);
-	};
-}
-function hasRouteRenderData(result) {
-	return routeRenderData.has(result);
-}
-function buildRenderResult(record, params, context, request, telemetry, load) {
-	const lazyImport = _preloadRouteRecord(record);
-	if (lazyImport) return lazyImport.then(() => buildLoadedRenderResult(record, params, context, request, telemetry, load));
-	return buildLoadedRenderResult(record, params, context, request, telemetry, load);
-}
-function buildLoadedRenderResult(record, params, context, request, telemetry, load) {
-	const renderHandler = getRenderHandler(record);
-	const loader = context.mode !== "ssg" && load ? record.options?.loader : void 0;
-	const preload = record.options?.preload;
-	const active = getActiveRenderContext();
-	const prefetch = active?.queryPrefetch ?? createQueryPrefetchContext({
-		mode: context.mode === "ssg" ? "ssr" : context.mode,
-		request,
-		signal: context.signal,
-		runtime: active?.dataRuntime,
-		telemetry
-	});
-	const runPreload = preload ? Promise.resolve(preload({
-		...context,
-		params,
-		request,
-		data: prefetch
-	})).then(() => void 0) : void 0;
-	if (loader) {
-		const load = () => withTelemetry(telemetry?.loader, { route: record.path }, () => loader({
-			...context,
-			params,
-			request
-		}));
-		const loaded = runPreload ? runPreload.then(load) : load();
-		const finalize = (data) => {
-			const hydration = context.mode === "ssr" ? prepareRouteHydrationData(data, record.options?.dehydrate, {
-				...context,
-				params,
-				request
-			}, context.href || context.pathname || record.path) : void 0;
-			const result = createRouteRenderResult(record, params, context, bindResolvedRouteData(renderHandler, data, hydration));
-			routeRenderData.set(result, data);
-			return result;
-		};
-		return isPromiseLike(loaded) ? Promise.resolve(loaded).then(finalize) : finalize(loaded);
-	}
-	if (runPreload) return runPreload.then(() => createRouteRenderResult(record, params, context, renderHandler));
-	return createRouteRenderResult(record, params, context, renderHandler);
-}
-function runPolicies(policies, context, record, params, request, telemetry, load, start = 0) {
-	for (let index = start; index < policies.length; index += 1) {
-		const result = policies[index](context);
-		if (isPromiseLike(result)) return Promise.resolve(result).then((decision) => decision.kind === "allow" ? runPolicies(policies, context, record, params, request, telemetry, load, index + 1) : decision);
-		if (result.kind !== "allow") return result;
-	}
-	return buildRenderResult(record, params, context, request, telemetry, load);
-}
-function resolvePath(value, fallback, context) {
-	return typeof value === "function" ? value(context) : value ?? fallback;
-}
-function appendNext(path, href) {
-	const target = new URL(path, "http://localhost");
-	target.searchParams.set("next", href);
-	return `${target.pathname}${target.search}${target.hash}`;
-}
-function mapAuthDecision(decision, context, options) {
-	if (decision.allowed) return { kind: "allow" };
-	if (decision.reason === "forbidden") return {
-		kind: "deny",
-		status: 403
-	};
-	const target = resolvePath(decision.reason === "unauthenticated" ? options?.loginPath : options?.authenticatedRedirectTo, decision.reason === "unauthenticated" ? "/login" : "/", context);
-	const finalize = (path) => ({
-		kind: "redirect",
-		to: decision.reason === "unauthenticated" ? appendNext(path, context.href) : path,
-		replace: decision.reason === "unauthenticated" ? context.mode === "spa" : true
-	});
-	return isPromiseLike(target) ? Promise.resolve(target).then(finalize) : finalize(target);
-}
-function resolveMatchedRoute(record, params, context, authOptions, request, telemetry, load) {
-	const continueResolution = (decision) => {
-		if (decision) {
-			const access = mapAuthDecision(decision, context, authOptions);
-			if (isPromiseLike(access)) return Promise.resolve(access).then((next) => next.kind === "allow" ? runPolicies(record.options.policies ?? [], context, record, params, request, telemetry, load) : next);
-			if (access.kind !== "allow") return access;
-		}
-		return runPolicies(record.options.policies ?? [], context, record, params, request, telemetry, load);
-	};
-	if (!record.options.auth) return continueResolution();
-	const decision = record.options.auth(context.auth);
-	return isPromiseLike(decision) ? Promise.resolve(decision).then(continueResolution) : continueResolution(decision);
-}
-/**
-* Callers may omit `signal`, and `RouteRequestOptions.signal` is optional in the
-* published contract. Route context still needs an `AbortSignal`, so this stands
-* in for "this caller supplied no cancellation". It never aborts: a route loader
-* receiving it cannot be cancelled through `context.signal`. Prefer passing a
-* real signal.
-*/
-const NEVER_ABORTED = new AbortController().signal;
-/** Resolve `target` against a route registry, applying auth/policies to produce a render/redirect/deny result. */
-function resolveRouteRequest(target, options) {
-	if (!options?.registry) throw new TypeError("resolveRouteRequest requires options.registry.");
-	const basePath = normalizeRouteBasePath(options.registry.manifest.basePath);
-	const logicalTarget = removeRouteBasePath(target, basePath);
-	if (logicalTarget === void 0) return null;
-	return withTelemetry(options.telemetry?.routeMatch, {}, () => {
-		const records = options.registry.manifest.records;
-		const match = getMatchingRouteRecord(logicalTarget, records);
-		if (!match) return null;
-		const mode = options.mode ?? getDefaultRouteMode();
-		const signal = options.signal ?? getActiveRenderContext()?.signal ?? NEVER_ABORTED;
-		const authOptions = getActiveRouteAuthOptions(options.auth ?? options.registry.manifest.auth);
-		const base = buildRouteContextBase(logicalTarget, match.params, {
-			mode,
-			signal
-		});
-		const exposeRedirect = (result) => result?.kind === "redirect" ? {
-			...result,
-			to: addRouteBasePath(result.to, basePath)
-		} : result;
-		const finalize = (authContext) => {
-			if (!signal.aborted) setCurrentAuth(authContext);
-			const result = resolveMatchedRoute(match.record, match.params, buildRouteContext(logicalTarget, match.params, {
-				mode,
-				signal,
-				authContext
-			}), authOptions, options.request, options.telemetry, options.load !== false);
-			if (!basePath) return result;
-			return isPromiseLike(result) ? Promise.resolve(result).then(exposeRedirect) : exposeRedirect(result);
-		};
-		if (options.authContext) return finalize(options.authContext);
-		if (!authOptions?.resolve) return finalize(anonymous());
-		const resolved = authOptions.resolve(base);
-		return isPromiseLike(resolved) ? Promise.resolve(resolved).then(finalize) : finalize(resolved);
-	});
-}
-//#endregion
-export { reviveDeferredValue as C, isDeferred as S, prepareRouteHydrationData as _, resolveRouteRequest as a, DEFERRED_BOUNDARY as b, Outlet as c, _preloadRouteHandler as d, lazy as f, guardHydratedRouteData as g, getRouteHydrationMetadata as h, hasRouteRenderData as i, createRouteHandler as l, RouteDataLoadError as m, getRouteRenderContext as n, resolvedRouteHasLoader as o, lazyRouteData as p, getRouteRenderData as r, currentAuth as s, bindResolvedRouteData as t, getRenderHandler as u, validateRouteHydrationData as v, defer as x, withoutRouteHydrationMetadata as y };