@benjavicente/router-core 1.168.9

package/dist/cjs/utils.d.cts

@@ -0,0 +1,178 @@
+import { RouteIds } from './routeInfo.cjs';
+import { AnyRouter } from './router.cjs';
+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/cjs/validators.d.cts

@@ -0,0 +1,51 @@
+import { SearchSchemaInput } from './route.cjs';
+export interface StandardSchemaValidatorProps<TInput, TOutput> {
+    readonly types?: StandardSchemaValidatorTypes<TInput, TOutput> | undefined;
+    readonly validate: AnyStandardSchemaValidate;
+}
+export interface StandardSchemaValidator<TInput, TOutput> {
+    readonly '~standard': StandardSchemaValidatorProps<TInput, TOutput>;
+}
+export type AnyStandardSchemaValidator = StandardSchemaValidator<any, any>;
+export interface StandardSchemaValidatorTypes<TInput, TOutput> {
+    readonly input: TInput;
+    readonly output: TOutput;
+}
+export interface AnyStandardSchemaValidateSuccess {
+    readonly value: any;
+    readonly issues?: undefined;
+}
+export interface AnyStandardSchemaValidateFailure {
+    readonly issues: ReadonlyArray<AnyStandardSchemaValidateIssue>;
+}
+export interface AnyStandardSchemaValidateIssue {
+    readonly message: string;
+}
+export interface AnyStandardSchemaValidateInput {
+    readonly value: any;
+}
+export type AnyStandardSchemaValidate = (value: unknown) => (AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure) | Promise<AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure>;
+export interface ValidatorObj<TInput, TOutput> {
+    parse: ValidatorFn<TInput, TOutput>;
+}
+export type AnyValidatorObj = ValidatorObj<any, any>;
+export interface ValidatorAdapter<TInput, TOutput> {
+    types: {
+        input: TInput;
+        output: TOutput;
+    };
+    parse: (input: unknown) => TOutput;
+}
+export type AnyValidatorAdapter = ValidatorAdapter<any, any>;
+export type AnyValidatorFn = ValidatorFn<any, any>;
+export type ValidatorFn<TInput, TOutput> = (input: TInput) => TOutput;
+export type Validator<TInput, TOutput> = ValidatorObj<TInput, TOutput> | ValidatorFn<TInput, TOutput> | ValidatorAdapter<TInput, TOutput> | StandardSchemaValidator<TInput, TOutput> | undefined;
+export type AnyValidator = Validator<any, any>;
+export type AnySchema = {};
+export type DefaultValidator = Validator<Record<string, unknown>, AnySchema>;
+export type ResolveSearchValidatorInputFn<TValidator> = TValidator extends (input: infer TSchemaInput) => any ? TSchemaInput extends SearchSchemaInput ? Omit<TSchemaInput, keyof SearchSchemaInput> : ResolveValidatorOutputFn<TValidator> : AnySchema;
+export type ResolveSearchValidatorInput<TValidator> = TValidator extends AnyStandardSchemaValidator ? NonNullable<TValidator['~standard']['types']>['input'] : TValidator extends AnyValidatorAdapter ? TValidator['types']['input'] : TValidator extends AnyValidatorObj ? ResolveSearchValidatorInputFn<TValidator['parse']> : ResolveSearchValidatorInputFn<TValidator>;
+export type ResolveValidatorInputFn<TValidator> = TValidator extends (input: infer TInput) => any ? TInput : undefined;
+export type ResolveValidatorInput<TValidator> = TValidator extends AnyStandardSchemaValidator ? NonNullable<TValidator['~standard']['types']>['input'] : TValidator extends AnyValidatorAdapter ? TValidator['types']['input'] : TValidator extends AnyValidatorObj ? ResolveValidatorInputFn<TValidator['parse']> : ResolveValidatorInputFn<TValidator>;
+export type ResolveValidatorOutputFn<TValidator> = TValidator extends (...args: any) => infer TSchema ? TSchema : AnySchema;
+export type ResolveValidatorOutput<TValidator> = unknown extends TValidator ? TValidator : TValidator extends AnyStandardSchemaValidator ? NonNullable<TValidator['~standard']['types']>['output'] : TValidator extends AnyValidatorAdapter ? TValidator['types']['output'] : TValidator extends AnyValidatorObj ? ResolveValidatorOutputFn<TValidator['parse']> : ResolveValidatorOutputFn<TValidator>;

package/dist/esm/Matches.d.ts

