camox 0.33.0 → 0.34.0

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/index.d.ts

@@ -0,0 +1,18 @@
+import { FileRouteTypes, InferFileRouteTypes, LazyRoute, LazyRouteOptions } from "./fileRoute.js";
+import { Assign, Awaitable, Constrain, ConstrainLiteral, ControlledPromise, Expand, ExtractObjects, ExtractPrimitives, IntersectAssign, IsNonEmptyObject, LooseAsyncReturnType, LooseReturnType, MakeDifferenceOptional, MergeAllPrimitive, NoInfer, NonNullableUpdater, PartialMergeAll, PartialMergeAllObject, PickAsRequired, Updater } from "./utils.js";
+import { AbsoluteToPath, AddLeadingSlash, AddTrailingSlash, FindDescendantToPaths, FromPathOption, InferDescendantToPaths, IsRequiredParams, MakeOptionalPathParams, MakeOptionalSearchParams, MaskOptions, NavigateOptions, PathParamOptions, RelativeToCurrentPath, RelativeToParentPath, RelativeToPath, RelativeToPathAutoComplete, RemoveLeadingSlashes, RemoveTrailingSlashes, RequiredToOptions, ResolveCurrentPath, ResolveParentPath, ResolveRelativePath, ResolveRoute, SearchParamOptions, ToMaskOptions, ToOptions, ToPathOption, ToSubOptions, ToSubOptionsProps } from "./link.js";
+import { AllParams, CodeRouteToPath, FullSearchSchema, FullSearchSchemaInput, ParseRoute, RouteById, RouteByPath, RoutePaths, RouteToPath, RoutesById, RoutesByPath, TrailingSlashOptionByRouter } from "./routeInfo.js";
+import { AnyRedirect, Redirect, RedirectFnRoute, RedirectOptions, RedirectOptionsRoute } from "./redirect.js";
+import { AnyRouteMatch, MakeRouteMatchFromRoute, MakeRouteMatchUnion, MatchRouteOptions, RouteMatch, RouteMatchExtensions } from "./Matches.js";
+import { RootRouteId, rootRouteId } from "./root.js";
+import { BuildLocationFn, CommitLocationOptions, NavigateFn } from "./RouterProvider.js";
+import { RawStream, RawStreamHint, RawStreamOptions } from "./ssr/serializer/RawStream.js";
+import { AnySerializationAdapter, DefaultSerializable, RegisteredSerializableInput, Serializable, SerializableExtensions, SerializationAdapter, SerializationError, SerializerExtensions, TSR_SERIALIZABLE, TsrSerializable, ValidateSerializable, ValidateSerializableInput } from "./ssr/serializer/transformer.js";
+import { AnyContext, AnyPathParams, AnyRoute, BaseRouteOptions, BeforeLoadContextOptions, BeforeLoadContextParameter, ContextAsyncReturnType, ContextOptions, ContextReturnType, FileBaseRouteOptions, FilebaseRouteOptionsInterface, FullSearchSchemaOption, InferAllContext, InferAllParams, InferFullSearchSchema, InferFullSearchSchemaInput, LoaderFnContext, LoaderStaleReloadMode, MakeRemountDepsOptionsUnion, ParamsOptions, ParseParamsFn, RemountDepsOptions, ResolveAllContext, ResolveAllParamsFromParent, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, ResolveLoaderData, ResolveOptionalParams, ResolveParams, ResolveRequiredParams, ResolveRouteContext, Route, RouteAddChildrenFn, RouteAddFileChildrenFn, RouteAddFileTypesFn, RouteContextOptions, RouteContextParameter, RouteExtensions, RouteLazyFn, RouteLoaderFn, RouteMask, RouteOptions, RoutePathOptions, RouteTypes, SearchFilter, SearchMiddleware, SearchMiddlewareContext, SearchSchemaInput, StaticDataRouteOption, StringifyParamsFn, TrimPathRight, UpdatableRouteOptions, UpdatableRouteOptionsExtensions, UpdatableStaticRouteOption } from "./route.js";
+import { AnySchema, AnyStandardSchemaValidate, AnyStandardSchemaValidateFailure, AnyStandardSchemaValidateIssue, AnyStandardSchemaValidateSuccess, AnyStandardSchemaValidator, AnyValidator, AnyValidatorAdapter, AnyValidatorObj, DefaultValidator, ResolveSearchValidatorInput, ResolveSearchValidatorInputFn, ResolveValidatorOutput, ResolveValidatorOutputFn, StandardSchemaValidator, StandardSchemaValidatorProps, StandardSchemaValidatorTypes, Validator, ValidatorAdapter, ValidatorFn, ValidatorObj } from "./validators.js";
+import { ParsedLocation } from "./location.js";
+import { SearchParser, SearchSerializer } from "./searchParams.js";
+import { AssetCrossOrigin, Manifest, ManifestAssetLink, RouterManagedTag } from "./manifest.js";
+import { GetStoreConfig, RouterBatchFn, RouterReadableStore, RouterStores, RouterWritableStore } from "./stores.js";
+import { AnyRouter, BuildNextOptions, ClearCacheFn, CommitLocationFn, DefaultRemountDepsFn, EmitFn, GetMatchFn, GetMatchRoutesFn, InvalidateFn, ListenerFn, LoadFn, LocationRewrite, LocationRewriteFunction, MatchRouteFn, MatchRoutesFn, MatchRoutesOpts, ParseLocationFn, PreloadRouteFn, Register, RegisteredRouter, RouterConstructorOptions, RouterContextOptions, RouterCore, RouterEvent, RouterEvents, RouterListener, RouterOptions, RouterOptionsExtensions, RouterState, SSROption, StartTransitionFn, SubscribeFn, TrailingSlashOption, UpdateFn, UpdateMatchFn, ViewTransitionOptions, trailingSlashOptions } from "./router.js";
+import { UseNavigateResult } from "./useNavigate.js";

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/link.d.ts

