@benjavicente/router-core 1.168.9

package/dist/esm/typePrimitives.d.ts

@@ -0,0 +1,65 @@
+import { FromPathOption, NavigateOptions, PathParamOptions, SearchParamOptions, ToPathOption } from './link.js';
+import { RedirectOptions } from './redirect.js';
+import { RouteIds } from './routeInfo.js';
+import { AnyRouter, RegisteredRouter } from './router.js';
+import { UseParamsResult } from './useParams.js';
+import { UseSearchResult } from './useSearch.js';
+import { Constrain, ConstrainLiteral } from './utils.js';
+export type ValidateFromPath<TRouter extends AnyRouter = RegisteredRouter, TFrom = string> = FromPathOption<TRouter, TFrom>;
+export type ValidateToPath<TRouter extends AnyRouter = RegisteredRouter, TTo extends string | undefined = undefined, TFrom extends string = string> = ToPathOption<TRouter, TFrom, TTo>;
+export type ValidateSearch<TRouter extends AnyRouter = RegisteredRouter, TTo extends string | undefined = undefined, TFrom extends string = string> = SearchParamOptions<TRouter, TFrom, TTo>;
+export type ValidateParams<TRouter extends AnyRouter = RegisteredRouter, TTo extends string | undefined = undefined, TFrom extends string = string> = PathParamOptions<TRouter, TFrom, TTo>;
+/**
+ * @private
+ */
+export type InferFrom<TOptions, TDefaultFrom extends string = string> = TOptions extends {
+    from: infer TFrom extends string;
+} ? TFrom : TDefaultFrom;
+/**
+ * @private
+ */
+export type InferTo<TOptions> = TOptions extends {
+    to: infer TTo extends string;
+} ? TTo : undefined;
+/**
+ * @private
+ */
+export type InferMaskTo<TOptions> = TOptions extends {
+    mask: {
+        to: infer TTo extends string;
+    };
+} ? TTo : '';
+export type InferMaskFrom<TOptions> = TOptions extends {
+    mask: {
+        from: infer TFrom extends string;
+    };
+} ? TFrom : string;
+export type ValidateNavigateOptions<TRouter extends AnyRouter = RegisteredRouter, TOptions = unknown, TDefaultFrom extends string = string> = Constrain<TOptions, NavigateOptions<TRouter, InferFrom<TOptions, TDefaultFrom>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
+export type ValidateNavigateOptionsArray<TRouter extends AnyRouter = RegisteredRouter, TOptions extends ReadonlyArray<any> = ReadonlyArray<unknown>, TDefaultFrom extends string = string> = {
+    [K in keyof TOptions]: ValidateNavigateOptions<TRouter, TOptions[K], TDefaultFrom>;
+};
+export type ValidateRedirectOptions<TRouter extends AnyRouter = RegisteredRouter, TOptions = unknown, TDefaultFrom extends string = string> = Constrain<TOptions, RedirectOptions<TRouter, InferFrom<TOptions, TDefaultFrom>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
+export type ValidateRedirectOptionsArray<TRouter extends AnyRouter = RegisteredRouter, TOptions extends ReadonlyArray<any> = ReadonlyArray<unknown>, TDefaultFrom extends string = string> = {
+    [K in keyof TOptions]: ValidateRedirectOptions<TRouter, TOptions[K], TDefaultFrom>;
+};
+export type ValidateId<TRouter extends AnyRouter = RegisteredRouter, TId extends string = string> = ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>;
+/**
+ * @private
+ */
+export type InferStrict<TOptions> = TOptions extends {
+    strict: infer TStrict extends boolean;
+} ? TStrict : true;
+/**
+ * @private
+ */
+export type InferShouldThrow<TOptions> = TOptions extends {
+    shouldThrow: infer TShouldThrow extends boolean;
+} ? TShouldThrow : true;
+/**
+ * @private
+ */
+export type InferSelected<TOptions> = TOptions extends {
+    select: (...args: Array<any>) => infer TSelected;
+} ? TSelected : unknown;
+export type ValidateUseSearchResult<TOptions, TRouter extends AnyRouter = RegisteredRouter> = UseSearchResult<TRouter, InferFrom<TOptions>, InferStrict<TOptions>, InferSelected<TOptions>>;
+export type ValidateUseParamsResult<TOptions, TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, UseParamsResult<TRouter, InferFrom<TOptions>, InferStrict<TOptions>, InferSelected<TOptions>>>;