@@ -0,0 +1,139 @@
+import { AnyRoute, StaticDataRouteOption } from './route.js';
+import { AllContext, AllLoaderData, AllParams, FullSearchSchema, ParseRoute, RouteById, RouteIds } from './routeInfo.js';
+import { AnyRouter, RegisteredRouter, SSROption } from './router.js';
+import { Constrain, ControlledPromise } from './utils.js';
+export type AnyMatchAndValue = {
+    match: any;
+    value: any;
+};
+export type FindValueByIndex<TKey, TValue extends ReadonlyArray<any>> = TKey extends `${infer TIndex extends number}` ? TValue[TIndex] : never;
+export type FindValueByKey<TKey, TValue> = TValue extends ReadonlyArray<any> ? FindValueByIndex<TKey, TValue> : TValue[TKey & keyof TValue];
+export type CreateMatchAndValue<TMatch, TValue> = TValue extends any ? {
+    match: TMatch;
+    value: TValue;
+} : never;
+export type NextMatchAndValue<TKey, TMatchAndValue extends AnyMatchAndValue> = TMatchAndValue extends any ? CreateMatchAndValue<TMatchAndValue['match'], FindValueByKey<TKey, TMatchAndValue['value']>> : never;
+export type IsMatchKeyOf<TValue> = TValue extends ReadonlyArray<any> ? number extends TValue['length'] ? `${number}` : keyof TValue & `${number}` : TValue extends object ? keyof TValue & string : never;
+export type IsMatchPath<TParentPath extends string, TMatchAndValue extends AnyMatchAndValue> = `${TParentPath}${IsMatchKeyOf<TMatchAndValue['value']>}`;
+export type IsMatchResult<TKey, TMatchAndValue extends AnyMatchAndValue> = TMatchAndValue extends any ? TKey extends keyof TMatchAndValue['value'] ? TMatchAndValue['match'] : never : never;
+export type IsMatchParse<TPath, TMatchAndValue extends AnyMatchAndValue, TParentPath extends string = ''> = TPath extends `${string}.${string}` ? TPath extends `${infer TFirst}.${infer TRest}` ? IsMatchParse<TRest, NextMatchAndValue<TFirst, TMatchAndValue>, `${TParentPath}${TFirst}.`> : never : {
+    path: IsMatchPath<TParentPath, TMatchAndValue>;
+    result: IsMatchResult<TPath, TMatchAndValue>;
+};
+export type IsMatch<TMatch, TPath> = IsMatchParse<TPath, TMatch extends any ? {
+    match: TMatch;
+    value: TMatch;
+} : never>;
+/**
+ * Narrows matches based on a path
+ * @experimental
+ */
+export declare const isMatch: <TMatch, TPath extends string>(match: TMatch, path: Constrain<TPath, IsMatch<TMatch, TPath>["path"]>) => match is IsMatch<TMatch, TPath>["result"];
+export interface DefaultRouteMatchExtensions {
+    scripts?: unknown;
+    links?: unknown;
+    headScripts?: unknown;
+    meta?: unknown;
+    styles?: unknown;
+}
+export interface RouteMatchExtensions extends DefaultRouteMatchExtensions {
+}
+export interface RouteMatch<out TRouteId, out TFullPath, out TAllParams, out TFullSearchSchema, out TLoaderData, out TAllContext, out TLoaderDeps> extends RouteMatchExtensions {
+    id: string;
+    routeId: TRouteId;
+    fullPath: TFullPath;
+    index: number;
+    pathname: string;
+    params: TAllParams;
+    _strictParams: TAllParams;
+    status: 'pending' | 'success' | 'error' | 'redirected' | 'notFound';
+    isFetching: false | 'beforeLoad' | 'loader';
+    error: unknown;
+    paramsError: unknown;
+    searchError: unknown;
+    updatedAt: number;
+    _nonReactive: {
+        loadPromise?: ControlledPromise<void>;
+        displayPendingPromise?: Promise<void>;
+        minPendingPromise?: ControlledPromise<void>;
+        dehydrated?: boolean;
+    };
+    loaderData?: TLoaderData;
+    context: TAllContext;
+    search: TFullSearchSchema;
+    _strictSearch: TFullSearchSchema;
+    fetchCount: number;
+    abortController: AbortController;
+    cause: 'preload' | 'enter' | 'stay';
+    loaderDeps: TLoaderDeps;
+    preload: boolean;
+    invalid: boolean;
+    headers?: Record<string, string>;
+    globalNotFound?: boolean;
+    staticData: StaticDataRouteOption;
+    /** This attribute is not reactive */
+    ssr?: SSROption;
+    _forcePending?: boolean;
+    _displayPending?: boolean;
+}
+export interface PreValidationErrorHandlingRouteMatch<TRouteId, TFullPath, TAllParams, TFullSearchSchema> {
+    id: string;
+    routeId: TRouteId;
+    fullPath: TFullPath;
+    index: number;
+    pathname: string;
+    search: {
+        status: 'success';
+        value: TFullSearchSchema;
+    } | {
+        status: 'error';
+        error: unknown;
+    };
+    params: {
+        status: 'success';
+        value: TAllParams;
+    } | {
+        status: 'error';
+        error: unknown;
+    };
+    staticData: StaticDataRouteOption;
+    ssr?: boolean | 'data-only';
+}
+export type MakePreValidationErrorHandlingRouteMatchUnion<TRouter extends AnyRouter = RegisteredRouter, TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>> = TRoute extends any ? PreValidationErrorHandlingRouteMatch<TRoute['id'], TRoute['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema']> : never;
+export type MakeRouteMatchFromRoute<TRoute extends AnyRoute> = RouteMatch<TRoute['types']['id'], TRoute['types']['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema'], TRoute['types']['loaderData'], TRoute['types']['allContext'], TRoute['types']['loaderDeps']>;
+export type MakeRouteMatch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TRouteId = RouteIds<TRouteTree>, TStrict extends boolean = true> = RouteMatch<TRouteId, RouteById<TRouteTree, TRouteId>['types']['fullPath'], TStrict extends false ? AllParams<TRouteTree> : RouteById<TRouteTree, TRouteId>['types']['allParams'], TStrict extends false ? FullSearchSchema<TRouteTree> : RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'], TStrict extends false ? AllLoaderData<TRouteTree> : RouteById<TRouteTree, TRouteId>['types']['loaderData'], TStrict extends false ? AllContext<TRouteTree> : RouteById<TRouteTree, TRouteId>['types']['allContext'], RouteById<TRouteTree, TRouteId>['types']['loaderDeps']>;
+export type AnyRouteMatch = RouteMatch<any, any, any, any, any, any, any>;
+export type MakeRouteMatchUnion<TRouter extends AnyRouter = RegisteredRouter, TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>> = TRoute extends any ? RouteMatch<TRoute['id'], TRoute['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema'], TRoute['types']['loaderData'], TRoute['types']['allContext'], TRoute['types']['loaderDeps']> : never;
+/**
+ * The `MatchRouteOptions` type is used to describe the options that can be used when matching a route.
+ *
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#matchrouteoptions-type)
+ */
+export interface MatchRouteOptions {
+    /**
+     * If `true`, will match against pending location instead of the current location.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#pending-property)
+     */
+    pending?: boolean;
+    /**
+     * If `true`, will match against the current location with case sensitivity.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#casesensitive-property)
+     *
+     * @deprecated Declare case sensitivity in the route definition instead, or globally for all routes using the `caseSensitive` option on the router.
+     */
+    caseSensitive?: boolean;
+    /**
+     * If `true`, will match against the current location's search params using a deep inclusive check. e.g. `{ a: 1 }` will match for a current location of `{ a: 1, b: 2 }`.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#includesearch-property)
+     */
+    includeSearch?: boolean;
+    /**
+     * If `true`, will match against the current location using a fuzzy match. e.g. `/posts` will match for a current location of `/posts/123`.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#fuzzy-property)
+     */
+    fuzzy?: boolean;
+}