@@ -0,0 +1,161 @@
+import { ConstrainLiteral, Expand, MakeDifferenceOptional, NoInfer, NonNullableUpdater, Updater } from "./utils.js";
+import { AllParams, CatchAllPaths, CurrentPath, FullSearchSchema, FullSearchSchemaInput, ParentPath, RouteByPath, RouteByToPath, RoutePaths, RouteToPath, ToPath } from "./routeInfo.js";
+import { ParsedLocation } from "./location.js";
+import { AnyRouter, RegisteredRouter, ViewTransitionOptions } from "./router.js";
+import { HistoryState, ParsedHistoryState } from "@tanstack/history";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/link.d.ts
+type IsRequiredParams<TParams> = Record<never, never> extends TParams ? never : true;
+interface ParsePathParamsResult<in out TRequired, in out TOptional, in out TRest> {
+  required: TRequired;
+  optional: TOptional;
+  rest: TRest;
+}
+type ParsePathParamsBoundaryStart<T extends string> = T extends `${infer TLeft}{-${infer TRight}` ? ParsePathParamsResult<ParsePathParams<TLeft>['required'], ParsePathParams<TLeft>['optional'] | ParsePathParams<TRight>['required'] | ParsePathParams<TRight>['optional'], ParsePathParams<TRight>['rest']> : T extends `${infer TLeft}{${infer TRight}` ? ParsePathParamsResult<ParsePathParams<TLeft>['required'] | ParsePathParams<TRight>['required'], ParsePathParams<TLeft>['optional'] | ParsePathParams<TRight>['optional'], ParsePathParams<TRight>['rest']> : never;
+type ParsePathParamsSymbol<T extends string> = T extends `${string}$${infer TRight}` ? TRight extends `${string}/${string}` ? TRight extends `${infer TParam}/${infer TRest}` ? TParam extends '' ? ParsePathParamsResult<ParsePathParams<TRest>['required'], '_splat' | ParsePathParams<TRest>['optional'], ParsePathParams<TRest>['rest']> : ParsePathParamsResult<TParam | ParsePathParams<TRest>['required'], ParsePathParams<TRest>['optional'], ParsePathParams<TRest>['rest']> : never : TRight extends '' ? ParsePathParamsResult<never, '_splat', never> : ParsePathParamsResult<TRight, never, never> : never;
+type ParsePathParamsBoundaryEnd<T extends string> = T extends `${infer TLeft}}${infer TRight}` ? ParsePathParamsResult<ParsePathParams<TLeft>['required'] | ParsePathParams<TRight>['required'], ParsePathParams<TLeft>['optional'] | ParsePathParams<TRight>['optional'], ParsePathParams<TRight>['rest']> : never;
+type ParsePathParamsEscapeStart<T extends string> = T extends `${infer TLeft}[${infer TRight}` ? ParsePathParamsResult<ParsePathParams<TLeft>['required'] | ParsePathParams<TRight>['required'], ParsePathParams<TLeft>['optional'] | ParsePathParams<TRight>['optional'], ParsePathParams<TRight>['rest']> : never;
+type ParsePathParamsEscapeEnd<T extends string> = T extends `${string}]${infer TRight}` ? ParsePathParams<TRight> : never;
+type ParsePathParams<T extends string> = T extends `${string}[${string}` ? ParsePathParamsEscapeStart<T> : T extends `${string}]${string}` ? ParsePathParamsEscapeEnd<T> : T extends `${string}}${string}` ? ParsePathParamsBoundaryEnd<T> : T extends `${string}{${string}` ? ParsePathParamsBoundaryStart<T> : T extends `${string}$${string}` ? ParsePathParamsSymbol<T> : never;
+type AddTrailingSlash<T> = T extends `${string}/` ? T : `${T & string}/`;
+type RemoveTrailingSlashes<T> = T & `${string}/` extends never ? T : T extends `${infer R}/` ? R : T;
+type AddLeadingSlash<T> = T & `/${string}` extends never ? `/${T & string}` : T;
+type RemoveLeadingSlashes<T> = T & `/${string}` extends never ? T : T extends `/${infer R}` ? R : T;
+type JoinPath<TLeft extends string, TRight extends string> = TRight extends '' ? TLeft : TLeft extends '' ? TRight : `${RemoveTrailingSlashes<TLeft>}/${RemoveLeadingSlashes<TRight>}`;
+type RemoveLastSegment<T extends string, TAcc extends string = ''> = T extends `${infer TSegment}/${infer TRest}` ? TRest & `${string}/${string}` extends never ? TRest extends '' ? TAcc : `${TAcc}${TSegment}` : RemoveLastSegment<TRest, `${TAcc}${TSegment}/`> : TAcc;
+type ResolveCurrentPath<TFrom extends string, TTo extends string> = TTo extends '.' ? TFrom : TTo extends './' ? AddTrailingSlash<TFrom> : TTo & `./${string}` extends never ? never : TTo extends `./${infer TRest}` ? AddLeadingSlash<JoinPath<TFrom, TRest>> : never;
+type ResolveParentPath<TFrom extends string, TTo extends string> = TTo extends '../' | '..' ? TFrom extends '' | '/' ? never : AddLeadingSlash<RemoveLastSegment<TFrom>> : TTo & `../${string}` extends never ? AddLeadingSlash<JoinPath<TFrom, TTo>> : TFrom extends '' | '/' ? never : TTo extends `../${infer ToRest}` ? ResolveParentPath<RemoveLastSegment<TFrom>, ToRest> : AddLeadingSlash<JoinPath<TFrom, TTo>>;
+type ResolveRelativePath<TFrom, TTo = '.'> = string extends TFrom ? TTo : string extends TTo ? TFrom : undefined extends TTo ? TFrom : TTo extends string ? TFrom extends string ? TTo extends `/${string}` ? TTo : TTo extends `..${string}` ? ResolveParentPath<TFrom, TTo> : TTo extends `.${string}` ? ResolveCurrentPath<TFrom, TTo> : AddLeadingSlash<JoinPath<TFrom, TTo>> : never : never;
+type FindDescendantToPaths<TRouter extends AnyRouter, TPrefix extends string> = `${TPrefix}/${string}` & RouteToPath<TRouter>;
+type InferDescendantToPaths<TRouter extends AnyRouter, TPrefix extends string, TPaths = FindDescendantToPaths<TRouter, TPrefix>> = TPaths extends `${TPrefix}/` ? never : TPaths extends `${TPrefix}/${infer TRest}` ? TRest : never;
+type RelativeToPath<TRouter extends AnyRouter, TTo extends string, TResolvedPath extends string> = (TResolvedPath & RouteToPath<TRouter> extends never ? never : ToPath<TRouter, TTo>) | `${RemoveTrailingSlashes<TTo>}/${InferDescendantToPaths<TRouter, RemoveTrailingSlashes<TResolvedPath>>}`;
+type RelativeToParentPath<TRouter extends AnyRouter, TFrom extends string, TTo extends string, TResolvedPath extends string = ResolveRelativePath<TFrom, TTo>> = RelativeToPath<TRouter, TTo, TResolvedPath> | (TTo extends `${string}..` | `${string}../` ? TResolvedPath extends '/' | '' ? never : FindDescendantToPaths<TRouter, RemoveTrailingSlashes<TResolvedPath>> extends never ? never : `${RemoveTrailingSlashes<TTo>}/${ParentPath<TRouter>}` : never);
+type RelativeToCurrentPath<TRouter extends AnyRouter, TFrom extends string, TTo extends string, TResolvedPath extends string = ResolveRelativePath<TFrom, TTo>> = RelativeToPath<TRouter, TTo, TResolvedPath> | CurrentPath<TRouter>;
+type AbsoluteToPath<TRouter extends AnyRouter, TFrom extends string> = (string extends TFrom ? CurrentPath<TRouter> : TFrom extends `/` ? never : CurrentPath<TRouter>) | (string extends TFrom ? ParentPath<TRouter> : TFrom extends `/` ? never : ParentPath<TRouter>) | RouteToPath<TRouter> | (TFrom extends '/' ? never : string extends TFrom ? never : InferDescendantToPaths<TRouter, RemoveTrailingSlashes<TFrom>>);
+type RelativeToPathAutoComplete<TRouter extends AnyRouter, TFrom extends string, TTo extends string> = string extends TTo ? string : string extends TFrom ? AbsoluteToPath<TRouter, TFrom> : TTo & `..${string}` extends never ? TTo & `.${string}` extends never ? AbsoluteToPath<TRouter, TFrom> : RelativeToCurrentPath<TRouter, TFrom, TTo> : RelativeToParentPath<TRouter, TFrom, TTo>;
+type NavigateOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = ToOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & NavigateOptionProps;
+/**
+ * The NavigateOptions type is used to describe the options that can be used when describing a navigation action in TanStack Router.
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType)
+ */
+interface NavigateOptionProps {
+  /**
+   * If set to `true`, the router will scroll the element with an id matching the hash into view with default `ScrollIntoViewOptions`.
+   * If set to `false`, the router will not scroll the element with an id matching the hash into view.
+   * If set to `ScrollIntoViewOptions`, the router will scroll the element with an id matching the hash into view with the provided options.
+   * @default true
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#hashscrollintoview)
+   * @see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView)
+   */
+  hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+  /**
+   * `replace` is a boolean that determines whether the navigation should replace the current history entry or push a new one.
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#replace)
+   */
+  replace?: boolean;
+  /**
+   * Defaults to `true` so that the scroll position will be reset to 0,0 after the location is committed to the browser history.
+   * If `false`, the scroll position will not be reset to 0,0 after the location is committed to history.
+   * @default true
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#resetscroll)
+   */
+  resetScroll?: boolean;
+  /** @deprecated All navigations now use startTransition under the hood */
+  startTransition?: boolean;
+  /**
+   * If set to `true`, the router will wrap the resulting navigation in a `document.startViewTransition()` call.
+   * If `ViewTransitionOptions`, route navigations will be called using `document.startViewTransition({update, types})`
+   * where `types` will be the strings array passed with `ViewTransitionOptions["types"]`.
+   * If the browser does not support viewTransition types, the navigation will fall back to normal `document.startTransition()`, same as if `true` was passed.
+   *
+   * If the browser does not support this api, this option will be ignored.
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#viewtransition)
+   * @see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Document/startViewTransition)
+   * @see [Google](https://developer.chrome.com/docs/web-platform/view-transitions/same-document#view-transition-types)
+   */
+  viewTransition?: boolean | ViewTransitionOptions;
+  /**
+   * If `true`, navigation will ignore any blockers that might prevent it.
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#ignoreblocker)
+   */
+  ignoreBlocker?: boolean;
+  /**
+   * If `true`, navigation to a route inside of router will trigger a full page load instead of the traditional SPA navigation.
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#reloaddocument)
+   */
+  reloadDocument?: boolean;
+  /**
+   * This can be used instead of `to` to navigate to a fully built href, e.g. pointing to an external target.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#href)
+   */
+  href?: string;
+}
+type ToOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = ToSubOptions<TRouter, TFrom, TTo> & MaskOptions<TRouter, TMaskFrom, TMaskTo>;
+interface MaskOptions<in out TRouter extends AnyRouter, in out TMaskFrom extends string, in out TMaskTo extends string> {
+  _fromLocation?: ParsedLocation;
+  mask?: ToMaskOptions<TRouter, TMaskFrom, TMaskTo>;
+}
+type ToMaskOptions<TRouter extends AnyRouter = RegisteredRouter, TMaskFrom extends string = string, TMaskTo extends string = '.'> = ToSubOptions<TRouter, TMaskFrom, TMaskTo> & {
+  unmaskOnReload?: boolean;
+};
+type ToSubOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.'> = ToSubOptionsProps<TRouter, TFrom, TTo> & SearchParamOptions<TRouter, TFrom, TTo> & PathParamOptions<TRouter, TFrom, TTo>;
+interface RequiredToOptions<in out TRouter extends AnyRouter, in out TFrom extends string, in out TTo extends string | undefined> {
+  /**
+   * The internal route path to navigate to. This should be a relative or absolute path within your application.
+   * For external URLs, use the `href` property instead.
+   * @example "/dashboard" or "../profile"
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#href)
+   */
+  to: ToPathOption<TRouter, TFrom, TTo> & {};
+}
+interface OptionalToOptions<in out TRouter extends AnyRouter, in out TFrom extends string, in out TTo extends string | undefined> {
+  /**
+   * The internal route path to navigate to. This should be a relative or absolute path within your application.
+   * For external URLs, use the `href` property instead.
+   * @example "/dashboard" or "../profile"
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#href)
+   */
+  to?: ToPathOption<TRouter, TFrom, TTo> & {};
+}
+type MakeToRequired<TRouter extends AnyRouter, TFrom extends string, TTo extends string | undefined> = string extends TFrom ? string extends TTo ? OptionalToOptions<TRouter, TFrom, TTo> : TTo & CatchAllPaths<TRouter> extends never ? RequiredToOptions<TRouter, TFrom, TTo> : OptionalToOptions<TRouter, TFrom, TTo> : OptionalToOptions<TRouter, TFrom, TTo>;
+type ToSubOptionsProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string | undefined = '.'> = MakeToRequired<TRouter, TFrom, TTo> & {
+  hash?: true | Updater<string>;
+  state?: true | NonNullableUpdater<ParsedHistoryState, HistoryState>;
+  from?: FromPathOption<TRouter, TFrom> & {};
+  unsafeRelative?: 'path';
+};
+type ParamsReducerFn<in out TRouter extends AnyRouter, in out TParamVariant extends ParamVariant, in out TFrom, in out TTo> = (current: Expand<ResolveFromParams<TRouter, TParamVariant, TFrom>>) => Expand<ResolveRelativeToParams<TRouter, TParamVariant, TFrom, TTo>>;
+type ParamsReducer<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo> = Expand<ResolveRelativeToParams<TRouter, TParamVariant, TFrom, TTo>> | (ParamsReducerFn<TRouter, TParamVariant, TFrom, TTo> & {});
+type ParamVariant = 'PATH' | 'SEARCH';
+type ResolveRoute<TRouter extends AnyRouter, TFrom, TTo, TPath = ResolveRelativePath<TFrom, TTo>> = TPath extends string ? TFrom extends TPath ? RouteByPath<TRouter['routeTree'], TPath> : RouteByToPath<TRouter, TPath> : never;
+type ResolveFromParamType<TParamVariant extends ParamVariant> = TParamVariant extends 'PATH' ? 'allParams' : 'fullSearchSchema';
+type ResolveFromAllParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant> = TParamVariant extends 'PATH' ? AllParams<TRouter['routeTree']> : FullSearchSchema<TRouter['routeTree']>;
+type ResolveFromParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom> = string extends TFrom ? ResolveFromAllParams<TRouter, TParamVariant> : RouteByPath<TRouter['routeTree'], TFrom>['types'][ResolveFromParamType<TParamVariant>];
+type ResolveToParamType<TParamVariant extends ParamVariant> = TParamVariant extends 'PATH' ? 'allParams' : 'fullSearchSchemaInput';
+type ResolveAllToParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant> = TParamVariant extends 'PATH' ? AllParams<TRouter['routeTree']> : FullSearchSchemaInput<TRouter['routeTree']>;
+type ResolveToParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo> = ResolveRelativePath<TFrom, TTo> extends infer TPath ? undefined extends TPath ? never : string extends TPath ? ResolveAllToParams<TRouter, TParamVariant> : TPath extends CatchAllPaths<TRouter> ? ResolveAllToParams<TRouter, TParamVariant> : ResolveRoute<TRouter, TFrom, TTo>['types'][ResolveToParamType<TParamVariant>] : never;
+type ResolveRelativeToParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo, TToParams = ResolveToParams<TRouter, TParamVariant, TFrom, TTo>> = TParamVariant extends 'SEARCH' ? TToParams : string extends TFrom ? TToParams : MakeDifferenceOptional<ResolveFromParams<TRouter, TParamVariant, TFrom>, TToParams>;
+interface MakeOptionalSearchParams<in out TRouter extends AnyRouter, in out TFrom, in out TTo> {
+  search?: true | (ParamsReducer<TRouter, 'SEARCH', TFrom, TTo> & {});
+}
+interface MakeOptionalPathParams<in out TRouter extends AnyRouter, in out TFrom, in out TTo> {
+  params?: true | (ParamsReducer<TRouter, 'PATH', TFrom, TTo> & {});
+}
+type MakeRequiredParamsReducer<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo> = (string extends TFrom ? never : ResolveFromParams<TRouter, TParamVariant, TFrom> extends ResolveRelativeToParams<TRouter, TParamVariant, TFrom, TTo> ? true : never) | (ParamsReducer<TRouter, TParamVariant, TFrom, TTo> & {});
+interface MakeRequiredPathParams<in out TRouter extends AnyRouter, in out TFrom, in out TTo> {
+  params: MakeRequiredParamsReducer<TRouter, 'PATH', TFrom, TTo> & {};
+}
+interface MakeRequiredSearchParams<in out TRouter extends AnyRouter, in out TFrom, in out TTo> {
+  search: MakeRequiredParamsReducer<TRouter, 'SEARCH', TFrom, TTo> & {};
+}
+type IsRequired<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo> = ResolveRelativePath<TFrom, TTo> extends infer TPath ? undefined extends TPath ? never : TPath extends CatchAllPaths<TRouter> ? never : IsRequiredParams<ResolveRelativeToParams<TRouter, TParamVariant, TFrom, TTo>> : never;
+type SearchParamOptions<TRouter extends AnyRouter, TFrom, TTo> = IsRequired<TRouter, 'SEARCH', TFrom, TTo> extends never ? MakeOptionalSearchParams<TRouter, TFrom, TTo> : MakeRequiredSearchParams<TRouter, TFrom, TTo>;
+type PathParamOptions<TRouter extends AnyRouter, TFrom, TTo> = IsRequired<TRouter, 'PATH', TFrom, TTo> extends never ? MakeOptionalPathParams<TRouter, TFrom, TTo> : MakeRequiredPathParams<TRouter, TFrom, TTo>;
+type ToPathOption<TRouter extends AnyRouter = AnyRouter, TFrom extends string = string, TTo extends string | undefined = string> = ConstrainLiteral<TTo, RelativeToPathAutoComplete<TRouter, NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>>;
+type FromPathOption<TRouter extends AnyRouter, TFrom> = ConstrainLiteral<TFrom, RoutePaths<TRouter['routeTree']>>;
+//#endregion
+export { AbsoluteToPath, AddLeadingSlash, AddTrailingSlash, FindDescendantToPaths, FromPathOption, InferDescendantToPaths, IsRequiredParams, MakeOptionalPathParams, MakeOptionalSearchParams, MaskOptions, NavigateOptions, ParsePathParams, PathParamOptions, RelativeToCurrentPath, RelativeToParentPath, RelativeToPath, RelativeToPathAutoComplete, RemoveLeadingSlashes, RemoveTrailingSlashes, RequiredToOptions, ResolveCurrentPath, ResolveParentPath, ResolveRelativePath, ResolveRoute, SearchParamOptions, ToMaskOptions, ToOptions, ToPathOption, ToSubOptions, ToSubOptionsProps };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/load-matches.d.ts