package/dist/esm/useLoaderData.d.ts

@@ -0,0 +1,5 @@
+import { AllLoaderData, RouteById } from './routeInfo.js';
+import { AnyRouter } from './router.js';
+import { Expand } from './utils.js';
+export type ResolveUseLoaderData<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllLoaderData<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['loaderData']>;
+export type UseLoaderDataResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveUseLoaderData<TRouter, TFrom, TStrict> : TSelected;

package/dist/esm/useLoaderDeps.d.ts

@@ -0,0 +1,5 @@
+import { RouteById } from './routeInfo.js';
+import { AnyRouter } from './router.js';
+import { Expand } from './utils.js';
+export type ResolveUseLoaderDeps<TRouter extends AnyRouter, TFrom> = Expand<RouteById<TRouter['routeTree'], TFrom>['types']['loaderDeps']>;
+export type UseLoaderDepsResult<TRouter extends AnyRouter, TFrom, TSelected> = unknown extends TSelected ? ResolveUseLoaderDeps<TRouter, TFrom> : TSelected;

package/dist/esm/useNavigate.d.ts

@@ -0,0 +1,3 @@
+import { NavigateOptions } from './link.js';
+import { RegisteredRouter } from './router.js';
+export type UseNavigateResult<TDefaultFrom extends string> = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends string = TDefaultFrom, TMaskFrom extends string = TFrom, TMaskTo extends string = ''>({ from, ...rest }: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;

package/dist/esm/useParams.d.ts

@@ -0,0 +1,5 @@
+import { AllParams, RouteById } from './routeInfo.js';
+import { AnyRouter } from './router.js';
+import { Expand } from './utils.js';
+export type ResolveUseParams<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllParams<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['allParams']>;
+export type UseParamsResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveUseParams<TRouter, TFrom, TStrict> : TSelected;

package/dist/esm/useRouteContext.d.ts

@@ -0,0 +1,9 @@
+import { AllContext, RouteById } from './routeInfo.js';
+import { AnyRouter } from './router.js';
+import { Expand, StrictOrFrom } from './utils.js';
+export interface UseRouteContextBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> {
+    select?: (search: ResolveUseRouteContext<TRouter, TFrom, TStrict>) => TSelected;
+}
+export type UseRouteContextOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseRouteContextBaseOptions<TRouter, TFrom, TStrict, TSelected>;
+export type ResolveUseRouteContext<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllContext<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['allContext']>;
+export type UseRouteContextResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveUseRouteContext<TRouter, TFrom, TStrict> : TSelected;

package/dist/esm/useSearch.d.ts

@@ -0,0 +1,5 @@
+import { FullSearchSchema, RouteById } from './routeInfo.js';
+import { AnyRouter } from './router.js';
+import { Expand } from './utils.js';
+export type UseSearchResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveUseSearch<TRouter, TFrom, TStrict> : TSelected;
+export type ResolveUseSearch<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? FullSearchSchema<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['fullSearchSchema']>;

package/dist/esm/utils.d.ts

@@ -0,0 +1,178 @@
+import { RouteIds } from './routeInfo.js';
+import { AnyRouter } from './router.js';
+export type Awaitable<T> = T | Promise<T>;
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export type IsAny<TValue, TYesResult, TNoResult = TValue> = 1 extends 0 & TValue ? TYesResult : TNoResult;
+export type PickAsRequired<TValue, TKey extends keyof TValue> = Omit<TValue, TKey> & Required<Pick<TValue, TKey>>;
+export type PickRequired<T> = {
+    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+};
+export type PickOptional<T> = {
+    [K in keyof T as undefined extends T[K] ? K : never]: T[K];
+};
+export type WithoutEmpty<T> = T extends any ? ({} extends T ? never : T) : never;
+export type Expand<T> = T extends object ? T extends infer O ? O extends Function ? O : {
+    [K in keyof O]: O[K];
+} : never : T;
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type MakeDifferenceOptional<TLeft, TRight> = keyof TLeft & keyof TRight extends never ? TRight : Omit<TRight, keyof TLeft & keyof TRight> & {
+    [K in keyof TLeft & keyof TRight]?: TRight[K];
+};
+export type IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : never) extends false ? false : true;
+export type IsNonEmptyObject<T> = T extends object ? keyof T extends never ? false : true : false;
+export type Assign<TLeft, TRight> = TLeft extends any ? TRight extends any ? IsNonEmptyObject<TLeft> extends false ? TRight : IsNonEmptyObject<TRight> extends false ? TLeft : keyof TLeft & keyof TRight extends never ? TLeft & TRight : Omit<TLeft, keyof TRight> & TRight : never : never;
+export type IntersectAssign<TLeft, TRight> = TLeft extends any ? TRight extends any ? IsNonEmptyObject<TLeft> extends false ? TRight : IsNonEmptyObject<TRight> extends false ? TLeft : TRight & TLeft : never : never;
+export type Timeout = ReturnType<typeof setTimeout>;
+export type Updater<TPrevious, TResult = TPrevious> = TResult | ((prev?: TPrevious) => TResult);
+export type NonNullableUpdater<TPrevious, TResult = TPrevious> = TResult | ((prev: TPrevious) => TResult);
+export type ExtractObjects<TUnion> = TUnion extends MergeAllPrimitive ? never : TUnion;
+export type PartialMergeAllObject<TUnion> = ExtractObjects<TUnion> extends infer TObj ? [TObj] extends [never] ? never : {
+    [TKey in TObj extends any ? keyof TObj : never]?: TObj extends any ? TKey extends keyof TObj ? TObj[TKey] : never : never;
+} : never;
+export type MergeAllPrimitive = ReadonlyArray<any> | number | string | bigint | boolean | symbol | undefined | null;
+export type ExtractPrimitives<TUnion> = TUnion extends MergeAllPrimitive ? TUnion : TUnion extends object ? never : TUnion;
+export type PartialMergeAll<TUnion> = ExtractPrimitives<TUnion> | PartialMergeAllObject<TUnion>;
+export type Constrain<T, TConstraint, TDefault = TConstraint> = (T extends TConstraint ? T : never) | TDefault;
+export type ConstrainLiteral<T, TConstraint, TDefault = TConstraint> = (T & TConstraint) | TDefault;
+/**
+ * To be added to router types
+ */
+export type UnionToIntersection<T> = (T extends any ? (arg: T) => any : never) extends (arg: infer T) => any ? T : never;
+/**
+ * Merges everything in a union into one object.
+ * This mapped type is homomorphic which means it preserves stuff! :)
+ */
+export type MergeAllObjects<TUnion, TIntersected = UnionToIntersection<ExtractObjects<TUnion>>> = [keyof TIntersected] extends [never] ? never : {
+    [TKey in keyof TIntersected]: TUnion extends any ? TUnion[TKey & keyof TUnion] : never;
+};
+export type MergeAll<TUnion> = MergeAllObjects<TUnion> | ExtractPrimitives<TUnion>;
+export type ValidateJSON<T> = ((...args: Array<any>) => any) extends T ? unknown extends T ? never : 'Function is not serializable' : {
+    [K in keyof T]: ValidateJSON<T[K]>;
+};
+export type LooseReturnType<T> = T extends (...args: Array<any>) => infer TReturn ? TReturn : never;
+export type LooseAsyncReturnType<T> = T extends (...args: Array<any>) => infer TReturn ? TReturn extends Promise<infer TReturn> ? TReturn : TReturn : never;
+/**
+ * Return the last element of an array.
+ * Intended for non-empty arrays used within router internals.
+ */
+export declare function last<T>(arr: ReadonlyArray<T>): T | undefined;
+/**
+ * Apply a value-or-updater to a previous value.
+ * Accepts either a literal value or a function of the previous value.
+ */
+export declare function functionalUpdate<TPrevious, TResult = TPrevious>(updater: Updater<TPrevious, TResult> | NonNullableUpdater<TPrevious, TResult>, previous: TPrevious): TResult;
+export declare const nullReplaceEqualDeep: typeof replaceEqualDeep;
+/**
+ * This function returns `prev` if `_next` is deeply equal.
+ * If not, it will replace any deeply equal children of `b` with those of `a`.
+ * This can be used for structural sharing between immutable JSON values for example.
+ * Do not use this with signals
+ */
+export declare function replaceEqualDeep<T>(prev: any, _next: T, _makeObj?: () => {}, _depth?: number): T;
+export declare function isPlainObject(o: any): boolean;
+/**
+ * Check if a value is a "plain" array (no extra enumerable keys).
+ */
+export declare function isPlainArray(value: unknown): value is Array<unknown>;
+/**
+ * Perform a deep equality check with options for partial comparison and
+ * ignoring `undefined` values. Optimized for router state comparisons.
+ */
+export declare function deepEqual(a: any, b: any, opts?: {
+    partial?: boolean;
+    ignoreUndefined?: boolean;
+}): boolean;
+export type StringLiteral<T> = T extends string ? string extends T ? string : T : never;
+export type ThrowOrOptional<T, TThrow extends boolean> = TThrow extends true ? T : T | undefined;
+export type StrictOrFrom<TRouter extends AnyRouter, TFrom, TStrict extends boolean = true> = TStrict extends false ? {
+    from?: never;
+    strict: TStrict;
+} : {
+    from: ConstrainLiteral<TFrom, RouteIds<TRouter['routeTree']>>;
+    strict?: TStrict;
+};
+export type ThrowConstraint<TStrict extends boolean, TThrow extends boolean> = TStrict extends false ? (TThrow extends true ? never : TThrow) : TThrow;
+export type ControlledPromise<T> = Promise<T> & {
+    resolve: (value: T) => void;
+    reject: (value: any) => void;
+    status: 'pending' | 'resolved' | 'rejected';
+    value?: T;
+};
+/**
+ * Create a promise with exposed resolve/reject and status fields.
+ * Useful for coordinating async router lifecycle operations.
+ */
+export declare function createControlledPromise<T>(onResolve?: (value: T) => void): ControlledPromise<T>;
+/**
+ * Heuristically detect dynamic import "module not found" errors
+ * across major browsers for lazy route component handling.
+ */
+export declare function isModuleNotFoundError(error: any): boolean;
+export declare function isPromise<T>(value: Promise<Awaited<T>> | T): value is Promise<Awaited<T>>;
+export declare function findLast<T>(array: ReadonlyArray<T>, predicate: (item: T) => boolean): T | undefined;
+/**
+ * Default list of URL protocols to allow in links, redirects, and navigation.
+ * Any absolute URL protocol not in this list is treated as dangerous by default.
+ */
+export declare const DEFAULT_PROTOCOL_ALLOWLIST: string[];
+/**
+ * Check if a URL string uses a protocol that is not in the allowlist.
+ * Returns true for blocked protocols like javascript:, blob:, data:, etc.
+ *
+ * The URL constructor correctly normalizes:
+ * - Mixed case (JavaScript: → javascript:)
+ * - Whitespace/control characters (java\nscript: → javascript:)
+ * - Leading whitespace
+ *
+ * For relative URLs (no protocol), returns false (safe).
+ *
+ * @param url - The URL string to check
+ * @param allowlist - Set of protocols to allow
+ * @returns true if the URL uses a protocol that is not allowed
+ */
+export declare function isDangerousProtocol(url: string, allowlist: Set<string>): boolean;
+/**
+ * Escape HTML special characters in a string to prevent XSS attacks
+ * when embedding strings in script tags during SSR.
+ *
+ * This is essential for preventing XSS vulnerabilities when user-controlled
+ * content is embedded in inline scripts.
+ */
+export declare function escapeHtml(str: string): string;
+export declare function decodePath(path: string): {
+    path: string;
+    handledProtocolRelativeURL: boolean;
+};
+/**
+ * Encodes a path the same way `new URL()` would, but without the overhead of full URL parsing.
+ *
+ * This function encodes:
+ * - Whitespace characters (spaces → %20, tabs → %09, etc.)
+ * - Non-ASCII/Unicode characters (emojis, accented characters, etc.)
+ *
+ * It preserves:
+ * - Already percent-encoded sequences (won't double-encode %2F, %25, etc.)
+ * - ASCII special characters valid in URL paths (@, $, &, +, etc.)
+ * - Forward slashes as path separators
+ *
+ * Used to generate proper href values for SSR without constructing URL objects.
+ *
+ * @example
+ * encodePathLikeUrl('/path/file name.pdf') // '/path/file%20name.pdf'
+ * encodePathLikeUrl('/path/日本語') // '/path/%E6%97%A5%E6%9C%AC%E8%AA%9E'
+ * encodePathLikeUrl('/path/already%20encoded') // '/path/already%20encoded' (preserved)
+ */
+export declare function encodePathLikeUrl(path: string): string;
+/**
+ * Builds the dev-mode CSS styles URL for route-scoped CSS collection.
+ * Used by HeadContent components in all framework implementations to construct
+ * the URL for the `/@tanstack-start/styles.css` endpoint.
+ *
+ * @param basepath - The router's basepath (may or may not have leading slash)
+ * @param routeIds - Array of matched route IDs to include in the CSS collection
+ * @returns The full URL path for the dev styles CSS endpoint
+ */
+export declare function buildDevStylesUrl(basepath: string, routeIds: Array<string>): string;
+export declare function arraysEqual<T>(a: Array<T>, b: Array<T>): boolean;