package/dist/esm/Matches.js

@@ -0,0 +1,17 @@
+//#region src/Matches.ts
+/**
+* Narrows matches based on a path
+* @experimental
+*/
+var isMatch = (match, path) => {
+	const parts = path.split(".");
+	let part;
+	let i = 0;
+	let value = match;
+	while ((part = parts[i++]) != null && value != null) value = value[part];
+	return value != null;
+};
+//#endregion
+export { isMatch };
+
+//# sourceMappingURL=Matches.js.map

package/dist/esm/Matches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Matches.js","names":[],"sources":["../../src/Matches.ts"],"sourcesContent":["import type { AnyRoute, StaticDataRouteOption } from './route'\nimport type {\n  AllContext,\n  AllLoaderData,\n  AllParams,\n  FullSearchSchema,\n  ParseRoute,\n  RouteById,\n  RouteIds,\n} from './routeInfo'\nimport type { AnyRouter, RegisteredRouter, SSROption } from './router'\nimport type { Constrain, ControlledPromise } from './utils'\n\nexport type AnyMatchAndValue = { match: any; value: any }\n\nexport type FindValueByIndex<\n  TKey,\n  TValue extends ReadonlyArray<any>,\n> = TKey extends `${infer TIndex extends number}` ? TValue[TIndex] : never\n\nexport type FindValueByKey<TKey, TValue> =\n  TValue extends ReadonlyArray<any>\n    ? FindValueByIndex<TKey, TValue>\n    : TValue[TKey & keyof TValue]\n\nexport type CreateMatchAndValue<TMatch, TValue> = TValue extends any\n  ? {\n      match: TMatch\n      value: TValue\n    }\n  : never\n\nexport type NextMatchAndValue<\n  TKey,\n  TMatchAndValue extends AnyMatchAndValue,\n> = TMatchAndValue extends any\n  ? CreateMatchAndValue<\n      TMatchAndValue['match'],\n      FindValueByKey<TKey, TMatchAndValue['value']>\n    >\n  : never\n\nexport type IsMatchKeyOf<TValue> =\n  TValue extends ReadonlyArray<any>\n    ? number extends TValue['length']\n      ? `${number}`\n      : keyof TValue & `${number}`\n    : TValue extends object\n      ? keyof TValue & string\n      : never\n\nexport type IsMatchPath<\n  TParentPath extends string,\n  TMatchAndValue extends AnyMatchAndValue,\n> = `${TParentPath}${IsMatchKeyOf<TMatchAndValue['value']>}`\n\nexport type IsMatchResult<\n  TKey,\n  TMatchAndValue extends AnyMatchAndValue,\n> = TMatchAndValue extends any\n  ? TKey extends keyof TMatchAndValue['value']\n    ? TMatchAndValue['match']\n    : never\n  : never\n\nexport type IsMatchParse<\n  TPath,\n  TMatchAndValue extends AnyMatchAndValue,\n  TParentPath extends string = '',\n> = TPath extends `${string}.${string}`\n  ? TPath extends `${infer TFirst}.${infer TRest}`\n    ? IsMatchParse<\n        TRest,\n        NextMatchAndValue<TFirst, TMatchAndValue>,\n        `${TParentPath}${TFirst}.`\n      >\n    : never\n  : {\n      path: IsMatchPath<TParentPath, TMatchAndValue>\n      result: IsMatchResult<TPath, TMatchAndValue>\n    }\n\nexport type IsMatch<TMatch, TPath> = IsMatchParse<\n  TPath,\n  TMatch extends any ? { match: TMatch; value: TMatch } : never\n>\n\n/**\n * Narrows matches based on a path\n * @experimental\n */\nexport const isMatch = <TMatch, TPath extends string>(\n  match: TMatch,\n  path: Constrain<TPath, IsMatch<TMatch, TPath>['path']>,\n): match is IsMatch<TMatch, TPath>['result'] => {\n  const parts = (path as string).split('.')\n  let part\n  let i = 0\n  let value: any = match\n\n  while ((part = parts[i++]) != null && value != null) {\n    value = value[part]\n  }\n\n  return value != null\n}\n\nexport interface DefaultRouteMatchExtensions {\n  scripts?: unknown\n  links?: unknown\n  headScripts?: unknown\n  meta?: unknown\n  styles?: unknown\n}\n\nexport interface RouteMatchExtensions extends DefaultRouteMatchExtensions {}\n\nexport interface RouteMatch<\n  out TRouteId,\n  out TFullPath,\n  out TAllParams,\n  out TFullSearchSchema,\n  out TLoaderData,\n  out TAllContext,\n  out TLoaderDeps,\n> extends RouteMatchExtensions {\n  id: string\n  routeId: TRouteId\n  fullPath: TFullPath\n  index: number\n  pathname: string\n  params: TAllParams\n  _strictParams: TAllParams\n  status: 'pending' | 'success' | 'error' | 'redirected' | 'notFound'\n  isFetching: false | 'beforeLoad' | 'loader'\n  error: unknown\n  paramsError: unknown\n  searchError: unknown\n  updatedAt: number\n  _nonReactive: {\n    /** @internal */\n    beforeLoadPromise?: ControlledPromise<void>\n    /** @internal */\n    loaderPromise?: ControlledPromise<void>\n    /** @internal */\n    pendingTimeout?: ReturnType<typeof setTimeout>\n    loadPromise?: ControlledPromise<void>\n    displayPendingPromise?: Promise<void>\n    minPendingPromise?: ControlledPromise<void>\n    dehydrated?: boolean\n    /** @internal */\n    error?: unknown\n  }\n  loaderData?: TLoaderData\n  /** @internal */\n  __routeContext?: Record<string, unknown>\n  /** @internal */\n  __beforeLoadContext?: Record<string, unknown>\n  context: TAllContext\n  search: TFullSearchSchema\n  _strictSearch: TFullSearchSchema\n  fetchCount: number\n  abortController: AbortController\n  cause: 'preload' | 'enter' | 'stay'\n  loaderDeps: TLoaderDeps\n  preload: boolean\n  invalid: boolean\n  headers?: Record<string, string>\n  globalNotFound?: boolean\n  staticData: StaticDataRouteOption\n  /** This attribute is not reactive */\n  ssr?: SSROption\n  _forcePending?: boolean\n  _displayPending?: boolean\n}\n\nexport interface PreValidationErrorHandlingRouteMatch<\n  TRouteId,\n  TFullPath,\n  TAllParams,\n  TFullSearchSchema,\n> {\n  id: string\n  routeId: TRouteId\n  fullPath: TFullPath\n  index: number\n  pathname: string\n  search:\n    | { status: 'success'; value: TFullSearchSchema }\n    | { status: 'error'; error: unknown }\n  params:\n    | { status: 'success'; value: TAllParams }\n    | { status: 'error'; error: unknown }\n  staticData: StaticDataRouteOption\n  ssr?: boolean | 'data-only'\n}\n\nexport type MakePreValidationErrorHandlingRouteMatchUnion<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>,\n> = TRoute extends any\n  ? PreValidationErrorHandlingRouteMatch<\n      TRoute['id'],\n      TRoute['fullPath'],\n      TRoute['types']['allParams'],\n      TRoute['types']['fullSearchSchema']\n    >\n  : never\n\nexport type MakeRouteMatchFromRoute<TRoute extends AnyRoute> = RouteMatch<\n  TRoute['types']['id'],\n  TRoute['types']['fullPath'],\n  TRoute['types']['allParams'],\n  TRoute['types']['fullSearchSchema'],\n  TRoute['types']['loaderData'],\n  TRoute['types']['allContext'],\n  TRoute['types']['loaderDeps']\n>\n\nexport type MakeRouteMatch<\n  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],\n  TRouteId = RouteIds<TRouteTree>,\n  TStrict extends boolean = true,\n> = RouteMatch<\n  TRouteId,\n  RouteById<TRouteTree, TRouteId>['types']['fullPath'],\n  TStrict extends false\n    ? AllParams<TRouteTree>\n    : RouteById<TRouteTree, TRouteId>['types']['allParams'],\n  TStrict extends false\n    ? FullSearchSchema<TRouteTree>\n    : RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'],\n  TStrict extends false\n    ? AllLoaderData<TRouteTree>\n    : RouteById<TRouteTree, TRouteId>['types']['loaderData'],\n  TStrict extends false\n    ? AllContext<TRouteTree>\n    : RouteById<TRouteTree, TRouteId>['types']['allContext'],\n  RouteById<TRouteTree, TRouteId>['types']['loaderDeps']\n>\n\nexport type AnyRouteMatch = RouteMatch<any, any, any, any, any, any, any>\n\nexport type MakeRouteMatchUnion<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>,\n> = TRoute extends any\n  ? RouteMatch<\n      TRoute['id'],\n      TRoute['fullPath'],\n      TRoute['types']['allParams'],\n      TRoute['types']['fullSearchSchema'],\n      TRoute['types']['loaderData'],\n      TRoute['types']['allContext'],\n      TRoute['types']['loaderDeps']\n    >\n  : never\n\n/**\n * The `MatchRouteOptions` type is used to describe the options that can be used when matching a route.\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#matchrouteoptions-type)\n */\nexport interface MatchRouteOptions {\n  /**\n   * If `true`, will match against pending location instead of the current location.\n   *\n   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#pending-property)\n   */\n  pending?: boolean\n  /**\n   * If `true`, will match against the current location with case sensitivity.\n   *\n   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#casesensitive-property)\n   *\n   * @deprecated Declare case sensitivity in the route definition instead, or globally for all routes using the `caseSensitive` option on the router.\n   */\n  caseSensitive?: boolean\n  /**\n   * If `true`, will match against the current location's search params using a deep inclusive check. e.g. `{ a: 1 }` will match for a current location of `{ a: 1, b: 2 }`.\n   *\n   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#includesearch-property)\n   */\n  includeSearch?: boolean\n  /**\n   * If `true`, will match against the current location using a fuzzy match. e.g. `/posts` will match for a current location of `/posts/123`.\n   *\n   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#fuzzy-property)\n   */\n  fuzzy?: boolean\n}\n"],"mappings":";;;;;AA2FA,IAAa,WACX,OACA,SAC8C;CAC9C,MAAM,QAAS,KAAgB,MAAM,IAAI;CACzC,IAAI;CACJ,IAAI,IAAI;CACR,IAAI,QAAa;AAEjB,SAAQ,OAAO,MAAM,SAAS,QAAQ,SAAS,KAC7C,SAAQ,MAAM;AAGhB,QAAO,SAAS"}

