astro-md-editor 0.0.1

package/.output/server/_libs/tanstack__react-router.mjs

@@ -0,0 +1,1464 @@
+import { j as jsxRuntimeExports, r as reactExports, R as React, a as React$1 } from "./react.mjs";
+import { i as isNotFound, d as defaultGetScrollRestorationKey, r as restoreScroll, e as escapeHtml, s as storageKey, a as rootRouteId, b as isRedirect, g as getLocationChangeInfo, t as transformReadableStreamWithRouter, c as transformPipeableStreamWithRouter, f as isDangerousProtocol, h as exactPathTest, j as removeTrailingSlash, k as deepEqual, l as functionalUpdate, B as BaseRootRoute, m as BaseRoute, n as isModuleNotFoundError, R as RouterCore } from "./tanstack__router-core.mjs";
+import { i as invariant } from "./tiny-invariant.mjs";
+import { PassThrough } from "node:stream";
+import { R as ReactDOMServer } from "./react-dom.mjs";
+import { i as isbot } from "./isbot.mjs";
+import { w as warning } from "./tiny-warning.mjs";
+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;
+      }
+    }
+  );
+}
+class CatchBoundaryImpl extends reactExports.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+  }
+  static getDerivedStateFromProps(props) {
+    return { resetKey: props.getResetKey() };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  reset() {
+    this.setState({ error: null });
+  }
+  componentDidUpdate(prevProps, prevState) {
+    if (prevState.error && prevState.resetKey !== this.state.resetKey) {
+      this.reset();
+    }
+  }
+  componentDidCatch(error, errorInfo) {
+    if (this.props.onCatch) {
+      this.props.onCatch(error, errorInfo);
+    }
+  }
+  render() {
+    return this.props.children({
+      error: this.state.resetKey !== this.props.getResetKey() ? null : 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
+  ] });
+}
+const routerContext = reactExports.createContext(null);
+function useRouter(opts) {
+  const value = reactExports.useContext(routerContext);
+  warning(
+    !((opts?.warn ?? true) && !value)
+  );
+  return value;
+}
+function useRouterState(opts) {
+  const contextRouter = useRouter({
+    warn: opts?.router === void 0
+  });
+  const router = opts?.router || contextRouter;
+  {
+    const state = router.state;
+    return opts?.select ? opts.select(state) : state;
+  }
+}
+const REACT_USE = "use";
+const reactUse = React[REACT_USE];
+function useForwardedRef(ref) {
+  const innerRef = reactExports.useRef(null);
+  reactExports.useImperativeHandle(ref, () => innerRef.current, []);
+  return innerRef;
+}
+const matchContext = reactExports.createContext(void 0);
+const dummyMatchContext = reactExports.createContext(
+  void 0
+);
+function CatchNotFound(props) {
+  const resetKey = useRouterState({
+    select: (s) => `not-found-${s.location.pathname}-${s.status}`
+  });
+  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 ScriptOnce({ children }) {
+  const router = useRouter();
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "script",
+    {
+      nonce: router.options.ssr?.nonce,
+      dangerouslySetInnerHTML: {
+        __html: children + ";document.currentScript.remove()"
+      }
+    }
+  );
+}
+function ScrollRestoration() {
+  const router = useRouter();
+  if (!router.isScrollRestoring || false) {
+    return null;
+  }
+  if (typeof router.options.scrollRestoration === "function") {
+    const shouldRestore = router.options.scrollRestoration({
+      location: router.latestLocation
+    });
+    if (!shouldRestore) {
+      return null;
+    }
+  }
+  const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey;
+  const userKey = getKey(router.latestLocation);
+  const resolvedKey = userKey !== defaultGetScrollRestorationKey(router.latestLocation) ? userKey : void 0;
+  const restoreScrollOptions = {
+    storageKey,
+    shouldScrollRestoration: true
+  };
+  if (resolvedKey) {
+    restoreScrollOptions.key = resolvedKey;
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    ScriptOnce,
+    {
+      children: `(${restoreScroll.toString()})(${escapeHtml(JSON.stringify(restoreScrollOptions))})`
+    }
+  );
+}
+function ClientOnly({ children, fallback = null }) {
+  return useHydrated() ? /* @__PURE__ */ jsxRuntimeExports.jsx(React$1.Fragment, { children }) : /* @__PURE__ */ jsxRuntimeExports.jsx(React$1.Fragment, { children: fallback });
+}
+function useHydrated() {
+  return React$1.useSyncExternalStore(
+    subscribe,
+    () => true,
+    () => false
+  );
+}
+function subscribe() {
+  return () => {
+  };
+}
+const Match = reactExports.memo(function MatchImpl({
+  matchId
+}) {
+  const router = useRouter();
+  const matchState = useRouterState({
+    select: (s) => {
+      const matchIndex = s.matches.findIndex((d) => d.id === matchId);
+      const match = s.matches[matchIndex];
+      invariant(
+        match
+      );
+      return {
+        routeId: match.routeId,
+        ssr: match.ssr,
+        _displayPending: match._displayPending,
+        resetKey: s.loadedAt,
+        parentRouteId: s.matches[matchIndex - 1]?.routeId
+      };
+    },
+    structuralSharing: true
+  });
+  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 ? (
+    // If it's the root route, use the globalNotFound option, with fallback to the notFoundRoute's component
+    route.options.notFoundComponent ?? router.options.notFoundRoute?.options.component
+  ) : route.options.notFoundComponent;
+  const resolvedNoSsr = matchState.ssr === false || matchState.ssr === "data-only";
+  const ResolvedSuspenseBoundary = (
+    // If we're on the root route, allow forcefully wrapping in suspense
+    (!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;
+  const ShellComponent = route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment;
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs(ShellComponent, { children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsx(matchContext.Provider, { value: matchId, children: /* @__PURE__ */ jsxRuntimeExports.jsx(ResolvedSuspenseBoundary, { fallback: pendingElement, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+      ResolvedCatchBoundary,
+      {
+        getResetKey: () => matchState.resetKey,
+        errorComponent: routeErrorComponent || ErrorComponent,
+        onCatch: (error, errorInfo) => {
+          if (isNotFound(error)) throw error;
+          routeOnCatch?.(error, errorInfo);
+        },
+        children: /* @__PURE__ */ jsxRuntimeExports.jsx(
+          ResolvedNotFoundBoundary,
+          {
+            fallback: (error) => {
+              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 && router.options.scrollRestoration ? /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx(OnRendered, {}),
+      /* @__PURE__ */ jsxRuntimeExports.jsx(ScrollRestoration, {})
+    ] }) : null
+  ] });
+});
+function OnRendered() {
+  const router = useRouter();
+  const prevLocationRef = reactExports.useRef(
+    void 0
+  );
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "script",
+    {
+      suppressHydrationWarning: true,
+      ref: (el) => {
+        if (el && (prevLocationRef.current === void 0 || prevLocationRef.current.href !== router.latestLocation.href)) {
+          router.emit({
+            type: "onRendered",
+            ...getLocationChangeInfo(router.state)
+          });
+          prevLocationRef.current = router.latestLocation;
+        }
+      }
+    },
+    router.latestLocation.state.__TSR_key
+  );
+}
+const MatchInner = reactExports.memo(function MatchInnerImpl({
+  matchId
+}) {
+  const router = useRouter();
+  const { match, key, routeId } = useRouterState({
+    select: (s) => {
+      const match2 = s.matches.find((d) => d.id === matchId);
+      const routeId2 = match2.routeId;
+      const remountFn = router.routesById[routeId2].options.remountDeps ?? router.options.defaultRemountDeps;
+      const remountDeps = remountFn?.({
+        routeId: routeId2,
+        loaderDeps: match2.loaderDeps,
+        params: match2._strictParams,
+        search: match2._strictSearch
+      });
+      const key2 = remountDeps ? JSON.stringify(remountDeps) : void 0;
+      return {
+        key: key2,
+        routeId: routeId2,
+        match: {
+          id: match2.id,
+          status: match2.status,
+          error: match2.error,
+          invalid: match2.invalid,
+          _forcePending: match2._forcePending,
+          _displayPending: match2._displayPending
+        }
+      };
+    },
+    structuralSharing: true
+  });
+  const route = router.routesById[routeId];
+  const out = reactExports.useMemo(() => {
+    const Comp = route.options.component ?? router.options.defaultComponent;
+    if (Comp) {
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(Comp, {}, key);
+    }
+    return /* @__PURE__ */ jsxRuntimeExports.jsx(Outlet, {});
+  }, [key, route.options.component, router.options.defaultComponent]);
+  if (match._displayPending) {
+    throw router.getMatch(match.id)?._nonReactive.displayPendingPromise;
+  }
+  if (match._forcePending) {
+    throw router.getMatch(match.id)?._nonReactive.minPendingPromise;
+  }
+  if (match.status === "pending") {
+    const pendingMinMs = route.options.pendingMinMs ?? router.options.defaultPendingMinMs;
+    if (pendingMinMs) {
+      const routerMatch = router.getMatch(match.id);
+      if (routerMatch && !routerMatch._nonReactive.minPendingPromise) ;
+    }
+    throw router.getMatch(match.id)?._nonReactive.loadPromise;
+  }
+  if (match.status === "notFound") {
+    invariant(isNotFound(match.error));
+    return renderRouteNotFound(router, route, match.error);
+  }
+  if (match.status === "redirected") {
+    invariant(isRedirect(match.error));
+    throw router.getMatch(match.id)?._nonReactive.loadPromise;
+  }
+  if (match.status === "error") {
+    {
+      const RouteErrorComponent = (route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent;
+      return /* @__PURE__ */ jsxRuntimeExports.jsx(
+        RouteErrorComponent,
+        {
+          error: match.error,
+          reset: void 0,
+          info: {
+            componentStack: ""
+          }
+        }
+      );
+    }
+  }
+  return out;
+});
+const Outlet = reactExports.memo(function OutletImpl() {
+  const router = useRouter();
+  const matchId = reactExports.useContext(matchContext);
+  const routeId = useRouterState({
+    select: (s) => s.matches.find((d) => d.id === matchId)?.routeId
+  });
+  const route = router.routesById[routeId];
+  const parentGlobalNotFound = useRouterState({
+    select: (s) => {
+      const matches = s.matches;
+      const parentMatch = matches.find((d) => d.id === matchId);
+      invariant(
+        parentMatch
+      );
+      return parentMatch.globalNotFound;
+    }
+  });
+  const childMatchId = useRouterState({
+    select: (s) => {
+      const matches = s.matches;
+      const index = matches.findIndex((d) => d.id === matchId);
+      return matches[index + 1]?.id;
+    }
+  });
+  const pendingElement = router.options.defaultPendingComponent ? /* @__PURE__ */ jsxRuntimeExports.jsx(router.options.defaultPendingComponent, {}) : null;
+  if (parentGlobalNotFound) {
+    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 rootRoute = router.routesById[rootRouteId];
+  const PendingComponent = rootRoute.options.pendingComponent ?? router.options.defaultPendingComponent;
+  const pendingElement = PendingComponent ? /* @__PURE__ */ jsxRuntimeExports.jsx(PendingComponent, {}) : null;
+  const ResolvedSuspense = SafeFragment;
+  const inner = /* @__PURE__ */ jsxRuntimeExports.jsxs(ResolvedSuspense, { 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 = useRouterState({
+    select: (s) => {
+      return s.matches[0]?.id;
+    }
+  });
+  const resetKey = useRouterState({
+    select: (s) => s.loadedAt
+  });
+  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
+    }
+  ) });
+}
+function RouterContextProvider({
+  router,
+  children,
+  ...rest
+}) {
+  if (Object.keys(rest).length > 0) {
+    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, {}) });
+}
+const 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.state.statusCode,
+      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.state.statusCode,
+      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."
+  );
+};
+function useMatch(opts) {
+  const nearestMatchId = reactExports.useContext(
+    opts.from ? dummyMatchContext : matchContext
+  );
+  const matchSelection = useRouterState({
+    select: (state) => {
+      const match = state.matches.find(
+        (d) => opts.from ? opts.from === d.routeId : d.id === nearestMatchId
+      );
+      invariant(
+        !((opts.shouldThrow ?? true) && !match),
+        `Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`
+      );
+      if (match === void 0) {
+        return void 0;
+      }
+      return opts.select ? opts.select(match) : match;
+    },
+    structuralSharing: opts.structuralSharing
+  });
+  return matchSelection;
+}
+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 useLinkProps(options, forwardedRef) {
+  const router = useRouter();
+  const innerRef = useForwardedRef(forwardedRef);
+  const {
+    // custom props
+    activeProps,
+    inactiveProps,
+    activeOptions,
+    to,
+    preload: userPreload,
+    preloadDelay: userPreloadDelay,
+    hashScrollIntoView,
+    replace,
+    startTransition,
+    resetScroll,
+    viewTransition,
+    // element props
+    children,
+    target,
+    disabled,
+    style,
+    className,
+    onClick,
+    onBlur,
+    onFocus,
+    onMouseEnter,
+    onMouseLeave,
+    onTouchStart,
+    ignoreBlocker,
+    // prevent these from being returned
+    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 && // Quick checks to avoid `new URL` in common internal-like cases
+    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 hrefOptionPublicHref2 = next2.maskedLocation ? next2.maskedLocation.publicHref : next2.publicHref;
+    const hrefOptionExternal2 = next2.maskedLocation ? next2.maskedLocation.external : next2.external;
+    const hrefOption2 = getHrefOption(
+      hrefOptionPublicHref2,
+      hrefOptionExternal2,
+      router.history,
+      disabled
+    );
+    const externalLink2 = (() => {
+      if (hrefOption2?.external) {
+        if (isDangerousProtocol(hrefOption2.href, router.protocolAllowlist)) {
+          return void 0;
+        }
+        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 void 0;
+          }
+          return to;
+        } catch {
+        }
+      }
+      return void 0;
+    })();
+    const isActive2 = (() => {
+      if (externalLink2) return false;
+      const currentLocation = router.state.location;
+      const exact = activeOptions?.exact ?? false;
+      if (exact) {
+        const testExact = exactPathTest(
+          currentLocation.pathname,
+          next2.pathname,
+          router.basepath
+        );
+        if (!testExact) {
+          return false;
+        }
+      } else {
+        const currentPathSplit = removeTrailingSlash(
+          currentLocation.pathname,
+          router.basepath
+        );
+        const nextPathSplit = removeTrailingSlash(
+          next2.pathname,
+          router.basepath
+        );
+        const pathIsFuzzyEqual = currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/");
+        if (!pathIsFuzzyEqual) {
+          return false;
+        }
+      }
+      const includeSearch = activeOptions?.includeSearch ?? true;
+      if (includeSearch) {
+        if (currentLocation.search !== next2.search) {
+          const currentSearchEmpty = !currentLocation.search || typeof currentLocation.search === "object" && Object.keys(currentLocation.search).length === 0;
+          const nextSearchEmpty = !next2.search || typeof next2.search === "object" && Object.keys(next2.search).length === 0;
+          if (!(currentSearchEmpty && nextSearchEmpty)) {
+            const searchTest = deepEqual(currentLocation.search, next2.search, {
+              partial: !exact,
+              ignoreUndefined: !activeOptions?.explicitUndefined
+            });
+            if (!searchTest) {
+              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 void 0;
+      }
+      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
+    };
+  }
+}
+const STATIC_EMPTY_OBJECT = {};
+const STATIC_ACTIVE_OBJECT = { className: "active" };
+const STATIC_DISABLED_PROPS = { role: "link", "aria-disabled": true };
+const 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;
+}
+const 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);
+  }
+);
+class Route 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 useMatch({
+        ...opts,
+        from: this.id,
+        select: (d) => opts?.select ? opts.select(d.context) : d.context
+      });
+    };
+    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$1.forwardRef(
+      (props, ref) => {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx(Link, { ref, from: this.fullPath, ...props });
+      }
+    );
+    this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
+  }
+}
+function createRoute(options) {
+  return new Route(
+    // TODO: Help us TypeChris, you're our only hope!
+    options
+  );
+}
+class RootRoute 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 useMatch({
+        ...opts,
+        from: this.id,
+        select: (d) => opts?.select ? opts.select(d.context) : d.context
+      });
+    };
+    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$1.forwardRef(
+      (props, ref) => {
+        return /* @__PURE__ */ jsxRuntimeExports.jsx(Link, { ref, from: this.fullPath, ...props });
+      }
+    );
+    this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
+  }
+}
+function createRootRoute(options) {
+  return new RootRoute(options);
+}
+function createFileRoute(path) {
+  if (typeof path === "object") {
+    return new FileRoute(path, {
+      silent: true
+    }).createRoute(path);
+  }
+  return new FileRoute(path, {
+    silent: true
+  }).createRoute;
+}
+class FileRoute {
+  constructor(path, _opts) {
+    this.path = path;
+    this.createRoute = (options) => {
+      const route = createRoute(options);
+      route.isRoot = false;
+      return route;
+    };
+    this.silent = _opts?.silent;
+  }
+}
+class LazyRoute {
+  constructor(opts) {
+    this.useMatch = (opts2) => {
+      return useMatch({
+        select: opts2?.select,
+        from: this.options.id,
+        structuralSharing: opts2?.structuralSharing
+      });
+    };
+    this.useRouteContext = (opts2) => {
+      return useMatch({
+        from: this.options.id,
+        select: (d) => opts2?.select ? opts2.select(d.context) : d.context
+      });
+    };
+    this.useSearch = (opts2) => {
+      return useSearch({
+        select: opts2?.select,
+        structuralSharing: opts2?.structuralSharing,
+        from: this.options.id
+      });
+    };
+    this.useParams = (opts2) => {
+      return useParams({
+        select: opts2?.select,
+        structuralSharing: opts2?.structuralSharing,
+        from: this.options.id
+      });
+    };
+    this.useLoaderDeps = (opts2) => {
+      return useLoaderDeps({ ...opts2, from: this.options.id });
+    };
+    this.useLoaderData = (opts2) => {
+      return useLoaderData({ ...opts2, from: this.options.id });
+    };
+    this.useNavigate = () => {
+      const router = useRouter();
+      return useNavigate({ from: router.routesById[this.options.id].fullPath });
+    };
+    this.options = opts;
+    this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo");
+  }
+}
+function createLazyFileRoute(id) {
+  if (typeof id === "object") {
+    return new LazyRoute(id);
+  }
+  return (opts) => new LazyRoute({ id, ...opts });
+}
+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 storageKey2 = `tanstack_router_reload:${error.message}`;
+            if (!sessionStorage.getItem(storageKey2)) {
+              sessionStorage.setItem(storageKey2, "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;
+}
+const createRouter = (options) => {
+  return new Router(options);
+};
+class Router extends RouterCore {
+  constructor(options) {
+    super(options);
+  }
+}
+if (typeof globalThis !== "undefined") {
+  globalThis.createFileRoute = createFileRoute;
+  globalThis.createLazyFileRoute = createLazyFileRoute;
+} else if (typeof window !== "undefined") {
+  window.createFileRoute = createFileRoute;
+  window.createLazyFileRoute = createLazyFileRoute;
+}
+function Asset({
+  tag,
+  attrs,
+  children,
+  nonce
+}) {
+  switch (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, nonce, suppressHydrationWarning: true });
+    case "style":
+      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;
+        }
+      })();
+      const existingScript = Array.from(
+        document.querySelectorAll("script[src]")
+      ).find((el) => el.src === normSrc);
+      if (existingScript) {
+        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;
+      const existingScript = 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;
+      });
+      if (existingScript) {
+        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);
+        }
+      };
+    }
+    return void 0;
+  }, [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;
+  }
+}
+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 = reactExports.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: {
+        ...attrs,
+        nonce
+      },
+      children
+    })),
+    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 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() {
+  const tags = useTags();
+  const router = useRouter();
+  const nonce = router.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 })) });
+}
+const Scripts = () => {
+  const router = useRouter();
+  const nonce = router.options.ssr?.nonce;
+  const assetScripts = useRouterState({
+    select: (state) => {
+      const assetScripts2 = [];
+      const manifest = router.ssr?.manifest;
+      if (!manifest) {
+        return [];
+      }
+      state.matches.map((match) => router.looseRoutesById[match.routeId]).forEach(
+        (route) => manifest.routes[route.id]?.assets?.filter((d) => d.tag === "script").forEach((asset) => {
+          assetScripts2.push({
+            tag: "script",
+            attrs: { ...asset.attrs, nonce },
+            children: asset.children
+          });
+        })
+      );
+      return assetScripts2;
+    },
+    structuralSharing: true
+  });
+  const { scripts } = useRouterState({
+    select: (state) => ({
+      scripts: state.matches.map((match) => match.scripts).flat(1).filter(Boolean).map(({ children, ...script }) => ({
+        tag: "script",
+        attrs: {
+          ...script,
+          suppressHydrationWarning: true,
+          nonce
+        },
+        children
+      }))
+    }),
+    structuralSharing: true
+  });
+  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}` })) });
+};
+export {
+  HeadContent as H,
+  RouterProvider as R,
+  Scripts as S,
+  createRootRoute as a,
+  createFileRoute as b,
+  createRouter as c,
+  lazyRouteComponent as l,
+  renderRouterToStream as r
+};