tanstack_start_ts 1.0.0

package/dist/server/assets/vendor-tanstack-react-router-XzqpA65A.js

@@ -0,0 +1,1120 @@
+import { r as reactExports, j as jsxRuntimeExports, R as React } from "./vendor-react-DvBrY0qp.js";
+import { t as invariant, u as isDangerousProtocol, k as exactPathTest, G as removeTrailingSlash, s as hasKeys, g as deepEqual, m as functionalUpdate, B as BaseRootRoute, a as BaseRoute, w as isModuleNotFoundError, x as isNotFound, q as getScrollRestorationScriptForRouter, I as rootRouteId, A as isServer, y as isRedirect, d as createNonReactiveReadonlyStore, c as createNonReactiveMutableStore, R as RouterCore, j as escapeHtml, v as isInlinableStylesheet, n as getAssetCrossOrigin, H as resolveManifestAssetLink, K as transformReadableStreamWithRouter, J as transformPipeableStreamWithRouter } from "./vendor-tanstack-router-core-6wywV3KN.js";
+import { a as ReactDOMServer } from "./vendor-react-dom-yvMLPM0j.js";
+import { PassThrough } from "node:stream";
+import { i as isbot } from "./vendor-isbot-CZ7WjwVs.js";
+var reactUse = reactExports.use;
+function useForwardedRef(ref) {
+  const innerRef = reactExports.useRef(null);
+  reactExports.useImperativeHandle(ref, () => innerRef.current, []);
+  return innerRef;
+}
+function CatchBoundary(props) {
+  const errorComponent = props.errorComponent ?? ErrorComponent;
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(CatchBoundaryImpl, {
+    getResetKey: props.getResetKey,
+    onCatch: props.onCatch,
+    children: ({ error, reset }) => {
+      if (error) return reactExports.createElement(errorComponent, {
+        error,
+        reset
+      });
+      return props.children;
+    }
+  });
+}
+var CatchBoundaryImpl = class extends reactExports.Component {
+  constructor(..._args) {
+    super(..._args);
+    this.state = { error: null };
+  }
+  static getDerivedStateFromProps(props, state) {
+    const resetKey = props.getResetKey();
+    if (state.error && state.resetKey !== resetKey) return {
+      resetKey,
+      error: null
+    };
+    return { resetKey };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  reset() {
+    this.setState({ error: null });
+  }
+  componentDidCatch(error, errorInfo) {
+    if (this.props.onCatch) this.props.onCatch(error, errorInfo);
+  }
+  render() {
+    return this.props.children({
+      error: this.state.error,
+      reset: () => {
+        this.reset();
+      }
+    });
+  }
+};
+function ErrorComponent({ error }) {
+  const [show, setShow] = reactExports.useState(false);
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", {
+    style: {
+      padding: ".5rem",
+      maxWidth: "100%"
+    },
+    children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", {
+        style: {
+          display: "flex",
+          alignItems: "center",
+          gap: ".5rem"
+        },
+        children: [/* @__PURE__ */ jsxRuntimeExports.jsx("strong", {
+          style: { fontSize: "1rem" },
+          children: "Something went wrong!"
+        }), /* @__PURE__ */ jsxRuntimeExports.jsx("button", {
+          style: {
+            appearance: "none",
+            fontSize: ".6em",
+            border: "1px solid currentColor",
+            padding: ".1rem .2rem",
+            fontWeight: "bold",
+            borderRadius: ".25rem"
+          },
+          onClick: () => setShow((d) => !d),
+          children: show ? "Hide Error" : "Show Error"
+        })]
+      }),
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { height: ".25rem" } }),
+      show ? /* @__PURE__ */ jsxRuntimeExports.jsx("div", { children: /* @__PURE__ */ jsxRuntimeExports.jsx("pre", {
+        style: {
+          fontSize: ".7em",
+          border: "1px solid red",
+          borderRadius: ".25rem",
+          padding: ".3rem",
+          color: "red",
+          overflow: "auto"
+        },
+        children: error.message ? /* @__PURE__ */ jsxRuntimeExports.jsx("code", { children: error.message }) : null
+      }) }) : null
+    ]
+  });
+}
+function ClientOnly({ children, fallback = null }) {
+  return useHydrated() ? /* @__PURE__ */ jsxRuntimeExports.jsx(React.Fragment, { children }) : /* @__PURE__ */ jsxRuntimeExports.jsx(React.Fragment, { children: fallback });
+}
+function useHydrated() {
+  return React.useSyncExternalStore(subscribe, () => true, () => false);
+}
+function subscribe() {
+  return () => {
+  };
+}
+var routerContext = reactExports.createContext(null);
+function useRouter(opts) {
+  const value = reactExports.useContext(routerContext);
+  return value;
+}
+var matchContext = reactExports.createContext(void 0);
+var dummyMatchContext = reactExports.createContext(void 0);
+function useMatch(opts) {
+  const router = useRouter();
+  const nearestMatchId = reactExports.useContext(opts.from ? dummyMatchContext : matchContext);
+  const key = opts.from ?? nearestMatchId;
+  const matchStore = key ? opts.from ? router.stores.getRouteMatchStore(key) : router.stores.matchStores.get(key) : void 0;
+  {
+    const match = matchStore?.get();
+    if ((opts.shouldThrow ?? true) && !match) {
+      invariant();
+    }
+    if (match === void 0) return;
+    return opts.select ? opts.select(match) : match;
+  }
+}
+function useLoaderData(opts) {
+  return useMatch({
+    from: opts.from,
+    strict: opts.strict,
+    structuralSharing: opts.structuralSharing,
+    select: (s) => {
+      return opts.select ? opts.select(s.loaderData) : s.loaderData;
+    }
+  });
+}
+function useLoaderDeps(opts) {
+  const { select, ...rest } = opts;
+  return useMatch({
+    ...rest,
+    select: (s) => {
+      return select ? select(s.loaderDeps) : s.loaderDeps;
+    }
+  });
+}
+function useParams(opts) {
+  return useMatch({
+    from: opts.from,
+    shouldThrow: opts.shouldThrow,
+    structuralSharing: opts.structuralSharing,
+    strict: opts.strict,
+    select: (match) => {
+      const params = opts.strict === false ? match.params : match._strictParams;
+      return opts.select ? opts.select(params) : params;
+    }
+  });
+}
+function useSearch(opts) {
+  return useMatch({
+    from: opts.from,
+    strict: opts.strict,
+    shouldThrow: opts.shouldThrow,
+    structuralSharing: opts.structuralSharing,
+    select: (match) => {
+      return opts.select ? opts.select(match.search) : match.search;
+    }
+  });
+}
+function useNavigate(_defaultOpts) {
+  const router = useRouter();
+  return reactExports.useCallback((options) => {
+    return router.navigate({
+      ...options,
+      from: options.from ?? _defaultOpts?.from
+    });
+  }, [_defaultOpts?.from, router]);
+}
+function useRouteContext(opts) {
+  return useMatch({
+    ...opts,
+    select: (match) => opts.select ? opts.select(match.context) : match.context
+  });
+}
+function useLinkProps(options, forwardedRef) {
+  const router = useRouter();
+  const innerRef = useForwardedRef(forwardedRef);
+  const { activeProps, inactiveProps, activeOptions, to, preload: userPreload, preloadDelay: userPreloadDelay, preloadIntentProximity: _preloadIntentProximity, hashScrollIntoView, replace, startTransition, resetScroll, viewTransition, children, target, disabled, style, className, onClick, onBlur, onFocus, onMouseEnter, onMouseLeave, onTouchStart, ignoreBlocker, params: _params, search: _search, hash: _hash, state: _state, mask: _mask, reloadDocument: _reloadDocument, unsafeRelative: _unsafeRelative, from: _from, _fromLocation, ...propsSafeToSpread } = options;
+  {
+    const safeInternal = isSafeInternal(to);
+    if (typeof to === "string" && !safeInternal && to.indexOf(":") > -1) try {
+      new URL(to);
+      if (isDangerousProtocol(to, router.protocolAllowlist)) {
+        if (false) ;
+        return {
+          ...propsSafeToSpread,
+          ref: innerRef,
+          href: void 0,
+          ...children && { children },
+          ...target && { target },
+          ...disabled && { disabled },
+          ...style && { style },
+          ...className && { className }
+        };
+      }
+      return {
+        ...propsSafeToSpread,
+        ref: innerRef,
+        href: to,
+        ...children && { children },
+        ...target && { target },
+        ...disabled && { disabled },
+        ...style && { style },
+        ...className && { className }
+      };
+    } catch {
+    }
+    const next2 = router.buildLocation({
+      ...options,
+      from: options.from
+    });
+    const hrefOption2 = getHrefOption(next2.maskedLocation ? next2.maskedLocation.publicHref : next2.publicHref, next2.maskedLocation ? next2.maskedLocation.external : next2.external, router.history, disabled);
+    const externalLink2 = (() => {
+      if (hrefOption2?.external) {
+        if (isDangerousProtocol(hrefOption2.href, router.protocolAllowlist)) {
+          return;
+        }
+        return hrefOption2.href;
+      }
+      if (safeInternal) return void 0;
+      if (typeof to === "string" && to.indexOf(":") > -1) try {
+        new URL(to);
+        if (isDangerousProtocol(to, router.protocolAllowlist)) {
+          if (false) ;
+          return;
+        }
+        return to;
+      } catch {
+      }
+    })();
+    const isActive2 = (() => {
+      if (externalLink2) return false;
+      const currentLocation2 = router.stores.location.get();
+      const exact = activeOptions?.exact ?? false;
+      if (exact) {
+        if (!exactPathTest(currentLocation2.pathname, next2.pathname, router.basepath)) return false;
+      } else {
+        const currentPathSplit = removeTrailingSlash(currentLocation2.pathname, router.basepath);
+        const nextPathSplit = removeTrailingSlash(next2.pathname, router.basepath);
+        if (!(currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/"))) return false;
+      }
+      if (activeOptions?.includeSearch ?? true) {
+        if (currentLocation2.search !== next2.search) {
+          const currentSearchEmpty = !currentLocation2.search || typeof currentLocation2.search === "object" && !hasKeys(currentLocation2.search);
+          const nextSearchEmpty = !next2.search || typeof next2.search === "object" && !hasKeys(next2.search);
+          if (!(currentSearchEmpty && nextSearchEmpty)) {
+            if (!deepEqual(currentLocation2.search, next2.search, {
+              partial: !exact,
+              ignoreUndefined: !activeOptions?.explicitUndefined
+            })) return false;
+          }
+        }
+      }
+      if (activeOptions?.includeHash) return false;
+      return true;
+    })();
+    if (externalLink2) return {
+      ...propsSafeToSpread,
+      ref: innerRef,
+      href: externalLink2,
+      ...children && { children },
+      ...target && { target },
+      ...disabled && { disabled },
+      ...style && { style },
+      ...className && { className }
+    };
+    const resolvedActiveProps2 = isActive2 ? functionalUpdate(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT;
+    const resolvedInactiveProps2 = isActive2 ? STATIC_EMPTY_OBJECT : functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT;
+    const resolvedStyle2 = (() => {
+      const baseStyle = style;
+      const activeStyle = resolvedActiveProps2.style;
+      const inactiveStyle = resolvedInactiveProps2.style;
+      if (!baseStyle && !activeStyle && !inactiveStyle) return;
+      if (baseStyle && !activeStyle && !inactiveStyle) return baseStyle;
+      if (!baseStyle && activeStyle && !inactiveStyle) return activeStyle;
+      if (!baseStyle && !activeStyle && inactiveStyle) return inactiveStyle;
+      return {
+        ...baseStyle,
+        ...activeStyle,
+        ...inactiveStyle
+      };
+    })();
+    const resolvedClassName2 = (() => {
+      const baseClassName = className;
+      const activeClassName = resolvedActiveProps2.className;
+      const inactiveClassName = resolvedInactiveProps2.className;
+      if (!baseClassName && !activeClassName && !inactiveClassName) return "";
+      let out = "";
+      if (baseClassName) out = baseClassName;
+      if (activeClassName) out = out ? `${out} ${activeClassName}` : activeClassName;
+      if (inactiveClassName) out = out ? `${out} ${inactiveClassName}` : inactiveClassName;
+      return out;
+    })();
+    return {
+      ...propsSafeToSpread,
+      ...resolvedActiveProps2,
+      ...resolvedInactiveProps2,
+      href: hrefOption2?.href,
+      ref: innerRef,
+      disabled: !!disabled,
+      target,
+      ...resolvedStyle2 && { style: resolvedStyle2 },
+      ...resolvedClassName2 && { className: resolvedClassName2 },
+      ...disabled && STATIC_DISABLED_PROPS,
+      ...isActive2 && STATIC_ACTIVE_PROPS
+    };
+  }
+}
+var STATIC_EMPTY_OBJECT = {};
+var STATIC_ACTIVE_OBJECT = { className: "active" };
+var STATIC_DISABLED_PROPS = {
+  role: "link",
+  "aria-disabled": true
+};
+var STATIC_ACTIVE_PROPS = {
+  "data-status": "active",
+  "aria-current": "page"
+};
+function getHrefOption(publicHref, external, history, disabled) {
+  if (disabled) return void 0;
+  if (external) return {
+    href: publicHref,
+    external: true
+  };
+  return {
+    href: history.createHref(publicHref) || "/",
+    external: false
+  };
+}
+function isSafeInternal(to) {
+  if (typeof to !== "string") return false;
+  const zero = to.charCodeAt(0);
+  if (zero === 47) return to.charCodeAt(1) !== 47;
+  return zero === 46;
+}
+var Link = reactExports.forwardRef((props, ref) => {
+  const { _asChild, ...rest } = props;
+  const { type: _type, ...linkProps } = useLinkProps(rest, ref);
+  const children = typeof rest.children === "function" ? rest.children({ isActive: linkProps["data-status"] === "active" }) : rest.children;
+  if (!_asChild) {
+    const { disabled: _, ...rest2 } = linkProps;
+    return reactExports.createElement("a", rest2, children);
+  }
+  return reactExports.createElement(_asChild, linkProps, children);
+});
+var Route = class extends BaseRoute {
+  /**
+  * @deprecated Use the `createRoute` function instead.
+  */
+  constructor(options) {
+    super(options);
+    this.useMatch = (opts) => {
+      return useMatch({
+        select: opts?.select,
+        from: this.id,
+        structuralSharing: opts?.structuralSharing
+      });
+    };
+    this.useRouteContext = (opts) => {
+      return useRouteContext({
+        ...opts,
+        from: this.id
+      });
+    };
+    this.useSearch = (opts) => {
+      return useSearch({
+        select: opts?.select,
+        structuralSharing: opts?.structuralSharing,
+        from: this.id
+      });
+    };
+    this.useParams = (opts) => {
+      return useParams({
+        select: opts?.select,
+        structuralSharing: opts?.structuralSharing,
+        from: this.id
+      });
+    };
+    this.useLoaderDeps = (opts) => {
+      return useLoaderDeps({
+        ...opts,
+        from: this.id
+      });
+    };
+    this.useLoaderData = (opts) => {
+      return useLoaderData({
+        ...opts,
+        from: this.id
+      });
+    };
+    this.useNavigate = () => {
+      return useNavigate({ from: this.fullPath });
+    };
+    this.Link = React.forwardRef((props, ref) => {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(Link, {
+        ref,
+        from: this.fullPath,
+        ...props
+      });
+    });
+  }
+};
+function createRoute(options) {
+  return new Route(options);
+}
+function createRootRouteWithContext() {
+  return (options) => {
+    return createRootRoute(options);
+  };
+}
+var RootRoute = class extends BaseRootRoute {
+  /**
+  * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
+  */
+  constructor(options) {
+    super(options);
+    this.useMatch = (opts) => {
+      return useMatch({
+        select: opts?.select,
+        from: this.id,
+        structuralSharing: opts?.structuralSharing
+      });
+    };
+    this.useRouteContext = (opts) => {
+      return useRouteContext({
+        ...opts,
+        from: this.id
+      });
+    };
+    this.useSearch = (opts) => {
+      return useSearch({
+        select: opts?.select,
+        structuralSharing: opts?.structuralSharing,
+        from: this.id
+      });
+    };
+    this.useParams = (opts) => {
+      return useParams({
+        select: opts?.select,
+        structuralSharing: opts?.structuralSharing,
+        from: this.id
+      });
+    };
+    this.useLoaderDeps = (opts) => {
+      return useLoaderDeps({
+        ...opts,
+        from: this.id
+      });
+    };
+    this.useLoaderData = (opts) => {
+      return useLoaderData({
+        ...opts,
+        from: this.id
+      });
+    };
+    this.useNavigate = () => {
+      return useNavigate({ from: this.fullPath });
+    };
+    this.Link = React.forwardRef((props, ref) => {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(Link, {
+        ref,
+        from: this.fullPath,
+        ...props
+      });
+    });
+  }
+};
+function createRootRoute(options) {
+  return new RootRoute(options);
+}
+function createFileRoute(path) {
+  return new FileRoute(path, { silent: true }).createRoute;
+}
+var FileRoute = class {
+  constructor(path, _opts) {
+    this.path = path;
+    this.createRoute = (options) => {
+      const route = createRoute(options);
+      route.isRoot = false;
+      return route;
+    };
+    this.silent = _opts?.silent;
+  }
+};
+function lazyRouteComponent(importer, exportName) {
+  let loadPromise;
+  let comp;
+  let error;
+  let reload;
+  const load = () => {
+    if (!loadPromise) loadPromise = importer().then((res) => {
+      loadPromise = void 0;
+      comp = res[exportName];
+    }).catch((err) => {
+      error = err;
+      if (isModuleNotFoundError(error)) {
+        if (error instanceof Error && typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+          const storageKey = `tanstack_router_reload:${error.message}`;
+          if (!sessionStorage.getItem(storageKey)) {
+            sessionStorage.setItem(storageKey, "1");
+            reload = true;
+          }
+        }
+      }
+    });
+    return loadPromise;
+  };
+  const lazyComp = function Lazy(props) {
+    if (reload) {
+      window.location.reload();
+      throw new Promise(() => {
+      });
+    }
+    if (error) throw error;
+    if (!comp) if (reactUse) reactUse(load());
+    else throw load();
+    return reactExports.createElement(comp, props);
+  };
+  lazyComp.preload = load;
+  return lazyComp;
+}
+function CatchNotFound(props) {
+  const router = useRouter();
+  {
+    const resetKey = `not-found-${router.stores.location.get().pathname}-${router.stores.status.get()}`;
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(CatchBoundary, {
+      getResetKey: () => resetKey,
+      onCatch: (error, errorInfo) => {
+        if (isNotFound(error)) props.onCatch?.(error, errorInfo);
+        else throw error;
+      },
+      errorComponent: ({ error }) => {
+        if (isNotFound(error)) return props.fallback?.(error);
+        else throw error;
+      },
+      children: props.children
+    });
+  }
+}
+function DefaultGlobalNotFound() {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx("p", { children: "Not Found" });
+}
+function SafeFragment(props) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: props.children });
+}
+function renderRouteNotFound(router, route, data) {
+  if (!route.options.notFoundComponent) {
+    if (router.options.defaultNotFoundComponent) return /* @__PURE__ */ jsxRuntimeExports.jsx(router.options.defaultNotFoundComponent, { ...data });
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(DefaultGlobalNotFound, {});
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(route.options.notFoundComponent, { ...data });
+}
+function ScrollRestoration() {
+  getScrollRestorationScriptForRouter(useRouter());
+  return null;
+}
+var Match = reactExports.memo(function MatchImpl({ matchId }) {
+  const router = useRouter();
+  {
+    const match2 = router.stores.matchStores.get(matchId)?.get();
+    if (!match2) {
+      invariant();
+    }
+    const routeId = match2.routeId;
+    const parentRouteId = router.routesById[routeId].parentRoute?.id;
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(MatchView, {
+      router,
+      matchId,
+      resetKey: router.stores.loadedAt.get(),
+      matchState: {
+        routeId,
+        ssr: match2.ssr,
+        _displayPending: match2._displayPending,
+        parentRouteId
+      }
+    });
+  }
+});
+function MatchView({ router, matchId, resetKey, matchState }) {
+  const route = router.routesById[matchState.routeId];
+  const PendingComponent = route.options.pendingComponent ?? router.options.defaultPendingComponent;
+  const pendingElement = PendingComponent ? /* @__PURE__ */ jsxRuntimeExports.jsx(PendingComponent, {}) : null;
+  const routeErrorComponent = route.options.errorComponent ?? router.options.defaultErrorComponent;
+  const routeOnCatch = route.options.onCatch ?? router.options.defaultOnCatch;
+  const routeNotFoundComponent = route.isRoot ? route.options.notFoundComponent ?? router.options.notFoundRoute?.options.component : route.options.notFoundComponent;
+  const resolvedNoSsr = matchState.ssr === false || matchState.ssr === "data-only";
+  const ResolvedSuspenseBoundary = (!route.isRoot || route.options.wrapInSuspense || resolvedNoSsr) && (route.options.wrapInSuspense ?? PendingComponent ?? (route.options.errorComponent?.preload || resolvedNoSsr)) ? reactExports.Suspense : SafeFragment;
+  const ResolvedCatchBoundary = routeErrorComponent ? CatchBoundary : SafeFragment;
+  const ResolvedNotFoundBoundary = routeNotFoundComponent ? CatchNotFound : SafeFragment;
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment, { children: [/* @__PURE__ */ jsxRuntimeExports.jsx(matchContext.Provider, {
+    value: matchId,
+    children: /* @__PURE__ */ jsxRuntimeExports.jsx(ResolvedSuspenseBoundary, {
+      fallback: pendingElement,
+      children: /* @__PURE__ */ jsxRuntimeExports.jsx(ResolvedCatchBoundary, {
+        getResetKey: () => resetKey,
+        errorComponent: routeErrorComponent || ErrorComponent,
+        onCatch: (error, errorInfo) => {
+          if (isNotFound(error)) {
+            error.routeId ??= matchState.routeId;
+            throw error;
+          }
+          routeOnCatch?.(error, errorInfo);
+        },
+        children: /* @__PURE__ */ jsxRuntimeExports.jsx(ResolvedNotFoundBoundary, {
+          fallback: (error) => {
+            error.routeId ??= matchState.routeId;
+            if (!routeNotFoundComponent || error.routeId && error.routeId !== matchState.routeId || !error.routeId && !route.isRoot) throw error;
+            return reactExports.createElement(routeNotFoundComponent, error);
+          },
+          children: resolvedNoSsr || matchState._displayPending ? /* @__PURE__ */ jsxRuntimeExports.jsx(ClientOnly, {
+            fallback: pendingElement,
+            children: /* @__PURE__ */ jsxRuntimeExports.jsx(MatchInner, { matchId })
+          }) : /* @__PURE__ */ jsxRuntimeExports.jsx(MatchInner, { matchId })
+        })
+      })
+    })
+  }), matchState.parentRouteId === rootRouteId ? /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [/* @__PURE__ */ jsxRuntimeExports.jsx(OnRendered, { resetKey }), router.options.scrollRestoration && isServer ? /* @__PURE__ */ jsxRuntimeExports.jsx(ScrollRestoration, {}) : null] }) : null] });
+}
+function OnRendered({ resetKey }) {
+  useRouter();
+  return null;
+}
+var MatchInner = reactExports.memo(function MatchInnerImpl({ matchId }) {
+  const router = useRouter();
+  const getMatchPromise = (match2, key2) => {
+    return router.getMatch(match2.id)?._nonReactive[key2] ?? match2._nonReactive[key2];
+  };
+  {
+    const match2 = router.stores.matchStores.get(matchId)?.get();
+    if (!match2) {
+      invariant();
+    }
+    const routeId2 = match2.routeId;
+    const route2 = router.routesById[routeId2];
+    const remountDeps = (router.routesById[routeId2].options.remountDeps ?? router.options.defaultRemountDeps)?.({
+      routeId: routeId2,
+      loaderDeps: match2.loaderDeps,
+      params: match2._strictParams,
+      search: match2._strictSearch
+    });
+    const key2 = remountDeps ? JSON.stringify(remountDeps) : void 0;
+    const Comp = route2.options.component ?? router.options.defaultComponent;
+    const out2 = Comp ? /* @__PURE__ */ jsxRuntimeExports.jsx(Comp, {}, key2) : /* @__PURE__ */ jsxRuntimeExports.jsx(Outlet, {});
+    if (match2._displayPending) throw getMatchPromise(match2, "displayPendingPromise");
+    if (match2._forcePending) throw getMatchPromise(match2, "minPendingPromise");
+    if (match2.status === "pending") throw getMatchPromise(match2, "loadPromise");
+    if (match2.status === "notFound") {
+      if (!isNotFound(match2.error)) {
+        invariant();
+      }
+      return renderRouteNotFound(router, route2, match2.error);
+    }
+    if (match2.status === "redirected") {
+      if (!isRedirect(match2.error)) {
+        invariant();
+      }
+      throw getMatchPromise(match2, "loadPromise");
+    }
+    if (match2.status === "error") return /* @__PURE__ */ jsxRuntimeExports.jsx((route2.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent, {
+      error: match2.error,
+      reset: void 0,
+      info: { componentStack: "" }
+    });
+    return out2;
+  }
+});
+var Outlet = reactExports.memo(function OutletImpl() {
+  const router = useRouter();
+  const matchId = reactExports.useContext(matchContext);
+  let routeId;
+  let parentGlobalNotFound = false;
+  let childMatchId;
+  {
+    const matches = router.stores.matches.get();
+    const parentIndex = matchId ? matches.findIndex((match) => match.id === matchId) : -1;
+    const parentMatch = parentIndex >= 0 ? matches[parentIndex] : void 0;
+    routeId = parentMatch?.routeId;
+    parentGlobalNotFound = parentMatch?.globalNotFound ?? false;
+    childMatchId = parentIndex >= 0 ? matches[parentIndex + 1]?.id : void 0;
+  }
+  const route = routeId ? router.routesById[routeId] : void 0;
+  const pendingElement = router.options.defaultPendingComponent ? /* @__PURE__ */ jsxRuntimeExports.jsx(router.options.defaultPendingComponent, {}) : null;
+  if (parentGlobalNotFound) {
+    if (!route) {
+      invariant();
+    }
+    return renderRouteNotFound(router, route, void 0);
+  }
+  if (!childMatchId) return null;
+  const nextMatch = /* @__PURE__ */ jsxRuntimeExports.jsx(Match, { matchId: childMatchId });
+  if (routeId === rootRouteId) return /* @__PURE__ */ jsxRuntimeExports.jsx(reactExports.Suspense, {
+    fallback: pendingElement,
+    children: nextMatch
+  });
+  return nextMatch;
+});
+function Matches() {
+  const router = useRouter();
+  const PendingComponent = router.routesById[rootRouteId].options.pendingComponent ?? router.options.defaultPendingComponent;
+  const pendingElement = PendingComponent ? /* @__PURE__ */ jsxRuntimeExports.jsx(PendingComponent, {}) : null;
+  const inner = /* @__PURE__ */ jsxRuntimeExports.jsxs(SafeFragment, {
+    fallback: pendingElement,
+    children: [false, /* @__PURE__ */ jsxRuntimeExports.jsx(MatchesInner, {})]
+  });
+  return router.options.InnerWrap ? /* @__PURE__ */ jsxRuntimeExports.jsx(router.options.InnerWrap, { children: inner }) : inner;
+}
+function MatchesInner() {
+  const router = useRouter();
+  const matchId = router.stores.firstId.get();
+  const resetKey = router.stores.loadedAt.get();
+  const matchComponent = matchId ? /* @__PURE__ */ jsxRuntimeExports.jsx(Match, { matchId }) : null;
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(matchContext.Provider, {
+    value: matchId,
+    children: router.options.disableGlobalCatchBoundary ? matchComponent : /* @__PURE__ */ jsxRuntimeExports.jsx(CatchBoundary, {
+      getResetKey: () => resetKey,
+      errorComponent: ErrorComponent,
+      onCatch: void 0,
+      children: matchComponent
+    })
+  });
+}
+var getStoreFactory = (opts) => {
+  return {
+    createMutableStore: createNonReactiveMutableStore,
+    createReadonlyStore: createNonReactiveReadonlyStore,
+    batch: (fn) => fn()
+  };
+};
+var createRouter = (options) => {
+  return new Router(options);
+};
+var Router = class extends RouterCore {
+  constructor(options) {
+    super(options, getStoreFactory);
+  }
+};
+function RouterContextProvider({ router, children, ...rest }) {
+  if (hasKeys(rest)) router.update({
+    ...router.options,
+    ...rest,
+    context: {
+      ...router.options.context,
+      ...rest.context
+    }
+  });
+  const provider = /* @__PURE__ */ jsxRuntimeExports.jsx(routerContext.Provider, {
+    value: router,
+    children
+  });
+  if (router.options.Wrap) return /* @__PURE__ */ jsxRuntimeExports.jsx(router.options.Wrap, { children: provider });
+  return provider;
+}
+function RouterProvider({ router, ...rest }) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(RouterContextProvider, {
+    router,
+    ...rest,
+    children: /* @__PURE__ */ jsxRuntimeExports.jsx(Matches, {})
+  });
+}
+function useRouterState(opts) {
+  const contextRouter = useRouter({ warn: opts?.router === void 0 });
+  const router = opts?.router || contextRouter;
+  {
+    const state = router.stores.__store.get();
+    return opts?.select ? opts.select(state) : state;
+  }
+}
+function Asset(asset) {
+  const { attrs, children, nonce } = asset;
+  switch (asset.tag) {
+    case "title":
+      return /* @__PURE__ */ jsxRuntimeExports.jsx("title", {
+        ...attrs,
+        suppressHydrationWarning: true,
+        children
+      });
+    case "meta":
+      return /* @__PURE__ */ jsxRuntimeExports.jsx("meta", {
+        ...attrs,
+        suppressHydrationWarning: true
+      });
+    case "link":
+      return /* @__PURE__ */ jsxRuntimeExports.jsx("link", {
+        ...attrs,
+        precedence: attrs?.precedence ?? (attrs?.rel === "stylesheet" ? "default" : void 0),
+        nonce,
+        suppressHydrationWarning: true
+      });
+    case "style":
+      if (asset.inlineCss && false) ;
+      return /* @__PURE__ */ jsxRuntimeExports.jsx("style", {
+        ...attrs,
+        dangerouslySetInnerHTML: { __html: children },
+        nonce
+      });
+    case "script":
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(Script, {
+        attrs,
+        children
+      });
+    default:
+      return null;
+  }
+}
+function Script({ attrs, children }) {
+  useRouter();
+  useHydrated();
+  const dataScript = typeof attrs?.type === "string" && attrs.type !== "" && attrs.type !== "text/javascript" && attrs.type !== "module";
+  reactExports.useEffect(() => {
+    if (dataScript) return;
+    if (attrs?.src) {
+      const normSrc = (() => {
+        try {
+          const base = document.baseURI || window.location.href;
+          return new URL(attrs.src, base).href;
+        } catch {
+          return attrs.src;
+        }
+      })();
+      if (Array.from(document.querySelectorAll("script[src]")).find((el) => el.src === normSrc)) return;
+      const script = document.createElement("script");
+      for (const [key, value] of Object.entries(attrs)) if (key !== "suppressHydrationWarning" && value !== void 0 && value !== false) script.setAttribute(key, typeof value === "boolean" ? "" : String(value));
+      document.head.appendChild(script);
+      return () => {
+        if (script.parentNode) script.parentNode.removeChild(script);
+      };
+    }
+    if (typeof children === "string") {
+      const typeAttr = typeof attrs?.type === "string" ? attrs.type : "text/javascript";
+      const nonceAttr = typeof attrs?.nonce === "string" ? attrs.nonce : void 0;
+      if (Array.from(document.querySelectorAll("script:not([src])")).find((el) => {
+        if (!(el instanceof HTMLScriptElement)) return false;
+        const sType = el.getAttribute("type") ?? "text/javascript";
+        const sNonce = el.getAttribute("nonce") ?? void 0;
+        return el.textContent === children && sType === typeAttr && sNonce === nonceAttr;
+      })) return;
+      const script = document.createElement("script");
+      script.textContent = children;
+      if (attrs) {
+        for (const [key, value] of Object.entries(attrs)) if (key !== "suppressHydrationWarning" && value !== void 0 && value !== false) script.setAttribute(key, typeof value === "boolean" ? "" : String(value));
+      }
+      document.head.appendChild(script);
+      return () => {
+        if (script.parentNode) script.parentNode.removeChild(script);
+      };
+    }
+  }, [
+    attrs,
+    children,
+    dataScript
+  ]);
+  {
+    if (attrs?.src) return /* @__PURE__ */ jsxRuntimeExports.jsx("script", {
+      ...attrs,
+      suppressHydrationWarning: true
+    });
+    if (typeof children === "string") return /* @__PURE__ */ jsxRuntimeExports.jsx("script", {
+      ...attrs,
+      dangerouslySetInnerHTML: { __html: children },
+      suppressHydrationWarning: true
+    });
+    return null;
+  }
+}
+function buildTagsFromMatches(router, nonce, matches, assetCrossOrigin) {
+  const routeMeta = matches.map((match) => match.meta).filter(Boolean);
+  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();
+  const constructedLinks = matches.map((match) => match.links).filter(Boolean).flat(1).map((link) => ({
+    tag: "link",
+    attrs: {
+      ...link,
+      nonce
+    }
+  }));
+  const manifest = router.ssr?.manifest;
+  const assetLinks = matches.map((match) => manifest?.routes[match.routeId]?.assets ?? []).filter(Boolean).flat(1).flatMap((asset) => {
+    if (asset.tag === "link") {
+      if (isInlinableStylesheet(manifest, asset)) return [];
+      return [{
+        tag: "link",
+        attrs: {
+          ...asset.attrs,
+          crossOrigin: getAssetCrossOrigin(assetCrossOrigin, "stylesheet") ?? asset.attrs?.crossOrigin,
+          suppressHydrationWarning: true,
+          nonce
+        }
+      }];
+    }
+    if (asset.tag === "style") return [{
+      tag: "style",
+      attrs: {
+        ...asset.attrs,
+        nonce
+      },
+      children: asset.children,
+      ...asset.inlineCss ? { inlineCss: true } : {}
+    }];
+    return [];
+  });
+  const preloadLinks = [];
+  matches.map((match) => router.looseRoutesById[match.routeId]).forEach((route) => router.ssr?.manifest?.routes[route.id]?.preloads?.filter(Boolean).forEach((preload) => {
+    const preloadLink = resolveManifestAssetLink(preload);
+    preloadLinks.push({
+      tag: "link",
+      attrs: {
+        rel: "modulepreload",
+        href: preloadLink.href,
+        crossOrigin: getAssetCrossOrigin(assetCrossOrigin, "modulepreload") ?? preloadLink.crossOrigin,
+        nonce
+      }
+    });
+  }));
+  const styles = matches.map((match) => match.styles).flat(1).filter(Boolean).map(({ children, ...attrs }) => ({
+    tag: "style",
+    attrs: {
+      ...attrs,
+      nonce
+    },
+    children
+  }));
+  const headScripts = matches.map((match) => match.headScripts).flat(1).filter(Boolean).map(({ children, ...script }) => ({
+    tag: "script",
+    attrs: {
+      ...script,
+      nonce
+    },
+    children
+  }));
+  return uniqBy([
+    ...resultMeta,
+    ...preloadLinks,
+    ...constructedLinks,
+    ...assetLinks,
+    ...styles,
+    ...headScripts
+  ], (d) => JSON.stringify(d));
+}
+var useTags = (assetCrossOrigin) => {
+  const router = useRouter();
+  const nonce = router.options.ssr?.nonce;
+  return buildTagsFromMatches(router, nonce, router.stores.matches.get(), assetCrossOrigin);
+};
+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;
+  });
+}
+function HeadContent(props) {
+  const tags = useTags(props.assetCrossOrigin);
+  const nonce = useRouter().options.ssr?.nonce;
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: tags.map((tag) => /* @__PURE__ */ reactExports.createElement(Asset, {
+    ...tag,
+    key: `tsr-meta-${JSON.stringify(tag)}`,
+    nonce
+  })) });
+}
+var Scripts = () => {
+  const router = useRouter();
+  const nonce = router.options.ssr?.nonce;
+  const getAssetScripts = (matches) => {
+    const assetScripts = [];
+    const manifest = router.ssr?.manifest;
+    if (!manifest) return [];
+    matches.map((match) => router.looseRoutesById[match.routeId]).forEach((route) => manifest.routes[route.id]?.assets?.filter((d) => d.tag === "script").forEach((asset) => {
+      assetScripts.push({
+        tag: "script",
+        attrs: {
+          ...asset.attrs,
+          nonce
+        },
+        children: asset.children
+      });
+    }));
+    return assetScripts;
+  };
+  const getScripts = (matches) => matches.map((match) => match.scripts).flat(1).filter(Boolean).map(({ children, ...script }) => ({
+    tag: "script",
+    attrs: {
+      ...script,
+      suppressHydrationWarning: true,
+      nonce
+    },
+    children
+  }));
+  {
+    const activeMatches = router.stores.matches.get();
+    const assetScripts = getAssetScripts(activeMatches);
+    return renderScripts(router, getScripts(activeMatches), assetScripts);
+  }
+};
+function renderScripts(router, scripts, assetScripts) {
+  let serverBufferedScript = void 0;
+  if (router.serverSsr) serverBufferedScript = router.serverSsr.takeBufferedScripts();
+  const allScripts = [...scripts, ...assetScripts];
+  if (serverBufferedScript) allScripts.unshift(serverBufferedScript);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: allScripts.map((asset, i) => /* @__PURE__ */ reactExports.createElement(Asset, {
+    ...asset,
+    key: `tsr-scripts-${asset.tag}-${i}`
+  })) });
+}
+var renderRouterToStream = async ({ request, router, responseHeaders, children }) => {
+  if (typeof ReactDOMServer.renderToReadableStream === "function") {
+    const stream = await ReactDOMServer.renderToReadableStream(children, {
+      signal: request.signal,
+      nonce: router.options.ssr?.nonce,
+      progressiveChunkSize: Number.POSITIVE_INFINITY
+    });
+    if (isbot(request.headers.get("User-Agent"))) await stream.allReady;
+    const responseStream = transformReadableStreamWithRouter(router, stream);
+    return new Response(responseStream, {
+      status: router.stores.statusCode.get(),
+      headers: responseHeaders
+    });
+  }
+  if (typeof ReactDOMServer.renderToPipeableStream === "function") {
+    const reactAppPassthrough = new PassThrough();
+    try {
+      const pipeable = ReactDOMServer.renderToPipeableStream(children, {
+        nonce: router.options.ssr?.nonce,
+        progressiveChunkSize: Number.POSITIVE_INFINITY,
+        ...isbot(request.headers.get("User-Agent")) ? { onAllReady() {
+          pipeable.pipe(reactAppPassthrough);
+        } } : { onShellReady() {
+          pipeable.pipe(reactAppPassthrough);
+        } },
+        onError: (error, info) => {
+          console.error("Error in renderToPipeableStream:", error, info);
+          if (!reactAppPassthrough.destroyed) reactAppPassthrough.destroy(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+    } catch (e) {
+      console.error("Error in renderToPipeableStream:", e);
+      reactAppPassthrough.destroy(e instanceof Error ? e : new Error(String(e)));
+    }
+    const responseStream = transformPipeableStreamWithRouter(router, reactAppPassthrough);
+    return new Response(responseStream, {
+      status: router.stores.statusCode.get(),
+      headers: responseHeaders
+    });
+  }
+  throw new Error("No renderToReadableStream or renderToPipeableStream found in react-dom/server. Ensure you are using a version of react-dom that supports streaming.");
+};
+export {
+  HeadContent as H,
+  Link as L,
+  Outlet as O,
+  RouterProvider as R,
+  Scripts as S,
+  createRootRouteWithContext as a,
+  createRouter as b,
+  createFileRoute as c,
+  useRouter as d,
+  useRouterState as e,
+  lazyRouteComponent as l,
+  renderRouterToStream as r,
+  useNavigate as u
+};