package/dist/esm/RouterProvider.d.ts

@@ -0,0 +1,27 @@
+import { NavigateOptions, ToOptions } from './link.js';
+import { ParsedLocation } from './location.js';
+import { RoutePaths } from './routeInfo.js';
+import { RegisteredRouter, ViewTransitionOptions } from './router.js';
+export interface MatchLocation {
+    to?: string | number | null;
+    fuzzy?: boolean;
+    caseSensitive?: boolean;
+    from?: string;
+}
+export interface CommitLocationOptions {
+    replace?: boolean;
+    resetScroll?: boolean;
+    hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+    viewTransition?: boolean | ViewTransitionOptions;
+    /**
+     * @deprecated All navigations use transitions under the hood now
+     **/
+    startTransition?: boolean;
+    ignoreBlocker?: boolean;
+}
+export type NavigateFn = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = ''>(opts: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
+export type BuildLocationFn = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = ''>(opts: ToOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    leaveParams?: boolean;
+    _includeValidateSearch?: boolean;
+    _isNavigate?: boolean;
+}) => ParsedLocation;

package/dist/esm/config.d.ts

@@ -0,0 +1,17 @@
+import { SSROption } from './router.js';
+import { AnySerializationAdapter } from './ssr/serializer/transformer.js';
+export interface RouterConfigOptions<in out TSerializationAdapters, in out TDefaultSsr> {
+    serializationAdapters?: TSerializationAdapters;
+    defaultSsr?: TDefaultSsr;
+}
+export interface RouterConfig<in out TSerializationAdapters, in out TDefaultSsr> {
+    '~types': RouterConfigTypes<TSerializationAdapters, TDefaultSsr>;
+    serializationAdapters: TSerializationAdapters;
+    defaultSsr: TDefaultSsr | undefined;
+}
+export interface RouterConfigTypes<in out TSerializationAdapters, in out TDefaultSsr> {
+    serializationAdapters: TSerializationAdapters;
+    defaultSsr: TDefaultSsr;
+}
+export declare const createRouterConfig: <const TSerializationAdapters extends ReadonlyArray<AnySerializationAdapter> = [], TDefaultSsr extends SSROption = SSROption>(options: RouterConfigOptions<TSerializationAdapters, TDefaultSsr>) => RouterConfig<TSerializationAdapters, TDefaultSsr>;
+export type AnyRouterConfig = RouterConfig<any, any>;