@@ -0,0 +1,6 @@
+import { AnyRoute } from "./route.js";
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/load-matches.d.ts
+type RouteComponentType = 'component' | 'errorComponent' | 'pendingComponent' | 'notFoundComponent';
+declare function loadRouteChunk(route: AnyRoute, componentTypesToLoad?: Array<RouteComponentType>): Promise<void> | undefined;
+//#endregion
+export { loadRouteChunk };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/location.d.ts

@@ -0,0 +1,54 @@
+import { AnySchema } from "./validators.js";
+import { ParsedHistoryState } from "@tanstack/history";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/location.d.ts
+interface ParsedLocation<TSearchObj extends AnySchema = {}> {
+  /**
+   * The full path of the location, including pathname, search, and hash.
+   * Does not include the origin. Is the equivalent of calling
+   * `url.replace(url.origin, '')`
+   */
+  href: string;
+  /**
+   * @description The pathname of the location, including the leading slash.
+   */
+  pathname: string;
+  /**
+   * The parsed search parameters of the location in object form.
+   */
+  search: TSearchObj;
+  /**
+   * The search string of the location, including the leading question mark.
+   */
+  searchStr: string;
+  /**
+   * The in-memory state of the location as it *may* exist in the browser's history.
+   */
+  state: ParsedHistoryState;
+  /**
+   * The hash of the location, excluding the leading hash character.
+   * (e.g., '123' instead of '#123')
+   */
+  hash: string;
+  /**
+   * The masked location of the location.
+   */
+  maskedLocation?: ParsedLocation<TSearchObj>;
+  /**
+   * Whether to unmask the location on reload.
+   */
+  unmaskOnReload?: boolean;
+  /**
+   * @private
+   * @description The public href of the location.
+   * If a rewrite is applied, the `href` property will be the rewritten URL.
+   */
+  publicHref: string;
+  /**
+   * @private
+   * @description Whether the publicHref is external (different origin from rewrite).
+   */
+  external: boolean;
+}
+//#endregion
+export { ParsedLocation };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/lru-cache.d.ts

