@tanstack/react-router 1.147.1 → 1.147.3

package/dist/cjs/index.dev.cjs

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const routerCore = require("@tanstack/router-core");
+const history = require("@tanstack/history");
+const awaited = require("./awaited.cjs");
+const CatchBoundary = require("./CatchBoundary.cjs");
+const ClientOnly = require("./ClientOnly.cjs");
+const fileRoute = require("./fileRoute.cjs");
+const lazyRouteComponent = require("./lazyRouteComponent.cjs");
+const link = require("./link.cjs");
+const Matches = require("./Matches.cjs");
+const matchContext = require("./matchContext.cjs");
+const Match = require("./Match.cjs");
+const useMatch = require("./useMatch.cjs");
+const useLoaderDeps = require("./useLoaderDeps.cjs");
+const useLoaderData = require("./useLoaderData.cjs");
+const route = require("./route.cjs");
+const router = require("./router.cjs");
+const RouterProvider = require("./RouterProvider.cjs");
+const ScrollRestoration = require("./ScrollRestoration.cjs");
+const useBlocker = require("./useBlocker.cjs");
+const useNavigate = require("./useNavigate.cjs");
+const useParams = require("./useParams.cjs");
+const useSearch = require("./useSearch.cjs");
+const routerContext = require("./routerContext.cjs");
+const useRouteContext = require("./useRouteContext.cjs");
+const useRouter = require("./useRouter.cjs");
+const useRouterState = require("./useRouterState.cjs");
+const useLocation = require("./useLocation.cjs");
+const useCanGoBack = require("./useCanGoBack.cjs");
+const utils = require("./utils.cjs");
+const notFound = require("./not-found.cjs");
+const ScriptOnce = require("./ScriptOnce.cjs");
+const Asset = require("./Asset.cjs");
+const headContentUtils = require("./headContentUtils.cjs");
+const Scripts = require("./Scripts.cjs");
+const HeadContent_dev = require("./HeadContent.dev.cjs");
+Object.defineProperty(exports, "PathParamError", {
+  enumerable: true,
+  get: () => routerCore.PathParamError
+});
+Object.defineProperty(exports, "SearchParamError", {
+  enumerable: true,
+  get: () => routerCore.SearchParamError
+});
+Object.defineProperty(exports, "TSR_DEFERRED_PROMISE", {
+  enumerable: true,
+  get: () => routerCore.TSR_DEFERRED_PROMISE
+});
+Object.defineProperty(exports, "cleanPath", {
+  enumerable: true,
+  get: () => routerCore.cleanPath
+});
+Object.defineProperty(exports, "componentTypes", {
+  enumerable: true,
+  get: () => routerCore.componentTypes
+});
+Object.defineProperty(exports, "composeRewrites", {
+  enumerable: true,
+  get: () => routerCore.composeRewrites
+});
+Object.defineProperty(exports, "createControlledPromise", {
+  enumerable: true,
+  get: () => routerCore.createControlledPromise
+});
+Object.defineProperty(exports, "createRouterConfig", {
+  enumerable: true,
+  get: () => routerCore.createRouterConfig
+});
+Object.defineProperty(exports, "createSerializationAdapter", {
+  enumerable: true,
+  get: () => routerCore.createSerializationAdapter
+});
+Object.defineProperty(exports, "deepEqual", {
+  enumerable: true,
+  get: () => routerCore.deepEqual
+});
+Object.defineProperty(exports, "defaultParseSearch", {
+  enumerable: true,
+  get: () => routerCore.defaultParseSearch
+});
+Object.defineProperty(exports, "defaultSerializeError", {
+  enumerable: true,
+  get: () => routerCore.defaultSerializeError
+});
+Object.defineProperty(exports, "defaultStringifySearch", {
+  enumerable: true,
+  get: () => routerCore.defaultStringifySearch
+});
+Object.defineProperty(exports, "defer", {
+  enumerable: true,
+  get: () => routerCore.defer
+});
+Object.defineProperty(exports, "functionalUpdate", {
+  enumerable: true,
+  get: () => routerCore.functionalUpdate
+});
+Object.defineProperty(exports, "getInitialRouterState", {
+  enumerable: true,
+  get: () => routerCore.getInitialRouterState
+});
+Object.defineProperty(exports, "interpolatePath", {
+  enumerable: true,
+  get: () => routerCore.interpolatePath
+});
+Object.defineProperty(exports, "isMatch", {
+  enumerable: true,
+  get: () => routerCore.isMatch
+});
+Object.defineProperty(exports, "isNotFound", {
+  enumerable: true,
+  get: () => routerCore.isNotFound
+});
+Object.defineProperty(exports, "isPlainArray", {
+  enumerable: true,
+  get: () => routerCore.isPlainArray
+});
+Object.defineProperty(exports, "isPlainObject", {
+  enumerable: true,
+  get: () => routerCore.isPlainObject
+});
+Object.defineProperty(exports, "isRedirect", {
+  enumerable: true,
+  get: () => routerCore.isRedirect
+});
+Object.defineProperty(exports, "joinPaths", {
+  enumerable: true,
+  get: () => routerCore.joinPaths
+});
+Object.defineProperty(exports, "lazyFn", {
+  enumerable: true,
+  get: () => routerCore.lazyFn
+});
+Object.defineProperty(exports, "notFound", {
+  enumerable: true,
+  get: () => routerCore.notFound
+});
+Object.defineProperty(exports, "parseSearchWith", {
+  enumerable: true,
+  get: () => routerCore.parseSearchWith
+});
+Object.defineProperty(exports, "redirect", {
+  enumerable: true,
+  get: () => routerCore.redirect
+});
+Object.defineProperty(exports, "replaceEqualDeep", {
+  enumerable: true,
+  get: () => routerCore.replaceEqualDeep
+});
+Object.defineProperty(exports, "resolvePath", {
+  enumerable: true,
+  get: () => routerCore.resolvePath
+});
+Object.defineProperty(exports, "retainSearchParams", {
+  enumerable: true,
+  get: () => routerCore.retainSearchParams
+});
+Object.defineProperty(exports, "rootRouteId", {
+  enumerable: true,
+  get: () => routerCore.rootRouteId
+});
+Object.defineProperty(exports, "stringifySearchWith", {
+  enumerable: true,
+  get: () => routerCore.stringifySearchWith
+});
+Object.defineProperty(exports, "stripSearchParams", {
+  enumerable: true,
+  get: () => routerCore.stripSearchParams
+});
+Object.defineProperty(exports, "trimPath", {
+  enumerable: true,
+  get: () => routerCore.trimPath
+});
+Object.defineProperty(exports, "trimPathLeft", {
+  enumerable: true,
+  get: () => routerCore.trimPathLeft
+});
+Object.defineProperty(exports, "trimPathRight", {
+  enumerable: true,
+  get: () => routerCore.trimPathRight
+});
+Object.defineProperty(exports, "createBrowserHistory", {
+  enumerable: true,
+  get: () => history.createBrowserHistory
+});
+Object.defineProperty(exports, "createHashHistory", {
+  enumerable: true,
+  get: () => history.createHashHistory
+});
+Object.defineProperty(exports, "createHistory", {
+  enumerable: true,
+  get: () => history.createHistory
+});
+Object.defineProperty(exports, "createMemoryHistory", {
+  enumerable: true,
+  get: () => history.createMemoryHistory
+});
+exports.Await = awaited.Await;
+exports.useAwaited = awaited.useAwaited;
+exports.CatchBoundary = CatchBoundary.CatchBoundary;
+exports.ErrorComponent = CatchBoundary.ErrorComponent;
+exports.ClientOnly = ClientOnly.ClientOnly;
+exports.useHydrated = ClientOnly.useHydrated;
+exports.FileRoute = fileRoute.FileRoute;
+exports.FileRouteLoader = fileRoute.FileRouteLoader;
+exports.LazyRoute = fileRoute.LazyRoute;
+exports.createFileRoute = fileRoute.createFileRoute;
+exports.createLazyFileRoute = fileRoute.createLazyFileRoute;
+exports.createLazyRoute = fileRoute.createLazyRoute;
+exports.lazyRouteComponent = lazyRouteComponent.lazyRouteComponent;
+exports.Link = link.Link;
+exports.createLink = link.createLink;
+exports.linkOptions = link.linkOptions;
+exports.useLinkProps = link.useLinkProps;
+exports.MatchRoute = Matches.MatchRoute;
+exports.Matches = Matches.Matches;
+exports.useChildMatches = Matches.useChildMatches;
+exports.useMatchRoute = Matches.useMatchRoute;
+exports.useMatches = Matches.useMatches;
+exports.useParentMatches = Matches.useParentMatches;
+exports.matchContext = matchContext.matchContext;
+exports.Match = Match.Match;
+exports.Outlet = Match.Outlet;
+exports.useMatch = useMatch.useMatch;
+exports.useLoaderDeps = useLoaderDeps.useLoaderDeps;
+exports.useLoaderData = useLoaderData.useLoaderData;
+exports.NotFoundRoute = route.NotFoundRoute;
+exports.RootRoute = route.RootRoute;
+exports.Route = route.Route;
+exports.RouteApi = route.RouteApi;
+exports.createRootRoute = route.createRootRoute;
+exports.createRootRouteWithContext = route.createRootRouteWithContext;
+exports.createRoute = route.createRoute;
+exports.createRouteMask = route.createRouteMask;
+exports.getRouteApi = route.getRouteApi;
+exports.rootRouteWithContext = route.rootRouteWithContext;
+exports.Router = router.Router;
+exports.createRouter = router.createRouter;
+exports.RouterContextProvider = RouterProvider.RouterContextProvider;
+exports.RouterProvider = RouterProvider.RouterProvider;
+exports.ScrollRestoration = ScrollRestoration.ScrollRestoration;
+exports.useElementScrollRestoration = ScrollRestoration.useElementScrollRestoration;
+exports.Block = useBlocker.Block;
+exports.useBlocker = useBlocker.useBlocker;
+exports.Navigate = useNavigate.Navigate;
+exports.useNavigate = useNavigate.useNavigate;
+exports.useParams = useParams.useParams;
+exports.useSearch = useSearch.useSearch;
+exports.getRouterContext = routerContext.getRouterContext;
+exports.useRouteContext = useRouteContext.useRouteContext;
+exports.useRouter = useRouter.useRouter;
+exports.useRouterState = useRouterState.useRouterState;
+exports.useLocation = useLocation.useLocation;
+exports.useCanGoBack = useCanGoBack.useCanGoBack;
+exports.useLayoutEffect = utils.useLayoutEffect;
+exports.useStableCallback = utils.useStableCallback;
+exports.CatchNotFound = notFound.CatchNotFound;
+exports.DefaultGlobalNotFound = notFound.DefaultGlobalNotFound;
+exports.ScriptOnce = ScriptOnce.ScriptOnce;
+exports.Asset = Asset.Asset;
+exports.useTags = headContentUtils.useTags;
+exports.Scripts = Scripts.Scripts;
+exports.HeadContent = HeadContent_dev.HeadContent;
+//# sourceMappingURL=index.dev.cjs.map