package/dist/esm/config.js

@@ -0,0 +1,11 @@
+//#region src/config.ts
+var createRouterConfig = (options) => {
+	return {
+		serializationAdapters: options.serializationAdapters,
+		defaultSsr: options.defaultSsr
+	};
+};
+//#endregion
+export { createRouterConfig };
+
+//# sourceMappingURL=config.js.map

package/dist/esm/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../../src/config.ts"],"sourcesContent":["import type { SSROption } from './router'\nimport type { AnySerializationAdapter } from './ssr/serializer/transformer'\n\nexport interface RouterConfigOptions<\n  in out TSerializationAdapters,\n  in out TDefaultSsr,\n> {\n  serializationAdapters?: TSerializationAdapters\n  defaultSsr?: TDefaultSsr\n}\n\nexport interface RouterConfig<\n  in out TSerializationAdapters,\n  in out TDefaultSsr,\n> {\n  '~types': RouterConfigTypes<TSerializationAdapters, TDefaultSsr>\n  serializationAdapters: TSerializationAdapters\n  defaultSsr: TDefaultSsr | undefined\n}\n\nexport interface RouterConfigTypes<\n  in out TSerializationAdapters,\n  in out TDefaultSsr,\n> {\n  serializationAdapters: TSerializationAdapters\n  defaultSsr: TDefaultSsr\n}\n\nexport const createRouterConfig = <\n  const TSerializationAdapters extends ReadonlyArray<AnySerializationAdapter> =\n    [],\n  TDefaultSsr extends SSROption = SSROption,\n>(\n  options: RouterConfigOptions<TSerializationAdapters, TDefaultSsr>,\n): RouterConfig<TSerializationAdapters, TDefaultSsr> => {\n  return {\n    serializationAdapters: options.serializationAdapters,\n    defaultSsr: options.defaultSsr,\n  } as RouterConfig<TSerializationAdapters, TDefaultSsr>\n}\n\nexport type AnyRouterConfig = RouterConfig<any, any>\n"],"mappings":";AA4BA,IAAa,sBAKX,YACsD;AACtD,QAAO;EACL,uBAAuB,QAAQ;EAC/B,YAAY,QAAQ;EACrB"}