@@ -0,0 +1,8 @@
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/lru-cache.d.ts
+type LRUCache<TKey, TValue> = {
+  get: (key: TKey) => TValue | undefined;
+  set: (key: TKey, value: TValue) => void;
+  clear: () => void;
+};
+//#endregion
+export { LRUCache };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/manifest.d.ts

@@ -0,0 +1,32 @@
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/manifest.d.ts
+type AssetCrossOrigin = 'anonymous' | 'use-credentials';
+type ManifestAssetLink = string | {
+  href: string;
+  crossOrigin?: AssetCrossOrigin;
+};
+type Manifest = {
+  routes: Record<string, {
+    filePath?: string;
+    preloads?: Array<ManifestAssetLink>;
+    assets?: Array<RouterManagedTag>;
+  }>;
+};
+type RouterManagedTag = {
+  tag: 'title';
+  attrs?: Record<string, any>;
+  children: string;
+} | {
+  tag: 'meta' | 'link';
+  attrs?: Record<string, any>;
+  children?: never;
+} | {
+  tag: 'script';
+  attrs?: Record<string, any>;
+  children?: string;
+} | {
+  tag: 'style';
+  attrs?: Record<string, any>;
+  children?: string;
+};
+//#endregion
+export { AssetCrossOrigin, Manifest, ManifestAssetLink, RouterManagedTag };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/new-process-route-tree.d.ts

