@nexushub/client 0.0.1

package/dist/index.js

@@ -0,0 +1,4301 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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"(exports2) {
+    "use strict";
+    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;
+    }
+    exports2._ = _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"(exports2) {
+    "use strict";
+    function _interop_require_default(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    exports2._ = _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"(exports2) {
+    "use strict";
+    "use client";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2) {
+    "use strict";
+    "use client";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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 = []) {
+      let node;
+      if (first) {
+        node = tree[1][parallelRouteKey];
+      } else {
+        const parallelRoutes = tree[1];
+        node = parallelRoutes.children ?? 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"(exports2) {
+    "use strict";
+    "use client";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/redirect-error.js
+var require_redirect_error = __commonJS({
+  "node_modules/next/dist/client/components/redirect-error.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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) {
+      type ?? (type = actionAsyncStorage?.getStore()?.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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/not-found.js
+var require_not_found = __commonJS({
+  "node_modules/next/dist/client/components/not-found.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/forbidden.js
+var require_forbidden = __commonJS({
+  "node_modules/next/dist/client/components/forbidden.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/unauthorized.js
+var require_unauthorized = __commonJS({
+  "node_modules/next/dist/client/components/unauthorized.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/invariant-error.js
+var require_invariant_error = __commonJS({
+  "node_modules/next/dist/shared/lib/invariant-error.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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) {
+      switch (workUnitStore.type) {
+        case "request":
+        case "prerender":
+        case "prerender-runtime":
+        case "prerender-client":
+          if (workUnitStore.renderResumeDataCache) {
+            return workUnitStore.renderResumeDataCache;
+          }
+        // fallthrough
+        case "prerender-ppr":
+          return workUnitStore.prerenderResumeDataCache ?? null;
+        case "cache":
+        case "private-cache":
+        case "unstable-cache":
+        case "prerender-legacy":
+          return null;
+        default:
+          return workUnitStore;
+      }
+    }
+    function getHmrRefreshHash(workStore, workUnitStore) {
+      if (workStore.dev) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "private-cache":
+          case "prerender":
+          case "prerender-runtime":
+            return workUnitStore.hmrRefreshHash;
+          case "request":
+            var _workUnitStore_cookies_get;
+            return (_workUnitStore_cookies_get = workUnitStore.cookies.get(_approuterheaders.NEXT_HMR_REFRESH_HASH_COOKIE)) == null ? void 0 : _workUnitStore_cookies_get.value;
+          case "prerender-client":
+          case "prerender-ppr":
+          case "prerender-legacy":
+          case "unstable-cache":
+            break;
+          default:
+            workUnitStore;
+        }
+      }
+      return void 0;
+    }
+    function isHmrRefresh(workStore, workUnitStore) {
+      if (workStore.dev) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "private-cache":
+          case "request":
+            return workUnitStore.isHmrRefresh ?? false;
+          case "prerender":
+          case "prerender-client":
+          case "prerender-runtime":
+          case "prerender-ppr":
+          case "prerender-legacy":
+          case "unstable-cache":
+            break;
+          default:
+            workUnitStore;
+        }
+      }
+      return false;
+    }
+    function getServerComponentsHmrCache(workStore, workUnitStore) {
+      if (workStore.dev) {
+        switch (workUnitStore.type) {
+          case "cache":
+          case "private-cache":
+          case "request":
+            return workUnitStore.serverComponentsHmrCache;
+          case "prerender":
+          case "prerender-client":
+          case "prerender-runtime":
+          case "prerender-ppr":
+          case "prerender-legacy":
+          case "unstable-cache":
+            break;
+          default:
+            workUnitStore;
+        }
+      }
+      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;
+          case "prerender":
+          case "prerender-client":
+          case "prerender-ppr":
+          case "prerender-legacy":
+            break;
+          default:
+            workUnitStore;
+        }
+      }
+      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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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;
+          case "prerender-legacy":
+          case "prerender-ppr":
+          case "request":
+            break;
+          default:
+            workUnitStore;
+        }
+      }
+      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;
+          default:
+            workUnitStore;
+        }
+      }
+    }
+    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;
+        default:
+          workUnitStore;
+      }
+    }
+    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;
+        default:
+          workUnitStore;
+      }
+    }
+    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
+            });
+          case "prerender-legacy":
+          case "request":
+          case "unstable-cache":
+            break;
+          default:
+            workUnitStore;
+        }
+      }
+    }
+    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;
+        default:
+          workUnitStore;
+      }
+    }
+    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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/unstable-rethrow.js
+var require_unstable_rethrow = __commonJS({
+  "node_modules/next/dist/client/components/unstable-rethrow.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports2, "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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.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"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      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 exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/components/navigation.js
+var require_navigation = __commonJS({
+  "node_modules/next/dist/client/components/navigation.js"(exports2, module2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports2, {
+      // 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 usePathname2;
+      },
+      useRouter: function() {
+        return useRouter;
+      },
+      useSearchParams: function() {
+        return useSearchParams2;
+      },
+      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 useSearchParams2() {
+      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 usePathname2() {
+      useDynamicRouteParams?.("usePathname()");
+      const pathname = (0, _react.useContext)(_hooksclientcontextsharedruntime.PathnameContext);
+      if (process.env.NODE_ENV !== "production" && "use" in _react.default) {
+        const navigationPromises = (0, _react.use)(_hooksclientcontextsharedruntime.NavigationPromisesContext);
+        if (navigationPromises) {
+          return (0, _react.use)(navigationPromises.pathname);
+        }
+      }
+      return pathname;
+    }
+    function useRouter() {
+      const router = (0, _react.useContext)(_approutercontextsharedruntime.AppRouterContext);
+      if (router === null) {
+        throw Object.defineProperty(new Error("invariant expected app router to be mounted"), "__NEXT_ERROR_CODE", {
+          value: "E238",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      return router;
+    }
+    function useParams() {
+      useDynamicRouteParams?.("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") {
+      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 = navigationPromises.selectedLayoutSegmentsPromises?.get(parallelRouteKey);
+          if (promise) {
+            return (0, _react.use)(promise);
+          }
+        }
+      }
+      return (0, _segment.getSelectedLayoutSegmentPath)(context.parentTree, parallelRouteKey);
+    }
+    function useSelectedLayoutSegment(parallelRouteKey = "children") {
+      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 = navigationPromises.selectedLayoutSegmentPromises?.get(parallelRouteKey);
+        if (promise) {
+          return (0, _react.use)(promise);
+        }
+      }
+      return (0, _segment.computeSelectedLayoutSegment)(selectedLayoutSegments, parallelRouteKey);
+    }
+    if ((typeof exports2.default === "function" || typeof exports2.default === "object" && exports2.default !== null) && typeof exports2.default.__esModule === "undefined") {
+      Object.defineProperty(exports2.default, "__esModule", { value: true });
+      Object.assign(exports2.default, exports2);
+      module2.exports = exports2.default;
+    }
+  }
+});
+
+// node_modules/next/navigation.js
+var require_navigation2 = __commonJS({
+  "node_modules/next/navigation.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_navigation();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BrowserCache: () => BrowserCache,
+  CacheTags: () => CacheTags,
+  ContentEngine: () => ContentEngine,
+  ExponentialBackoff: () => ExponentialBackoff,
+  LocalCache: () => LocalCache,
+  MemoryCache: () => MemoryCache,
+  NexusClient: () => NexusClient,
+  NexusProvider: () => NexusProvider,
+  RateLimiter: () => RateLimiter,
+  RequestBatcher: () => RequestBatcher,
+  createNexusClient: () => createNexusClient,
+  nexus: () => nexus,
+  useNexusAuth: () => useNexusAuth
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var DEFAULT_API_URL = "https://api.nexushub.com/v1";
+var hasEnv = () => {
+  return typeof process !== "undefined" && typeof process.env !== "undefined" && Object.keys(process.env).length > 0;
+};
+var getEnvConfig = () => {
+  if (!hasEnv()) {
+    return {
+      apiUrl: DEFAULT_API_URL
+    };
+  }
+  const env = process.env;
+  const projectId = env.NEXT_PUBLIC_NEXUS_ID ?? env.NEXUS_PROJECT_ID ?? env.NEXUS_PROJECT_ID;
+  const apiKey = env.NEXT_PUBLIC_NEXUS_KEY ?? env.NEXUS_API_KEY ?? env.NEXUS_API_KEY;
+  const apiUrl = env.NEXT_PUBLIC_NEXUS_API_URL ?? env.NEXUS_API_URL ?? DEFAULT_API_URL;
+  return {
+    projectId,
+    apiKey,
+    apiUrl
+  };
+};
+var mergeConfigs = (base, override) => {
+  return {
+    ...base,
+    ...override,
+    apiUrl: override.apiUrl || base.apiUrl || DEFAULT_API_URL,
+    projectId: override.projectId || base.projectId
+  };
+};
+var getFullConfig = (partialConfig) => {
+  const envConfig = getEnvConfig();
+  const merged = mergeConfigs(envConfig, partialConfig || {});
+  if (!merged.apiUrl) {
+    merged.apiUrl = DEFAULT_API_URL;
+  }
+  return merged;
+};
+var validateConfig = (config) => {
+  const errors = [];
+  if (!config.projectId) {
+    errors.push("Missing projectId");
+  }
+  if (!config.apiUrl) {
+    errors.push("Missing apiUrl");
+  }
+  if (config.apiUrl && !config.apiUrl.startsWith("http")) {
+    errors.push("apiUrl must be a valid URL starting with http:// or https://");
+  }
+  return errors;
+};
+
+// src/content/cache.ts
+var CacheTags = {
+  project: (projectId) => `nexus_project_${projectId}`,
+  content: (slug) => `content_${slug}`,
+  collection: (collectionId) => `collection_${collectionId}`,
+  global: "nexus_global_config",
+  user: (userId) => `user_${userId}`,
+  media: (mediaId) => `media_${mediaId}`
+};
+var MemoryCache = class {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.tagIndex = /* @__PURE__ */ new Map();
+    this.stats = {
+      size: 0,
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      evictions: 0
+    };
+    this.maxSize = options.maxSize || 1e3;
+    this.defaultTTL = options.ttl || 5 * 60 * 1e3;
+  }
+  set(key, data, options = {}) {
+    if (this.cache.size >= this.maxSize) {
+      this.evictLRU();
+    }
+    const metadata = {
+      timestamp: Date.now(),
+      expiresAt: Date.now() + (options.ttl || this.defaultTTL),
+      tags: options.tags || [],
+      size: this.calculateSize(data)
+    };
+    this.cache.set(key, { data, metadata });
+    this.stats.size = this.cache.size;
+    metadata.tags.forEach((tag) => {
+      if (!this.tagIndex.has(tag)) {
+        this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+      }
+      this.tagIndex.get(tag).add(key);
+    });
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      this.updateHitRate();
+      return null;
+    }
+    if (Date.now() > entry.metadata.expiresAt) {
+      this.delete(key);
+      this.stats.misses++;
+      this.updateHitRate();
+      return null;
+    }
+    entry.metadata.timestamp = Date.now();
+    this.stats.hits++;
+    this.updateHitRate();
+    return entry;
+  }
+  delete(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    entry.metadata.tags.forEach((tag) => {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        keys.delete(key);
+        if (keys.size === 0) {
+          this.tagIndex.delete(tag);
+        }
+      }
+    });
+    this.cache.delete(key);
+    this.stats.size = this.cache.size;
+    return true;
+  }
+  invalidateByTags(tags) {
+    const keysToDelete = /* @__PURE__ */ new Set();
+    tags.forEach((tag) => {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        keys.forEach((key) => keysToDelete.add(key));
+        this.tagIndex.delete(tag);
+      }
+    });
+    keysToDelete.forEach((key) => this.delete(key));
+    if (process.env.NODE_ENV === "development") {
+      console.log(`[MemoryCache] Invalidated ${keysToDelete.size} entries by tags: ${tags.join(", ")}`);
+    }
+  }
+  clear() {
+    this.cache.clear();
+    this.tagIndex.clear();
+    this.stats = {
+      size: 0,
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      evictions: 0
+    };
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  evictLRU() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.metadata.timestamp < oldestTime) {
+        oldestTime = entry.metadata.timestamp;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.delete(oldestKey);
+      this.stats.evictions++;
+    }
+  }
+  calculateSize(data) {
+    try {
+      const jsonString = JSON.stringify(data);
+      return new Blob([jsonString]).size;
+    } catch {
+      return 0;
+    }
+  }
+  updateHitRate() {
+    const total = this.stats.hits + this.stats.misses;
+    this.stats.hitRate = total > 0 ? this.stats.hits / total : 0;
+  }
+};
+var LocalCache = class {
+  constructor(customPath) {
+    this.data = null;
+    this.hasLoaded = false;
+    this.cachePath = customPath || ".nexus/cache.json";
+  }
+  isLoaded() {
+    return this.hasLoaded;
+  }
+  load() {
+    if (typeof window !== "undefined") return;
+    if (process.env.NODE_ENV !== "development") return;
+    if (this.hasLoaded) return;
+    try {
+      const fs = require("fs");
+      const path = require("path");
+      const fullPath = path.resolve(process.cwd(), this.cachePath);
+      if (fs.existsSync(fullPath)) {
+        const fileContent = fs.readFileSync(fullPath, "utf-8");
+        this.data = JSON.parse(fileContent);
+        this.hasLoaded = true;
+        console.log(`\u26A1 NexusHub: Serving content from local cache (${this.cachePath})`);
+        console.log(`   - Pages: ${this.data.pages?.length || 0}`);
+        console.log(`   - Collections: ${Object.keys(this.data.collections || {}).length}`);
+        console.log(`   - Globals: ${this.data.globals ? "Loaded" : "Not found"}`);
+      }
+    } catch (error) {
+      if (this.shouldWarnAboutMissingCache(error)) {
+        console.warn(
+          `\u26A0\uFE0F NexusHub: Local cache not found at ${this.cachePath}
+   Run \`npx nexus pull\` to generate seed data or
+   Use the Dashboard to create content first.`
+        );
+      }
+    }
+  }
+  getPage(slug) {
+    this.load();
+    if (!this.data?.pages) return null;
+    const page = this.data.pages.find((p) => p.slug === slug);
+    if (!page) {
+      console.warn(`\u26A0\uFE0F NexusHub: Page '${slug}' not found in local cache`);
+      return null;
+    }
+    return page.data;
+  }
+  getCollection(collectionId) {
+    this.load();
+    if (!this.data?.collections) return null;
+    const collection = this.data.collections[collectionId];
+    if (!collection) {
+      console.warn(`\u26A0\uFE0F NexusHub: Collection '${collectionId}' not found in local cache`);
+      return null;
+    }
+    return collection;
+  }
+  getGlobals() {
+    this.load();
+    return this.data?.globals || null;
+  }
+  getAllData() {
+    this.load();
+    return this.data;
+  }
+  shouldWarnAboutMissingCache(error) {
+    return error.code === "ENOENT" || error.message && error.message.includes("ENOENT");
+  }
+};
+var BrowserCache = class {
+  constructor(projectId) {
+    this.projectId = projectId;
+    this.prefix = "nexushub_";
+    this.maxSize = 5 * 1024 * 1024;
+    // 5MB
+    this.currentSize = 0;
+    this.calculateCurrentSize();
+  }
+  set(key, data, ttl = 5 * 60 * 1e3) {
+    const storageKey = this.getStorageKey(key);
+    const entry = {
+      data,
+      metadata: {
+        timestamp: Date.now(),
+        expiresAt: Date.now() + ttl,
+        size: this.calculateStorageSize(data)
+      }
+    };
+    const serialized = JSON.stringify(entry);
+    const newSize = new Blob([serialized]).size;
+    if (this.currentSize + newSize > this.maxSize) {
+      this.evictOldest();
+    }
+    try {
+      localStorage.setItem(storageKey, serialized);
+      this.currentSize += newSize;
+    } catch (error) {
+      console.warn("[BrowserCache] Failed to save to localStorage:", error);
+      this.evictOldest();
+      this.set(key, data, ttl);
+    }
+  }
+  get(key) {
+    const storageKey = this.getStorageKey(key);
+    const item = localStorage.getItem(storageKey);
+    if (!item) return null;
+    try {
+      const entry = JSON.parse(item);
+      if (Date.now() > entry.metadata.expiresAt) {
+        this.delete(key);
+        return null;
+      }
+      return entry.data;
+    } catch {
+      this.delete(key);
+      return null;
+    }
+  }
+  delete(key) {
+    const storageKey = this.getStorageKey(key);
+    const item = localStorage.getItem(storageKey);
+    if (item) {
+      this.currentSize -= new Blob([item]).size;
+    }
+    localStorage.removeItem(storageKey);
+  }
+  clear() {
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.prefix)) {
+        keysToRemove.push(key);
+      }
+    }
+    keysToRemove.forEach((key) => localStorage.removeItem(key));
+    this.currentSize = 0;
+  }
+  getStorageKey(key) {
+    return `${this.prefix}${this.projectId}_${key}`;
+  }
+  calculateCurrentSize() {
+    this.currentSize = 0;
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.prefix)) {
+        const item = localStorage.getItem(key);
+        if (item) {
+          this.currentSize += new Blob([item]).size;
+        }
+      }
+    }
+  }
+  calculateStorageSize(data) {
+    return new Blob([JSON.stringify(data)]).size;
+  }
+  evictOldest() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.prefix)) {
+        const item = localStorage.getItem(key);
+        if (item) {
+          try {
+            const entry = JSON.parse(item);
+            if (entry.metadata.timestamp < oldestTime) {
+              oldestTime = entry.metadata.timestamp;
+              oldestKey = key;
+            }
+          } catch {
+            localStorage.removeItem(key);
+          }
+        }
+      }
+    }
+    if (oldestKey) {
+      const item = localStorage.getItem(oldestKey);
+      if (item) {
+        this.currentSize -= new Blob([item]).size;
+      }
+      localStorage.removeItem(oldestKey);
+    }
+  }
+};
+
+// src/content/strategies.ts
+var RateLimiter = class {
+  constructor(config) {
+    this.requests = [];
+    this.config = config;
+  }
+  async checkLimit() {
+    const now = Date.now();
+    const windowStart = now - this.config.timeWindow;
+    this.requests = this.requests.filter((time) => time > windowStart);
+    if (this.requests.length >= this.config.maxRequests) {
+      const oldestRequest = this.requests[0];
+      const waitTime = windowStart + this.config.timeWindow - now;
+      if (waitTime > 0) {
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+        return this.checkLimit();
+      }
+    }
+    this.requests.push(now);
+  }
+  getStats() {
+    const now = Date.now();
+    const windowStart = now - this.config.timeWindow;
+    const currentRequests = this.requests.filter((time) => time > windowStart).length;
+    return {
+      currentRequests,
+      limit: this.config.maxRequests
+    };
+  }
+};
+var ExponentialBackoff = class {
+  constructor(config) {
+    this.config = {
+      jitter: true,
+      ...config
+    };
+  }
+  async execute(fn, onRetry) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (this.isClientError(error) && !this.isRateLimitError(error)) {
+          throw error;
+        }
+        if (attempt === this.config.maxRetries) {
+          break;
+        }
+        const delay = this.calculateDelay(attempt);
+        if (onRetry) {
+          onRetry(attempt + 1, delay, error);
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+  calculateDelay(attempt) {
+    let delay = this.config.baseDelay * Math.pow(2, attempt);
+    delay = Math.min(delay, this.config.maxDelay);
+    if (this.config.jitter) {
+      delay = delay * (0.5 + Math.random());
+    }
+    return delay;
+  }
+  isClientError(error) {
+    return error?.status >= 400 && error?.status < 500;
+  }
+  isRateLimitError(error) {
+    return error?.status === 429;
+  }
+};
+var RequestBatcher = class {
+  constructor(batchWindow = 10, maxBatchSize = 20) {
+    this.batchWindow = batchWindow;
+    this.maxBatchSize = maxBatchSize;
+    this.batch = [];
+    this.processing = false;
+  }
+  async schedule(key, request) {
+    return new Promise((resolve, reject) => {
+      this.batch.push({ key, resolve, reject });
+      if (this.batch.length >= this.maxBatchSize) {
+        this.processBatch(request);
+      } else if (!this.batchTimeout) {
+        this.batchTimeout = setTimeout(
+          () => this.processBatch(request),
+          this.batchWindow
+        );
+      }
+    });
+  }
+  async processBatch(request) {
+    if (this.processing || this.batch.length === 0) return;
+    this.processing = true;
+    if (this.batchTimeout) {
+      clearTimeout(this.batchTimeout);
+      this.batchTimeout = void 0;
+    }
+    const currentBatch = [...this.batch];
+    this.batch = [];
+    try {
+      const result = await request();
+      currentBatch.forEach((item) => {
+        item.resolve(result);
+      });
+    } catch (error) {
+      currentBatch.forEach((item) => {
+        item.reject(error);
+      });
+    } finally {
+      this.processing = false;
+      if (this.batch.length > 0) {
+        setTimeout(() => this.processBatch(request), 0);
+      }
+    }
+  }
+};
+
+// src/content/utils.ts
+function validateSlug(slug) {
+  if (!slug || typeof slug !== "string") {
+    throw new Error("Slug must be a non-empty string");
+  }
+  if (!/^[a-z0-9-_]+$/.test(slug)) {
+    throw new Error("Slug can only contain lowercase letters, numbers, hyphens, and underscores");
+  }
+}
+function normalizeQuery(query) {
+  const normalized = { ...query };
+  normalized.page = Math.max(1, normalized.page || 1);
+  normalized.limit = Math.min(100, Math.max(1, normalized.limit || 10));
+  normalized.order = normalized.order || "desc";
+  if (normalized.page < 1) {
+    throw new Error("Page must be greater than 0");
+  }
+  if (normalized.limit < 1 || normalized.limit > 100) {
+    throw new Error("Limit must be between 1 and 100");
+  }
+  return normalized;
+}
+function buildQueryString(query) {
+  const params = new URLSearchParams();
+  if (query.page) params.append("page", query.page.toString());
+  if (query.limit) params.append("limit", query.limit.toString());
+  if (query.sort) params.append("sort", query.sort);
+  if (query.order) params.append("order", query.order);
+  if (query.search) params.append("search", query.search);
+  if (query.include?.length) {
+    params.append("include", query.include.join(","));
+  }
+  if (query.fields?.length) {
+    params.append("fields", query.fields.join(","));
+  }
+  if (query.filter) {
+    params.append("filter", JSON.stringify(query.filter));
+  }
+  return params.toString();
+}
+function measurePerformance(name, fn) {
+  const start = performance.now();
+  const result = fn();
+  const end = performance.now();
+  if (process.env.NODE_ENV === "development") {
+    console.log(`\u23F1\uFE0F ${name}: ${(end - start).toFixed(2)}ms`);
+  }
+  return { result, duration: end - start };
+}
+
+// src/content/index.ts
+var ContentEngine = class {
+  constructor(config) {
+    this.config = config;
+    this.localCache = new LocalCache();
+    this.memoryCache = new MemoryCache({
+      maxSize: 500,
+      ttl: 5 * 60 * 1e3
+      // 5 minutes
+    });
+    if (typeof window !== "undefined") {
+      this.browserCache = new BrowserCache(config.projectId);
+    }
+    this.rateLimiter = new RateLimiter({
+      maxRequests: config.debug ? 100 : 30,
+      timeWindow: 6e4
+      // 1 minute
+    });
+    this.backoff = new ExponentialBackoff({
+      maxRetries: config.retries || 3,
+      baseDelay: 100,
+      maxDelay: 5e3,
+      jitter: true
+    });
+    this.requestBatcher = new RequestBatcher(10, 20);
+    this.defaultRevalidate = config.revalidateTime || 60;
+    this.cacheStrategy = config.cacheStrategy || "memory";
+    this.isServer = typeof window === "undefined";
+    if (typeof window !== "undefined") {
+      window.addEventListener("beforeunload", this.cleanup.bind(this));
+    }
+  }
+  /**
+   * Fetch a Singleton Page with enhanced caching
+   */
+  async getPage(slug, options = {}) {
+    const { result, duration } = measurePerformance(
+      `getPage("${slug}")`,
+      () => this._getPage(slug, options)
+    );
+    if (this.config.debug && duration > 100) {
+      console.warn(`[NexusHub] \u26A0\uFE0F getPage("${slug}") took ${duration.toFixed(2)}ms`);
+    }
+    return result;
+  }
+  async _getPage(slug, options = {}) {
+    validateSlug(slug);
+    const {
+      revalidate = this.defaultRevalidate,
+      tags = [],
+      forceRefresh = false,
+      includeMetadata = false
+    } = options;
+    const cacheKey = `page:${slug}`;
+    if (!forceRefresh && this.cacheStrategy === "memory") {
+      const cached = this.memoryCache.get(cacheKey);
+      if (cached && this.isCacheValid(cached.metadata)) {
+        if (this.config.debug) {
+          console.log(`[NexusHub] \u26A1 Served '${slug}' from memory cache.`);
+        }
+        return includeMetadata ? cached : cached.data;
+      }
+    }
+    if (!forceRefresh && !this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+      const cached = this.browserCache.get(cacheKey);
+      if (cached) {
+        if (this.config.debug) {
+          console.log(`[NexusHub] \u{1FAA3} Served '${slug}' from browser cache.`);
+        }
+        return cached;
+      }
+    }
+    if (!forceRefresh && process.env.NODE_ENV === "development") {
+      const localData = this.localCache.getPage(slug);
+      if (localData) {
+        if (this.config.debug) {
+          console.log(`[NexusHub] \u{1F4C1} Served '${slug}' from local cache.`);
+        }
+        this.memoryCache.set(cacheKey, localData, {
+          tags: [...tags, CacheTags.content(slug)],
+          revalidate
+        });
+        return localData;
+      }
+    }
+    try {
+      await this.rateLimiter.checkLimit();
+      const data = await this.backoff.execute(
+        async () => {
+          return this.fetchPage(slug, cacheKey, tags, revalidate, forceRefresh);
+        },
+        (attempt, delay, error) => {
+          if (this.config.debug) {
+            console.log(`[NexusHub] \u{1F504} Retry ${attempt} for '${slug}' after ${delay}ms: ${error.message}`);
+          }
+        }
+      );
+      return includeMetadata ? data : data.data;
+    } catch (error) {
+      const staleCache = this.memoryCache.get(cacheKey);
+      if (staleCache && !forceRefresh) {
+        console.warn(`[NexusHub] \u26A0\uFE0F Using stale cache for '${slug}' due to fetch error:`, error);
+        return includeMetadata ? staleCache : staleCache.data;
+      }
+      throw this.normalizeError(error, `Failed to fetch page '${slug}'`);
+    }
+  }
+  /**
+   * Fetch a Collection with advanced query capabilities
+   */
+  async getCollection(collectionId, query = {}, options = {}) {
+    const { result, duration } = measurePerformance(
+      `getCollection("${collectionId}")`,
+      () => this._getCollection(collectionId, query, options)
+    );
+    if (this.config.debug && duration > 100) {
+      console.warn(`[NexusHub] \u26A0\uFE0F getCollection("${collectionId}") took ${duration.toFixed(2)}ms`);
+    }
+    return result;
+  }
+  async _getCollection(collectionId, query = {}, options = {}) {
+    const normalizedQuery = normalizeQuery(query);
+    const {
+      revalidate = this.defaultRevalidate,
+      tags = [],
+      forceRefresh = false,
+      includeMetadata = false
+    } = options;
+    const queryString = buildQueryString(normalizedQuery);
+    const cacheKey = `collection:${collectionId}:${queryString}`;
+    if (!forceRefresh && this.cacheStrategy === "memory") {
+      const cached = this.memoryCache.get(cacheKey);
+      if (cached && this.isCacheValid(cached.metadata)) {
+        if (this.config.debug) {
+          console.log(`[NexusHub] \u26A1 Served collection '${collectionId}' from memory cache.`);
+        }
+        return includeMetadata ? cached : cached.data;
+      }
+    }
+    if (!forceRefresh && !this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+      const cached = this.browserCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    if (!forceRefresh && process.env.NODE_ENV === "development") {
+      const localCollection = this.localCache.getCollection(collectionId);
+      if (localCollection) {
+        const result = this.applyLocalQuery(localCollection, normalizedQuery);
+        if (this.config.debug) {
+          console.log(`[NexusHub] \u{1F4C1} Served collection '${collectionId}' from local cache.`);
+        }
+        this.memoryCache.set(cacheKey, result, {
+          tags: [...tags, CacheTags.collection(collectionId)],
+          revalidate
+        });
+        return result;
+      }
+    }
+    try {
+      await this.rateLimiter.checkLimit();
+      const result = await this.backoff.execute(async () => {
+        return this.fetchCollection(collectionId, normalizedQuery, cacheKey, tags, revalidate);
+      });
+      return includeMetadata ? result : result.data;
+    } catch (error) {
+      const staleCache = this.memoryCache.get(cacheKey);
+      if (staleCache && !forceRefresh) {
+        console.warn(`[NexusHub] \u26A0\uFE0F Using stale cache for collection '${collectionId}'`);
+        return includeMetadata ? staleCache : staleCache.data;
+      }
+      throw this.normalizeError(error, `Failed to fetch collection '${collectionId}'`);
+    }
+  }
+  /**
+   * Fetch Global Settings with nested includes support
+   */
+  async getGlobals(options = {}) {
+    const {
+      include = [],
+      revalidate = this.defaultRevalidate,
+      forceRefresh = false
+    } = options;
+    const cacheKey = `globals:${include.join(",")}`;
+    if (!forceRefresh && this.cacheStrategy === "memory") {
+      const cached = this.memoryCache.get(cacheKey);
+      if (cached && this.isCacheValid(cached.metadata)) {
+        if (this.config.debug) console.log("[NexusHub] \u26A1 Served globals from memory cache.");
+        return cached.data;
+      }
+    }
+    if (!forceRefresh && !this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+      const cached = this.browserCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    if (!forceRefresh && process.env.NODE_ENV === "development") {
+      const localGlobals = this.localCache.getGlobals();
+      if (localGlobals) {
+        this.memoryCache.set(cacheKey, localGlobals, {
+          tags: [CacheTags.global],
+          revalidate
+        });
+        return localGlobals;
+      }
+    }
+    try {
+      await this.rateLimiter.checkLimit();
+      const url = `${this.config.apiUrl}/content/${this.config.projectId}/globals`;
+      const params = include.length > 0 ? `?include=${include.join(",")}` : "";
+      const res = await this.fetchWithTimeout(
+        `${url}${params}`,
+        {
+          method: "GET",
+          headers: this.getHeaders(),
+          next: {
+            tags: [CacheTags.project(this.config.projectId), CacheTags.global],
+            revalidate
+          }
+        }
+      );
+      if (!res.ok) {
+        throw new Error(`API Error ${res.status}: ${res.statusText}`);
+      }
+      const json = await res.json();
+      const data = json.data || json;
+      this.memoryCache.set(cacheKey, data, {
+        tags: [CacheTags.project(this.config.projectId), CacheTags.global],
+        revalidate
+      });
+      if (!this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+        this.browserCache.set(cacheKey, data, revalidate * 1e3);
+      }
+      return data;
+    } catch (error) {
+      const staleCache = this.memoryCache.get(cacheKey);
+      if (staleCache && !forceRefresh) {
+        console.warn("[NexusHub] \u26A0\uFE0F Using stale cache for globals");
+        return staleCache.data;
+      }
+      throw this.normalizeError(error, "Failed to fetch globals");
+    }
+  }
+  /**
+   * Fetch a single item from a collection
+   */
+  async getItem(collectionId, itemId, options = {}) {
+    const cacheKey = `item:${collectionId}:${itemId}`;
+    if (this.cacheStrategy === "memory") {
+      const cached = this.memoryCache.get(cacheKey);
+      if (cached && this.isCacheValid(cached.metadata)) {
+        if (this.config.debug) {
+          console.log(`[NexusHub] \u26A1 Served item '${itemId}' from cache.`);
+        }
+        return cached.data;
+      }
+    }
+    const params = new URLSearchParams();
+    if (options.include?.length) {
+      params.append("include", options.include.join(","));
+    }
+    const url = `${this.config.apiUrl}/content/${this.config.projectId}/collection/${collectionId}/${itemId}?${params}`;
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.getHeaders(),
+      next: {
+        tags: [
+          CacheTags.project(this.config.projectId),
+          CacheTags.collection(collectionId),
+          `item_${itemId}`,
+          ...options.tags || []
+        ],
+        revalidate: options.revalidate || this.defaultRevalidate
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`API Error ${res.status}: ${res.statusText}`);
+    }
+    const json = await res.json();
+    const data = json.data || json;
+    if (this.cacheStrategy === "memory") {
+      this.memoryCache.set(cacheKey, data, {
+        tags: [
+          CacheTags.project(this.config.projectId),
+          CacheTags.collection(collectionId),
+          `item_${itemId}`
+        ],
+        revalidate: options.revalidate || this.defaultRevalidate
+      });
+    }
+    return data;
+  }
+  /**
+   * Search across collections
+   */
+  async search(query, options = {}) {
+    const params = new URLSearchParams({
+      q: query,
+      limit: (options.limit || 20).toString()
+    });
+    if (options.collections?.length) {
+      params.append("collections", options.collections.join(","));
+    }
+    if (options.fields?.length) {
+      params.append("fields", options.fields.join(","));
+    }
+    const url = `${this.config.apiUrl}/content/${this.config.projectId}/search?${params}`;
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.getHeaders(),
+      next: {
+        tags: [CacheTags.project(this.config.projectId), "search"],
+        revalidate: options.revalidate || 60
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`API Error ${res.status}: ${res.statusText}`);
+    }
+    return await res.json();
+  }
+  /**
+   * Prefetch content for better performance
+   */
+  async prefetch(urls) {
+    if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+      requestIdleCallback(async () => {
+        await Promise.allSettled(
+          urls.map((url) => fetch(url, { priority: "low" }))
+        );
+      });
+    }
+  }
+  /**
+   * Invalidate cache by tags
+   */
+  invalidateCache(tags) {
+    this.memoryCache.invalidateByTags(tags);
+    if (this.config.debug) {
+      console.log(`[NexusHub] \u267B\uFE0F Invalidated cache for tags: ${tags.join(", ")}`);
+    }
+  }
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.memoryCache.clear();
+    if (this.browserCache) {
+      this.browserCache.clear();
+    }
+    if (this.config.debug) {
+      console.log("[NexusHub] \u{1F9F9} Cleared all caches");
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    const stats = {
+      memory: this.memoryCache.getStats(),
+      local: { loaded: this.localCache.isLoaded() }
+    };
+    if (this.browserCache) {
+      stats.browser = { size: 0 };
+    }
+    return stats;
+  }
+  /**
+   * Cancel ongoing requests
+   */
+  cancelRequests() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = new AbortController();
+    }
+  }
+  /**
+   * Subscribe to content updates (SSE)
+   */
+  subscribeToUpdates(callback) {
+    if (typeof EventSource === "undefined") {
+      console.warn("[NexusHub] EventSource not supported in this environment");
+      return () => {
+      };
+    }
+    const eventSource = new EventSource(
+      `${this.config.apiUrl}/content/${this.config.projectId}/updates`
+    );
+    eventSource.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        callback(data);
+        if (data.type === "content.updated" && data.slug) {
+          this.invalidateCache([CacheTags.content(data.slug)]);
+        }
+      } catch (error) {
+        console.error("[NexusHub] Failed to parse update event:", error);
+      }
+    };
+    eventSource.onerror = (error) => {
+      console.error("[NexusHub] EventSource error:", error);
+      eventSource.close();
+    };
+    return () => {
+      eventSource.close();
+    };
+  }
+  // Private helper methods
+  async fetchPage(slug, cacheKey, tags, revalidate, forceRefresh) {
+    const url = `${this.config.apiUrl}/content/${this.config.projectId}/page/${slug}`;
+    if (this.config.debug) {
+      console.log(`[NexusHub] \u{1F310} Fetching: ${url}`);
+    }
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.getHeaders(),
+      next: {
+        tags: [
+          CacheTags.project(this.config.projectId),
+          CacheTags.content(slug),
+          ...tags
+        ],
+        revalidate
+      }
+    });
+    if (!res.ok) {
+      if (res.status === 404) {
+        throw new Error(`Page '${slug}' not found. Check your Dashboard or Seed data.`);
+      }
+      throw new Error(`API Error ${res.status}: ${res.statusText}`);
+    }
+    const json = await res.json();
+    const etag = res.headers.get("etag");
+    const cacheEntry = {
+      data: json.data,
+      metadata: {
+        timestamp: Date.now(),
+        etag: etag || void 0,
+        expiresAt: Date.now() + revalidate * 1e3,
+        tags: [...tags, CacheTags.content(slug)]
+      }
+    };
+    if (this.cacheStrategy === "memory") {
+      this.memoryCache.set(cacheKey, cacheEntry.data, {
+        tags: cacheEntry.metadata.tags,
+        revalidate
+      });
+    }
+    if (!this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+      this.browserCache.set(cacheKey, cacheEntry.data, revalidate * 1e3);
+    }
+    return cacheEntry;
+  }
+  async fetchCollection(collectionId, query, cacheKey, tags, revalidate) {
+    const params = buildQueryString(query);
+    const url = `${this.config.apiUrl}/content/${this.config.projectId}/collection/${collectionId}?${params}`;
+    if (this.config.debug) {
+      console.log(`[NexusHub] \u{1F310} Fetching Collection: ${url}`);
+    }
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.getHeaders(),
+      next: {
+        tags: [
+          CacheTags.project(this.config.projectId),
+          CacheTags.collection(collectionId),
+          ...tags
+        ],
+        revalidate
+      }
+    });
+    if (!res.ok) {
+      throw new Error(`API Error ${res.status}: ${res.statusText}`);
+    }
+    const json = await res.json();
+    const etag = res.headers.get("etag");
+    const cacheEntry = {
+      data: json,
+      metadata: {
+        timestamp: Date.now(),
+        etag: etag || void 0,
+        expiresAt: Date.now() + revalidate * 1e3,
+        tags: [...tags, CacheTags.collection(collectionId)]
+      }
+    };
+    if (this.cacheStrategy === "memory") {
+      this.memoryCache.set(cacheKey, cacheEntry.data, {
+        tags: cacheEntry.metadata.tags,
+        revalidate
+      });
+    }
+    if (!this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+      this.browserCache.set(cacheKey, cacheEntry.data, revalidate * 1e3);
+    }
+    return cacheEntry;
+  }
+  async fetchWithTimeout(url, options = {}) {
+    const { timeout = this.config.timeout || 1e4, next, ...fetchOptions } = options;
+    this.abortController = new AbortController();
+    const timeoutId = setTimeout(() => {
+      this.abortController.abort();
+    }, timeout);
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        signal: this.abortController.signal
+      });
+      clearTimeout(timeoutId);
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  applyLocalQuery(items, query) {
+    let filtered = [...items];
+    if (query.search) {
+      const searchLower = query.search.toLowerCase();
+      filtered = filtered.filter(
+        (item) => JSON.stringify(item).toLowerCase().includes(searchLower)
+      );
+    }
+    if (query.filter) {
+      filtered = filtered.filter((item) => {
+        return Object.entries(query.filter).every(([key, value]) => {
+          const itemValue = item[key];
+          if (itemValue === void 0) return false;
+          if (Array.isArray(value)) {
+            return value.includes(itemValue);
+          }
+          return itemValue === value;
+        });
+      });
+    }
+    if (query.sort) {
+      filtered.sort((a, b) => {
+        const aVal = a[query.sort];
+        const bVal = b[query.sort];
+        const order = query.order === "asc" ? 1 : -1;
+        if (aVal < bVal) return -1 * order;
+        if (aVal > bVal) return 1 * order;
+        return 0;
+      });
+    }
+    const page = query.page || 1;
+    const limit = query.limit || 10;
+    const start = (page - 1) * limit;
+    const end = start + limit;
+    const total = filtered.length;
+    return {
+      items: filtered.slice(start, end),
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit),
+      hasNext: end < total,
+      hasPrev: start > 0
+    };
+  }
+  isCacheValid(metadata) {
+    return Date.now() < metadata.expiresAt;
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Nexus-Client": "client-sdk/1.0.0",
+      "X-Nexus-Project": this.config.projectId
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    return headers;
+  }
+  normalizeError(error, context) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new Error(`${context}: Request timeout`);
+      }
+      return error;
+    }
+    return new Error(`${context}: ${String(error)}`);
+  }
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.cancelRequests();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("beforeunload", this.cleanup.bind(this));
+    }
+  }
+};
+
+// src/client.ts
+var NexusClient = class {
+  constructor(config) {
+    const fullConfig = getFullConfig(config);
+    this.config = {
+      debug: config?.debug || false,
+      cacheStrategy: config?.cacheStrategy || "memory",
+      revalidateTime: config?.revalidateTime || 60,
+      timeout: config?.timeout || 1e4,
+      retries: config?.retries || 3,
+      ...fullConfig
+    };
+    const errors = validateConfig(this.config);
+    if (errors.length > 0) {
+      console.warn("\u26A0\uFE0F NexusHub: Configuration issues:", errors.join(", "));
+      if (!this.config.projectId) {
+        console.warn("\u26A0\uFE0F NexusHub: No Project ID found. Content fetching will fail.");
+      }
+    }
+    this.content = new ContentEngine(this.config);
+  }
+  // Helper alias for cleaner code
+  getPage(slug, options) {
+    return this.content.getPage(slug, options);
+  }
+  // Get current config (readonly)
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var nexus = new NexusClient();
+var createNexusClient = (config) => new NexusClient(config);
+
+// src/components/NexusProvider.tsx
+var import_react2 = require("react");
+var import_navigation = __toESM(require_navigation2());
+
+// src/analytics/tracker.ts
+var Tracker = class {
+  constructor(config) {
+    this.queue = [];
+    this.isFlushing = false;
+    this.SDK_VERSION = "1.0.0";
+    this.config = config;
+    this.sessionId = this.getSessionId();
+    this.sessionStart = Date.now();
+    this.endpoint = `${this.config.apiUrl.replace("/v1", "")}:3002/collect`;
+    if (typeof window !== "undefined") {
+      this.startFlushing();
+    }
+  }
+  /**
+   * Generates or retrieves a persistent Session ID
+   */
+  getSessionId() {
+    if (typeof window === "undefined") return "server-session";
+    let sid = localStorage.getItem("nexus_sid");
+    let sessionStart = localStorage.getItem("nexus_session_start");
+    const now = Date.now();
+    const THIRTY_MINUTES = 30 * 60 * 1e3;
+    if (!sid || !sessionStart || now - parseInt(sessionStart) > THIRTY_MINUTES) {
+      sid = `sess_${Math.random().toString(36).substring(2, 11)}_${now}`;
+      localStorage.setItem("nexus_sid", sid);
+      localStorage.setItem("nexus_session_start", now.toString());
+      localStorage.removeItem("nexus_last_event");
+    }
+    return sid;
+  }
+  /**
+   * Start periodic flushing of analytics queue
+   */
+  startFlushing() {
+    this.flushInterval = setInterval(() => {
+      this.flushQueue();
+    }, 1e4);
+    window.addEventListener("beforeunload", () => {
+      this.flushQueue(true);
+    });
+  }
+  /**
+   * Send data to Rust Engine via Beacon or Fetch
+   */
+  send(eventType, payload = {}) {
+    if (typeof window === "undefined") return;
+    const eventData = {
+      project_id: this.config.projectId,
+      session_id: this.sessionId,
+      url: window.location.href,
+      referrer: document.referrer,
+      user_agent: window.navigator.userAgent,
+      screen_width: window.screen.width,
+      screen_height: window.screen.height,
+      language: window.navigator.language,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      event_type: eventType,
+      event_data: payload,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      version: this.SDK_VERSION
+    };
+    this.queue.push(eventData);
+    localStorage.setItem("nexus_last_event", JSON.stringify({
+      type: eventType,
+      timestamp: eventData.timestamp
+    }));
+    if (this.queue.length >= 20) {
+      this.flushQueue();
+    }
+  }
+  /**
+   * Get session ID
+   */
+  getSession() {
+    return this.sessionId;
+  }
+  /**
+   * Get session duration
+   */
+  getSessionDuration() {
+    return Date.now() - this.sessionStart;
+  }
+  /**
+   * Get session information
+   */
+  getSessionInfo() {
+    return {
+      id: this.sessionId,
+      start: this.sessionStart,
+      duration: this.getSessionDuration(),
+      eventsCount: this.queue.length
+    };
+  }
+  /**
+   * Flush the queue to the analytics endpoint
+   */
+  async flushQueue(forceSync = false) {
+    if (this.isFlushing || this.queue.length === 0) return;
+    this.isFlushing = true;
+    const events = [...this.queue];
+    this.queue = [];
+    try {
+      const payload = {
+        project_id: this.config.projectId,
+        events,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (forceSync && "navigator" in window && navigator.sendBeacon) {
+        const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
+        const success = navigator.sendBeacon(this.endpoint, blob);
+        if (!success) {
+          await fetch(this.endpoint, {
+            method: "POST",
+            body: JSON.stringify(payload),
+            headers: { "Content-Type": "application/json" },
+            keepalive: true
+          });
+        }
+      } else {
+        await fetch(this.endpoint, {
+          method: "POST",
+          body: JSON.stringify(payload),
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    } catch (error) {
+      console.error("NexusHub Analytics Error:", error);
+      const fiveMinutesAgo = Date.now() - 5 * 60 * 1e3;
+      const recentEvents = events.filter(
+        (event) => new Date(event.timestamp).getTime() > fiveMinutesAgo
+      );
+      this.queue.unshift(...recentEvents);
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Manually flush events
+   */
+  async flush() {
+    await this.flushQueue();
+  }
+  /**
+   * Stop tracking and cleanup
+   */
+  stop() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+    }
+    this.flushQueue(true);
+  }
+};
+
+// src/analytics/vitals.ts
+var import_web_vitals = require("web-vitals");
+var initVitals = (tracker) => {
+  if (typeof window === "undefined") return;
+  const sendMetric = (metric) => {
+    tracker.send("web_vital", {
+      metric_name: metric.name,
+      value: Math.round(metric.value * 100) / 100,
+      // Round to 2 decimal places
+      rating: metric.rating,
+      // 'good', 'needs-improvement', 'poor'
+      delta: Math.round(metric.delta * 100) / 100,
+      id: metric.id,
+      navigation_type: metric.navigationType
+    });
+    if (process.env.NODE_ENV === "development") {
+      console.log(`\u{1F4CA} ${metric.name}: ${metric.value} (${metric.rating})`);
+    }
+  };
+  (0, import_web_vitals.onCLS)(sendMetric);
+  (0, import_web_vitals.onLCP)(sendMetric);
+  (0, import_web_vitals.onTTFB)(sendMetric);
+  (0, import_web_vitals.onINP)(sendMetric);
+  if ("PerformanceObserver" in window) {
+    const lcpObserver = new PerformanceObserver((entryList) => {
+      for (const entry of entryList.getEntries()) {
+        const lcpEntry = entry;
+        tracker.send("performance_entry", {
+          type: entry.entryType,
+          name: entry.name,
+          startTime: Math.round(entry.startTime),
+          duration: Math.round(entry.duration),
+          renderTime: Math.round(lcpEntry.renderTime || 0),
+          loadTime: Math.round(lcpEntry.loadTime || 0),
+          size: lcpEntry.size
+        });
+      }
+    });
+    lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+    const fcpObserver = new PerformanceObserver((entryList) => {
+      for (const entry of entryList.getEntries()) {
+        tracker.send("performance_entry", {
+          type: entry.entryType,
+          name: entry.name,
+          startTime: Math.round(entry.startTime)
+        });
+      }
+    });
+    fcpObserver.observe({ type: "paint", buffered: true });
+    const longTaskObserver = new PerformanceObserver((entryList) => {
+      for (const entry of entryList.getEntries()) {
+        if (entry.duration > 50) {
+          const taskEntry = entry;
+          tracker.send("long_task", {
+            duration: Math.round(entry.duration),
+            startTime: Math.round(entry.startTime),
+            attribution: taskEntry.attribution
+          });
+        }
+      }
+    });
+    longTaskObserver.observe({ type: "longtask", buffered: true });
+  }
+  if ("memory" in performance) {
+    const memory = performance.memory;
+    tracker.send("memory_usage", {
+      usedJSHeapSize: memory.usedJSHeapSize,
+      totalJSHeapSize: memory.totalJSHeapSize,
+      jsHeapSizeLimit: memory.jsHeapSizeLimit
+    });
+  }
+  if ("connection" in navigator && navigator.connection) {
+    const connection = navigator.connection;
+    tracker.send("network_info", {
+      effectiveType: connection.effectiveType,
+      downlink: connection.downlink,
+      rtt: connection.rtt,
+      saveData: connection.saveData
+    });
+  }
+};
+
+// src/analytics/index.ts
+var AnalyticsEngine = class {
+  constructor(config) {
+    this.tracker = new Tracker(config);
+  }
+  start() {
+    this.pageView();
+    initVitals(this.tracker);
+    if (typeof window !== "undefined") {
+      window.addEventListener("click", (e) => {
+        const target = e.target;
+        const link = target.closest("a");
+        if (link) {
+          this.tracker.send("click", {
+            href: link.href,
+            text: link.innerText.substring(0, 100),
+            // Limit text length
+            id: link.id,
+            className: link.className,
+            dataset: link.dataset
+          });
+        }
+        const button = target.closest("button");
+        if (button) {
+          this.tracker.send("button_click", {
+            text: button.innerText.substring(0, 100),
+            id: button.id,
+            className: button.className,
+            type: button.type
+          });
+        }
+      });
+      document.addEventListener("submit", (e) => {
+        const form = e.target;
+        if (form) {
+          this.tracker.send("form_submit", {
+            formId: form.id,
+            action: form.action,
+            method: form.method,
+            fieldsCount: form.elements.length
+          });
+        }
+      });
+      if (typeof window.history !== "undefined") {
+        const originalPushState = history.pushState;
+        const originalReplaceState = history.replaceState;
+        history.pushState = function(...args) {
+          originalPushState.apply(this, args);
+          window.dispatchEvent(new Event("pushstate"));
+          window.dispatchEvent(new Event("locationchange"));
+        };
+        history.replaceState = function(...args) {
+          originalReplaceState.apply(this, args);
+          window.dispatchEvent(new Event("replacestate"));
+          window.dispatchEvent(new Event("locationchange"));
+        };
+        window.addEventListener("popstate", () => {
+          window.dispatchEvent(new Event("locationchange"));
+        });
+        window.addEventListener("locationchange", () => {
+          this.pageView();
+        });
+      }
+    }
+  }
+  pageView() {
+    if (typeof window !== "undefined") {
+      const pageData = {
+        path: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash,
+        referrer: document.referrer,
+        title: document.title
+      };
+      this.tracker.send("page_view", pageData);
+    }
+  }
+  /**
+   * The "Handshake" - Linking Anonymous to Known User
+   */
+  async identify(userId, traits = {}) {
+    try {
+      const endpoint = `${this.tracker["config"].apiUrl.replace("/v1", "")}:3002/identify`;
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          project_id: this.tracker["config"].projectId,
+          session_id: this.tracker.getSession(),
+          user_id: userId,
+          traits,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      });
+      return response.ok;
+    } catch (error) {
+      console.error("NexusHub Analytics Identify Error:", error);
+      return false;
+    }
+  }
+  /**
+   * Track custom events
+   */
+  track(eventName, properties = {}) {
+    this.tracker.send("custom_event", {
+      event_name: eventName,
+      ...properties
+    });
+  }
+  /**
+   * Set user properties
+   */
+  setUserProperties(properties) {
+    this.tracker.send("user_properties", properties);
+  }
+  /**
+   * Track e-commerce events
+   */
+  trackPurchase(orderData) {
+    this.tracker.send("purchase", {
+      ...orderData,
+      currency: orderData.currency || "USD",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Track errors
+   */
+  trackError(error, context) {
+    this.tracker.send("error", {
+      message: error.message,
+      stack: error.stack,
+      context,
+      url: typeof window !== "undefined" ? window.location.href : "",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return this.tracker.getSession();
+  }
+  /**
+   * Stop analytics tracking
+   */
+  stop() {
+    this.tracker.send("session_end", {
+      session_id: this.tracker.getSession(),
+      duration: this.tracker.getSessionDuration()
+    });
+  }
+};
+
+// src/auth/context.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var AuthContext = (0, import_react.createContext)(null);
+var AuthProvider = ({
+  children,
+  config
+}) => {
+  const [user, setUser] = (0, import_react.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const [error, setError] = (0, import_react.useState)(null);
+  const API_URL = `${config.apiUrl}/project-auth`;
+  (0, import_react.useEffect)(() => {
+    checkSession();
+  }, []);
+  const checkSession = async () => {
+    try {
+      const res = await fetch(`${API_URL}/me`, {
+        headers: { "x-project-id": config.projectId }
+      });
+      if (res.ok) {
+        const data = await res.json();
+        setUser(data);
+      }
+    } catch (err) {
+      setUser(null);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const login = async (creds) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const res = await fetch(`${API_URL}/login`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-project-id": config.projectId
+        },
+        body: JSON.stringify(creds)
+      });
+      if (!res.ok) throw new Error(await res.text());
+      const data = await res.json();
+      setUser(data.user);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const register = async (creds) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const res = await fetch(`${API_URL}/register`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-project-id": config.projectId
+        },
+        body: JSON.stringify(creds)
+      });
+      if (!res.ok) throw new Error(await res.text());
+      const data = await res.json();
+      setUser(data.user);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const logout = async () => {
+    try {
+      await fetch(`${API_URL}/logout`, { method: "POST" });
+      setUser(null);
+    } catch (err) {
+      console.error("Logout failed", err);
+    }
+  };
+  const loginWithGoogle = () => {
+    window.location.href = `${API_URL}/google?projectId=${config.projectId}`;
+  };
+  const updateProfile = async (data) => {
+    const res = await fetch(`${API_URL}/me`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        "x-project-id": config.projectId
+      },
+      body: JSON.stringify(data)
+    });
+    if (res.ok) {
+      const updated = await res.json();
+      setUser(updated);
+    }
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value: {
+    user,
+    isLoading,
+    error,
+    isAuthenticated: !!user,
+    login,
+    register,
+    logout,
+    loginWithGoogle,
+    updateProfile
+  }, children });
+};
+var useNexusAuth = () => {
+  const context = (0, import_react.useContext)(AuthContext);
+  if (!context) {
+    throw new Error("useNexusAuth must be used within a NexusProvider");
+  }
+  return context;
+};
+
+// src/components/NexusProvider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var NexusContext = (0, import_react2.createContext)(null);
+var NexusProvider = ({
+  children,
+  projectId
+}) => {
+  const pathname = (0, import_navigation.usePathname)();
+  const searchParams = (0, import_navigation.useSearchParams)();
+  const analyticsRef = (0, import_react2.useRef)(null);
+  (0, import_react2.useEffect)(() => {
+    if (!analyticsRef.current) {
+      if (projectId) {
+        nexus["config"].projectId = projectId;
+      }
+      analyticsRef.current = new AnalyticsEngine(nexus["config"]);
+      analyticsRef.current.start();
+    }
+  }, [projectId]);
+  (0, import_react2.useEffect)(() => {
+    if (analyticsRef.current) {
+      analyticsRef.current.pageView();
+    }
+  }, [pathname, searchParams]);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(NexusContext.Provider, { value: nexus, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthProvider, { config: nexus["config"], children }) });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserCache,
+  CacheTags,
+  ContentEngine,
+  ExponentialBackoff,
+  LocalCache,
+  MemoryCache,
+  NexusClient,
+  NexusProvider,
+  RateLimiter,
+  RequestBatcher,
+  createNexusClient,
+  nexus,
+  useNexusAuth
+});