package/dist/esm/defer.d.ts

@@ -0,0 +1,37 @@
+import { defaultSerializeError } from './router.js';
+/**
+ * Well-known symbol used by {@link defer} to tag a promise with
+ * its deferred state. Consumers can read `promise[TSR_DEFERRED_PROMISE]`
+ * to access `status`, `data`, or `error`.
+ */
+export declare const TSR_DEFERRED_PROMISE: unique symbol;
+export type DeferredPromiseState<T> = {
+    status: 'pending';
+    data?: T;
+    error?: unknown;
+} | {
+    status: 'success';
+    data: T;
+} | {
+    status: 'error';
+    data?: T;
+    error: unknown;
+};
+export type DeferredPromise<T> = Promise<T> & {
+    [TSR_DEFERRED_PROMISE]: DeferredPromiseState<T>;
+};
+/**
+ * Wrap a promise with a deferred state for use with `<Await>` and `useAwaited`.
+ *
+ * The returned promise is augmented with internal state (status/data/error)
+ * so UI can read progress or suspend until it settles.
+ *
+ * @param _promise The promise to wrap.
+ * @param options Optional config. Provide `serializeError` to customize how
+ * errors are serialized for transfer.
+ * @returns The same promise with attached deferred metadata.
+ * @link https://tanstack.com/router/latest/docs/framework/react/api/router/deferFunction
+ */
+export declare function defer<T>(_promise: Promise<T>, options?: {
+    serializeError?: typeof defaultSerializeError;
+}): DeferredPromise<T>;

package/dist/esm/defer.js

