boreal-ui 0.0.39 → 0.0.41

package/dist/next/navigation-DxXFNXZM.js

@@ -0,0 +1,2444 @@
+import { r as require_interop_require_default, a as require_interop_require_wildcard, d as requireInvariantError, e as requireSegment } from "./link-CxWP3aXr.js";
+import React from "react";
+var navigation$1 = { exports: {} };
+var appRouterContext_sharedRuntime = {};
+var hasRequiredAppRouterContext_sharedRuntime;
+function requireAppRouterContext_sharedRuntime() {
+  if (hasRequiredAppRouterContext_sharedRuntime) return appRouterContext_sharedRuntime;
+  hasRequiredAppRouterContext_sharedRuntime = 1;
+  (function(exports$1) {
+    "use client";
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      AppRouterContext: function() {
+        return AppRouterContext;
+      },
+      GlobalLayoutRouterContext: function() {
+        return GlobalLayoutRouterContext;
+      },
+      LayoutRouterContext: function() {
+        return LayoutRouterContext;
+      },
+      MissingSlotContext: function() {
+        return MissingSlotContext;
+      },
+      TemplateContext: function() {
+        return TemplateContext;
+      }
+    });
+    const _interop_require_default = /* @__PURE__ */ require_interop_require_default();
+    const _react = /* @__PURE__ */ _interop_require_default._(React);
+    const AppRouterContext = _react.default.createContext(null);
+    const LayoutRouterContext = _react.default.createContext(null);
+    const GlobalLayoutRouterContext = _react.default.createContext(null);
+    const TemplateContext = _react.default.createContext(null);
+    if (process.env.NODE_ENV !== "production") {
+      AppRouterContext.displayName = "AppRouterContext";
+      LayoutRouterContext.displayName = "LayoutRouterContext";
+      GlobalLayoutRouterContext.displayName = "GlobalLayoutRouterContext";
+      TemplateContext.displayName = "TemplateContext";
+    }
+    const MissingSlotContext = _react.default.createContext(/* @__PURE__ */ new Set());
+  })(appRouterContext_sharedRuntime);
+  return appRouterContext_sharedRuntime;
+}
+var hooksClientContext_sharedRuntime = {};
+var hasRequiredHooksClientContext_sharedRuntime;
+function requireHooksClientContext_sharedRuntime() {
+  if (hasRequiredHooksClientContext_sharedRuntime) return hooksClientContext_sharedRuntime;
+  hasRequiredHooksClientContext_sharedRuntime = 1;
+  (function(exports$1) {
+    "use client";
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      NavigationPromisesContext: function() {
+        return NavigationPromisesContext;
+      },
+      PathParamsContext: function() {
+        return PathParamsContext;
+      },
+      PathnameContext: function() {
+        return PathnameContext;
+      },
+      SearchParamsContext: function() {
+        return SearchParamsContext;
+      },
+      createDevToolsInstrumentedPromise: function() {
+        return createDevToolsInstrumentedPromise;
+      }
+    });
+    const _react = React;
+    const SearchParamsContext = (0, _react.createContext)(null);
+    const PathnameContext = (0, _react.createContext)(null);
+    const PathParamsContext = (0, _react.createContext)(null);
+    const NavigationPromisesContext = (0, _react.createContext)(null);
+    function createDevToolsInstrumentedPromise(displayName, value) {
+      const promise = Promise.resolve(value);
+      promise.status = "fulfilled";
+      promise.value = value;
+      promise.displayName = `${displayName} (SSR)`;
+      return promise;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      SearchParamsContext.displayName = "SearchParamsContext";
+      PathnameContext.displayName = "PathnameContext";
+      PathParamsContext.displayName = "PathParamsContext";
+      NavigationPromisesContext.displayName = "NavigationPromisesContext";
+    }
+  })(hooksClientContext_sharedRuntime);
+  return hooksClientContext_sharedRuntime;
+}
+var readonlyUrlSearchParams = { exports: {} };
+var hasRequiredReadonlyUrlSearchParams;
+function requireReadonlyUrlSearchParams() {
+  if (hasRequiredReadonlyUrlSearchParams) return readonlyUrlSearchParams.exports;
+  hasRequiredReadonlyUrlSearchParams = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "ReadonlyURLSearchParams", {
+      enumerable: true,
+      get: function() {
+        return ReadonlyURLSearchParams;
+      }
+    });
+    class ReadonlyURLSearchParamsError extends Error {
+      constructor() {
+        super("Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams");
+      }
+    }
+    class ReadonlyURLSearchParams extends URLSearchParams {
+      /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */
+      append() {
+        throw new ReadonlyURLSearchParamsError();
+      }
+      /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */
+      delete() {
+        throw new ReadonlyURLSearchParamsError();
+      }
+      /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */
+      set() {
+        throw new ReadonlyURLSearchParamsError();
+      }
+      /** @deprecated Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams */
+      sort() {
+        throw new ReadonlyURLSearchParamsError();
+      }
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(readonlyUrlSearchParams, readonlyUrlSearchParams.exports);
+  return readonlyUrlSearchParams.exports;
+}
+var serverInsertedHtml_sharedRuntime = {};
+var hasRequiredServerInsertedHtml_sharedRuntime;
+function requireServerInsertedHtml_sharedRuntime() {
+  if (hasRequiredServerInsertedHtml_sharedRuntime) return serverInsertedHtml_sharedRuntime;
+  hasRequiredServerInsertedHtml_sharedRuntime = 1;
+  (function(exports$1) {
+    "use client";
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      ServerInsertedHTMLContext: function() {
+        return ServerInsertedHTMLContext;
+      },
+      useServerInsertedHTML: function() {
+        return useServerInsertedHTML;
+      }
+    });
+    const _interop_require_wildcard = /* @__PURE__ */ require_interop_require_wildcard();
+    const _react = /* @__PURE__ */ _interop_require_wildcard._(React);
+    const ServerInsertedHTMLContext = /* @__PURE__ */ _react.default.createContext(null);
+    function useServerInsertedHTML(callback) {
+      const addInsertedServerHTMLCallback = (0, _react.useContext)(ServerInsertedHTMLContext);
+      if (addInsertedServerHTMLCallback) {
+        addInsertedServerHTMLCallback(callback);
+      }
+    }
+  })(serverInsertedHtml_sharedRuntime);
+  return serverInsertedHtml_sharedRuntime;
+}
+var unrecognizedActionError = { exports: {} };
+var hasRequiredUnrecognizedActionError;
+function requireUnrecognizedActionError() {
+  if (hasRequiredUnrecognizedActionError) return unrecognizedActionError.exports;
+  hasRequiredUnrecognizedActionError = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      UnrecognizedActionError: function() {
+        return UnrecognizedActionError;
+      },
+      unstable_isUnrecognizedActionError: function() {
+        return unstable_isUnrecognizedActionError;
+      }
+    });
+    class UnrecognizedActionError extends Error {
+      constructor(...args) {
+        super(...args);
+        this.name = "UnrecognizedActionError";
+      }
+    }
+    function unstable_isUnrecognizedActionError(error) {
+      return !!(error && typeof error === "object" && error instanceof UnrecognizedActionError);
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(unrecognizedActionError, unrecognizedActionError.exports);
+  return unrecognizedActionError.exports;
+}
+var navigation_reactServer = { exports: {} };
+var redirect = { exports: {} };
+var redirectStatusCode = { exports: {} };
+var hasRequiredRedirectStatusCode;
+function requireRedirectStatusCode() {
+  if (hasRequiredRedirectStatusCode) return redirectStatusCode.exports;
+  hasRequiredRedirectStatusCode = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "RedirectStatusCode", {
+      enumerable: true,
+      get: function() {
+        return RedirectStatusCode;
+      }
+    });
+    var RedirectStatusCode = /* @__PURE__ */ (function(RedirectStatusCode2) {
+      RedirectStatusCode2[RedirectStatusCode2["SeeOther"] = 303] = "SeeOther";
+      RedirectStatusCode2[RedirectStatusCode2["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+      RedirectStatusCode2[RedirectStatusCode2["PermanentRedirect"] = 308] = "PermanentRedirect";
+      return RedirectStatusCode2;
+    })({});
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(redirectStatusCode, redirectStatusCode.exports);
+  return redirectStatusCode.exports;
+}
+var redirectError = { exports: {} };
+var hasRequiredRedirectError;
+function requireRedirectError() {
+  if (hasRequiredRedirectError) return redirectError.exports;
+  hasRequiredRedirectError = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      REDIRECT_ERROR_CODE: function() {
+        return REDIRECT_ERROR_CODE;
+      },
+      RedirectType: function() {
+        return RedirectType;
+      },
+      isRedirectError: function() {
+        return isRedirectError;
+      }
+    });
+    const _redirectstatuscode = requireRedirectStatusCode();
+    const REDIRECT_ERROR_CODE = "NEXT_REDIRECT";
+    var RedirectType = /* @__PURE__ */ (function(RedirectType2) {
+      RedirectType2["push"] = "push";
+      RedirectType2["replace"] = "replace";
+      return RedirectType2;
+    })({});
+    function isRedirectError(error) {
+      if (typeof error !== "object" || error === null || !("digest" in error) || typeof error.digest !== "string") {
+        return false;
+      }
+      const digest = error.digest.split(";");
+      const [errorCode, type] = digest;
+      const destination = digest.slice(2, -2).join(";");
+      const status = digest.at(-2);
+      const statusCode = Number(status);
+      return errorCode === REDIRECT_ERROR_CODE && (type === "replace" || type === "push") && typeof destination === "string" && !isNaN(statusCode) && statusCode in _redirectstatuscode.RedirectStatusCode;
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(redirectError, redirectError.exports);
+  return redirectError.exports;
+}
+var actionAsyncStorage_external = {};
+var actionAsyncStorageInstance = {};
+var asyncLocalStorage = {};
+var hasRequiredAsyncLocalStorage;
+function requireAsyncLocalStorage() {
+  if (hasRequiredAsyncLocalStorage) return asyncLocalStorage;
+  hasRequiredAsyncLocalStorage = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      bindSnapshot: function() {
+        return bindSnapshot;
+      },
+      createAsyncLocalStorage: function() {
+        return createAsyncLocalStorage;
+      },
+      createSnapshot: function() {
+        return createSnapshot;
+      }
+    });
+    const sharedAsyncLocalStorageNotAvailableError = Object.defineProperty(new Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available"), "__NEXT_ERROR_CODE", {
+      value: "E504",
+      enumerable: false,
+      configurable: true
+    });
+    class FakeAsyncLocalStorage {
+      disable() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      getStore() {
+        return void 0;
+      }
+      run() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      exit() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      enterWith() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      static bind(fn) {
+        return fn;
+      }
+    }
+    const maybeGlobalAsyncLocalStorage = typeof globalThis !== "undefined" && globalThis.AsyncLocalStorage;
+    function createAsyncLocalStorage() {
+      if (maybeGlobalAsyncLocalStorage) {
+        return new maybeGlobalAsyncLocalStorage();
+      }
+      return new FakeAsyncLocalStorage();
+    }
+    function bindSnapshot(fn) {
+      if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.bind(fn);
+      }
+      return FakeAsyncLocalStorage.bind(fn);
+    }
+    function createSnapshot() {
+      if (maybeGlobalAsyncLocalStorage) {
+        return maybeGlobalAsyncLocalStorage.snapshot();
+      }
+      return function(fn, ...args) {
+        return fn(...args);
+      };
+    }
+  })(asyncLocalStorage);
+  return asyncLocalStorage;
+}
+var hasRequiredActionAsyncStorageInstance;
+function requireActionAsyncStorageInstance() {
+  if (hasRequiredActionAsyncStorageInstance) return actionAsyncStorageInstance;
+  hasRequiredActionAsyncStorageInstance = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "actionAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return actionAsyncStorageInstance2;
+      }
+    });
+    const _asynclocalstorage = requireAsyncLocalStorage();
+    const actionAsyncStorageInstance2 = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  })(actionAsyncStorageInstance);
+  return actionAsyncStorageInstance;
+}
+var hasRequiredActionAsyncStorage_external;
+function requireActionAsyncStorage_external() {
+  if (hasRequiredActionAsyncStorage_external) return actionAsyncStorage_external;
+  hasRequiredActionAsyncStorage_external = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "actionAsyncStorage", {
+      enumerable: true,
+      get: function() {
+        return _actionasyncstorageinstance.actionAsyncStorageInstance;
+      }
+    });
+    const _actionasyncstorageinstance = requireActionAsyncStorageInstance();
+  })(actionAsyncStorage_external);
+  return actionAsyncStorage_external;
+}
+var hasRequiredRedirect;
+function requireRedirect() {
+  if (hasRequiredRedirect) return redirect.exports;
+  hasRequiredRedirect = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      getRedirectError: function() {
+        return getRedirectError;
+      },
+      getRedirectStatusCodeFromError: function() {
+        return getRedirectStatusCodeFromError;
+      },
+      getRedirectTypeFromError: function() {
+        return getRedirectTypeFromError;
+      },
+      getURLFromRedirectError: function() {
+        return getURLFromRedirectError;
+      },
+      permanentRedirect: function() {
+        return permanentRedirect;
+      },
+      redirect: function() {
+        return redirect2;
+      }
+    });
+    const _redirectstatuscode = requireRedirectStatusCode();
+    const _redirecterror = requireRedirectError();
+    const actionAsyncStorage = typeof window === "undefined" ? requireActionAsyncStorage_external().actionAsyncStorage : void 0;
+    function getRedirectError(url, type, statusCode = _redirectstatuscode.RedirectStatusCode.TemporaryRedirect) {
+      const error = Object.defineProperty(new Error(_redirecterror.REDIRECT_ERROR_CODE), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+      error.digest = `${_redirecterror.REDIRECT_ERROR_CODE};${type};${url};${statusCode};`;
+      return error;
+    }
+    function redirect2(url, type) {
+      var _a;
+      type ?? (type = ((_a = actionAsyncStorage == null ? void 0 : actionAsyncStorage.getStore()) == null ? void 0 : _a.isAction) ? _redirecterror.RedirectType.push : _redirecterror.RedirectType.replace);
+      throw getRedirectError(url, type, _redirectstatuscode.RedirectStatusCode.TemporaryRedirect);
+    }
+    function permanentRedirect(url, type = _redirecterror.RedirectType.replace) {
+      throw getRedirectError(url, type, _redirectstatuscode.RedirectStatusCode.PermanentRedirect);
+    }
+    function getURLFromRedirectError(error) {
+      if (!(0, _redirecterror.isRedirectError)(error)) return null;
+      return error.digest.split(";").slice(2, -2).join(";");
+    }
+    function getRedirectTypeFromError(error) {
+      if (!(0, _redirecterror.isRedirectError)(error)) {
+        throw Object.defineProperty(new Error("Not a redirect error"), "__NEXT_ERROR_CODE", {
+          value: "E260",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      return error.digest.split(";", 2)[1];
+    }
+    function getRedirectStatusCodeFromError(error) {
+      if (!(0, _redirecterror.isRedirectError)(error)) {
+        throw Object.defineProperty(new Error("Not a redirect error"), "__NEXT_ERROR_CODE", {
+          value: "E260",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      return Number(error.digest.split(";").at(-2));
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(redirect, redirect.exports);
+  return redirect.exports;
+}
+var notFound = { exports: {} };
+var httpAccessFallback = { exports: {} };
+var hasRequiredHttpAccessFallback;
+function requireHttpAccessFallback() {
+  if (hasRequiredHttpAccessFallback) return httpAccessFallback.exports;
+  hasRequiredHttpAccessFallback = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      HTTPAccessErrorStatus: function() {
+        return HTTPAccessErrorStatus;
+      },
+      HTTP_ERROR_FALLBACK_ERROR_CODE: function() {
+        return HTTP_ERROR_FALLBACK_ERROR_CODE;
+      },
+      getAccessFallbackErrorTypeByStatus: function() {
+        return getAccessFallbackErrorTypeByStatus;
+      },
+      getAccessFallbackHTTPStatus: function() {
+        return getAccessFallbackHTTPStatus;
+      },
+      isHTTPAccessFallbackError: function() {
+        return isHTTPAccessFallbackError;
+      }
+    });
+    const HTTPAccessErrorStatus = {
+      NOT_FOUND: 404,
+      FORBIDDEN: 403,
+      UNAUTHORIZED: 401
+    };
+    const ALLOWED_CODES = new Set(Object.values(HTTPAccessErrorStatus));
+    const HTTP_ERROR_FALLBACK_ERROR_CODE = "NEXT_HTTP_ERROR_FALLBACK";
+    function isHTTPAccessFallbackError(error) {
+      if (typeof error !== "object" || error === null || !("digest" in error) || typeof error.digest !== "string") {
+        return false;
+      }
+      const [prefix, httpStatus] = error.digest.split(";");
+      return prefix === HTTP_ERROR_FALLBACK_ERROR_CODE && ALLOWED_CODES.has(Number(httpStatus));
+    }
+    function getAccessFallbackHTTPStatus(error) {
+      const httpStatus = error.digest.split(";")[1];
+      return Number(httpStatus);
+    }
+    function getAccessFallbackErrorTypeByStatus(status) {
+      switch (status) {
+        case 401:
+          return "unauthorized";
+        case 403:
+          return "forbidden";
+        case 404:
+          return "not-found";
+        default:
+          return;
+      }
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(httpAccessFallback, httpAccessFallback.exports);
+  return httpAccessFallback.exports;
+}
+var hasRequiredNotFound;
+function requireNotFound() {
+  if (hasRequiredNotFound) return notFound.exports;
+  hasRequiredNotFound = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "notFound", {
+      enumerable: true,
+      get: function() {
+        return notFound2;
+      }
+    });
+    const _httpaccessfallback = requireHttpAccessFallback();
+    const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};404`;
+    function notFound2() {
+      const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+      error.digest = DIGEST;
+      throw error;
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(notFound, notFound.exports);
+  return notFound.exports;
+}
+var forbidden = { exports: {} };
+var hasRequiredForbidden;
+function requireForbidden() {
+  if (hasRequiredForbidden) return forbidden.exports;
+  hasRequiredForbidden = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "forbidden", {
+      enumerable: true,
+      get: function() {
+        return forbidden2;
+      }
+    });
+    const _httpaccessfallback = requireHttpAccessFallback();
+    const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};403`;
+    function forbidden2() {
+      if (!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS) {
+        throw Object.defineProperty(new Error(`\`forbidden()\` is experimental and only allowed to be enabled when \`experimental.authInterrupts\` is enabled.`), "__NEXT_ERROR_CODE", {
+          value: "E488",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+      error.digest = DIGEST;
+      throw error;
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(forbidden, forbidden.exports);
+  return forbidden.exports;
+}
+var unauthorized = { exports: {} };
+var hasRequiredUnauthorized;
+function requireUnauthorized() {
+  if (hasRequiredUnauthorized) return unauthorized.exports;
+  hasRequiredUnauthorized = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "unauthorized", {
+      enumerable: true,
+      get: function() {
+        return unauthorized2;
+      }
+    });
+    const _httpaccessfallback = requireHttpAccessFallback();
+    const DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};401`;
+    function unauthorized2() {
+      if (!process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS) {
+        throw Object.defineProperty(new Error(`\`unauthorized()\` is experimental and only allowed to be used when \`experimental.authInterrupts\` is enabled.`), "__NEXT_ERROR_CODE", {
+          value: "E411",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      const error = Object.defineProperty(new Error(DIGEST), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+      error.digest = DIGEST;
+      throw error;
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(unauthorized, unauthorized.exports);
+  return unauthorized.exports;
+}
+var unstableRethrow = { exports: {} };
+var unstableRethrow_server = { exports: {} };
+var dynamicRenderingUtils = {};
+var hasRequiredDynamicRenderingUtils;
+function requireDynamicRenderingUtils() {
+  if (hasRequiredDynamicRenderingUtils) return dynamicRenderingUtils;
+  hasRequiredDynamicRenderingUtils = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      isHangingPromiseRejectionError: function() {
+        return isHangingPromiseRejectionError;
+      },
+      makeDevtoolsIOAwarePromise: function() {
+        return makeDevtoolsIOAwarePromise;
+      },
+      makeHangingPromise: function() {
+        return makeHangingPromise;
+      }
+    });
+    function isHangingPromiseRejectionError(err) {
+      if (typeof err !== "object" || err === null || !("digest" in err)) {
+        return false;
+      }
+      return err.digest === HANGING_PROMISE_REJECTION;
+    }
+    const HANGING_PROMISE_REJECTION = "HANGING_PROMISE_REJECTION";
+    class HangingPromiseRejectionError extends Error {
+      constructor(route, expression) {
+        super(`During prerendering, ${expression} rejects when the prerender is complete. Typically these errors are handled by React but if you move ${expression} to a different context by using \`setTimeout\`, \`after\`, or similar functions you may observe this error and you should handle it in that context. This occurred at route "${route}".`), this.route = route, this.expression = expression, this.digest = HANGING_PROMISE_REJECTION;
+      }
+    }
+    const abortListenersBySignal = /* @__PURE__ */ new WeakMap();
+    function makeHangingPromise(signal, route, expression) {
+      if (signal.aborted) {
+        return Promise.reject(new HangingPromiseRejectionError(route, expression));
+      } else {
+        const hangingPromise = new Promise((_, reject) => {
+          const boundRejection = reject.bind(null, new HangingPromiseRejectionError(route, expression));
+          let currentListeners = abortListenersBySignal.get(signal);
+          if (currentListeners) {
+            currentListeners.push(boundRejection);
+          } else {
+            const listeners = [
+              boundRejection
+            ];
+            abortListenersBySignal.set(signal, listeners);
+            signal.addEventListener("abort", () => {
+              for (let i = 0; i < listeners.length; i++) {
+                listeners[i]();
+              }
+            }, {
+              once: true
+            });
+          }
+        });
+        hangingPromise.catch(ignoreReject);
+        return hangingPromise;
+      }
+    }
+    function ignoreReject() {
+    }
+    function makeDevtoolsIOAwarePromise(underlying, requestStore, stage) {
+      if (requestStore.stagedRendering) {
+        return requestStore.stagedRendering.delayUntilStage(stage, void 0, underlying);
+      }
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(underlying);
+        }, 0);
+      });
+    }
+  })(dynamicRenderingUtils);
+  return dynamicRenderingUtils;
+}
+var isPostpone = {};
+var hasRequiredIsPostpone;
+function requireIsPostpone() {
+  if (hasRequiredIsPostpone) return isPostpone;
+  hasRequiredIsPostpone = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "isPostpone", {
+      enumerable: true,
+      get: function() {
+        return isPostpone2;
+      }
+    });
+    const REACT_POSTPONE_TYPE = Symbol.for("react.postpone");
+    function isPostpone2(error) {
+      return typeof error === "object" && error !== null && error.$$typeof === REACT_POSTPONE_TYPE;
+    }
+  })(isPostpone);
+  return isPostpone;
+}
+var bailoutToCsr = {};
+var hasRequiredBailoutToCsr;
+function requireBailoutToCsr() {
+  if (hasRequiredBailoutToCsr) return bailoutToCsr;
+  hasRequiredBailoutToCsr = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      BailoutToCSRError: function() {
+        return BailoutToCSRError;
+      },
+      isBailoutToCSRError: function() {
+        return isBailoutToCSRError;
+      }
+    });
+    const BAILOUT_TO_CSR = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+    class BailoutToCSRError extends Error {
+      constructor(reason) {
+        super(`Bail out to client-side rendering: ${reason}`), this.reason = reason, this.digest = BAILOUT_TO_CSR;
+      }
+    }
+    function isBailoutToCSRError(err) {
+      if (typeof err !== "object" || err === null || !("digest" in err)) {
+        return false;
+      }
+      return err.digest === BAILOUT_TO_CSR;
+    }
+  })(bailoutToCsr);
+  return bailoutToCsr;
+}
+var isNextRouterError = { exports: {} };
+var hasRequiredIsNextRouterError;
+function requireIsNextRouterError() {
+  if (hasRequiredIsNextRouterError) return isNextRouterError.exports;
+  hasRequiredIsNextRouterError = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "isNextRouterError", {
+      enumerable: true,
+      get: function() {
+        return isNextRouterError2;
+      }
+    });
+    const _httpaccessfallback = requireHttpAccessFallback();
+    const _redirecterror = requireRedirectError();
+    function isNextRouterError2(error) {
+      return (0, _redirecterror.isRedirectError)(error) || (0, _httpaccessfallback.isHTTPAccessFallbackError)(error);
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(isNextRouterError, isNextRouterError.exports);
+  return isNextRouterError.exports;
+}
+var dynamicRendering = {};
+var hooksServerContext = { exports: {} };
+var hasRequiredHooksServerContext;
+function requireHooksServerContext() {
+  if (hasRequiredHooksServerContext) return hooksServerContext.exports;
+  hasRequiredHooksServerContext = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      DynamicServerError: function() {
+        return DynamicServerError;
+      },
+      isDynamicServerError: function() {
+        return isDynamicServerError;
+      }
+    });
+    const DYNAMIC_ERROR_CODE = "DYNAMIC_SERVER_USAGE";
+    class DynamicServerError extends Error {
+      constructor(description) {
+        super(`Dynamic server usage: ${description}`), this.description = description, this.digest = DYNAMIC_ERROR_CODE;
+      }
+    }
+    function isDynamicServerError(err) {
+      if (typeof err !== "object" || err === null || !("digest" in err) || typeof err.digest !== "string") {
+        return false;
+      }
+      return err.digest === DYNAMIC_ERROR_CODE;
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(hooksServerContext, hooksServerContext.exports);
+  return hooksServerContext.exports;
+}
+var staticGenerationBailout = { exports: {} };
+var hasRequiredStaticGenerationBailout;
+function requireStaticGenerationBailout() {
+  if (hasRequiredStaticGenerationBailout) return staticGenerationBailout.exports;
+  hasRequiredStaticGenerationBailout = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      StaticGenBailoutError: function() {
+        return StaticGenBailoutError;
+      },
+      isStaticGenBailoutError: function() {
+        return isStaticGenBailoutError;
+      }
+    });
+    const NEXT_STATIC_GEN_BAILOUT = "NEXT_STATIC_GEN_BAILOUT";
+    class StaticGenBailoutError extends Error {
+      constructor(...args) {
+        super(...args), this.code = NEXT_STATIC_GEN_BAILOUT;
+      }
+    }
+    function isStaticGenBailoutError(error) {
+      if (typeof error !== "object" || error === null || !("code" in error)) {
+        return false;
+      }
+      return error.code === NEXT_STATIC_GEN_BAILOUT;
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(staticGenerationBailout, staticGenerationBailout.exports);
+  return staticGenerationBailout.exports;
+}
+var workUnitAsyncStorage_external = {};
+var workUnitAsyncStorageInstance = {};
+var hasRequiredWorkUnitAsyncStorageInstance;
+function requireWorkUnitAsyncStorageInstance() {
+  if (hasRequiredWorkUnitAsyncStorageInstance) return workUnitAsyncStorageInstance;
+  hasRequiredWorkUnitAsyncStorageInstance = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "workUnitAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return workUnitAsyncStorageInstance2;
+      }
+    });
+    const _asynclocalstorage = requireAsyncLocalStorage();
+    const workUnitAsyncStorageInstance2 = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  })(workUnitAsyncStorageInstance);
+  return workUnitAsyncStorageInstance;
+}
+var appRouterHeaders = { exports: {} };
+var hasRequiredAppRouterHeaders;
+function requireAppRouterHeaders() {
+  if (hasRequiredAppRouterHeaders) return appRouterHeaders.exports;
+  hasRequiredAppRouterHeaders = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      ACTION_HEADER: function() {
+        return ACTION_HEADER;
+      },
+      FLIGHT_HEADERS: function() {
+        return FLIGHT_HEADERS;
+      },
+      NEXT_ACTION_NOT_FOUND_HEADER: function() {
+        return NEXT_ACTION_NOT_FOUND_HEADER;
+      },
+      NEXT_DID_POSTPONE_HEADER: function() {
+        return NEXT_DID_POSTPONE_HEADER;
+      },
+      NEXT_HMR_REFRESH_HASH_COOKIE: function() {
+        return NEXT_HMR_REFRESH_HASH_COOKIE;
+      },
+      NEXT_HMR_REFRESH_HEADER: function() {
+        return NEXT_HMR_REFRESH_HEADER;
+      },
+      NEXT_HTML_REQUEST_ID_HEADER: function() {
+        return NEXT_HTML_REQUEST_ID_HEADER;
+      },
+      NEXT_IS_PRERENDER_HEADER: function() {
+        return NEXT_IS_PRERENDER_HEADER;
+      },
+      NEXT_REQUEST_ID_HEADER: function() {
+        return NEXT_REQUEST_ID_HEADER;
+      },
+      NEXT_REWRITTEN_PATH_HEADER: function() {
+        return NEXT_REWRITTEN_PATH_HEADER;
+      },
+      NEXT_REWRITTEN_QUERY_HEADER: function() {
+        return NEXT_REWRITTEN_QUERY_HEADER;
+      },
+      NEXT_ROUTER_PREFETCH_HEADER: function() {
+        return NEXT_ROUTER_PREFETCH_HEADER;
+      },
+      NEXT_ROUTER_SEGMENT_PREFETCH_HEADER: function() {
+        return NEXT_ROUTER_SEGMENT_PREFETCH_HEADER;
+      },
+      NEXT_ROUTER_STALE_TIME_HEADER: function() {
+        return NEXT_ROUTER_STALE_TIME_HEADER;
+      },
+      NEXT_ROUTER_STATE_TREE_HEADER: function() {
+        return NEXT_ROUTER_STATE_TREE_HEADER;
+      },
+      NEXT_RSC_UNION_QUERY: function() {
+        return NEXT_RSC_UNION_QUERY;
+      },
+      NEXT_URL: function() {
+        return NEXT_URL;
+      },
+      RSC_CONTENT_TYPE_HEADER: function() {
+        return RSC_CONTENT_TYPE_HEADER;
+      },
+      RSC_HEADER: function() {
+        return RSC_HEADER;
+      }
+    });
+    const RSC_HEADER = "rsc";
+    const ACTION_HEADER = "next-action";
+    const NEXT_ROUTER_STATE_TREE_HEADER = "next-router-state-tree";
+    const NEXT_ROUTER_PREFETCH_HEADER = "next-router-prefetch";
+    const NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = "next-router-segment-prefetch";
+    const NEXT_HMR_REFRESH_HEADER = "next-hmr-refresh";
+    const NEXT_HMR_REFRESH_HASH_COOKIE = "__next_hmr_refresh_hash__";
+    const NEXT_URL = "next-url";
+    const RSC_CONTENT_TYPE_HEADER = "text/x-component";
+    const FLIGHT_HEADERS = [
+      RSC_HEADER,
+      NEXT_ROUTER_STATE_TREE_HEADER,
+      NEXT_ROUTER_PREFETCH_HEADER,
+      NEXT_HMR_REFRESH_HEADER,
+      NEXT_ROUTER_SEGMENT_PREFETCH_HEADER
+    ];
+    const NEXT_RSC_UNION_QUERY = "_rsc";
+    const NEXT_ROUTER_STALE_TIME_HEADER = "x-nextjs-stale-time";
+    const NEXT_DID_POSTPONE_HEADER = "x-nextjs-postponed";
+    const NEXT_REWRITTEN_PATH_HEADER = "x-nextjs-rewritten-path";
+    const NEXT_REWRITTEN_QUERY_HEADER = "x-nextjs-rewritten-query";
+    const NEXT_IS_PRERENDER_HEADER = "x-nextjs-prerender";
+    const NEXT_ACTION_NOT_FOUND_HEADER = "x-nextjs-action-not-found";
+    const NEXT_REQUEST_ID_HEADER = "x-nextjs-request-id";
+    const NEXT_HTML_REQUEST_ID_HEADER = "x-nextjs-html-request-id";
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(appRouterHeaders, appRouterHeaders.exports);
+  return appRouterHeaders.exports;
+}
+var hasRequiredWorkUnitAsyncStorage_external;
+function requireWorkUnitAsyncStorage_external() {
+  if (hasRequiredWorkUnitAsyncStorage_external) return workUnitAsyncStorage_external;
+  hasRequiredWorkUnitAsyncStorage_external = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      getCacheSignal: function() {
+        return getCacheSignal;
+      },
+      getDraftModeProviderForCacheScope: function() {
+        return getDraftModeProviderForCacheScope;
+      },
+      getHmrRefreshHash: function() {
+        return getHmrRefreshHash;
+      },
+      getPrerenderResumeDataCache: function() {
+        return getPrerenderResumeDataCache;
+      },
+      getRenderResumeDataCache: function() {
+        return getRenderResumeDataCache;
+      },
+      getRuntimeStagePromise: function() {
+        return getRuntimeStagePromise;
+      },
+      getServerComponentsHmrCache: function() {
+        return getServerComponentsHmrCache;
+      },
+      isHmrRefresh: function() {
+        return isHmrRefresh;
+      },
+      throwForMissingRequestStore: function() {
+        return throwForMissingRequestStore;
+      },
+      throwInvariantForMissingStore: function() {
+        return throwInvariantForMissingStore;
+      },
+      workUnitAsyncStorage: function() {
+        return _workunitasyncstorageinstance.workUnitAsyncStorageInstance;
+      }
+    });
+    const _workunitasyncstorageinstance = requireWorkUnitAsyncStorageInstance();
+    const _approuterheaders = requireAppRouterHeaders();
+    const _invarianterror = requireInvariantError();
+    function throwForMissingRequestStore(callingExpression) {
+      throw Object.defineProperty(new Error(`\`${callingExpression}\` was called outside a request scope. Read more: https://nextjs.org/docs/messages/next-dynamic-api-wrong-context`), "__NEXT_ERROR_CODE", {
+        value: "E251",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function throwInvariantForMissingStore() {
+      throw Object.defineProperty(new _invarianterror.InvariantError("Expected workUnitAsyncStorage to have a store."), "__NEXT_ERROR_CODE", {
+        value: "E696",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    function getPrerenderResumeDataCache(workUnitStore) {
+      switch (workUnitStore.type) {
+        case "prerender":
+        case "prerender-runtime":
+        case "prerender-ppr":
+          return workUnitStore.prerenderResumeDataCache;
+        case "prerender-client":
+          return workUnitStore.prerenderResumeDataCache;
+        case "request": {
+          if (workUnitStore.prerenderResumeDataCache) {
+            return workUnitStore.prerenderResumeDataCache;
+          }
+        }
+        case "prerender-legacy":
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+          return null;
+        default:
+          return workUnitStore;
+      }
+    }
+    function getRenderResumeDataCache(workUnitStore) {
+      switch (workUnitStore.type) {
+        case "request":
+        case "prerender":
+        case "prerender-runtime":
+        case "prerender-client":
+          if (workUnitStore.renderResumeDataCache) {
+            return workUnitStore.renderResumeDataCache;
+          }
+        // fallthrough
+        case "prerender-ppr":
+          return workUnitStore.prerenderResumeDataCache ?? null;
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+        case "prerender-legacy":
+          return null;
+        default:
+          return workUnitStore;
+      }
+    }
+    function getHmrRefreshHash(workStore, workUnitStore) {
+      if (workStore.dev) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "private-cache":
+          case "prerender":
+          case "prerender-runtime":
+            return workUnitStore.hmrRefreshHash;
+          case "request":
+            var _workUnitStore_cookies_get;
+            return (_workUnitStore_cookies_get = workUnitStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _workUnitStore_cookies_get.value;
+        }
+      }
+      return void 0;
+    }
+    function isHmrRefresh(workStore, workUnitStore) {
+      if (workStore.dev) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "private-cache":
+          case "request":
+            return workUnitStore.isHmrRefresh ?? false;
+        }
+      }
+      return false;
+    }
+    function getServerComponentsHmrCache(workStore, workUnitStore) {
+      if (workStore.dev) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "private-cache":
+          case "request":
+            return workUnitStore.serverComponentsHmrCache;
+        }
+      }
+      return void 0;
+    }
+    function getDraftModeProviderForCacheScope(workStore, workUnitStore) {
+      if (workStore.isDraftMode) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "private-cache":
+          case "unstable-cache":
+          case "prerender-runtime":
+          case "request":
+            return workUnitStore.draftMode;
+        }
+      }
+      return void 0;
+    }
+    function getCacheSignal(workUnitStore) {
+      switch (workUnitStore.type) {
+        case "prerender":
+        case "prerender-client":
+        case "prerender-runtime":
+          return workUnitStore.cacheSignal;
+        case "request": {
+          if (workUnitStore.cacheSignal) {
+            return workUnitStore.cacheSignal;
+          }
+        }
+        case "prerender-ppr":
+        case "prerender-legacy":
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+          return null;
+        default:
+          return workUnitStore;
+      }
+    }
+    function getRuntimeStagePromise(workUnitStore) {
+      switch (workUnitStore.type) {
+        case "prerender-runtime":
+        case "private-cache":
+          return workUnitStore.runtimeStagePromise;
+        case "prerender":
+        case "prerender-client":
+        case "prerender-ppr":
+        case "prerender-legacy":
+        case "request":
+        case "cache":
+        case "unstable-cache":
+          return null;
+        default:
+          return workUnitStore;
+      }
+    }
+  })(workUnitAsyncStorage_external);
+  return workUnitAsyncStorage_external;
+}
+var workAsyncStorage_external = {};
+var workAsyncStorageInstance = {};
+var hasRequiredWorkAsyncStorageInstance;
+function requireWorkAsyncStorageInstance() {
+  if (hasRequiredWorkAsyncStorageInstance) return workAsyncStorageInstance;
+  hasRequiredWorkAsyncStorageInstance = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "workAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return workAsyncStorageInstance2;
+      }
+    });
+    const _asynclocalstorage = requireAsyncLocalStorage();
+    const workAsyncStorageInstance2 = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  })(workAsyncStorageInstance);
+  return workAsyncStorageInstance;
+}
+var hasRequiredWorkAsyncStorage_external;
+function requireWorkAsyncStorage_external() {
+  if (hasRequiredWorkAsyncStorage_external) return workAsyncStorage_external;
+  hasRequiredWorkAsyncStorage_external = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "workAsyncStorage", {
+      enumerable: true,
+      get: function() {
+        return _workasyncstorageinstance.workAsyncStorageInstance;
+      }
+    });
+    const _workasyncstorageinstance = requireWorkAsyncStorageInstance();
+  })(workAsyncStorage_external);
+  return workAsyncStorage_external;
+}
+var boundaryConstants = {};
+var hasRequiredBoundaryConstants;
+function requireBoundaryConstants() {
+  if (hasRequiredBoundaryConstants) return boundaryConstants;
+  hasRequiredBoundaryConstants = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      METADATA_BOUNDARY_NAME: function() {
+        return METADATA_BOUNDARY_NAME;
+      },
+      OUTLET_BOUNDARY_NAME: function() {
+        return OUTLET_BOUNDARY_NAME;
+      },
+      ROOT_LAYOUT_BOUNDARY_NAME: function() {
+        return ROOT_LAYOUT_BOUNDARY_NAME;
+      },
+      VIEWPORT_BOUNDARY_NAME: function() {
+        return VIEWPORT_BOUNDARY_NAME;
+      }
+    });
+    const METADATA_BOUNDARY_NAME = "__next_metadata_boundary__";
+    const VIEWPORT_BOUNDARY_NAME = "__next_viewport_boundary__";
+    const OUTLET_BOUNDARY_NAME = "__next_outlet_boundary__";
+    const ROOT_LAYOUT_BOUNDARY_NAME = "__next_root_layout_boundary__";
+  })(boundaryConstants);
+  return boundaryConstants;
+}
+var scheduler = {};
+var hasRequiredScheduler;
+function requireScheduler() {
+  if (hasRequiredScheduler) return scheduler;
+  hasRequiredScheduler = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      atLeastOneTask: function() {
+        return atLeastOneTask;
+      },
+      scheduleImmediate: function() {
+        return scheduleImmediate;
+      },
+      scheduleOnNextTick: function() {
+        return scheduleOnNextTick;
+      },
+      waitAtLeastOneReactRenderTask: function() {
+        return waitAtLeastOneReactRenderTask;
+      }
+    });
+    const scheduleOnNextTick = (cb) => {
+      Promise.resolve().then(() => {
+        if (process.env.NEXT_RUNTIME === "edge") {
+          setTimeout(cb, 0);
+        } else {
+          process.nextTick(cb);
+        }
+      });
+    };
+    const scheduleImmediate = (cb) => {
+      if (process.env.NEXT_RUNTIME === "edge") {
+        setTimeout(cb, 0);
+      } else {
+        setImmediate(cb);
+      }
+    };
+    function atLeastOneTask() {
+      return new Promise((resolve) => scheduleImmediate(resolve));
+    }
+    function waitAtLeastOneReactRenderTask() {
+      if (process.env.NEXT_RUNTIME === "edge") {
+        return new Promise((r) => setTimeout(r, 0));
+      } else {
+        return new Promise((r) => setImmediate(r));
+      }
+    }
+  })(scheduler);
+  return scheduler;
+}
+var stagedRendering = {};
+var promiseWithResolvers = {};
+var hasRequiredPromiseWithResolvers;
+function requirePromiseWithResolvers() {
+  if (hasRequiredPromiseWithResolvers) return promiseWithResolvers;
+  hasRequiredPromiseWithResolvers = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "createPromiseWithResolvers", {
+      enumerable: true,
+      get: function() {
+        return createPromiseWithResolvers;
+      }
+    });
+    function createPromiseWithResolvers() {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      return {
+        resolve,
+        reject,
+        promise
+      };
+    }
+  })(promiseWithResolvers);
+  return promiseWithResolvers;
+}
+var hasRequiredStagedRendering;
+function requireStagedRendering() {
+  if (hasRequiredStagedRendering) return stagedRendering;
+  hasRequiredStagedRendering = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      RenderStage: function() {
+        return RenderStage;
+      },
+      StagedRenderingController: function() {
+        return StagedRenderingController;
+      }
+    });
+    const _invarianterror = requireInvariantError();
+    const _promisewithresolvers = requirePromiseWithResolvers();
+    var RenderStage = /* @__PURE__ */ (function(RenderStage2) {
+      RenderStage2[RenderStage2["Static"] = 1] = "Static";
+      RenderStage2[RenderStage2["Runtime"] = 2] = "Runtime";
+      RenderStage2[RenderStage2["Dynamic"] = 3] = "Dynamic";
+      return RenderStage2;
+    })({});
+    class StagedRenderingController {
+      constructor(abortSignal = null) {
+        this.abortSignal = abortSignal;
+        this.currentStage = 1;
+        this.runtimeStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        this.dynamicStagePromise = (0, _promisewithresolvers.createPromiseWithResolvers)();
+        if (abortSignal) {
+          abortSignal.addEventListener("abort", () => {
+            const { reason } = abortSignal;
+            if (this.currentStage < 2) {
+              this.runtimeStagePromise.promise.catch(ignoreReject);
+              this.runtimeStagePromise.reject(reason);
+            }
+            if (this.currentStage < 3) {
+              this.dynamicStagePromise.promise.catch(ignoreReject);
+              this.dynamicStagePromise.reject(reason);
+            }
+          }, {
+            once: true
+          });
+        }
+      }
+      advanceStage(stage) {
+        if (this.currentStage >= stage) {
+          return;
+        }
+        this.currentStage = stage;
+        if (stage >= 2) {
+          this.runtimeStagePromise.resolve();
+        }
+        if (stage >= 3) {
+          this.dynamicStagePromise.resolve();
+        }
+      }
+      getStagePromise(stage) {
+        switch (stage) {
+          case 2: {
+            return this.runtimeStagePromise.promise;
+          }
+          case 3: {
+            return this.dynamicStagePromise.promise;
+          }
+          default: {
+            throw Object.defineProperty(new _invarianterror.InvariantError(`Invalid render stage: ${stage}`), "__NEXT_ERROR_CODE", {
+              value: "E881",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+      }
+      waitForStage(stage) {
+        return this.getStagePromise(stage);
+      }
+      delayUntilStage(stage, displayName, resolvedValue) {
+        const ioTriggerPromise = this.getStagePromise(stage);
+        const promise = makeDevtoolsIOPromiseFromIOTrigger(ioTriggerPromise, displayName, resolvedValue);
+        if (this.abortSignal) {
+          promise.catch(ignoreReject);
+        }
+        return promise;
+      }
+    }
+    function ignoreReject() {
+    }
+    function makeDevtoolsIOPromiseFromIOTrigger(ioTrigger, displayName, resolvedValue) {
+      const promise = new Promise((resolve, reject) => {
+        ioTrigger.then(resolve.bind(null, resolvedValue), reject);
+      });
+      if (displayName !== void 0) {
+        promise.displayName = displayName;
+      }
+      return promise;
+    }
+  })(stagedRendering);
+  return stagedRendering;
+}
+var hasRequiredDynamicRendering;
+function requireDynamicRendering() {
+  if (hasRequiredDynamicRendering) return dynamicRendering;
+  hasRequiredDynamicRendering = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      Postpone: function() {
+        return Postpone;
+      },
+      PreludeState: function() {
+        return PreludeState;
+      },
+      abortAndThrowOnSynchronousRequestDataAccess: function() {
+        return abortAndThrowOnSynchronousRequestDataAccess;
+      },
+      abortOnSynchronousPlatformIOAccess: function() {
+        return abortOnSynchronousPlatformIOAccess;
+      },
+      accessedDynamicData: function() {
+        return accessedDynamicData;
+      },
+      annotateDynamicAccess: function() {
+        return annotateDynamicAccess;
+      },
+      consumeDynamicAccess: function() {
+        return consumeDynamicAccess;
+      },
+      createDynamicTrackingState: function() {
+        return createDynamicTrackingState;
+      },
+      createDynamicValidationState: function() {
+        return createDynamicValidationState;
+      },
+      createHangingInputAbortSignal: function() {
+        return createHangingInputAbortSignal;
+      },
+      createRenderInBrowserAbortSignal: function() {
+        return createRenderInBrowserAbortSignal;
+      },
+      delayUntilRuntimeStage: function() {
+        return delayUntilRuntimeStage;
+      },
+      formatDynamicAPIAccesses: function() {
+        return formatDynamicAPIAccesses;
+      },
+      getFirstDynamicReason: function() {
+        return getFirstDynamicReason;
+      },
+      isDynamicPostpone: function() {
+        return isDynamicPostpone;
+      },
+      isPrerenderInterruptedError: function() {
+        return isPrerenderInterruptedError;
+      },
+      logDisallowedDynamicError: function() {
+        return logDisallowedDynamicError;
+      },
+      markCurrentScopeAsDynamic: function() {
+        return markCurrentScopeAsDynamic;
+      },
+      postponeWithTracking: function() {
+        return postponeWithTracking;
+      },
+      throwIfDisallowedDynamic: function() {
+        return throwIfDisallowedDynamic;
+      },
+      throwToInterruptStaticGeneration: function() {
+        return throwToInterruptStaticGeneration;
+      },
+      trackAllowedDynamicAccess: function() {
+        return trackAllowedDynamicAccess;
+      },
+      trackDynamicDataInDynamicRender: function() {
+        return trackDynamicDataInDynamicRender;
+      },
+      trackSynchronousPlatformIOAccessInDev: function() {
+        return trackSynchronousPlatformIOAccessInDev;
+      },
+      useDynamicRouteParams: function() {
+        return useDynamicRouteParams;
+      },
+      useDynamicSearchParams: function() {
+        return useDynamicSearchParams;
+      }
+    });
+    const _react = /* @__PURE__ */ _interop_require_default(React);
+    const _hooksservercontext = requireHooksServerContext();
+    const _staticgenerationbailout = requireStaticGenerationBailout();
+    const _workunitasyncstorageexternal = requireWorkUnitAsyncStorage_external();
+    const _workasyncstorageexternal = requireWorkAsyncStorage_external();
+    const _dynamicrenderingutils = requireDynamicRenderingUtils();
+    const _boundaryconstants = requireBoundaryConstants();
+    const _scheduler = requireScheduler();
+    const _bailouttocsr = requireBailoutToCsr();
+    const _invarianterror = requireInvariantError();
+    const _stagedrendering = requireStagedRendering();
+    function _interop_require_default(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+    const hasPostpone = typeof _react.default.unstable_postpone === "function";
+    function createDynamicTrackingState(isDebugDynamicAccesses) {
+      return {
+        isDebugDynamicAccesses,
+        dynamicAccesses: [],
+        syncDynamicErrorWithStack: null
+      };
+    }
+    function createDynamicValidationState() {
+      return {
+        hasSuspenseAboveBody: false,
+        hasDynamicMetadata: false,
+        hasDynamicViewport: false,
+        hasAllowedDynamic: false,
+        dynamicErrors: []
+      };
+    }
+    function getFirstDynamicReason(trackingState) {
+      var _trackingState_dynamicAccesses_;
+      return (_trackingState_dynamicAccesses_ = trackingState.dynamicAccesses[0]) == null ? void 0 : _trackingState_dynamicAccesses_.expression;
+    }
+    function markCurrentScopeAsDynamic(store, workUnitStore, expression) {
+      if (workUnitStore) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "unstable-cache":
+            return;
+          case "private-cache":
+            return;
+        }
+      }
+      if (store.forceDynamic || store.forceStatic) return;
+      if (store.dynamicShouldError) {
+        throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${store.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+          value: "E553",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      if (workUnitStore) {
+        switch (workUnitStore.type) {
+          case "prerender-ppr":
+            return postponeWithTracking(store.route, expression, workUnitStore.dynamicTracking);
+          case "prerender-legacy":
+            workUnitStore.revalidate = 0;
+            const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used ${expression}. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+              value: "E550",
+              enumerable: false,
+              configurable: true
+            });
+            store.dynamicUsageDescription = expression;
+            store.dynamicUsageStack = err.stack;
+            throw err;
+          case "request":
+            if (process.env.NODE_ENV !== "production") {
+              workUnitStore.usedDynamic = true;
+            }
+            break;
+        }
+      }
+    }
+    function throwToInterruptStaticGeneration(expression, store, prerenderStore) {
+      const err = Object.defineProperty(new _hooksservercontext.DynamicServerError(`Route ${store.route} couldn't be rendered statically because it used \`${expression}\`. See more info here: https://nextjs.org/docs/messages/dynamic-server-error`), "__NEXT_ERROR_CODE", {
+        value: "E558",
+        enumerable: false,
+        configurable: true
+      });
+      prerenderStore.revalidate = 0;
+      store.dynamicUsageDescription = expression;
+      store.dynamicUsageStack = err.stack;
+      throw err;
+    }
+    function trackDynamicDataInDynamicRender(workUnitStore) {
+      switch (workUnitStore.type) {
+        case "cache":
+        case "unstable-cache":
+          return;
+        case "private-cache":
+          return;
+        case "prerender":
+        case "prerender-runtime":
+        case "prerender-legacy":
+        case "prerender-ppr":
+        case "prerender-client":
+          break;
+        case "request":
+          if (process.env.NODE_ENV !== "production") {
+            workUnitStore.usedDynamic = true;
+          }
+          break;
+      }
+    }
+    function abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore) {
+      const reason = `Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`;
+      const error = createPrerenderInterruptedError(reason);
+      prerenderStore.controller.abort(error);
+      const dynamicTracking = prerenderStore.dynamicTracking;
+      if (dynamicTracking) {
+        dynamicTracking.dynamicAccesses.push({
+          // When we aren't debugging, we don't need to create another error for the
+          // stack trace.
+          stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : void 0,
+          expression
+        });
+      }
+    }
+    function abortOnSynchronousPlatformIOAccess(route, expression, errorWithStack, prerenderStore) {
+      const dynamicTracking = prerenderStore.dynamicTracking;
+      abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
+      if (dynamicTracking) {
+        if (dynamicTracking.syncDynamicErrorWithStack === null) {
+          dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
+        }
+      }
+    }
+    function trackSynchronousPlatformIOAccessInDev(requestStore) {
+      if (requestStore.stagedRendering) {
+        requestStore.stagedRendering.advanceStage(_stagedrendering.RenderStage.Dynamic);
+      }
+    }
+    function abortAndThrowOnSynchronousRequestDataAccess(route, expression, errorWithStack, prerenderStore) {
+      const prerenderSignal = prerenderStore.controller.signal;
+      if (prerenderSignal.aborted === false) {
+        abortOnSynchronousDynamicDataAccess(route, expression, prerenderStore);
+        const dynamicTracking = prerenderStore.dynamicTracking;
+        if (dynamicTracking) {
+          if (dynamicTracking.syncDynamicErrorWithStack === null) {
+            dynamicTracking.syncDynamicErrorWithStack = errorWithStack;
+          }
+        }
+      }
+      throw createPrerenderInterruptedError(`Route ${route} needs to bail out of prerendering at this point because it used ${expression}.`);
+    }
+    function Postpone({ reason, route }) {
+      const prerenderStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      const dynamicTracking = prerenderStore && prerenderStore.type === "prerender-ppr" ? prerenderStore.dynamicTracking : null;
+      postponeWithTracking(route, reason, dynamicTracking);
+    }
+    function postponeWithTracking(route, expression, dynamicTracking) {
+      assertPostpone();
+      if (dynamicTracking) {
+        dynamicTracking.dynamicAccesses.push({
+          // When we aren't debugging, we don't need to create another error for the
+          // stack trace.
+          stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : void 0,
+          expression
+        });
+      }
+      _react.default.unstable_postpone(createPostponeReason(route, expression));
+    }
+    function createPostponeReason(route, expression) {
+      return `Route ${route} needs to bail out of prerendering at this point because it used ${expression}. React throws this special object to indicate where. It should not be caught by your own try/catch. Learn more: https://nextjs.org/docs/messages/ppr-caught-error`;
+    }
+    function isDynamicPostpone(err) {
+      if (typeof err === "object" && err !== null && typeof err.message === "string") {
+        return isDynamicPostponeReason(err.message);
+      }
+      return false;
+    }
+    function isDynamicPostponeReason(reason) {
+      return reason.includes("needs to bail out of prerendering at this point because it used") && reason.includes("Learn more: https://nextjs.org/docs/messages/ppr-caught-error");
+    }
+    if (isDynamicPostponeReason(createPostponeReason("%%%", "^^^")) === false) {
+      throw Object.defineProperty(new Error("Invariant: isDynamicPostpone misidentified a postpone reason. This is a bug in Next.js"), "__NEXT_ERROR_CODE", {
+        value: "E296",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    const NEXT_PRERENDER_INTERRUPTED = "NEXT_PRERENDER_INTERRUPTED";
+    function createPrerenderInterruptedError(message) {
+      const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+      error.digest = NEXT_PRERENDER_INTERRUPTED;
+      return error;
+    }
+    function isPrerenderInterruptedError(error) {
+      return typeof error === "object" && error !== null && error.digest === NEXT_PRERENDER_INTERRUPTED && "name" in error && "message" in error && error instanceof Error;
+    }
+    function accessedDynamicData(dynamicAccesses) {
+      return dynamicAccesses.length > 0;
+    }
+    function consumeDynamicAccess(serverDynamic, clientDynamic) {
+      serverDynamic.dynamicAccesses.push(...clientDynamic.dynamicAccesses);
+      return serverDynamic.dynamicAccesses;
+    }
+    function formatDynamicAPIAccesses(dynamicAccesses) {
+      return dynamicAccesses.filter((access) => typeof access.stack === "string" && access.stack.length > 0).map(({ expression, stack }) => {
+        stack = stack.split("\n").slice(4).filter((line) => {
+          if (line.includes("node_modules/next/")) {
+            return false;
+          }
+          if (line.includes(" (<anonymous>)")) {
+            return false;
+          }
+          if (line.includes(" (node:")) {
+            return false;
+          }
+          return true;
+        }).join("\n");
+        return `Dynamic API Usage Debug - ${expression}:
+${stack}`;
+      });
+    }
+    function assertPostpone() {
+      if (!hasPostpone) {
+        throw Object.defineProperty(new Error(`Invariant: React.unstable_postpone is not defined. This suggests the wrong version of React was loaded. This is a bug in Next.js`), "__NEXT_ERROR_CODE", {
+          value: "E224",
+          enumerable: false,
+          configurable: true
+        });
+      }
+    }
+    function createRenderInBrowserAbortSignal() {
+      const controller = new AbortController();
+      controller.abort(Object.defineProperty(new _bailouttocsr.BailoutToCSRError("Render in Browser"), "__NEXT_ERROR_CODE", {
+        value: "E721",
+        enumerable: false,
+        configurable: true
+      }));
+      return controller.signal;
+    }
+    function createHangingInputAbortSignal(workUnitStore) {
+      switch (workUnitStore.type) {
+        case "prerender":
+        case "prerender-runtime":
+          const controller = new AbortController();
+          if (workUnitStore.cacheSignal) {
+            workUnitStore.cacheSignal.inputReady().then(() => {
+              controller.abort();
+            });
+          } else {
+            const runtimeStagePromise = (0, _workunitasyncstorageexternal.getRuntimeStagePromise)(workUnitStore);
+            if (runtimeStagePromise) {
+              runtimeStagePromise.then(() => (0, _scheduler.scheduleOnNextTick)(() => controller.abort()));
+            } else {
+              (0, _scheduler.scheduleOnNextTick)(() => controller.abort());
+            }
+          }
+          return controller.signal;
+        case "prerender-client":
+        case "prerender-ppr":
+        case "prerender-legacy":
+        case "request":
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+          return void 0;
+      }
+    }
+    function annotateDynamicAccess(expression, prerenderStore) {
+      const dynamicTracking = prerenderStore.dynamicTracking;
+      if (dynamicTracking) {
+        dynamicTracking.dynamicAccesses.push({
+          stack: dynamicTracking.isDebugDynamicAccesses ? new Error().stack : void 0,
+          expression
+        });
+      }
+    }
+    function useDynamicRouteParams(expression) {
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (workStore && workUnitStore) {
+        switch (workUnitStore.type) {
+          case "prerender-client":
+          case "prerender": {
+            const fallbackParams = workUnitStore.fallbackRouteParams;
+            if (fallbackParams && fallbackParams.size > 0) {
+              _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
+            }
+            break;
+          }
+          case "prerender-ppr": {
+            const fallbackParams = workUnitStore.fallbackRouteParams;
+            if (fallbackParams && fallbackParams.size > 0) {
+              return postponeWithTracking(workStore.route, expression, workUnitStore.dynamicTracking);
+            }
+            break;
+          }
+          case "prerender-runtime":
+            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called during a runtime prerender. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+              value: "E771",
+              enumerable: false,
+              configurable: true
+            });
+          case "cache":
+          case "private-cache":
+            throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called inside a cache scope. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+              value: "E745",
+              enumerable: false,
+              configurable: true
+            });
+        }
+      }
+    }
+    function useDynamicSearchParams(expression) {
+      const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+      const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+      if (!workStore) {
+        return;
+      }
+      if (!workUnitStore) {
+        (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(expression);
+      }
+      switch (workUnitStore.type) {
+        case "prerender-client": {
+          _react.default.use((0, _dynamicrenderingutils.makeHangingPromise)(workUnitStore.renderSignal, workStore.route, expression));
+          break;
+        }
+        case "prerender-legacy":
+        case "prerender-ppr": {
+          if (workStore.forceStatic) {
+            return;
+          }
+          throw Object.defineProperty(new _bailouttocsr.BailoutToCSRError(expression), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        case "prerender":
+        case "prerender-runtime":
+          throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called from a Server Component. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+            value: "E795",
+            enumerable: false,
+            configurable: true
+          });
+        case "cache":
+        case "unstable-cache":
+        case "private-cache":
+          throw Object.defineProperty(new _invarianterror.InvariantError(`\`${expression}\` was called inside a cache scope. Next.js should be preventing ${expression} from being included in server components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+            value: "E745",
+            enumerable: false,
+            configurable: true
+          });
+        case "request":
+          return;
+      }
+    }
+    const hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
+    const bodyAndImplicitTags = "body|div|main|section|article|aside|header|footer|nav|form|p|span|h1|h2|h3|h4|h5|h6";
+    const hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp(`\\n\\s+at Suspense \\(<anonymous>\\)(?:(?!\\n\\s+at (?:${bodyAndImplicitTags}) \\(<anonymous>\\))[\\s\\S])*?\\n\\s+at ${_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME} \\([^\\n]*\\)`);
+    const hasMetadataRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
+    const hasViewportRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
+    const hasOutletRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.OUTLET_BOUNDARY_NAME}[\\n\\s]`);
+    function trackAllowedDynamicAccess(workStore, componentStack, dynamicValidation, clientDynamic) {
+      if (hasOutletRegex.test(componentStack)) {
+        return;
+      } else if (hasMetadataRegex.test(componentStack)) {
+        dynamicValidation.hasDynamicMetadata = true;
+        return;
+      } else if (hasViewportRegex.test(componentStack)) {
+        dynamicValidation.hasDynamicViewport = true;
+        return;
+      } else if (hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex.test(componentStack)) {
+        dynamicValidation.hasAllowedDynamic = true;
+        dynamicValidation.hasSuspenseAboveBody = true;
+        return;
+      } else if (hasSuspenseRegex.test(componentStack)) {
+        dynamicValidation.hasAllowedDynamic = true;
+        return;
+      } else if (clientDynamic.syncDynamicErrorWithStack) {
+        dynamicValidation.dynamicErrors.push(clientDynamic.syncDynamicErrorWithStack);
+        return;
+      } else {
+        const message = `Route "${workStore.route}": Uncached data was accessed outside of <Suspense>. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/blocking-route`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicErrors.push(error);
+        return;
+      }
+    }
+    function createErrorWithComponentOrOwnerStack(message, componentStack) {
+      const ownerStack = process.env.NODE_ENV !== "production" && _react.default.captureOwnerStack ? _react.default.captureOwnerStack() : null;
+      const error = Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+        value: "E394",
+        enumerable: false,
+        configurable: true
+      });
+      error.stack = error.name + ": " + message + (ownerStack ?? componentStack);
+      return error;
+    }
+    var PreludeState = /* @__PURE__ */ (function(PreludeState2) {
+      PreludeState2[PreludeState2["Full"] = 0] = "Full";
+      PreludeState2[PreludeState2["Empty"] = 1] = "Empty";
+      PreludeState2[PreludeState2["Errored"] = 2] = "Errored";
+      return PreludeState2;
+    })({});
+    function logDisallowedDynamicError(workStore, error) {
+      console.error(error);
+      if (!workStore.dev) {
+        if (workStore.hasReadableErrorStacks) {
+          console.error(`To get a more detailed stack trace and pinpoint the issue, start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.`);
+        } else {
+          console.error(`To get a more detailed stack trace and pinpoint the issue, try one of the following:
+  - Start the app in development mode by running \`next dev\`, then open "${workStore.route}" in your browser to investigate the error.
+  - Rerun the production build with \`next build --debug-prerender\` to generate better stack traces.`);
+        }
+      }
+    }
+    function throwIfDisallowedDynamic(workStore, prelude, dynamicValidation, serverDynamic) {
+      if (serverDynamic.syncDynamicErrorWithStack) {
+        logDisallowedDynamicError(workStore, serverDynamic.syncDynamicErrorWithStack);
+        throw new _staticgenerationbailout.StaticGenBailoutError();
+      }
+      if (prelude !== 0) {
+        if (dynamicValidation.hasSuspenseAboveBody) {
+          return;
+        }
+        const dynamicErrors = dynamicValidation.dynamicErrors;
+        if (dynamicErrors.length > 0) {
+          for (let i = 0; i < dynamicErrors.length; i++) {
+            logDisallowedDynamicError(workStore, dynamicErrors[i]);
+          }
+          throw new _staticgenerationbailout.StaticGenBailoutError();
+        }
+        if (dynamicValidation.hasDynamicViewport) {
+          console.error(`Route "${workStore.route}" has a \`generateViewport\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) without explicitly allowing fully dynamic rendering. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`);
+          throw new _staticgenerationbailout.StaticGenBailoutError();
+        }
+        if (prelude === 1) {
+          console.error(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason. This is a bug in Next.js.`);
+          throw new _staticgenerationbailout.StaticGenBailoutError();
+        }
+      } else {
+        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.hasDynamicMetadata) {
+          console.error(`Route "${workStore.route}" has a \`generateMetadata\` that depends on Request data (\`cookies()\`, etc...) or uncached external data (\`fetch(...)\`, etc...) when the rest of the route does not. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`);
+          throw new _staticgenerationbailout.StaticGenBailoutError();
+        }
+      }
+    }
+    function delayUntilRuntimeStage(prerenderStore, result) {
+      if (prerenderStore.runtimeStagePromise) {
+        return prerenderStore.runtimeStagePromise.then(() => result);
+      }
+      return result;
+    }
+  })(dynamicRendering);
+  return dynamicRendering;
+}
+var hasRequiredUnstableRethrow_server;
+function requireUnstableRethrow_server() {
+  if (hasRequiredUnstableRethrow_server) return unstableRethrow_server.exports;
+  hasRequiredUnstableRethrow_server = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "unstable_rethrow", {
+      enumerable: true,
+      get: function() {
+        return unstable_rethrow;
+      }
+    });
+    const _dynamicrenderingutils = requireDynamicRenderingUtils();
+    const _ispostpone = requireIsPostpone();
+    const _bailouttocsr = requireBailoutToCsr();
+    const _isnextroutererror = requireIsNextRouterError();
+    const _dynamicrendering = requireDynamicRendering();
+    const _hooksservercontext = requireHooksServerContext();
+    function unstable_rethrow(error) {
+      if ((0, _isnextroutererror.isNextRouterError)(error) || (0, _bailouttocsr.isBailoutToCSRError)(error) || (0, _hooksservercontext.isDynamicServerError)(error) || (0, _dynamicrendering.isDynamicPostpone)(error) || (0, _ispostpone.isPostpone)(error) || (0, _dynamicrenderingutils.isHangingPromiseRejectionError)(error) || (0, _dynamicrendering.isPrerenderInterruptedError)(error)) {
+        throw error;
+      }
+      if (error instanceof Error && "cause" in error) {
+        unstable_rethrow(error.cause);
+      }
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(unstableRethrow_server, unstableRethrow_server.exports);
+  return unstableRethrow_server.exports;
+}
+var unstableRethrow_browser = { exports: {} };
+var hasRequiredUnstableRethrow_browser;
+function requireUnstableRethrow_browser() {
+  if (hasRequiredUnstableRethrow_browser) return unstableRethrow_browser.exports;
+  hasRequiredUnstableRethrow_browser = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "unstable_rethrow", {
+      enumerable: true,
+      get: function() {
+        return unstable_rethrow;
+      }
+    });
+    const _bailouttocsr = requireBailoutToCsr();
+    const _isnextroutererror = requireIsNextRouterError();
+    function unstable_rethrow(error) {
+      if ((0, _isnextroutererror.isNextRouterError)(error) || (0, _bailouttocsr.isBailoutToCSRError)(error)) {
+        throw error;
+      }
+      if (error instanceof Error && "cause" in error) {
+        unstable_rethrow(error.cause);
+      }
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(unstableRethrow_browser, unstableRethrow_browser.exports);
+  return unstableRethrow_browser.exports;
+}
+var hasRequiredUnstableRethrow;
+function requireUnstableRethrow() {
+  if (hasRequiredUnstableRethrow) return unstableRethrow.exports;
+  hasRequiredUnstableRethrow = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "unstable_rethrow", {
+      enumerable: true,
+      get: function() {
+        return unstable_rethrow;
+      }
+    });
+    const unstable_rethrow = typeof window === "undefined" ? requireUnstableRethrow_server().unstable_rethrow : requireUnstableRethrow_browser().unstable_rethrow;
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(unstableRethrow, unstableRethrow.exports);
+  return unstableRethrow.exports;
+}
+var hasRequiredNavigation_reactServer;
+function requireNavigation_reactServer() {
+  if (hasRequiredNavigation_reactServer) return navigation_reactServer.exports;
+  hasRequiredNavigation_reactServer = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      ReadonlyURLSearchParams: function() {
+        return _readonlyurlsearchparams.ReadonlyURLSearchParams;
+      },
+      RedirectType: function() {
+        return _redirecterror.RedirectType;
+      },
+      forbidden: function() {
+        return _forbidden.forbidden;
+      },
+      notFound: function() {
+        return _notfound.notFound;
+      },
+      permanentRedirect: function() {
+        return _redirect.permanentRedirect;
+      },
+      redirect: function() {
+        return _redirect.redirect;
+      },
+      unauthorized: function() {
+        return _unauthorized.unauthorized;
+      },
+      unstable_isUnrecognizedActionError: function() {
+        return unstable_isUnrecognizedActionError;
+      },
+      unstable_rethrow: function() {
+        return _unstablerethrow.unstable_rethrow;
+      }
+    });
+    const _readonlyurlsearchparams = requireReadonlyUrlSearchParams();
+    const _redirect = requireRedirect();
+    const _redirecterror = requireRedirectError();
+    const _notfound = requireNotFound();
+    const _forbidden = requireForbidden();
+    const _unauthorized = requireUnauthorized();
+    const _unstablerethrow = requireUnstableRethrow();
+    function unstable_isUnrecognizedActionError() {
+      throw Object.defineProperty(new Error("`unstable_isUnrecognizedActionError` can only be used on the client."), "__NEXT_ERROR_CODE", {
+        value: "E776",
+        enumerable: false,
+        configurable: true
+      });
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(navigation_reactServer, navigation_reactServer.exports);
+  return navigation_reactServer.exports;
+}
+var hasRequiredNavigation$1;
+function requireNavigation$1() {
+  if (hasRequiredNavigation$1) return navigation$1.exports;
+  hasRequiredNavigation$1 = 1;
+  (function(module, exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports$1, {
+      ReadonlyURLSearchParams: function() {
+        return _navigationreactserver.ReadonlyURLSearchParams;
+      },
+      RedirectType: function() {
+        return _navigationreactserver.RedirectType;
+      },
+      ServerInsertedHTMLContext: function() {
+        return _serverinsertedhtmlsharedruntime.ServerInsertedHTMLContext;
+      },
+      forbidden: function() {
+        return _navigationreactserver.forbidden;
+      },
+      notFound: function() {
+        return _navigationreactserver.notFound;
+      },
+      permanentRedirect: function() {
+        return _navigationreactserver.permanentRedirect;
+      },
+      redirect: function() {
+        return _navigationreactserver.redirect;
+      },
+      unauthorized: function() {
+        return _navigationreactserver.unauthorized;
+      },
+      unstable_isUnrecognizedActionError: function() {
+        return _unrecognizedactionerror.unstable_isUnrecognizedActionError;
+      },
+      unstable_rethrow: function() {
+        return _navigationreactserver.unstable_rethrow;
+      },
+      useParams: function() {
+        return useParams;
+      },
+      usePathname: function() {
+        return usePathname;
+      },
+      useRouter: function() {
+        return useRouter;
+      },
+      useSearchParams: function() {
+        return useSearchParams;
+      },
+      useSelectedLayoutSegment: function() {
+        return useSelectedLayoutSegment;
+      },
+      useSelectedLayoutSegments: function() {
+        return useSelectedLayoutSegments;
+      },
+      useServerInsertedHTML: function() {
+        return _serverinsertedhtmlsharedruntime.useServerInsertedHTML;
+      }
+    });
+    const _interop_require_wildcard = /* @__PURE__ */ require_interop_require_wildcard();
+    const _react = /* @__PURE__ */ _interop_require_wildcard._(React);
+    const _approutercontextsharedruntime = requireAppRouterContext_sharedRuntime();
+    const _hooksclientcontextsharedruntime = requireHooksClientContext_sharedRuntime();
+    const _segment = requireSegment();
+    const _readonlyurlsearchparams = requireReadonlyUrlSearchParams();
+    const _serverinsertedhtmlsharedruntime = requireServerInsertedHtml_sharedRuntime();
+    const _unrecognizedactionerror = requireUnrecognizedActionError();
+    const _navigationreactserver = requireNavigation_reactServer();
+    const useDynamicRouteParams = typeof window === "undefined" ? requireDynamicRendering().useDynamicRouteParams : void 0;
+    const useDynamicSearchParams = typeof window === "undefined" ? requireDynamicRendering().useDynamicSearchParams : void 0;
+    function useSearchParams() {
+      useDynamicSearchParams == null ? void 0 : useDynamicSearchParams("useSearchParams()");
+      const searchParams = (0, _react.useContext)(_hooksclientcontextsharedruntime.SearchParamsContext);
+      const readonlySearchParams = (0, _react.useMemo)(() => {
+        if (!searchParams) {
+          return null;
+        }
+        return new _readonlyurlsearchparams.ReadonlyURLSearchParams(searchParams);
+      }, [
+        searchParams
+      ]);
+      if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
+        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+        if (navigationPromises) {
+          return (0, _react.use)(navigationPromises.searchParams);
+        }
+      }
+      return readonlySearchParams;
+    }
+    function usePathname() {
+      useDynamicRouteParams == null ? void 0 : useDynamicRouteParams("usePathname()");
+      const pathname = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
+      if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
+        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+        if (navigationPromises) {
+          return (0, _react.use)(navigationPromises.pathname);
+        }
+      }
+      return pathname;
+    }
+    function useRouter() {
+      const router = (0, _react.useContext)(_approutercontextsharedruntime.AppRouterContext);
+      if (router === null) {
+        throw Object.defineProperty(new Error("invariant expected app router to be mounted"), "__NEXT_ERROR_CODE", {
+          value: "E238",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      return router;
+    }
+    function useParams() {
+      useDynamicRouteParams == null ? void 0 : useDynamicRouteParams("useParams()");
+      const params = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathParamsContext);
+      if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
+        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+        if (navigationPromises) {
+          return (0, _react.use)(navigationPromises.params);
+        }
+      }
+      return params;
+    }
+    function useSelectedLayoutSegments(parallelRouteKey = "children") {
+      var _a;
+      useDynamicRouteParams == null ? void 0 : useDynamicRouteParams("useSelectedLayoutSegments()");
+      const context = (0, _react.useContext)(_approutercontextsharedruntime.LayoutRouterContext);
+      if (!context) return null;
+      if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
+        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+        if (navigationPromises) {
+          const promise = (_a = navigationPromises.selectedLayoutSegmentsPromises) == null ? void 0 : _a.get(parallelRouteKey);
+          if (promise) {
+            return (0, _react.use)(promise);
+          }
+        }
+      }
+      return (0, _segment.getSelectedLayoutSegmentPath)(context.parentTree, parallelRouteKey);
+    }
+    function useSelectedLayoutSegment(parallelRouteKey = "children") {
+      var _a;
+      useDynamicRouteParams == null ? void 0 : useDynamicRouteParams("useSelectedLayoutSegment()");
+      const navigationPromises = (0, _react.useContext)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+      const selectedLayoutSegments = useSelectedLayoutSegments(parallelRouteKey);
+      if (process.env.NODE_ENV !== "production" && navigationPromises && "use" in _react.default) {
+        const promise = (_a = navigationPromises.selectedLayoutSegmentPromises) == null ? void 0 : _a.get(parallelRouteKey);
+        if (promise) {
+          return (0, _react.use)(promise);
+        }
+      }
+      return (0, _segment.computeSelectedLayoutSegment)(selectedLayoutSegments, parallelRouteKey);
+    }
+    if ((typeof exports$1.default === "function" || typeof exports$1.default === "object" && exports$1.default !== null) && typeof exports$1.default.__esModule === "undefined") {
+      Object.defineProperty(exports$1.default, "__esModule", { value: true });
+      Object.assign(exports$1.default, exports$1);
+      module.exports = exports$1.default;
+    }
+  })(navigation$1, navigation$1.exports);
+  return navigation$1.exports;
+}
+var navigation;
+var hasRequiredNavigation;
+function requireNavigation() {
+  if (hasRequiredNavigation) return navigation;
+  hasRequiredNavigation = 1;
+  navigation = requireNavigation$1();
+  return navigation;
+}
+var navigationExports = requireNavigation();
+export {
+  navigationExports as n
+};
+//# sourceMappingURL=navigation-DxXFNXZM.js.map