@khraben/flowui 1.0.1 → 1.0.2

package/{dist/index.mjs → index.mjs}

@@ -7,10 +7,14 @@ import { enUS } from 'date-fns/locale';
 import 'react-datepicker/dist/react-datepicker.css';
 import { motion } from 'framer-motion';
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -26,6 +30,12 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -36,8 +46,2474 @@ var __objRest = (source, exclude) => {
       if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
         target[prop] = source[prop];
     }
-  return target;
-};
+  return target;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs
+var require_interop_require_wildcard = __commonJS({
+  "node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs"(exports$1) {
+    function _getRequireWildcardCache(nodeInterop) {
+      if (typeof WeakMap !== "function") return null;
+      var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+      var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(nodeInterop2) {
+        return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+      })(nodeInterop);
+    }
+    function _interop_require_wildcard(obj, nodeInterop) {
+      if (!nodeInterop && obj && obj.__esModule) return obj;
+      if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { default: obj };
+      var cache = _getRequireWildcardCache(nodeInterop);
+      if (cache && cache.has(obj)) return cache.get(obj);
+      var newObj = { __proto__: null };
+      var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var key in obj) {
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+          var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+          if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+          else newObj[key] = obj[key];
+        }
+      }
+      newObj.default = obj;
+      if (cache) cache.set(obj, newObj);
+      return newObj;
+    }
+    exports$1._ = _interop_require_wildcard;
+  }
+});
+
+// node_modules/@swc/helpers/cjs/_interop_require_default.cjs
+var require_interop_require_default = __commonJS({
+  "node_modules/@swc/helpers/cjs/_interop_require_default.cjs"(exports$1) {
+    function _interop_require_default(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    exports$1._ = _interop_require_default;
+  }
+});
+
+// node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js
+var require_app_router_context_shared_runtime = __commonJS({
+  "node_modules/next/dist/shared/lib/app-router-context.shared-runtime.js"(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;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _react = /* @__PURE__ */ _interop_require_default._(__require("react"));
+    var AppRouterContext = _react.default.createContext(null);
+    var LayoutRouterContext = _react.default.createContext(null);
+    var GlobalLayoutRouterContext = _react.default.createContext(null);
+    var TemplateContext = _react.default.createContext(null);
+    if (process.env.NODE_ENV !== "production") {
+      AppRouterContext.displayName = "AppRouterContext";
+      LayoutRouterContext.displayName = "LayoutRouterContext";
+      GlobalLayoutRouterContext.displayName = "GlobalLayoutRouterContext";
+      TemplateContext.displayName = "TemplateContext";
+    }
+    var MissingSlotContext = _react.default.createContext(/* @__PURE__ */ new Set());
+  }
+});
+
+// node_modules/next/dist/client/components/readonly-url-search-params.js
+var require_readonly_url_search_params = __commonJS({
+  "node_modules/next/dist/client/components/readonly-url-search-params.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "ReadonlyURLSearchParams", {
+      enumerable: true,
+      get: function() {
+        return ReadonlyURLSearchParams;
+      }
+    });
+    var ReadonlyURLSearchParamsError = class extends Error {
+      constructor() {
+        super("Method unavailable on `ReadonlyURLSearchParams`. Read more: https://nextjs.org/docs/app/api-reference/functions/use-search-params#updating-searchparams");
+      }
+    };
+    var ReadonlyURLSearchParams = class 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;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js
+var require_hooks_client_context_shared_runtime = __commonJS({
+  "node_modules/next/dist/shared/lib/hooks-client-context.shared-runtime.js"(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;
+      },
+      ReadonlyURLSearchParams: function() {
+        return _readonlyurlsearchparams.ReadonlyURLSearchParams;
+      },
+      SearchParamsContext: function() {
+        return SearchParamsContext;
+      },
+      createDevToolsInstrumentedPromise: function() {
+        return createDevToolsInstrumentedPromise;
+      }
+    });
+    var _react = __require("react");
+    var _readonlyurlsearchparams = require_readonly_url_search_params();
+    var SearchParamsContext = (0, _react.createContext)(null);
+    var PathnameContext = (0, _react.createContext)(null);
+    var PathParamsContext = (0, _react.createContext)(null);
+    var 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";
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/segment.js
+var require_segment = __commonJS({
+  "node_modules/next/dist/shared/lib/segment.js"(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, {
+      DEFAULT_SEGMENT_KEY: function() {
+        return DEFAULT_SEGMENT_KEY;
+      },
+      NOT_FOUND_SEGMENT_KEY: function() {
+        return NOT_FOUND_SEGMENT_KEY;
+      },
+      PAGE_SEGMENT_KEY: function() {
+        return PAGE_SEGMENT_KEY;
+      },
+      addSearchParamsIfPageSegment: function() {
+        return addSearchParamsIfPageSegment;
+      },
+      computeSelectedLayoutSegment: function() {
+        return computeSelectedLayoutSegment;
+      },
+      getSegmentValue: function() {
+        return getSegmentValue;
+      },
+      getSelectedLayoutSegmentPath: function() {
+        return getSelectedLayoutSegmentPath;
+      },
+      isGroupSegment: function() {
+        return isGroupSegment;
+      },
+      isParallelRouteSegment: function() {
+        return isParallelRouteSegment;
+      }
+    });
+    function getSegmentValue(segment) {
+      return Array.isArray(segment) ? segment[1] : segment;
+    }
+    function isGroupSegment(segment) {
+      return segment[0] === "(" && segment.endsWith(")");
+    }
+    function isParallelRouteSegment(segment) {
+      return segment.startsWith("@") && segment !== "@children";
+    }
+    function addSearchParamsIfPageSegment(segment, searchParams) {
+      const isPageSegment = segment.includes(PAGE_SEGMENT_KEY);
+      if (isPageSegment) {
+        const stringifiedQuery = JSON.stringify(searchParams);
+        return stringifiedQuery !== "{}" ? PAGE_SEGMENT_KEY + "?" + stringifiedQuery : PAGE_SEGMENT_KEY;
+      }
+      return segment;
+    }
+    function computeSelectedLayoutSegment(segments, parallelRouteKey) {
+      if (!segments || segments.length === 0) {
+        return null;
+      }
+      const rawSegment = parallelRouteKey === "children" ? segments[0] : segments[segments.length - 1];
+      return rawSegment === DEFAULT_SEGMENT_KEY ? null : rawSegment;
+    }
+    function getSelectedLayoutSegmentPath(tree, parallelRouteKey, first = true, segmentPath = []) {
+      var _a;
+      let node;
+      if (first) {
+        node = tree[1][parallelRouteKey];
+      } else {
+        const parallelRoutes = tree[1];
+        node = (_a = parallelRoutes.children) != null ? _a : Object.values(parallelRoutes)[0];
+      }
+      if (!node) return segmentPath;
+      const segment = node[0];
+      let segmentValue = getSegmentValue(segment);
+      if (!segmentValue || segmentValue.startsWith(PAGE_SEGMENT_KEY)) {
+        return segmentPath;
+      }
+      segmentPath.push(segmentValue);
+      return getSelectedLayoutSegmentPath(node, parallelRouteKey, false, segmentPath);
+    }
+    var PAGE_SEGMENT_KEY = "__PAGE__";
+    var DEFAULT_SEGMENT_KEY = "__DEFAULT__";
+    var NOT_FOUND_SEGMENT_KEY = "/_not-found";
+  }
+});
+
+// node_modules/next/dist/shared/lib/server-inserted-html.shared-runtime.js
+var require_server_inserted_html_shared_runtime = __commonJS({
+  "node_modules/next/dist/shared/lib/server-inserted-html.shared-runtime.js"(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;
+      }
+    });
+    var _interop_require_wildcard = require_interop_require_wildcard();
+    var _react = /* @__PURE__ */ _interop_require_wildcard._(__require("react"));
+    var ServerInsertedHTMLContext = /* @__PURE__ */ _react.default.createContext(null);
+    function useServerInsertedHTML(callback) {
+      const addInsertedServerHTMLCallback = (0, _react.useContext)(ServerInsertedHTMLContext);
+      if (addInsertedServerHTMLCallback) {
+        addInsertedServerHTMLCallback(callback);
+      }
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/unrecognized-action-error.js
+var require_unrecognized_action_error = __commonJS({
+  "node_modules/next/dist/client/components/unrecognized-action-error.js"(exports$1, module) {
+    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;
+      }
+    });
+    var UnrecognizedActionError = class 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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/redirect-status-code.js
+var require_redirect_status_code = __commonJS({
+  "node_modules/next/dist/client/components/redirect-status-code.js"(exports$1, module) {
+    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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/redirect-error.js
+var require_redirect_error = __commonJS({
+  "node_modules/next/dist/client/components/redirect-error.js"(exports$1, module) {
+    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;
+      }
+    });
+    var _redirectstatuscode = require_redirect_status_code();
+    var 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;
+    }
+  }
+});
+
+// node_modules/next/dist/server/app-render/async-local-storage.js
+var require_async_local_storage = __commonJS({
+  "node_modules/next/dist/server/app-render/async-local-storage.js"(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;
+      }
+    });
+    var sharedAsyncLocalStorageNotAvailableError = Object.defineProperty(new Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available"), "__NEXT_ERROR_CODE", {
+      value: "E504",
+      enumerable: false,
+      configurable: true
+    });
+    var FakeAsyncLocalStorage = class {
+      disable() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      getStore() {
+        return void 0;
+      }
+      run() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      exit() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      enterWith() {
+        throw sharedAsyncLocalStorageNotAvailableError;
+      }
+      static bind(fn) {
+        return fn;
+      }
+    };
+    var 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);
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/server/app-render/action-async-storage-instance.js
+var require_action_async_storage_instance = __commonJS({
+  "node_modules/next/dist/server/app-render/action-async-storage-instance.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "actionAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return actionAsyncStorageInstance;
+      }
+    });
+    var _asynclocalstorage = require_async_local_storage();
+    var actionAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  }
+});
+
+// node_modules/next/dist/server/app-render/action-async-storage.external.js
+var require_action_async_storage_external = __commonJS({
+  "node_modules/next/dist/server/app-render/action-async-storage.external.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "actionAsyncStorage", {
+      enumerable: true,
+      get: function() {
+        return _actionasyncstorageinstance.actionAsyncStorageInstance;
+      }
+    });
+    var _actionasyncstorageinstance = require_action_async_storage_instance();
+  }
+});
+
+// node_modules/next/dist/client/components/redirect.js
+var require_redirect = __commonJS({
+  "node_modules/next/dist/client/components/redirect.js"(exports$1, module) {
+    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 redirect;
+      }
+    });
+    var _redirectstatuscode = require_redirect_status_code();
+    var _redirecterror = require_redirect_error();
+    var actionAsyncStorage = typeof window === "undefined" ? require_action_async_storage_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 redirect(url, type) {
+      var _a;
+      type != null ? 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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/http-access-fallback/http-access-fallback.js
+var require_http_access_fallback = __commonJS({
+  "node_modules/next/dist/client/components/http-access-fallback/http-access-fallback.js"(exports$1, module) {
+    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;
+      }
+    });
+    var HTTPAccessErrorStatus = {
+      NOT_FOUND: 404,
+      FORBIDDEN: 403,
+      UNAUTHORIZED: 401
+    };
+    var ALLOWED_CODES = new Set(Object.values(HTTPAccessErrorStatus));
+    var 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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/not-found.js
+var require_not_found = __commonJS({
+  "node_modules/next/dist/client/components/not-found.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "notFound", {
+      enumerable: true,
+      get: function() {
+        return notFound;
+      }
+    });
+    var _httpaccessfallback = require_http_access_fallback();
+    var DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};404`;
+    function notFound() {
+      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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/forbidden.js
+var require_forbidden = __commonJS({
+  "node_modules/next/dist/client/components/forbidden.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "forbidden", {
+      enumerable: true,
+      get: function() {
+        return forbidden;
+      }
+    });
+    var _httpaccessfallback = require_http_access_fallback();
+    var DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};403`;
+    function forbidden() {
+      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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/unauthorized.js
+var require_unauthorized = __commonJS({
+  "node_modules/next/dist/client/components/unauthorized.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "unauthorized", {
+      enumerable: true,
+      get: function() {
+        return unauthorized;
+      }
+    });
+    var _httpaccessfallback = require_http_access_fallback();
+    var DIGEST = `${_httpaccessfallback.HTTP_ERROR_FALLBACK_ERROR_CODE};401`;
+    function unauthorized() {
+      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;
+    }
+  }
+});
+
+// node_modules/next/dist/server/dynamic-rendering-utils.js
+var require_dynamic_rendering_utils = __commonJS({
+  "node_modules/next/dist/server/dynamic-rendering-utils.js"(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;
+    }
+    var HANGING_PROMISE_REJECTION = "HANGING_PROMISE_REJECTION";
+    var HangingPromiseRejectionError = class 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;
+      }
+    };
+    var 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);
+      });
+    }
+  }
+});
+
+// node_modules/next/dist/server/lib/router-utils/is-postpone.js
+var require_is_postpone = __commonJS({
+  "node_modules/next/dist/server/lib/router-utils/is-postpone.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "isPostpone", {
+      enumerable: true,
+      get: function() {
+        return isPostpone;
+      }
+    });
+    var REACT_POSTPONE_TYPE = /* @__PURE__ */ Symbol.for("react.postpone");
+    function isPostpone(error) {
+      return typeof error === "object" && error !== null && error.$$typeof === REACT_POSTPONE_TYPE;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/lazy-dynamic/bailout-to-csr.js
+var require_bailout_to_csr = __commonJS({
+  "node_modules/next/dist/shared/lib/lazy-dynamic/bailout-to-csr.js"(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;
+      }
+    });
+    var BAILOUT_TO_CSR = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+    var BailoutToCSRError = class 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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/is-next-router-error.js
+var require_is_next_router_error = __commonJS({
+  "node_modules/next/dist/client/components/is-next-router-error.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "isNextRouterError", {
+      enumerable: true,
+      get: function() {
+        return isNextRouterError;
+      }
+    });
+    var _httpaccessfallback = require_http_access_fallback();
+    var _redirecterror = require_redirect_error();
+    function isNextRouterError(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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/hooks-server-context.js
+var require_hooks_server_context = __commonJS({
+  "node_modules/next/dist/client/components/hooks-server-context.js"(exports$1, module) {
+    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;
+      }
+    });
+    var DYNAMIC_ERROR_CODE = "DYNAMIC_SERVER_USAGE";
+    var DynamicServerError = class 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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/static-generation-bailout.js
+var require_static_generation_bailout = __commonJS({
+  "node_modules/next/dist/client/components/static-generation-bailout.js"(exports$1, module) {
+    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;
+      }
+    });
+    var NEXT_STATIC_GEN_BAILOUT = "NEXT_STATIC_GEN_BAILOUT";
+    var StaticGenBailoutError = class 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;
+    }
+  }
+});
+
+// node_modules/next/dist/server/app-render/work-unit-async-storage-instance.js
+var require_work_unit_async_storage_instance = __commonJS({
+  "node_modules/next/dist/server/app-render/work-unit-async-storage-instance.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "workUnitAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return workUnitAsyncStorageInstance;
+      }
+    });
+    var _asynclocalstorage = require_async_local_storage();
+    var workUnitAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  }
+});
+
+// node_modules/next/dist/client/components/app-router-headers.js
+var require_app_router_headers = __commonJS({
+  "node_modules/next/dist/client/components/app-router-headers.js"(exports$1, module) {
+    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_ACTION_REVALIDATED_HEADER: function() {
+        return NEXT_ACTION_REVALIDATED_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;
+      }
+    });
+    var RSC_HEADER = "rsc";
+    var ACTION_HEADER = "next-action";
+    var NEXT_ROUTER_STATE_TREE_HEADER = "next-router-state-tree";
+    var NEXT_ROUTER_PREFETCH_HEADER = "next-router-prefetch";
+    var NEXT_ROUTER_SEGMENT_PREFETCH_HEADER = "next-router-segment-prefetch";
+    var NEXT_HMR_REFRESH_HEADER = "next-hmr-refresh";
+    var NEXT_HMR_REFRESH_HASH_COOKIE = "__next_hmr_refresh_hash__";
+    var NEXT_URL = "next-url";
+    var RSC_CONTENT_TYPE_HEADER = "text/x-component";
+    var FLIGHT_HEADERS = [
+      RSC_HEADER,
+      NEXT_ROUTER_STATE_TREE_HEADER,
+      NEXT_ROUTER_PREFETCH_HEADER,
+      NEXT_HMR_REFRESH_HEADER,
+      NEXT_ROUTER_SEGMENT_PREFETCH_HEADER
+    ];
+    var NEXT_RSC_UNION_QUERY = "_rsc";
+    var NEXT_ROUTER_STALE_TIME_HEADER = "x-nextjs-stale-time";
+    var NEXT_DID_POSTPONE_HEADER = "x-nextjs-postponed";
+    var NEXT_REWRITTEN_PATH_HEADER = "x-nextjs-rewritten-path";
+    var NEXT_REWRITTEN_QUERY_HEADER = "x-nextjs-rewritten-query";
+    var NEXT_IS_PRERENDER_HEADER = "x-nextjs-prerender";
+    var NEXT_ACTION_NOT_FOUND_HEADER = "x-nextjs-action-not-found";
+    var NEXT_REQUEST_ID_HEADER = "x-nextjs-request-id";
+    var NEXT_HTML_REQUEST_ID_HEADER = "x-nextjs-html-request-id";
+    var NEXT_ACTION_REVALIDATED_HEADER = "x-action-revalidated";
+    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;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/invariant-error.js
+var require_invariant_error = __commonJS({
+  "node_modules/next/dist/shared/lib/invariant-error.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "InvariantError", {
+      enumerable: true,
+      get: function() {
+        return InvariantError;
+      }
+    });
+    var InvariantError = class extends Error {
+      constructor(message, options) {
+        super(`Invariant: ${message.endsWith(".") ? message : message + "."} This is a bug in Next.js.`, options);
+        this.name = "InvariantError";
+      }
+    };
+  }
+});
+
+// node_modules/next/dist/server/app-render/work-unit-async-storage.external.js
+var require_work_unit_async_storage_external = __commonJS({
+  "node_modules/next/dist/server/app-render/work-unit-async-storage.external.js"(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;
+      }
+    });
+    var _workunitasyncstorageinstance = require_work_unit_async_storage_instance();
+    var _approuterheaders = require_app_router_headers();
+    var _invarianterror = require_invariant_error();
+    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) {
+      var _a;
+      switch (workUnitStore.type) {
+        case "request":
+        case "prerender":
+        case "prerender-runtime":
+        case "prerender-client":
+          if (workUnitStore.renderResumeDataCache) {
+            return workUnitStore.renderResumeDataCache;
+          }
+        // fallthrough
+        case "prerender-ppr":
+          return (_a = workUnitStore.prerenderResumeDataCache) != null ? _a : 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) {
+      var _a;
+      if (workStore.dev) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "private-cache":
+          case "request":
+            return (_a = workUnitStore.isHmrRefresh) != null ? _a : 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;
+      }
+    }
+  }
+});
+
+// node_modules/next/dist/server/app-render/work-async-storage-instance.js
+var require_work_async_storage_instance = __commonJS({
+  "node_modules/next/dist/server/app-render/work-async-storage-instance.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "workAsyncStorageInstance", {
+      enumerable: true,
+      get: function() {
+        return workAsyncStorageInstance;
+      }
+    });
+    var _asynclocalstorage = require_async_local_storage();
+    var workAsyncStorageInstance = (0, _asynclocalstorage.createAsyncLocalStorage)();
+  }
+});
+
+// node_modules/next/dist/server/app-render/work-async-storage.external.js
+var require_work_async_storage_external = __commonJS({
+  "node_modules/next/dist/server/app-render/work-async-storage.external.js"(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "workAsyncStorage", {
+      enumerable: true,
+      get: function() {
+        return _workasyncstorageinstance.workAsyncStorageInstance;
+      }
+    });
+    var _workasyncstorageinstance = require_work_async_storage_instance();
+  }
+});
+
+// node_modules/next/dist/lib/framework/boundary-constants.js
+var require_boundary_constants = __commonJS({
+  "node_modules/next/dist/lib/framework/boundary-constants.js"(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;
+      }
+    });
+    var METADATA_BOUNDARY_NAME = "__next_metadata_boundary__";
+    var VIEWPORT_BOUNDARY_NAME = "__next_viewport_boundary__";
+    var OUTLET_BOUNDARY_NAME = "__next_outlet_boundary__";
+    var ROOT_LAYOUT_BOUNDARY_NAME = "__next_root_layout_boundary__";
+  }
+});
+
+// node_modules/next/dist/lib/scheduler.js
+var require_scheduler = __commonJS({
+  "node_modules/next/dist/lib/scheduler.js"(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;
+      }
+    });
+    var scheduleOnNextTick = (cb) => {
+      Promise.resolve().then(() => {
+        if (process.env.NEXT_RUNTIME === "edge") {
+          setTimeout(cb, 0);
+        } else {
+          process.nextTick(cb);
+        }
+      });
+    };
+    var 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));
+      }
+    }
+  }
+});
+
+// node_modules/next/dist/server/app-render/dynamic-rendering.js
+var require_dynamic_rendering = __commonJS({
+  "node_modules/next/dist/server/app-render/dynamic-rendering.js"(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;
+      },
+      getStaticShellDisallowedDynamicReasons: function() {
+        return getStaticShellDisallowedDynamicReasons;
+      },
+      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;
+      },
+      trackDynamicHoleInRuntimeShell: function() {
+        return trackDynamicHoleInRuntimeShell;
+      },
+      trackDynamicHoleInStaticShell: function() {
+        return trackDynamicHoleInStaticShell;
+      },
+      useDynamicRouteParams: function() {
+        return useDynamicRouteParams;
+      },
+      useDynamicSearchParams: function() {
+        return useDynamicSearchParams;
+      }
+    });
+    var _react = /* @__PURE__ */ _interop_require_default(__require("react"));
+    var _hooksservercontext = require_hooks_server_context();
+    var _staticgenerationbailout = require_static_generation_bailout();
+    var _workunitasyncstorageexternal = require_work_unit_async_storage_external();
+    var _workasyncstorageexternal = require_work_async_storage_external();
+    var _dynamicrenderingutils = require_dynamic_rendering_utils();
+    var _boundaryconstants = require_boundary_constants();
+    var _scheduler = require_scheduler();
+    var _bailouttocsr = require_bailout_to_csr();
+    var _invarianterror = require_invariant_error();
+    function _interop_require_default(obj) {
+      return obj && obj.__esModule ? obj : {
+        default: obj
+      };
+    }
+    var hasPostpone = typeof _react.default.unstable_postpone === "function";
+    function createDynamicTrackingState(isDebugDynamicAccesses) {
+      return {
+        isDebugDynamicAccesses,
+        dynamicAccesses: [],
+        syncDynamicErrorWithStack: null
+      };
+    }
+    function createDynamicValidationState() {
+      return {
+        hasSuspenseAboveBody: false,
+        hasDynamicMetadata: false,
+        dynamicMetadata: null,
+        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 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
+      });
+    }
+    var 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;
+      }
+    }
+    var hasSuspenseRegex = /\n\s+at Suspense \(<anonymous>\)/;
+    var bodyAndImplicitTags = "body|div|main|section|article|aside|header|footer|nav|form|p|span|h1|h2|h3|h4|h5|h6";
+    var hasSuspenseBeforeRootLayoutWithoutBodyOrImplicitBodyRegex = new RegExp(`\\n\\s+at Suspense \\(<anonymous>\\)(?:(?!\\n\\s+at (?:${bodyAndImplicitTags}) \\(<anonymous>\\))[\\s\\S])*?\\n\\s+at ${_boundaryconstants.ROOT_LAYOUT_BOUNDARY_NAME} \\([^\\n]*\\)`);
+    var hasMetadataRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.METADATA_BOUNDARY_NAME}[\\n\\s]`);
+    var hasViewportRegex = new RegExp(`\\n\\s+at ${_boundaryconstants.VIEWPORT_BOUNDARY_NAME}[\\n\\s]`);
+    var 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 trackDynamicHoleInRuntimeShell(workStore, componentStack, dynamicValidation, clientDynamic) {
+      if (hasOutletRegex.test(componentStack)) {
+        return;
+      } else if (hasMetadataRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateMetadata\`. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicMetadata = error;
+        return;
+      } else if (hasViewportRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Uncached data or \`connection()\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicErrors.push(error);
+        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 or \`connection()\` 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 trackDynamicHoleInStaticShell(workStore, componentStack, dynamicValidation, clientDynamic) {
+      if (hasOutletRegex.test(componentStack)) {
+        return;
+      } else if (hasMetadataRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateMetadata\` or you have file-based metadata such as icons that depend on dynamic params segments. Except for this instance, the page would have been entirely prerenderable which may have been the intended behavior. See more info here: https://nextjs.org/docs/messages/next-prerender-dynamic-metadata`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicMetadata = error;
+        return;
+      } else if (hasViewportRegex.test(componentStack)) {
+        const message = `Route "${workStore.route}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` was accessed inside \`generateViewport\`. This delays the entire page from rendering, resulting in a slow user experience. Learn more: https://nextjs.org/docs/messages/next-prerender-dynamic-viewport`;
+        const error = createErrorWithComponentOrOwnerStack(message, componentStack);
+        dynamicValidation.dynamicErrors.push(error);
+        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}": Runtime data such as \`cookies()\`, \`headers()\`, \`params\`, or \`searchParams\` 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 getStaticShellDisallowedDynamicReasons(workStore, prelude, dynamicValidation) {
+      if (dynamicValidation.hasSuspenseAboveBody) {
+        return [];
+      }
+      if (prelude !== 0) {
+        const dynamicErrors = dynamicValidation.dynamicErrors;
+        if (dynamicErrors.length > 0) {
+          return dynamicErrors;
+        }
+        if (prelude === 1) {
+          return [
+            Object.defineProperty(new _invarianterror.InvariantError(`Route "${workStore.route}" did not produce a static shell and Next.js was unable to determine a reason.`), "__NEXT_ERROR_CODE", {
+              value: "E936",
+              enumerable: false,
+              configurable: true
+            })
+          ];
+        }
+      } else {
+        if (dynamicValidation.hasAllowedDynamic === false && dynamicValidation.dynamicErrors.length === 0 && dynamicValidation.dynamicMetadata) {
+          return [
+            dynamicValidation.dynamicMetadata
+          ];
+        }
+      }
+      return [];
+    }
+    function delayUntilRuntimeStage(prerenderStore, result) {
+      if (prerenderStore.runtimeStagePromise) {
+        return prerenderStore.runtimeStagePromise.then(() => result);
+      }
+      return result;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/unstable-rethrow.server.js
+var require_unstable_rethrow_server = __commonJS({
+  "node_modules/next/dist/client/components/unstable-rethrow.server.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "unstable_rethrow", {
+      enumerable: true,
+      get: function() {
+        return unstable_rethrow;
+      }
+    });
+    var _dynamicrenderingutils = require_dynamic_rendering_utils();
+    var _ispostpone = require_is_postpone();
+    var _bailouttocsr = require_bailout_to_csr();
+    var _isnextroutererror = require_is_next_router_error();
+    var _dynamicrendering = require_dynamic_rendering();
+    var _hooksservercontext = require_hooks_server_context();
+    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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/unstable-rethrow.browser.js
+var require_unstable_rethrow_browser = __commonJS({
+  "node_modules/next/dist/client/components/unstable-rethrow.browser.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "unstable_rethrow", {
+      enumerable: true,
+      get: function() {
+        return unstable_rethrow;
+      }
+    });
+    var _bailouttocsr = require_bailout_to_csr();
+    var _isnextroutererror = require_is_next_router_error();
+    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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/unstable-rethrow.js
+var require_unstable_rethrow = __commonJS({
+  "node_modules/next/dist/client/components/unstable-rethrow.js"(exports$1, module) {
+    Object.defineProperty(exports$1, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports$1, "unstable_rethrow", {
+      enumerable: true,
+      get: function() {
+        return unstable_rethrow;
+      }
+    });
+    var unstable_rethrow = typeof window === "undefined" ? require_unstable_rethrow_server().unstable_rethrow : require_unstable_rethrow_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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/navigation.react-server.js
+var require_navigation_react_server = __commonJS({
+  "node_modules/next/dist/client/components/navigation.react-server.js"(exports$1, module) {
+    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;
+      }
+    });
+    var _readonlyurlsearchparams = require_readonly_url_search_params();
+    var _redirect = require_redirect();
+    var _redirecterror = require_redirect_error();
+    var _notfound = require_not_found();
+    var _forbidden = require_forbidden();
+    var _unauthorized = require_unauthorized();
+    var _unstablerethrow = require_unstable_rethrow();
+    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;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/navigation.js
+var require_navigation = __commonJS({
+  "node_modules/next/dist/client/components/navigation.js"(exports$1, module) {
+    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, {
+      // We need the same class that was used to instantiate the context value
+      // Otherwise instanceof checks will fail in usercode
+      ReadonlyURLSearchParams: function() {
+        return _hooksclientcontextsharedruntime.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 usePathname3;
+      },
+      useRouter: function() {
+        return useRouter3;
+      },
+      useSearchParams: function() {
+        return useSearchParams;
+      },
+      useSelectedLayoutSegment: function() {
+        return useSelectedLayoutSegment;
+      },
+      useSelectedLayoutSegments: function() {
+        return useSelectedLayoutSegments;
+      },
+      useServerInsertedHTML: function() {
+        return _serverinsertedhtmlsharedruntime.useServerInsertedHTML;
+      }
+    });
+    var _interop_require_wildcard = require_interop_require_wildcard();
+    var _react = /* @__PURE__ */ _interop_require_wildcard._(__require("react"));
+    var _approutercontextsharedruntime = require_app_router_context_shared_runtime();
+    var _hooksclientcontextsharedruntime = require_hooks_client_context_shared_runtime();
+    var _segment = require_segment();
+    var _serverinsertedhtmlsharedruntime = require_server_inserted_html_shared_runtime();
+    var _unrecognizedactionerror = require_unrecognized_action_error();
+    var _navigationreactserver = require_navigation_react_server();
+    var useDynamicRouteParams = typeof window === "undefined" ? require_dynamic_rendering().useDynamicRouteParams : void 0;
+    var useDynamicSearchParams = typeof window === "undefined" ? require_dynamic_rendering().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 _hooksclientcontextsharedruntime.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 usePathname3() {
+      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 useRouter3() {
+      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;
+    }
+  }
+});
+
+// node_modules/next/navigation.js
+var require_navigation2 = __commonJS({
+  "node_modules/next/navigation.js"(exports$1, module) {
+    module.exports = require_navigation();
+  }
+});
 
 // src/app/types/colors.ts
 function hasExtendedColors(config) {
@@ -4424,6 +6900,9 @@ var ConfirmationModal = ({
   );
 };
 var ConfirmationModal_default = ConfirmationModal;
+
+// src/app/components/SideBar/SideBar.tsx
+var import_navigation = __toESM(require_navigation2());
 var SIDEBAR_DISPLAY_NAME = "SideBar";
 var getContainerStyles = (isOpen, openWidth, closedWidth, backgroundColor) => ({
   position: "fixed",
@@ -4526,23 +7005,9 @@ var SideBar = ({
   languageSelector
 }) => {
   const [internalIsOpen, setInternalIsOpen] = useState(false);
-  const [currentPathname, setCurrentPathname] = useState(
-    () => typeof window !== "undefined" ? window.location.pathname : "/"
-  );
+  const currentPathname = (0, import_navigation.usePathname)();
+  const router = (0, import_navigation.useRouter)();
   const isOpen = controlledIsOpen != null ? controlledIsOpen : internalIsOpen;
-  useEffect(() => {
-    const handleRouteChange = () => {
-      setCurrentPathname(window.location.pathname);
-    };
-    window.addEventListener("popstate", handleRouteChange);
-    window.addEventListener("pushstate", handleRouteChange);
-    window.addEventListener("replacestate", handleRouteChange);
-    return () => {
-      window.removeEventListener("popstate", handleRouteChange);
-      window.removeEventListener("pushstate", handleRouteChange);
-      window.removeEventListener("replacestate", handleRouteChange);
-    };
-  }, []);
   const backgroundColor = customBg || colors.secondary;
   const textColor = customTextColor || getContrastColor(backgroundColor);
   const hoverBackgroundColor = customHoverBg || adjustOpacity(colors.primary, 0.8);
@@ -4603,12 +7068,13 @@ var SideBar = ({
       return /* @__PURE__ */ jsx("li", { style: getListItemStyles(), children: /* @__PURE__ */ jsxs(
         "button",
         {
-          onClick: isActive ? void 0 : () => {
+          onClick: isActive ? void 0 : (e) => {
+            e.currentTarget.style.backgroundColor = "transparent";
+            e.currentTarget.style.color = itemTextColor;
             if (item.onClick) {
               item.onClick();
-            }
-            if (item.href && typeof window !== "undefined") {
-              window.location.href = item.href;
+            } else if (item.href) {
+              router.push(item.href);
             }
           },
           className: "sidebar-menu-item",
@@ -4642,7 +7108,8 @@ var SideBar = ({
       logoutTextColor,
       logoutHoverBg,
       logoutHoverTextColor,
-      isMenuItemActive
+      isMenuItemActive,
+      router
     ]
   );
   return /* @__PURE__ */ jsxs(Fragment, { children: [
@@ -4696,7 +7163,10 @@ var SideBar = ({
           /* @__PURE__ */ jsx(
             "button",
             {
-              onClick: handleToggle,
+              onClick: (e) => {
+                e.currentTarget.style.backgroundColor = toggleBtnBg;
+                handleToggle();
+              },
               className: "sidebar-toggle-btn",
               style: getToggleButtonStyles(toggleBtnBg, textColor),
               onMouseEnter: (e) => {
@@ -4800,6 +7270,9 @@ var SideBar = ({
   ] });
 };
 SideBar.displayName = SIDEBAR_DISPLAY_NAME;
+
+// src/app/components/NavBar/NavBar.tsx
+var import_navigation2 = __toESM(require_navigation2());
 var NAVBAR_DISPLAY_NAME = "NavBar";
 var getContainerStyles2 = (backgroundColor, height) => ({
   position: "fixed",
@@ -4962,23 +7435,9 @@ var NavBar = ({
   languageSelector
 }) => {
   const [internalMobileMenu, setInternalMobileMenu] = useState(false);
-  const [currentPathname, setCurrentPathname] = useState(
-    () => typeof window !== "undefined" ? window.location.pathname : "/"
-  );
+  const currentPathname = (0, import_navigation2.usePathname)();
+  const router = (0, import_navigation2.useRouter)();
   const isMobileMenuOpen = controlledMobileMenu != null ? controlledMobileMenu : internalMobileMenu;
-  useEffect(() => {
-    const handleRouteChange = () => {
-      setCurrentPathname(window.location.pathname);
-    };
-    window.addEventListener("popstate", handleRouteChange);
-    window.addEventListener("pushstate", handleRouteChange);
-    window.addEventListener("replacestate", handleRouteChange);
-    return () => {
-      window.removeEventListener("popstate", handleRouteChange);
-      window.removeEventListener("pushstate", handleRouteChange);
-      window.removeEventListener("replacestate", handleRouteChange);
-    };
-  }, []);
   const backgroundColor = customBgColor || colors.secondary;
   const textColor = customTextColor || getContrastColor(backgroundColor);
   const activeColor = customActiveColor || colors.accent;
@@ -5004,17 +7463,19 @@ var NavBar = ({
     if (logo == null ? void 0 : logo.onClick) {
       logo.onClick();
     } else if (logo == null ? void 0 : logo.href) {
-      window.location.href = logo.href;
-    }
-  }, [logo]);
-  const handleMenuItemClick = useCallback((item) => {
-    if (item.onClick) {
-      item.onClick();
+      router.push(logo.href);
     }
-    if (item.href) {
-      window.location.href = item.href;
-    }
-  }, []);
+  }, [logo, router]);
+  const handleMenuItemClick = useCallback(
+    (item) => {
+      if (item.onClick) {
+        item.onClick();
+      } else if (item.href) {
+        router.push(item.href);
+      }
+    },
+    [router]
+  );
   const isMenuItemActive = useCallback(
     (item) => {
       if (item.isActive !== void 0) {
@@ -5087,7 +7548,10 @@ var NavBar = ({
         "div",
         {
           style: getLogoLinkStyles(),
-          onClick: handleLogoClick,
+          onClick: (e) => {
+            e.currentTarget.style.opacity = "1";
+            handleLogoClick();
+          },
           onMouseEnter: (e) => {
             e.currentTarget.style.opacity = "0.8";
           },
@@ -5115,7 +7579,12 @@ var NavBar = ({
         return /* @__PURE__ */ jsx(
           "div",
           {
-            onClick: () => handleMenuItemClick(item),
+            onClick: (e) => {
+              if (!isActive) {
+                e.currentTarget.style.color = textColor;
+              }
+              handleMenuItemClick(item);
+            },
             style: getMenuItemStyles(textColor, isActive, activeColor),
             onMouseEnter: (e) => {
               if (!isActive) {
@@ -5175,7 +7644,10 @@ var NavBar = ({
         {
           className: "navbar-mobile-toggle",
           style: getMobileToggleStyles(textColor),
-          onClick: handleMobileMenuToggle,
+          onClick: (e) => {
+            e.currentTarget.style.backgroundColor = "transparent";
+            handleMobileMenuToggle();
+          },
           onMouseEnter: (e) => {
             e.currentTarget.style.backgroundColor = dynamicColors.hoverBg;
           },
@@ -5200,7 +7672,10 @@ var NavBar = ({
                 "div",
                 {
                   style: getMobileCloseStyles(textColor),
-                  onClick: handleMobileMenuToggle,
+                  onClick: (e) => {
+                    e.currentTarget.style.backgroundColor = "transparent";
+                    handleMobileMenuToggle();
+                  },
                   onMouseEnter: (e) => {
                     e.currentTarget.style.backgroundColor = dynamicColors.hoverBg;
                   },
@@ -5223,7 +7698,8 @@ var NavBar = ({
                     dynamicColors.activeItemBg,
                     activeColor
                   ),
-                  onClick: () => {
+                  onClick: (e) => {
+                    e.currentTarget.style.backgroundColor = isActive ? dynamicColors.activeItemBg : "transparent";
                     handleMenuItemClick(item);
                     handleMobileMenuToggle();
                   },