@@ -0,0 +1,40 @@
+import { defaultSerializeError } from "./router.js";
+//#region src/defer.ts
+/**
+* Well-known symbol used by {@link defer} to tag a promise with
+* its deferred state. Consumers can read `promise[TSR_DEFERRED_PROMISE]`
+* to access `status`, `data`, or `error`.
+*/
+var TSR_DEFERRED_PROMISE = Symbol.for("TSR_DEFERRED_PROMISE");
+/**
+* Wrap a promise with a deferred state for use with `<Await>` and `useAwaited`.
+*
+* The returned promise is augmented with internal state (status/data/error)
+* so UI can read progress or suspend until it settles.
+*
+* @param _promise The promise to wrap.
+* @param options Optional config. Provide `serializeError` to customize how
+* errors are serialized for transfer.
+* @returns The same promise with attached deferred metadata.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/deferFunction
+*/
+function defer(_promise, options) {
+	const promise = _promise;
+	if (promise[TSR_DEFERRED_PROMISE]) return promise;
+	promise[TSR_DEFERRED_PROMISE] = { status: "pending" };
+	promise.then((data) => {
+		promise[TSR_DEFERRED_PROMISE].status = "success";
+		promise[TSR_DEFERRED_PROMISE].data = data;
+	}).catch((error) => {
+		promise[TSR_DEFERRED_PROMISE].status = "error";
+		promise[TSR_DEFERRED_PROMISE].error = {
+			data: (options?.serializeError ?? defaultSerializeError)(error),
+			__isServerError: true
+		};
+	});
+	return promise;
+}
+//#endregion
+export { TSR_DEFERRED_PROMISE, defer };
+
+//# sourceMappingURL=defer.js.map