@@ -0,0 +1,115 @@
+import { LRUCache } from "./lru-cache.js";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/new-process-route-tree.d.ts
+declare const SEGMENT_TYPE_PATHNAME = 0;
+declare const SEGMENT_TYPE_PARAM = 1;
+declare const SEGMENT_TYPE_WILDCARD = 2;
+declare const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
+declare const SEGMENT_TYPE_INDEX = 4;
+declare const SEGMENT_TYPE_PATHLESS = 5;
+/**
+ * All the kinds of segments that can be present in a route path.
+ */
+type SegmentKind = typeof SEGMENT_TYPE_PATHNAME | typeof SEGMENT_TYPE_PARAM | typeof SEGMENT_TYPE_WILDCARD | typeof SEGMENT_TYPE_OPTIONAL_PARAM;
+/**
+ * All the kinds of segments that can be present in the segment tree.
+ */
+type ExtendedSegmentKind = SegmentKind | typeof SEGMENT_TYPE_INDEX | typeof SEGMENT_TYPE_PATHLESS;
+type StaticSegmentNode<T extends RouteLike> = SegmentNode<T> & {
+  kind: typeof SEGMENT_TYPE_PATHNAME | typeof SEGMENT_TYPE_PATHLESS | typeof SEGMENT_TYPE_INDEX;
+};
+type DynamicSegmentNode<T extends RouteLike> = SegmentNode<T> & {
+  kind: typeof SEGMENT_TYPE_PARAM | typeof SEGMENT_TYPE_WILDCARD | typeof SEGMENT_TYPE_OPTIONAL_PARAM;
+  prefix?: string;
+  suffix?: string;
+  caseSensitive: boolean;
+};
+type AnySegmentNode<T extends RouteLike> = StaticSegmentNode<T> | DynamicSegmentNode<T>;
+type SegmentNode<T extends RouteLike> = {
+  kind: ExtendedSegmentKind;
+  pathless: Array<StaticSegmentNode<T>> | null; /** Exact index segment (highest priority) */
+  index: StaticSegmentNode<T> | null; /** Static segments (2nd priority) */
+  static: Map<string, StaticSegmentNode<T>> | null; /** Case insensitive static segments (3rd highest priority) */
+  staticInsensitive: Map<string, StaticSegmentNode<T>> | null; /** Dynamic segments ($param) */
+  dynamic: Array<DynamicSegmentNode<T>> | null; /** Optional dynamic segments ({-$param}) */
+  optional: Array<DynamicSegmentNode<T>> | null; /** Wildcard segments ($ - lowest priority) */
+  wildcard: Array<DynamicSegmentNode<T>> | null; /** Terminal route (if this path can end here) */
+  route: T | null; /** The full path for this segment node (will only be valid on leaf nodes) */
+  fullPath: string;
+  parent: AnySegmentNode<T> | null;
+  depth: number; /** route.options.params.parse function, set on the last node of the route */
+  parse: null | ((params: Record<string, string>) => any); /** options.skipRouteOnParseError.params ?? false */
+  skipOnParamError: boolean; /** options.skipRouteOnParseError.priority ?? 0 */
+  parsingPriority: number;
+};
+type RouteLike = {
+  id?: string;
+  path?: string;
+  children?: Array<RouteLike>;
+  parentRoute?: RouteLike;
+  isRoot?: boolean;
+  options?: {
+    skipRouteOnParseError?: {
+      params?: boolean;
+      priority?: number;
+    };
+    caseSensitive?: boolean;
+    params?: {
+      parse?: (params: Record<string, string>) => any;
+    };
+  };
+} & ({
+  fullPath: string;
+  from?: never;
+} | {
+  fullPath?: never;
+  from: string;
+});
+type ProcessedTree<TTree extends Extract<RouteLike, {
+  fullPath: string;
+}>, TFlat extends Extract<RouteLike, {
+  from: string;
+}>, TSingle extends Extract<RouteLike, {
+  from: string;
+}>> = {
+  /** a representation of the `routeTree` as a segment tree */segmentTree: AnySegmentNode<TTree>; /** a mini route tree generated from the flat `routeMasks` list */
+  masksTree: AnySegmentNode<TFlat> | null; /** @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree */
+  singleCache: LRUCache<string, AnySegmentNode<TSingle>>; /** a cache of route matches from the `segmentTree` */
+  matchCache: LRUCache<string, RouteMatch<TTree> | null>; /** a cache of route matches from the `masksTree` */
+  flatCache: LRUCache<string, ReturnType<typeof findMatch<TFlat>>> | null;
+};
+type RouteMatch<T extends Extract<RouteLike, {
+  fullPath: string;
+}>> = {
+  route: T;
+  rawParams: Record<string, string>;
+  parsedParams?: Record<string, unknown>;
+  branch: ReadonlyArray<T>;
+};
+interface ProcessRouteTreeResult<TRouteLike extends Extract<RouteLike, {
+  fullPath: string;
+}> & {
+  id: string;
+}> {
+  /** Should be considered a black box, needs to be provided to all matching functions in this module. */
+  processedTree: ProcessedTree<TRouteLike, any, any>;
+  /** A lookup map of routes by their unique IDs. */
+  routesById: Record<string, TRouteLike>;
+  /** A lookup map of routes by their trimmed full paths. */
+  routesByPath: Record<string, TRouteLike>;
+}
+declare function findMatch<T extends RouteLike>(path: string, segmentTree: AnySegmentNode<T>, fuzzy?: boolean): {
+  route: T;
+  /**
+   * The raw (unparsed) params extracted from the path.
+   * This will be the exhaustive list of all params defined in the route's path.
+   */
+  rawParams: Record<string, string>;
+  /**
+   * The accumlulated parsed params of each route in the branch that had `skipRouteOnParseError` enabled.
+   * Will not contain all params defined in the route's path. Those w/ a `params.parse` but no `skipRouteOnParseError` will need to be parsed separately.
+   */
+  parsedParams?: Record<string, unknown>;
+} | null;
+//#endregion
+export { ProcessRouteTreeResult, ProcessedTree };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/not-found.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/redirect.d.ts