package/dist/esm/utils.js

@@ -0,0 +1,322 @@
+import { isServer } from "@benjavicente/router-core/isServer";
+//#region src/utils.ts
+/**
+* Return the last element of an array.
+* Intended for non-empty arrays used within router internals.
+*/
+function last(arr) {
+	return arr[arr.length - 1];
+}
+function isFunction(d) {
+	return typeof d === "function";
+}
+/**
+* Apply a value-or-updater to a previous value.
+* Accepts either a literal value or a function of the previous value.
+*/
+function functionalUpdate(updater, previous) {
+	if (isFunction(updater)) return updater(previous);
+	return updater;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var createNull = () => Object.create(null);
+var nullReplaceEqualDeep = (prev, next) => replaceEqualDeep(prev, next, createNull);
+/**
+* This function returns `prev` if `_next` is deeply equal.
+* If not, it will replace any deeply equal children of `b` with those of `a`.
+* This can be used for structural sharing between immutable JSON values for example.
+* Do not use this with signals
+*/
+function replaceEqualDeep(prev, _next, _makeObj = () => ({}), _depth = 0) {
+	if (isServer) return _next;
+	if (prev === _next) return prev;
+	if (_depth > 500) return _next;
+	const next = _next;
+	const array = isPlainArray(prev) && isPlainArray(next);
+	if (!array && !(isPlainObject(prev) && isPlainObject(next))) return next;
+	const prevItems = array ? prev : getEnumerableOwnKeys(prev);
+	if (!prevItems) return next;
+	const nextItems = array ? next : getEnumerableOwnKeys(next);
+	if (!nextItems) return next;
+	const prevSize = prevItems.length;
+	const nextSize = nextItems.length;
+	const copy = array ? new Array(nextSize) : _makeObj();
+	let equalItems = 0;
+	for (let i = 0; i < nextSize; i++) {
+		const key = array ? i : nextItems[i];
+		const p = prev[key];
+		const n = next[key];
+		if (p === n) {
+			copy[key] = p;
+			if (array ? i < prevSize : hasOwn.call(prev, key)) equalItems++;
+			continue;
+		}
+		if (p === null || n === null || typeof p !== "object" || typeof n !== "object") {
+			copy[key] = n;
+			continue;
+		}
+		const v = replaceEqualDeep(p, n, _makeObj, _depth + 1);
+		copy[key] = v;
+		if (v === p) equalItems++;
+	}
+	return prevSize === nextSize && equalItems === prevSize ? prev : copy;
+}
+/**
+* Equivalent to `Reflect.ownKeys`, but ensures that objects are "clone-friendly":
+* will return false if object has any non-enumerable properties.
+*
+* Optimized for the common case where objects have no symbol properties.
+*/
+function getEnumerableOwnKeys(o) {
+	const names = Object.getOwnPropertyNames(o);
+	for (const name of names) if (!isEnumerable.call(o, name)) return false;
+	const symbols = Object.getOwnPropertySymbols(o);
+	if (symbols.length === 0) return names;
+	const keys = names;
+	for (const symbol of symbols) {
+		if (!isEnumerable.call(o, symbol)) return false;
+		keys.push(symbol);
+	}
+	return keys;
+}
+function isPlainObject(o) {
+	if (!hasObjectPrototype(o)) return false;
+	const ctor = o.constructor;
+	if (typeof ctor === "undefined") return true;
+	const prot = ctor.prototype;
+	if (!hasObjectPrototype(prot)) return false;
+	if (!prot.hasOwnProperty("isPrototypeOf")) return false;
+	return true;
+}
+function hasObjectPrototype(o) {
+	return Object.prototype.toString.call(o) === "[object Object]";
+}
+/**
+* Check if a value is a "plain" array (no extra enumerable keys).
+*/
+function isPlainArray(value) {
+	return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+/**
+* Perform a deep equality check with options for partial comparison and
+* ignoring `undefined` values. Optimized for router state comparisons.
+*/
+function deepEqual(a, b, opts) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0, l = a.length; i < l; i++) if (!deepEqual(a[i], b[i], opts)) return false;
+		return true;
+	}
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const ignoreUndefined = opts?.ignoreUndefined ?? true;
+		if (opts?.partial) {
+			for (const k in b) if (!ignoreUndefined || b[k] !== void 0) {
+				if (!deepEqual(a[k], b[k], opts)) return false;
+			}
+			return true;
+		}
+		let aCount = 0;
+		if (!ignoreUndefined) aCount = Object.keys(a).length;
+		else for (const k in a) if (a[k] !== void 0) aCount++;
+		let bCount = 0;
+		for (const k in b) if (!ignoreUndefined || b[k] !== void 0) {
+			bCount++;
+			if (bCount > aCount || !deepEqual(a[k], b[k], opts)) return false;
+		}
+		return aCount === bCount;
+	}
+	return false;
+}
+/**
+* Create a promise with exposed resolve/reject and status fields.
+* Useful for coordinating async router lifecycle operations.
+*/
+function createControlledPromise(onResolve) {
+	let resolveLoadPromise;
+	let rejectLoadPromise;
+	const controlledPromise = new Promise((resolve, reject) => {
+		resolveLoadPromise = resolve;
+		rejectLoadPromise = reject;
+	});
+	controlledPromise.status = "pending";
+	controlledPromise.resolve = (value) => {
+		controlledPromise.status = "resolved";
+		controlledPromise.value = value;
+		resolveLoadPromise(value);
+		onResolve?.(value);
+	};
+	controlledPromise.reject = (e) => {
+		controlledPromise.status = "rejected";
+		rejectLoadPromise(e);
+	};
+	return controlledPromise;
+}
+/**
+* Heuristically detect dynamic import "module not found" errors
+* across major browsers for lazy route component handling.
+*/
+function isModuleNotFoundError(error) {
+	if (typeof error?.message !== "string") return false;
+	return error.message.startsWith("Failed to fetch dynamically imported module") || error.message.startsWith("error loading dynamically imported module") || error.message.startsWith("Importing a module script failed");
+}
+function isPromise(value) {
+	return Boolean(value && typeof value === "object" && typeof value.then === "function");
+}
+function findLast(array, predicate) {
+	for (let i = array.length - 1; i >= 0; i--) {
+		const item = array[i];
+		if (predicate(item)) return item;
+	}
+}
+/**
+* Remove control characters that can cause open redirect vulnerabilities.
+* Characters like \r (CR) and \n (LF) can trick URL parsers into interpreting
+* paths like "/\r/evil.com" as "http://evil.com".
+*/
+function sanitizePathSegment(segment) {
+	return segment.replace(/[\x00-\x1f\x7f]/g, "");
+}
+function decodeSegment(segment) {
+	let decoded;
+	try {
+		decoded = decodeURI(segment);
+	} catch {
+		decoded = segment.replaceAll(/%[0-9A-F]{2}/gi, (match) => {
+			try {
+				return decodeURI(match);
+			} catch {
+				return match;
+			}
+		});
+	}
+	return sanitizePathSegment(decoded);
+}
+/**
+* Default list of URL protocols to allow in links, redirects, and navigation.
+* Any absolute URL protocol not in this list is treated as dangerous by default.
+*/
+var DEFAULT_PROTOCOL_ALLOWLIST = [
+	"http:",
+	"https:",
+	"mailto:",
+	"tel:"
+];
+/**
+* Check if a URL string uses a protocol that is not in the allowlist.
+* Returns true for blocked protocols like javascript:, blob:, data:, etc.
+*
+* The URL constructor correctly normalizes:
+* - Mixed case (JavaScript: → javascript:)
+* - Whitespace/control characters (java\nscript: → javascript:)
+* - Leading whitespace
+*
+* For relative URLs (no protocol), returns false (safe).
+*
+* @param url - The URL string to check
+* @param allowlist - Set of protocols to allow
+* @returns true if the URL uses a protocol that is not allowed
+*/
+function isDangerousProtocol(url, allowlist) {
+	if (!url) return false;
+	try {
+		const parsed = new URL(url);
+		return !allowlist.has(parsed.protocol);
+	} catch {
+		return false;
+	}
+}
+var HTML_ESCAPE_LOOKUP = {
+	"&": "\\u0026",
+	">": "\\u003e",
+	"<": "\\u003c",
+	"\u2028": "\\u2028",
+	"\u2029": "\\u2029"
+};
+var HTML_ESCAPE_REGEX = /[&><\u2028\u2029]/g;
+/**
+* Escape HTML special characters in a string to prevent XSS attacks
+* when embedding strings in script tags during SSR.
+*
+* This is essential for preventing XSS vulnerabilities when user-controlled
+* content is embedded in inline scripts.
+*/
+function escapeHtml(str) {
+	return str.replace(HTML_ESCAPE_REGEX, (match) => HTML_ESCAPE_LOOKUP[match]);
+}
+function decodePath(path) {
+	if (!path) return {
+		path,
+		handledProtocolRelativeURL: false
+	};
+	if (!/[%\\\x00-\x1f\x7f]/.test(path) && !path.startsWith("//")) return {
+		path,
+		handledProtocolRelativeURL: false
+	};
+	const re = /%25|%5C/gi;
+	let cursor = 0;
+	let result = "";
+	let match;
+	while (null !== (match = re.exec(path))) {
+		result += decodeSegment(path.slice(cursor, match.index)) + match[0];
+		cursor = re.lastIndex;
+	}
+	result = result + decodeSegment(cursor ? path.slice(cursor) : path);
+	let handledProtocolRelativeURL = false;
+	if (result.startsWith("//")) {
+		handledProtocolRelativeURL = true;
+		result = "/" + result.replace(/^\/+/, "");
+	}
+	return {
+		path: result,
+		handledProtocolRelativeURL
+	};
+}
+/**
+* Encodes a path the same way `new URL()` would, but without the overhead of full URL parsing.
+*
+* This function encodes:
+* - Whitespace characters (spaces → %20, tabs → %09, etc.)
+* - Non-ASCII/Unicode characters (emojis, accented characters, etc.)
+*
+* It preserves:
+* - Already percent-encoded sequences (won't double-encode %2F, %25, etc.)
+* - ASCII special characters valid in URL paths (@, $, &, +, etc.)
+* - Forward slashes as path separators
+*
+* Used to generate proper href values for SSR without constructing URL objects.
+*
+* @example
+* encodePathLikeUrl('/path/file name.pdf') // '/path/file%20name.pdf'
+* encodePathLikeUrl('/path/日本語') // '/path/%E6%97%A5%E6%9C%AC%E8%AA%9E'
+* encodePathLikeUrl('/path/already%20encoded') // '/path/already%20encoded' (preserved)
+*/
+function encodePathLikeUrl(path) {
+	if (!/\s|[^\u0000-\u007F]/.test(path)) return path;
+	return path.replace(/\s|[^\u0000-\u007F]/gu, encodeURIComponent);
+}
+/**
+* Builds the dev-mode CSS styles URL for route-scoped CSS collection.
+* Used by HeadContent components in all framework implementations to construct
+* the URL for the `/@tanstack-start/styles.css` endpoint.
+*
+* @param basepath - The router's basepath (may or may not have leading slash)
+* @param routeIds - Array of matched route IDs to include in the CSS collection
+* @returns The full URL path for the dev styles CSS endpoint
+*/
+function buildDevStylesUrl(basepath, routeIds) {
+	const trimmedBasepath = basepath.replace(/^\/+|\/+$/g, "");
+	return `${trimmedBasepath === "" ? "" : `/${trimmedBasepath}`}/@tanstack-start/styles.css?routes=${encodeURIComponent(routeIds.join(","))}`;
+}
+function arraysEqual(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+//#endregion
+export { DEFAULT_PROTOCOL_ALLOWLIST, arraysEqual, buildDevStylesUrl, createControlledPromise, decodePath, deepEqual, encodePathLikeUrl, escapeHtml, findLast, functionalUpdate, isDangerousProtocol, isModuleNotFoundError, isPlainArray, isPlainObject, isPromise, last, nullReplaceEqualDeep, replaceEqualDeep };
+
+//# sourceMappingURL=utils.js.map