package/dist/esm/defer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defer.js","names":[],"sources":["../../src/defer.ts"],"sourcesContent":["import { defaultSerializeError } from './router'\n\n/**\n * Well-known symbol used by {@link defer} to tag a promise with\n * its deferred state. Consumers can read `promise[TSR_DEFERRED_PROMISE]`\n * to access `status`, `data`, or `error`.\n */\nexport const TSR_DEFERRED_PROMISE = Symbol.for('TSR_DEFERRED_PROMISE')\n\nexport type DeferredPromiseState<T> =\n  | {\n      status: 'pending'\n      data?: T\n      error?: unknown\n    }\n  | {\n      status: 'success'\n      data: T\n    }\n  | {\n      status: 'error'\n      data?: T\n      error: unknown\n    }\n\nexport type DeferredPromise<T> = Promise<T> & {\n  [TSR_DEFERRED_PROMISE]: DeferredPromiseState<T>\n}\n\n/**\n * Wrap a promise with a deferred state for use with `<Await>` and `useAwaited`.\n *\n * The returned promise is augmented with internal state (status/data/error)\n * so UI can read progress or suspend until it settles.\n *\n * @param _promise The promise to wrap.\n * @param options Optional config. Provide `serializeError` to customize how\n * errors are serialized for transfer.\n * @returns The same promise with attached deferred metadata.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/deferFunction\n */\nexport function defer<T>(\n  _promise: Promise<T>,\n  options?: {\n    serializeError?: typeof defaultSerializeError\n  },\n) {\n  const promise = _promise as DeferredPromise<T>\n  // this is already deferred promise\n  if ((promise as any)[TSR_DEFERRED_PROMISE]) {\n    return promise\n  }\n  promise[TSR_DEFERRED_PROMISE] = { status: 'pending' }\n\n  promise\n    .then((data) => {\n      promise[TSR_DEFERRED_PROMISE].status = 'success'\n      promise[TSR_DEFERRED_PROMISE].data = data\n    })\n    .catch((error) => {\n      promise[TSR_DEFERRED_PROMISE].status = 'error'\n      ;(promise[TSR_DEFERRED_PROMISE] as any).error = {\n        data: (options?.serializeError ?? defaultSerializeError)(error),\n        __isServerError: true,\n      }\n    })\n\n  return promise\n}\n"],"mappings":";;;;;;;AAOA,IAAa,uBAAuB,OAAO,IAAI,uBAAuB;;;;;;;;;;;;;AAkCtE,SAAgB,MACd,UACA,SAGA;CACA,MAAM,UAAU;AAEhB,KAAK,QAAgB,sBACnB,QAAO;AAET,SAAQ,wBAAwB,EAAE,QAAQ,WAAW;AAErD,SACG,MAAM,SAAS;AACd,UAAQ,sBAAsB,SAAS;AACvC,UAAQ,sBAAsB,OAAO;GACrC,CACD,OAAO,UAAU;AAChB,UAAQ,sBAAsB,SAAS;AACrC,UAAQ,sBAA8B,QAAQ;GAC9C,OAAO,SAAS,kBAAkB,uBAAuB,MAAM;GAC/D,iBAAiB;GAClB;GACD;AAEJ,QAAO"}

package/dist/esm/fileRoute.d.ts

@@ -0,0 +1,24 @@
+import { Register } from './router.js';
+import { AnyContext, AnyPathParams, AnyRoute, FileBaseRouteOptions, ResolveParams, Route, RouteConstraints, UpdatableRouteOptions } from './route.js';
+import { AnyValidator } from './validators.js';
+export interface FileRouteTypes {
+    fileRoutesByFullPath: any;
+    fullPaths: any;
+    to: any;
+    fileRoutesByTo: any;
+    id: any;
+    fileRoutesById: any;
+}
+export type InferFileRouteTypes<TRouteTree extends AnyRoute> = unknown extends TRouteTree['types']['fileRouteTypes'] ? never : TRouteTree['types']['fileRouteTypes'] extends FileRouteTypes ? TRouteTree['types']['fileRouteTypes'] : never;
+export interface FileRoutesByPath {
+}
+export interface FileRouteOptions<TRegister, TFilePath extends string, TParentRoute extends AnyRoute, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TSearchValidator = undefined, TParams = ResolveParams<TPath>, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined> extends FileBaseRouteOptions<TRegister, TParentRoute, TId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, AnyContext, TRouteContextFn, TBeforeLoadFn, AnyContext, TSSR, TServerMiddlewares, THandlers>, UpdatableRouteOptions<TParentRoute, TId, TFullPath, TParams, TSearchValidator, TLoaderFn, TLoaderDeps, AnyContext, TRouteContextFn, TBeforeLoadFn> {
+}
+export type CreateFileRoute<TFilePath extends string, TParentRoute extends AnyRoute, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath']> = <TRegister = Register, TSearchValidator = undefined, TParams = ResolveParams<TPath>, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined>(options?: FileRouteOptions<TRegister, TFilePath, TParentRoute, TId, TPath, TFullPath, TSearchValidator, TParams, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, TServerMiddlewares, THandlers>) => Route<TRegister, TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchValidator, TParams, AnyContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, unknown, unknown, TSSR, TServerMiddlewares, THandlers>;
+export type LazyRouteOptions = Pick<UpdatableRouteOptions<AnyRoute, string, string, AnyPathParams, AnyValidator, {}, AnyContext, AnyContext, AnyContext, AnyContext>, 'component' | 'errorComponent' | 'pendingComponent' | 'notFoundComponent'>;
+export interface LazyRoute<in out TRoute extends AnyRoute> {
+    options: {
+        id: string;
+    } & LazyRouteOptions;
+}
+export type CreateLazyFileRoute<TRoute extends AnyRoute> = (opts: LazyRouteOptions) => LazyRoute<TRoute>;

package/dist/esm/global.d.ts

@@ -0,0 +1,7 @@
+import { AnyRouter } from './router.js';
+declare global {
+    interface Window {
+        __TSR_ROUTER__?: AnyRouter;
+    }
+}
+export {};

package/dist/esm/hash-scroll.d.ts

@@ -0,0 +1,7 @@
+import { AnyRouter } from './router.js';
+/**
+ * @private
+ * Handles hash-based scrolling after navigation completes.
+ * To be used in framework-specific <Transitioner> components during the onResolved event.
+ */
+export declare function handleHashScroll(router: AnyRouter): void;

package/dist/esm/hash-scroll.js

@@ -0,0 +1,20 @@
+//#region src/hash-scroll.ts
+/**
+* @private
+* Handles hash-based scrolling after navigation completes.
+* To be used in framework-specific <Transitioner> components during the onResolved event.
+*/
+function handleHashScroll(router) {
+	if (typeof document !== "undefined" && document.querySelector) {
+		const location = router.stores.location.state;
+		const hashScrollIntoViewOptions = location.state.__hashScrollIntoViewOptions ?? true;
+		if (hashScrollIntoViewOptions && location.hash !== "") {
+			const el = document.getElementById(location.hash);
+			if (el) el.scrollIntoView(hashScrollIntoViewOptions);
+		}
+	}
+}
+//#endregion
+export { handleHashScroll };
+
+//# sourceMappingURL=hash-scroll.js.map

package/dist/esm/hash-scroll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-scroll.js","names":[],"sources":["../../src/hash-scroll.ts"],"sourcesContent":["import type { AnyRouter } from './router'\n\n/**\n * @private\n * Handles hash-based scrolling after navigation completes.\n * To be used in framework-specific <Transitioner> components during the onResolved event.\n */\nexport function handleHashScroll(router: AnyRouter) {\n  if (typeof document !== 'undefined' && (document as any).querySelector) {\n    const location = router.stores.location.state\n    const hashScrollIntoViewOptions =\n      location.state.__hashScrollIntoViewOptions ?? true\n\n    if (hashScrollIntoViewOptions && location.hash !== '') {\n      const el = document.getElementById(location.hash)\n      if (el) {\n        el.scrollIntoView(hashScrollIntoViewOptions)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;AAOA,SAAgB,iBAAiB,QAAmB;AAClD,KAAI,OAAO,aAAa,eAAgB,SAAiB,eAAe;EACtE,MAAM,WAAW,OAAO,OAAO,SAAS;EACxC,MAAM,4BACJ,SAAS,MAAM,+BAA+B;AAEhD,MAAI,6BAA6B,SAAS,SAAS,IAAI;GACrD,MAAM,KAAK,SAAS,eAAe,SAAS,KAAK;AACjD,OAAI,GACF,IAAG,eAAe,0BAA0B"}