package/dist/cjs/index.dev.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.dev.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/index.dev.d.cts

@@ -0,0 +1,2 @@
+export * from './index.cjs';
+export { HeadContent } from './HeadContent.dev';

package/dist/cjs/lazyRouteComponent.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const React = require("react");
 const routerCore = require("@tanstack/router-core");
+const utils = require("./utils.cjs");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -54,8 +55,8 @@ function lazyRouteComponent(importer, exportName) {
       throw error;
     }
     if (!comp) {
-      if (React__namespace.use) {
-        React__namespace.use(load());
+      if (utils.reactUse) {
+        utils.reactUse(load());
       } else {
         throw load();
       }

package/dist/cjs/lazyRouteComponent.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"lazyRouteComponent.cjs","sources":["../../src/lazyRouteComponent.tsx"],"sourcesContent":["import * as React from 'react'\nimport { isModuleNotFoundError } from '@tanstack/router-core'\nimport type { AsyncRouteComponent } from './route'\n\n/**\n * Wrap a dynamic import to create a route component that supports\n * `.preload()` and friendly reload-on-module-missing behavior.\n *\n * @param importer Function returning a module promise\n * @param exportName Named export to use (default: `default`)\n * @returns A lazy route component compatible with TanStack Router\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/lazyRouteComponentFunction\n */\nexport function lazyRouteComponent<\n  T extends Record<string, any>,\n  TKey extends keyof T = 'default',\n>(\n  importer: () => Promise<T>,\n  exportName?: TKey,\n): T[TKey] extends (props: infer TProps) => any\n  ? AsyncRouteComponent<TProps>\n  : never {\n  let loadPromise: Promise<any> | undefined\n  let comp: T[TKey] | T['default']\n  let error: any\n  let reload: boolean\n\n  const load = () => {\n    if (!loadPromise) {\n      loadPromise = importer()\n        .then((res) => {\n          loadPromise = undefined\n          comp = res[exportName ?? 'default']\n        })\n        .catch((err) => {\n          // We don't want an error thrown from preload in this case, because\n          // there's nothing we want to do about module not found during preload.\n          // Record the error, the rest is handled during the render path.\n          error = err\n          // If the load fails due to module not found, it may mean a new version of\n          // the build was deployed and the user's browser is still using an old version.\n          // If this happens, the old version in the user's browser would have an outdated\n          // URL to the lazy module.\n          // In that case, we want to attempt one window refresh to get the latest.\n          if (isModuleNotFoundError(error)) {\n            if (\n              error instanceof Error &&\n              typeof window !== 'undefined' &&\n              typeof sessionStorage !== 'undefined'\n            ) {\n              // Again, we want to reload one time on module not found error and not enter\n              // a reload loop if there is some other issue besides an old deploy.\n              // That's why we store our reload attempt in sessionStorage.\n              // Use error.message as key because it contains the module path that failed.\n              const storageKey = `tanstack_router_reload:${error.message}`\n              if (!sessionStorage.getItem(storageKey)) {\n                sessionStorage.setItem(storageKey, '1')\n                reload = true\n              }\n            }\n          }\n        })\n    }\n\n    return loadPromise\n  }\n\n  const lazyComp = function Lazy(props: any) {\n    // Now that we're out of preload and into actual render path,\n    if (reload) {\n      // If it was a module loading error,\n      // throw eternal suspense while we wait for window to reload\n      window.location.reload()\n      throw new Promise(() => {})\n    }\n    if (error) {\n      // Otherwise, just throw the error\n      throw error\n    }\n\n    if (!comp) {\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      if (React.use) {\n        React.use(load())\n      } else {\n        throw load()\n      }\n    }\n\n    return React.createElement(comp, props)\n  }\n\n  ;(lazyComp as any).preload = load\n\n  return lazyComp as any\n}\n"],"names":["isModuleNotFoundError","React"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAaO,SAAS,mBAId,UACA,YAGQ;AACR,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AAEJ,QAAM,OAAO,MAAM;AACjB,QAAI,CAAC,aAAa;AAChB,oBAAc,SAAA,EACX,KAAK,CAAC,QAAQ;AACb,sBAAc;AACd,eAAO,IAAI,cAAc,SAAS;AAAA,MACpC,CAAC,EACA,MAAM,CAAC,QAAQ;AAId,gBAAQ;AAMR,YAAIA,WAAAA,sBAAsB,KAAK,GAAG;AAChC,cACE,iBAAiB,SACjB,OAAO,WAAW,eAClB,OAAO,mBAAmB,aAC1B;AAKA,kBAAM,aAAa,0BAA0B,MAAM,OAAO;AAC1D,gBAAI,CAAC,eAAe,QAAQ,UAAU,GAAG;AACvC,6BAAe,QAAQ,YAAY,GAAG;AACtC,uBAAS;AAAA,YACX;AAAA,UACF;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACL;AAEA,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,SAAS,KAAK,OAAY;AAEzC,QAAI,QAAQ;AAGV,aAAO,SAAS,OAAA;AAChB,YAAM,IAAI,QAAQ,MAAM;AAAA,MAAC,CAAC;AAAA,IAC5B;AACA,QAAI,OAAO;AAET,YAAM;AAAA,IACR;AAEA,QAAI,CAAC,MAAM;AAET,UAAIC,iBAAM,KAAK;AACbA,yBAAM,IAAI,MAAM;AAAA,MAClB,OAAO;AACL,cAAM,KAAA;AAAA,MACR;AAAA,IACF;AAEA,WAAOA,iBAAM,cAAc,MAAM,KAAK;AAAA,EACxC;AAEE,WAAiB,UAAU;AAE7B,SAAO;AACT;;"}
+{"version":3,"file":"lazyRouteComponent.cjs","sources":["../../src/lazyRouteComponent.tsx"],"sourcesContent":["import * as React from 'react'\nimport { isModuleNotFoundError } from '@tanstack/router-core'\nimport { reactUse } from './utils'\nimport type { AsyncRouteComponent } from './route'\n\n/**\n * Wrap a dynamic import to create a route component that supports\n * `.preload()` and friendly reload-on-module-missing behavior.\n *\n * @param importer Function returning a module promise\n * @param exportName Named export to use (default: `default`)\n * @returns A lazy route component compatible with TanStack Router\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/lazyRouteComponentFunction\n */\nexport function lazyRouteComponent<\n  T extends Record<string, any>,\n  TKey extends keyof T = 'default',\n>(\n  importer: () => Promise<T>,\n  exportName?: TKey,\n): T[TKey] extends (props: infer TProps) => any\n  ? AsyncRouteComponent<TProps>\n  : never {\n  let loadPromise: Promise<any> | undefined\n  let comp: T[TKey] | T['default']\n  let error: any\n  let reload: boolean\n\n  const load = () => {\n    if (!loadPromise) {\n      loadPromise = importer()\n        .then((res) => {\n          loadPromise = undefined\n          comp = res[exportName ?? 'default']\n        })\n        .catch((err) => {\n          // We don't want an error thrown from preload in this case, because\n          // there's nothing we want to do about module not found during preload.\n          // Record the error, the rest is handled during the render path.\n          error = err\n          // If the load fails due to module not found, it may mean a new version of\n          // the build was deployed and the user's browser is still using an old version.\n          // If this happens, the old version in the user's browser would have an outdated\n          // URL to the lazy module.\n          // In that case, we want to attempt one window refresh to get the latest.\n          if (isModuleNotFoundError(error)) {\n            if (\n              error instanceof Error &&\n              typeof window !== 'undefined' &&\n              typeof sessionStorage !== 'undefined'\n            ) {\n              // Again, we want to reload one time on module not found error and not enter\n              // a reload loop if there is some other issue besides an old deploy.\n              // That's why we store our reload attempt in sessionStorage.\n              // Use error.message as key because it contains the module path that failed.\n              const storageKey = `tanstack_router_reload:${error.message}`\n              if (!sessionStorage.getItem(storageKey)) {\n                sessionStorage.setItem(storageKey, '1')\n                reload = true\n              }\n            }\n          }\n        })\n    }\n\n    return loadPromise\n  }\n\n  const lazyComp = function Lazy(props: any) {\n    // Now that we're out of preload and into actual render path,\n    if (reload) {\n      // If it was a module loading error,\n      // throw eternal suspense while we wait for window to reload\n      window.location.reload()\n      throw new Promise(() => {})\n    }\n    if (error) {\n      // Otherwise, just throw the error\n      throw error\n    }\n\n    if (!comp) {\n      if (reactUse) {\n        reactUse(load())\n      } else {\n        throw load()\n      }\n    }\n\n    return React.createElement(comp, props)\n  }\n\n  ;(lazyComp as any).preload = load\n\n  return lazyComp as any\n}\n"],"names":["isModuleNotFoundError","reactUse","React"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAcO,SAAS,mBAId,UACA,YAGQ;AACR,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AAEJ,QAAM,OAAO,MAAM;AACjB,QAAI,CAAC,aAAa;AAChB,oBAAc,SAAA,EACX,KAAK,CAAC,QAAQ;AACb,sBAAc;AACd,eAAO,IAAI,cAAc,SAAS;AAAA,MACpC,CAAC,EACA,MAAM,CAAC,QAAQ;AAId,gBAAQ;AAMR,YAAIA,WAAAA,sBAAsB,KAAK,GAAG;AAChC,cACE,iBAAiB,SACjB,OAAO,WAAW,eAClB,OAAO,mBAAmB,aAC1B;AAKA,kBAAM,aAAa,0BAA0B,MAAM,OAAO;AAC1D,gBAAI,CAAC,eAAe,QAAQ,UAAU,GAAG;AACvC,6BAAe,QAAQ,YAAY,GAAG;AACtC,uBAAS;AAAA,YACX;AAAA,UACF;AAAA,QACF;AAAA,MACF,CAAC;AAAA,IACL;AAEA,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,SAAS,KAAK,OAAY;AAEzC,QAAI,QAAQ;AAGV,aAAO,SAAS,OAAA;AAChB,YAAM,IAAI,QAAQ,MAAM;AAAA,MAAC,CAAC;AAAA,IAC5B;AACA,QAAI,OAAO;AAET,YAAM;AAAA,IACR;AAEA,QAAI,CAAC,MAAM;AACT,UAAIC,gBAAU;AACZA,cAAAA,SAAS,MAAM;AAAA,MACjB,OAAO;AACL,cAAM,KAAA;AAAA,MACR;AAAA,IACF;AAEA,WAAOC,iBAAM,cAAc,MAAM,KAAK;AAAA,EACxC;AAEE,WAAiB,UAAU;AAE7B,SAAO;AACT;;"}

package/dist/cjs/utils.cjs

@@ -18,6 +18,8 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 const React__namespace = /* @__PURE__ */ _interopNamespaceDefault(React);
+const REACT_USE = "use";
+const reactUse = React__namespace[REACT_USE];
 function useStableCallback(fn) {
   const fnRef = React__namespace.useRef(fn);
   fnRef.current = fn;
@@ -58,6 +60,7 @@ function useForwardedRef(ref) {
   React__namespace.useImperativeHandle(ref, () => innerRef.current, []);
   return innerRef;
 }
+exports.reactUse = reactUse;
 exports.useForwardedRef = useForwardedRef;
 exports.useIntersectionObserver = useIntersectionObserver;
 exports.useLayoutEffect = useLayoutEffect;

package/dist/cjs/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","sources":["../../src/utils.ts"],"sourcesContent":["import * as React from 'react'\n\nexport function useStableCallback<T extends (...args: Array<any>) => any>(\n  fn: T,\n): T {\n  const fnRef = React.useRef(fn)\n  fnRef.current = fn\n\n  const ref = React.useRef((...args: Array<any>) => fnRef.current(...args))\n  return ref.current as T\n}\n\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious<T>(value: T): T | null {\n  // initialise the ref with previous and current values\n  const ref = React.useRef<{ value: T; prev: T | null }>({\n    value: value,\n    prev: null,\n  })\n\n  const current = ref.current.value\n\n  // if the value passed into hook doesn't match what we store as \"current\"\n  // move the \"current\" to the \"previous\"\n  // and store the passed value as \"current\"\n  if (value !== current) {\n    ref.current = {\n      value: value,\n      prev: current,\n    }\n  }\n\n  // return the previous value only\n  return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef<HTMLDivElement>(null)\n * useIntersectionObserver(\n *  ref,\n *  (entry) => { doSomething(entry) },\n *  { rootMargin: '10px' },\n *  { disabled: false }\n * )\n * return <div ref={ref} />\n * ```\n */\nexport function useIntersectionObserver<T extends Element>(\n  ref: React.RefObject<T | null>,\n  callback: (entry: IntersectionObserverEntry | undefined) => void,\n  intersectionObserverOptions: IntersectionObserverInit = {},\n  options: { disabled?: boolean } = {},\n) {\n  React.useEffect(() => {\n    if (\n      !ref.current ||\n      options.disabled ||\n      typeof IntersectionObserver !== 'function'\n    ) {\n      return\n    }\n\n    const observer = new IntersectionObserver(([entry]) => {\n      callback(entry)\n    }, intersectionObserverOptions)\n\n    observer.observe(ref.current)\n\n    return () => {\n      observer.disconnect()\n    }\n  }, [callback, intersectionObserverOptions, options.disabled, ref])\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n *  const innerRef = useForwardedRef(ref)\n *  return <div ref={innerRef} />\n * })\n * ```\n */\nexport function useForwardedRef<T>(ref?: React.ForwardedRef<T>) {\n  const innerRef = React.useRef<T>(null)\n  React.useImperativeHandle(ref, () => innerRef.current!, [])\n  return innerRef\n}\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;AAEO,SAAS,kBACd,IACG;AACH,QAAM,QAAQA,iBAAM,OAAO,EAAE;AAC7B,QAAM,UAAU;AAEhB,QAAM,MAAMA,iBAAM,OAAO,IAAI,SAAqB,MAAM,QAAQ,GAAG,IAAI,CAAC;AACxE,SAAO,IAAI;AACb;AAEO,MAAM,kBACX,OAAO,WAAW,cAAcA,iBAAM,kBAAkBA,iBAAM;AAKzD,SAAS,YAAe,OAAoB;AAEjD,QAAM,MAAMA,iBAAM,OAAqC;AAAA,IACrD;AAAA,IACA,MAAM;AAAA,EAAA,CACP;AAED,QAAM,UAAU,IAAI,QAAQ;AAK5B,MAAI,UAAU,SAAS;AACrB,QAAI,UAAU;AAAA,MACZ;AAAA,MACA,MAAM;AAAA,IAAA;AAAA,EAEV;AAGA,SAAO,IAAI,QAAQ;AACrB;AA2BO,SAAS,wBACd,KACA,UACA,8BAAwD,CAAA,GACxD,UAAkC,IAClC;AACAA,mBAAM,UAAU,MAAM;AACpB,QACE,CAAC,IAAI,WACL,QAAQ,YACR,OAAO,yBAAyB,YAChC;AACA;AAAA,IACF;AAEA,UAAM,WAAW,IAAI,qBAAqB,CAAC,CAAC,KAAK,MAAM;AACrD,eAAS,KAAK;AAAA,IAChB,GAAG,2BAA2B;AAE9B,aAAS,QAAQ,IAAI,OAAO;AAE5B,WAAO,MAAM;AACX,eAAS,WAAA;AAAA,IACX;AAAA,EACF,GAAG,CAAC,UAAU,6BAA6B,QAAQ,UAAU,GAAG,CAAC;AACnE;AAeO,SAAS,gBAAmB,KAA6B;AAC9D,QAAM,WAAWA,iBAAM,OAAU,IAAI;AACrCA,mBAAM,oBAAoB,KAAK,MAAM,SAAS,SAAU,CAAA,CAAE;AAC1D,SAAO;AACT;;;;;;"}
+{"version":3,"file":"utils.cjs","sources":["../../src/utils.ts"],"sourcesContent":["import * as React from 'react'\n\n// Safe version of React.use() that will not cause compilation errors against\n// React 18 with Webpack, which statically analyzes imports and fails when it\n// sees React.use referenced (since 'use' is not exported from React 18).\n// This uses a dynamic string lookup to avoid the static analysis.\nconst REACT_USE = 'use'\n\n/**\n * React.use if available (React 19+), undefined otherwise.\n * Use dynamic lookup to avoid Webpack compilation errors with React 18.\n */\nexport const reactUse:\n  | (<T>(usable: Promise<T> | React.Context<T>) => T)\n  | undefined = (React as any)[REACT_USE]\n\nexport function useStableCallback<T extends (...args: Array<any>) => any>(\n  fn: T,\n): T {\n  const fnRef = React.useRef(fn)\n  fnRef.current = fn\n\n  const ref = React.useRef((...args: Array<any>) => fnRef.current(...args))\n  return ref.current as T\n}\n\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious<T>(value: T): T | null {\n  // initialise the ref with previous and current values\n  const ref = React.useRef<{ value: T; prev: T | null }>({\n    value: value,\n    prev: null,\n  })\n\n  const current = ref.current.value\n\n  // if the value passed into hook doesn't match what we store as \"current\"\n  // move the \"current\" to the \"previous\"\n  // and store the passed value as \"current\"\n  if (value !== current) {\n    ref.current = {\n      value: value,\n      prev: current,\n    }\n  }\n\n  // return the previous value only\n  return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef<HTMLDivElement>(null)\n * useIntersectionObserver(\n *  ref,\n *  (entry) => { doSomething(entry) },\n *  { rootMargin: '10px' },\n *  { disabled: false }\n * )\n * return <div ref={ref} />\n * ```\n */\nexport function useIntersectionObserver<T extends Element>(\n  ref: React.RefObject<T | null>,\n  callback: (entry: IntersectionObserverEntry | undefined) => void,\n  intersectionObserverOptions: IntersectionObserverInit = {},\n  options: { disabled?: boolean } = {},\n) {\n  React.useEffect(() => {\n    if (\n      !ref.current ||\n      options.disabled ||\n      typeof IntersectionObserver !== 'function'\n    ) {\n      return\n    }\n\n    const observer = new IntersectionObserver(([entry]) => {\n      callback(entry)\n    }, intersectionObserverOptions)\n\n    observer.observe(ref.current)\n\n    return () => {\n      observer.disconnect()\n    }\n  }, [callback, intersectionObserverOptions, options.disabled, ref])\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n *  const innerRef = useForwardedRef(ref)\n *  return <div ref={innerRef} />\n * })\n * ```\n */\nexport function useForwardedRef<T>(ref?: React.ForwardedRef<T>) {\n  const innerRef = React.useRef<T>(null)\n  React.useImperativeHandle(ref, () => innerRef.current!, [])\n  return innerRef\n}\n"],"names":["React"],"mappings":";;;;;;;;;;;;;;;;;;;;AAMA,MAAM,YAAY;AAMX,MAAM,WAEIA,iBAAc,SAAS;AAEjC,SAAS,kBACd,IACG;AACH,QAAM,QAAQA,iBAAM,OAAO,EAAE;AAC7B,QAAM,UAAU;AAEhB,QAAM,MAAMA,iBAAM,OAAO,IAAI,SAAqB,MAAM,QAAQ,GAAG,IAAI,CAAC;AACxE,SAAO,IAAI;AACb;AAEO,MAAM,kBACX,OAAO,WAAW,cAAcA,iBAAM,kBAAkBA,iBAAM;AAKzD,SAAS,YAAe,OAAoB;AAEjD,QAAM,MAAMA,iBAAM,OAAqC;AAAA,IACrD;AAAA,IACA,MAAM;AAAA,EAAA,CACP;AAED,QAAM,UAAU,IAAI,QAAQ;AAK5B,MAAI,UAAU,SAAS;AACrB,QAAI,UAAU;AAAA,MACZ;AAAA,MACA,MAAM;AAAA,IAAA;AAAA,EAEV;AAGA,SAAO,IAAI,QAAQ;AACrB;AA2BO,SAAS,wBACd,KACA,UACA,8BAAwD,CAAA,GACxD,UAAkC,IAClC;AACAA,mBAAM,UAAU,MAAM;AACpB,QACE,CAAC,IAAI,WACL,QAAQ,YACR,OAAO,yBAAyB,YAChC;AACA;AAAA,IACF;AAEA,UAAM,WAAW,IAAI,qBAAqB,CAAC,CAAC,KAAK,MAAM;AACrD,eAAS,KAAK;AAAA,IAChB,GAAG,2BAA2B;AAE9B,aAAS,QAAQ,IAAI,OAAO;AAE5B,WAAO,MAAM;AACX,eAAS,WAAA;AAAA,IACX;AAAA,EACF,GAAG,CAAC,UAAU,6BAA6B,QAAQ,UAAU,GAAG,CAAC;AACnE;AAeO,SAAS,gBAAmB,KAA6B;AAC9D,QAAM,WAAWA,iBAAM,OAAU,IAAI;AACrCA,mBAAM,oBAAoB,KAAK,MAAM,SAAS,SAAU,CAAA,CAAE;AAC1D,SAAO;AACT;;;;;;;"}

package/dist/cjs/utils.d.cts

@@ -1,4 +1,9 @@
 import * as React from 'react';
+/**
+ * React.use if available (React 19+), undefined otherwise.
+ * Use dynamic lookup to avoid Webpack compilation errors with React 18.
+ */
+export declare const reactUse: (<T>(usable: Promise<T> | React.Context<T>) => T) | undefined;
 export declare function useStableCallback<T extends (...args: Array<any>) => any>(fn: T): T;
 export declare const useLayoutEffect: typeof React.useLayoutEffect;
 /**

package/dist/esm/HeadContent.d.ts

@@ -1,9 +1,3 @@
-import { RouterManagedTag } from '@tanstack/router-core';
-/**
- * Build the list of head/link/meta/script tags to render for active matches.
- * Used internally by `HeadContent`.
- */
-export declare const useTags: () => RouterManagedTag[];
 /**
  * Render route-managed head tags (title, meta, links, styles, head scripts).
  * Place inside the document head of your app shell.

package/dist/esm/HeadContent.dev.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Render route-managed head tags (title, meta, links, styles, head scripts).
+ * Place inside the document head of your app shell.
+ *
+ * Development version: filters out dev styles link after hydration and
+ * includes a fallback cleanup effect for hydration mismatch cases.
+ *
+ * @link https://tanstack.com/router/latest/docs/framework/react/guide/document-head-management
+ */
+export declare function HeadContent(): import("react/jsx-runtime").JSX.Element;

package/dist/esm/HeadContent.dev.js

@@ -0,0 +1,25 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import * as React from "react";
+import { createElement } from "react";
+import { Asset } from "./Asset.js";
+import { useRouter } from "./useRouter.js";
+import { useHydrated } from "./ClientOnly.js";
+import { useTags } from "./headContentUtils.js";
+const DEV_STYLES_ATTR = "data-tanstack-router-dev-styles";
+function HeadContent() {
+  const tags = useTags();
+  const router = useRouter();
+  const nonce = router.options.ssr?.nonce;
+  const hydrated = useHydrated();
+  React.useEffect(() => {
+    if (hydrated) {
+      document.querySelectorAll(`link[${DEV_STYLES_ATTR}]`).forEach((el) => el.remove());
+    }
+  }, [hydrated]);
+  const filteredTags = hydrated ? tags.filter((tag) => !tag.attrs?.[DEV_STYLES_ATTR]) : tags;
+  return /* @__PURE__ */ jsx(Fragment, { children: filteredTags.map((tag) => /* @__PURE__ */ createElement(Asset, { ...tag, key: `tsr-meta-${JSON.stringify(tag)}`, nonce })) });
+}
+export {
+  HeadContent
+};
+//# sourceMappingURL=HeadContent.dev.js.map

package/dist/esm/HeadContent.dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeadContent.dev.js","sources":["../../src/HeadContent.dev.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Asset } from './Asset'\nimport { useRouter } from './useRouter'\nimport { useHydrated } from './ClientOnly'\nimport { useTags } from './headContentUtils'\n\nconst DEV_STYLES_ATTR = 'data-tanstack-router-dev-styles'\n\n/**\n * Render route-managed head tags (title, meta, links, styles, head scripts).\n * Place inside the document head of your app shell.\n *\n * Development version: filters out dev styles link after hydration and\n * includes a fallback cleanup effect for hydration mismatch cases.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/guide/document-head-management\n */\nexport function HeadContent() {\n  const tags = useTags()\n  const router = useRouter()\n  const nonce = router.options.ssr?.nonce\n  const hydrated = useHydrated()\n\n  // Fallback cleanup for hydration mismatch cases\n  // Runs when hydration completes to remove any orphaned dev styles links from DOM\n  React.useEffect(() => {\n    if (hydrated) {\n      document\n        .querySelectorAll(`link[${DEV_STYLES_ATTR}]`)\n        .forEach((el) => el.remove())\n    }\n  }, [hydrated])\n\n  // Filter out dev styles after hydration\n  const filteredTags = hydrated\n    ? tags.filter((tag) => !tag.attrs?.[DEV_STYLES_ATTR])\n    : tags\n\n  return (\n    <>\n      {filteredTags.map((tag) => (\n        <Asset {...tag} key={`tsr-meta-${JSON.stringify(tag)}`} nonce={nonce} />\n      ))}\n    </>\n  )\n}\n"],"names":[],"mappings":";;;;;;;AAMA,MAAM,kBAAkB;AAWjB,SAAS,cAAc;AAC5B,QAAM,OAAO,QAAA;AACb,QAAM,SAAS,UAAA;AACf,QAAM,QAAQ,OAAO,QAAQ,KAAK;AAClC,QAAM,WAAW,YAAA;AAIjB,QAAM,UAAU,MAAM;AACpB,QAAI,UAAU;AACZ,eACG,iBAAiB,QAAQ,eAAe,GAAG,EAC3C,QAAQ,CAAC,OAAO,GAAG,OAAA,CAAQ;AAAA,IAChC;AAAA,EACF,GAAG,CAAC,QAAQ,CAAC;AAGb,QAAM,eAAe,WACjB,KAAK,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,eAAe,CAAC,IAClD;AAEJ,yCAEK,UAAA,aAAa,IAAI,CAAC,QACjB,8BAAC,SAAO,GAAG,KAAK,KAAK,YAAY,KAAK,UAAU,GAAG,CAAC,IAAI,OAAc,CACvE,GACH;AAEJ;"}

package/dist/esm/HeadContent.js

@@ -1,197 +1,15 @@
-import { jsxs, Fragment, jsx } from "react/jsx-runtime";
-import * as React from "react";
+import { jsx, Fragment } from "react/jsx-runtime";
 import { createElement } from "react";
-import { escapeHtml, buildDevStylesUrl } from "@tanstack/router-core";
 import { Asset } from "./Asset.js";
 import { useRouter } from "./useRouter.js";
-import { useRouterState } from "./useRouterState.js";
-const useTags = () => {
-  const router = useRouter();
-  const nonce = router.options.ssr?.nonce;
-  const routeMeta = useRouterState({
-    select: (state) => {
-      return state.matches.map((match) => match.meta).filter(Boolean);
-    }
-  });
-  const meta = React.useMemo(() => {
-    const resultMeta = [];
-    const metaByAttribute = {};
-    let title;
-    for (let i = routeMeta.length - 1; i >= 0; i--) {
-      const metas = routeMeta[i];
-      for (let j = metas.length - 1; j >= 0; j--) {
-        const m = metas[j];
-        if (!m) continue;
-        if (m.title) {
-          if (!title) {
-            title = {
-              tag: "title",
-              children: m.title
-            };
-          }
-        } else if ("script:ld+json" in m) {
-          try {
-            const json = JSON.stringify(m["script:ld+json"]);
-            resultMeta.push({
-              tag: "script",
-              attrs: {
-                type: "application/ld+json"
-              },
-              children: escapeHtml(json)
-            });
-          } catch {
-          }
-        } else {
-          const attribute = m.name ?? m.property;
-          if (attribute) {
-            if (metaByAttribute[attribute]) {
-              continue;
-            } else {
-              metaByAttribute[attribute] = true;
-            }
-          }
-          resultMeta.push({
-            tag: "meta",
-            attrs: {
-              ...m,
-              nonce
-            }
-          });
-        }
-      }
-    }
-    if (title) {
-      resultMeta.push(title);
-    }
-    if (nonce) {
-      resultMeta.push({
-        tag: "meta",
-        attrs: {
-          property: "csp-nonce",
-          content: nonce
-        }
-      });
-    }
-    resultMeta.reverse();
-    return resultMeta;
-  }, [routeMeta, nonce]);
-  const links = useRouterState({
-    select: (state) => {
-      const constructed = state.matches.map((match) => match.links).filter(Boolean).flat(1).map((link) => ({
-        tag: "link",
-        attrs: {
-          ...link,
-          nonce
-        }
-      }));
-      const manifest = router.ssr?.manifest;
-      const assets = state.matches.map((match) => manifest?.routes[match.routeId]?.assets ?? []).filter(Boolean).flat(1).filter((asset) => asset.tag === "link").map(
-        (asset) => ({
-          tag: "link",
-          attrs: {
-            ...asset.attrs,
-            suppressHydrationWarning: true,
-            nonce
-          }
-        })
-      );
-      return [...constructed, ...assets];
-    },
-    structuralSharing: true
-  });
-  const preloadLinks = useRouterState({
-    select: (state) => {
-      const preloadLinks2 = [];
-      state.matches.map((match) => router.looseRoutesById[match.routeId]).forEach(
-        (route) => router.ssr?.manifest?.routes[route.id]?.preloads?.filter(Boolean).forEach((preload) => {
-          preloadLinks2.push({
-            tag: "link",
-            attrs: {
-              rel: "modulepreload",
-              href: preload,
-              nonce
-            }
-          });
-        })
-      );
-      return preloadLinks2;
-    },
-    structuralSharing: true
-  });
-  const styles = useRouterState({
-    select: (state) => state.matches.map((match) => match.styles).flat(1).filter(Boolean).map(({ children, ...attrs }) => ({
-      tag: "style",
-      attrs,
-      children,
-      nonce
-    })),
-    structuralSharing: true
-  });
-  const headScripts = useRouterState({
-    select: (state) => state.matches.map((match) => match.headScripts).flat(1).filter(Boolean).map(({ children, ...script }) => ({
-      tag: "script",
-      attrs: {
-        ...script,
-        nonce
-      },
-      children
-    })),
-    structuralSharing: true
-  });
-  return uniqBy(
-    [
-      ...meta,
-      ...preloadLinks,
-      ...links,
-      ...styles,
-      ...headScripts
-    ],
-    (d) => {
-      return JSON.stringify(d);
-    }
-  );
-};
-function DevStylesLink() {
-  const router = useRouter();
-  const routeIds = useRouterState({
-    select: (state) => state.matches.map((match) => match.routeId)
-  });
-  React.useEffect(() => {
-    document.querySelectorAll("[data-tanstack-start-dev-styles]").forEach((el) => el.remove());
-  }, []);
-  const href = buildDevStylesUrl(router.basepath, routeIds);
-  return /* @__PURE__ */ jsx(
-    "link",
-    {
-      rel: "stylesheet",
-      href,
-      "data-tanstack-start-dev-styles": true,
-      suppressHydrationWarning: true
-    }
-  );
-}
+import { useTags } from "./headContentUtils.js";
 function HeadContent() {
   const tags = useTags();
   const router = useRouter();
   const nonce = router.options.ssr?.nonce;
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    process.env.NODE_ENV !== "production" && /* @__PURE__ */ jsx(DevStylesLink, {}),
-    tags.map((tag) => /* @__PURE__ */ createElement(Asset, { ...tag, key: `tsr-meta-${JSON.stringify(tag)}`, nonce }))
-  ] });
-}
-function uniqBy(arr, fn) {
-  const seen = /* @__PURE__ */ new Set();
-  return arr.filter((item) => {
-    const key = fn(item);
-    if (seen.has(key)) {
-      return false;
-    }
-    seen.add(key);
-    return true;
-  });
+  return /* @__PURE__ */ jsx(Fragment, { children: tags.map((tag) => /* @__PURE__ */ createElement(Asset, { ...tag, key: `tsr-meta-${JSON.stringify(tag)}`, nonce })) });
 }
 export {
-  HeadContent,
-  useTags
+  HeadContent
 };
 //# sourceMappingURL=HeadContent.js.map

package/dist/esm/HeadContent.js.map

@@ -1 +1 @@
-{"version":3,"file":"HeadContent.js","sources":["../../src/HeadContent.tsx"],"sourcesContent":["import * as React from 'react'\nimport { buildDevStylesUrl, escapeHtml } from '@tanstack/router-core'\nimport { Asset } from './Asset'\nimport { useRouter } from './useRouter'\nimport { useRouterState } from './useRouterState'\nimport type { RouterManagedTag } from '@tanstack/router-core'\n\n/**\n * Build the list of head/link/meta/script tags to render for active matches.\n * Used internally by `HeadContent`.\n */\nexport const useTags = () => {\n  const router = useRouter()\n  const nonce = router.options.ssr?.nonce\n  const routeMeta = useRouterState({\n    select: (state) => {\n      return state.matches.map((match) => match.meta!).filter(Boolean)\n    },\n  })\n\n  const meta: Array<RouterManagedTag> = React.useMemo(() => {\n    const resultMeta: Array<RouterManagedTag> = []\n    const metaByAttribute: Record<string, true> = {}\n    let title: RouterManagedTag | undefined\n    for (let i = routeMeta.length - 1; i >= 0; i--) {\n      const metas = routeMeta[i]!\n      for (let j = metas.length - 1; j >= 0; j--) {\n        const m = metas[j]\n        if (!m) continue\n\n        if (m.title) {\n          if (!title) {\n            title = {\n              tag: 'title',\n              children: m.title,\n            }\n          }\n        } else if ('script:ld+json' in m) {\n          // Handle JSON-LD structured data\n          // Content is HTML-escaped to prevent XSS when injected via dangerouslySetInnerHTML\n          try {\n            const json = JSON.stringify(m['script:ld+json'])\n            resultMeta.push({\n              tag: 'script',\n              attrs: {\n                type: 'application/ld+json',\n              },\n              children: escapeHtml(json),\n            })\n          } catch {\n            // Skip invalid JSON-LD objects\n          }\n        } else {\n          const attribute = m.name ?? m.property\n          if (attribute) {\n            if (metaByAttribute[attribute]) {\n              continue\n            } else {\n              metaByAttribute[attribute] = true\n            }\n          }\n\n          resultMeta.push({\n            tag: 'meta',\n            attrs: {\n              ...m,\n              nonce,\n            },\n          })\n        }\n      }\n    }\n\n    if (title) {\n      resultMeta.push(title)\n    }\n\n    if (nonce) {\n      resultMeta.push({\n        tag: 'meta',\n        attrs: {\n          property: 'csp-nonce',\n          content: nonce,\n        },\n      })\n    }\n    resultMeta.reverse()\n\n    return resultMeta\n  }, [routeMeta, nonce])\n\n  const links = useRouterState({\n    select: (state) => {\n      const constructed = state.matches\n        .map((match) => match.links!)\n        .filter(Boolean)\n        .flat(1)\n        .map((link) => ({\n          tag: 'link',\n          attrs: {\n            ...link,\n            nonce,\n          },\n        })) satisfies Array<RouterManagedTag>\n\n      const manifest = router.ssr?.manifest\n\n      // These are the assets extracted from the ViteManifest\n      // using the `startManifestPlugin`\n      const assets = state.matches\n        .map((match) => manifest?.routes[match.routeId]?.assets ?? [])\n        .filter(Boolean)\n        .flat(1)\n        .filter((asset) => asset.tag === 'link')\n        .map(\n          (asset) =>\n            ({\n              tag: 'link',\n              attrs: {\n                ...asset.attrs,\n                suppressHydrationWarning: true,\n                nonce,\n              },\n            }) satisfies RouterManagedTag,\n        )\n\n      return [...constructed, ...assets]\n    },\n    structuralSharing: true as any,\n  })\n\n  const preloadLinks = useRouterState({\n    select: (state) => {\n      const preloadLinks: Array<RouterManagedTag> = []\n\n      state.matches\n        .map((match) => router.looseRoutesById[match.routeId]!)\n        .forEach((route) =>\n          router.ssr?.manifest?.routes[route.id]?.preloads\n            ?.filter(Boolean)\n            .forEach((preload) => {\n              preloadLinks.push({\n                tag: 'link',\n                attrs: {\n                  rel: 'modulepreload',\n                  href: preload,\n                  nonce,\n                },\n              })\n            }),\n        )\n\n      return preloadLinks\n    },\n    structuralSharing: true as any,\n  })\n\n  const styles = useRouterState({\n    select: (state) =>\n      (\n        state.matches\n          .map((match) => match.styles!)\n          .flat(1)\n          .filter(Boolean) as Array<RouterManagedTag>\n      ).map(({ children, ...attrs }) => ({\n        tag: 'style',\n        attrs,\n        children,\n        nonce,\n      })),\n    structuralSharing: true as any,\n  })\n\n  const headScripts: Array<RouterManagedTag> = useRouterState({\n    select: (state) =>\n      (\n        state.matches\n          .map((match) => match.headScripts!)\n          .flat(1)\n          .filter(Boolean) as Array<RouterManagedTag>\n      ).map(({ children, ...script }) => ({\n        tag: 'script',\n        attrs: {\n          ...script,\n          nonce,\n        },\n        children,\n      })),\n    structuralSharing: true as any,\n  })\n\n  return uniqBy(\n    [\n      ...meta,\n      ...preloadLinks,\n      ...links,\n      ...styles,\n      ...headScripts,\n    ] as Array<RouterManagedTag>,\n    (d) => {\n      return JSON.stringify(d)\n    },\n  )\n}\n\n/**\n * Renders a stylesheet link for dev mode CSS collection.\n * On the server, renders the full link with route-scoped CSS URL.\n * On the client, renders the same link to avoid hydration mismatch,\n * then removes it after hydration since Vite's HMR handles CSS updates.\n */\nfunction DevStylesLink() {\n  const router = useRouter()\n  const routeIds = useRouterState({\n    select: (state) => state.matches.map((match) => match.routeId),\n  })\n\n  React.useEffect(() => {\n    // After hydration, remove the SSR-rendered dev styles link\n    document\n      .querySelectorAll('[data-tanstack-start-dev-styles]')\n      .forEach((el) => el.remove())\n  }, [])\n\n  const href = buildDevStylesUrl(router.basepath, routeIds)\n\n  return (\n    <link\n      rel=\"stylesheet\"\n      href={href}\n      data-tanstack-start-dev-styles\n      suppressHydrationWarning\n    />\n  )\n}\n\n/**\n * Render route-managed head tags (title, meta, links, styles, head scripts).\n * Place inside the document head of your app shell.\n * @link https://tanstack.com/router/latest/docs/framework/react/guide/document-head-management\n */\nexport function HeadContent() {\n  const tags = useTags()\n  const router = useRouter()\n  const nonce = router.options.ssr?.nonce\n  return (\n    <>\n      {process.env.NODE_ENV !== 'production' && <DevStylesLink />}\n      {tags.map((tag) => (\n        <Asset {...tag} key={`tsr-meta-${JSON.stringify(tag)}`} nonce={nonce} />\n      ))}\n    </>\n  )\n}\n\nfunction uniqBy<T>(arr: Array<T>, fn: (item: T) => string) {\n  const seen = new Set<string>()\n  return arr.filter((item) => {\n    const key = fn(item)\n    if (seen.has(key)) {\n      return false\n    }\n    seen.add(key)\n    return true\n  })\n}\n"],"names":["preloadLinks"],"mappings":"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"}
+{"version":3,"file":"HeadContent.js","sources":["../../src/HeadContent.tsx"],"sourcesContent":["import * as React from 'react'\nimport { Asset } from './Asset'\nimport { useRouter } from './useRouter'\nimport { useTags } from './headContentUtils'\n\n/**\n * Render route-managed head tags (title, meta, links, styles, head scripts).\n * Place inside the document head of your app shell.\n * @link https://tanstack.com/router/latest/docs/framework/react/guide/document-head-management\n */\nexport function HeadContent() {\n  const tags = useTags()\n  const router = useRouter()\n  const nonce = router.options.ssr?.nonce\n  return (\n    <>\n      {tags.map((tag) => (\n        <Asset {...tag} key={`tsr-meta-${JSON.stringify(tag)}`} nonce={nonce} />\n      ))}\n    </>\n  )\n}\n"],"names":[],"mappings":";;;;;AAUO,SAAS,cAAc;AAC5B,QAAM,OAAO,QAAA;AACb,QAAM,SAAS,UAAA;AACf,QAAM,QAAQ,OAAO,QAAQ,KAAK;AAClC,yCAEK,UAAA,KAAK,IAAI,CAAC,QACT,8BAAC,SAAO,GAAG,KAAK,KAAK,YAAY,KAAK,UAAU,GAAG,CAAC,IAAI,OAAc,CACvE,GACH;AAEJ;"}