@@ -0,0 +1,49 @@
+import { NavigateOptions } from "./link.js";
+import { AnyRouter, RegisteredRouter } from "./router.js";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/redirect.d.ts
+type AnyRedirect = Redirect<any, any, any, any, any>;
+/**
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType)
+ */
+type Redirect<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = Response & {
+  options: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {};
+  redirectHandled?: boolean;
+};
+type RedirectOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = {
+  href?: string;
+  /**
+   * @deprecated Use `statusCode` instead
+   **/
+  code?: number;
+  /**
+   * The HTTP status code to use when redirecting.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType#statuscode-property)
+   */
+  statusCode?: number;
+  /**
+   * If provided, will throw the redirect object instead of returning it. This can be useful in places where `throwing` in a function might cause it to have a return type of `never`. In that case, you can use `redirect({ throw: true })` to throw the redirect object instead of returning it.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType#throw-property)
+   */
+  throw?: any;
+  /**
+   * The HTTP headers to use when redirecting.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType#headers-property)
+   */
+  headers?: HeadersInit;
+} & NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+/**
+ * Options for route-bound redirect, where 'from' is automatically set.
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType)
+ */
+type RedirectOptionsRoute<TDefaultFrom extends string = string, TRouter extends AnyRouter = RegisteredRouter, TTo extends string | undefined = undefined, TMaskTo extends string = ''> = Omit<RedirectOptions<TRouter, TDefaultFrom, TTo, TDefaultFrom, TMaskTo>, 'from'>;
+/**
+ * A redirect function bound to a specific route, with 'from' pre-set to the route's fullPath.
+ * This enables relative redirects like `Route.redirect({ to: './overview' })`.
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType)
+ */
+interface RedirectFnRoute<in out TDefaultFrom extends string = string> {
+  <TRouter extends AnyRouter = RegisteredRouter, const TTo extends string | undefined = undefined, const TMaskTo extends string = ''>(opts: RedirectOptionsRoute<TDefaultFrom, TRouter, TTo, TMaskTo>): Redirect<TRouter, TDefaultFrom, TTo, TDefaultFrom, TMaskTo>;
+}
+//#endregion
+export { AnyRedirect, Redirect, RedirectFnRoute, RedirectOptions, RedirectOptionsRoute };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/rewrite.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/root.d.ts

@@ -0,0 +1,6 @@
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/root.d.ts
+/** Stable identifier used for the root route in a route tree. */
+declare const rootRouteId = "__root__";
+type RootRouteId = typeof rootRouteId;
+//#endregion
+export { RootRouteId, rootRouteId };