flowlink-auth 2.7.6 → 2.7.8

package/dist/index.js

@@ -1,3 +1,3767 @@
+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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs
+var require_interop_require_wildcard = __commonJS({
+  "node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs"(exports) {
+    "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;
+    }
+    exports._ = _interop_require_wildcard;
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/querystring.js
+var require_querystring = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/querystring.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      assign: function() {
+        return assign;
+      },
+      searchParamsToUrlQuery: function() {
+        return searchParamsToUrlQuery;
+      },
+      urlQueryToSearchParams: function() {
+        return urlQueryToSearchParams;
+      }
+    });
+    function searchParamsToUrlQuery(searchParams) {
+      const query = {};
+      for (const [key, value] of searchParams.entries()) {
+        const existing = query[key];
+        if (typeof existing === "undefined") {
+          query[key] = value;
+        } else if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          query[key] = [
+            existing,
+            value
+          ];
+        }
+      }
+      return query;
+    }
+    function stringifyUrlQueryParam(param) {
+      if (typeof param === "string") {
+        return param;
+      }
+      if (typeof param === "number" && !isNaN(param) || typeof param === "boolean") {
+        return String(param);
+      } else {
+        return "";
+      }
+    }
+    function urlQueryToSearchParams(query) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(query)) {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            searchParams.append(key, stringifyUrlQueryParam(item));
+          }
+        } else {
+          searchParams.set(key, stringifyUrlQueryParam(value));
+        }
+      }
+      return searchParams;
+    }
+    function assign(target, ...searchParamsList) {
+      for (const searchParams of searchParamsList) {
+        for (const key of searchParams.keys()) {
+          target.delete(key);
+        }
+        for (const [key, value] of searchParams.entries()) {
+          target.append(key, value);
+        }
+      }
+      return target;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/format-url.js
+var require_format_url = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/format-url.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      formatUrl: function() {
+        return formatUrl;
+      },
+      formatWithValidation: function() {
+        return formatWithValidation;
+      },
+      urlObjectKeys: function() {
+        return urlObjectKeys;
+      }
+    });
+    var _interop_require_wildcard = require_interop_require_wildcard();
+    var _querystring = /* @__PURE__ */ _interop_require_wildcard._(require_querystring());
+    var slashedProtocols = /https?|ftp|gopher|file/;
+    function formatUrl(urlObj) {
+      let { auth, hostname } = urlObj;
+      let protocol = urlObj.protocol || "";
+      let pathname = urlObj.pathname || "";
+      let hash = urlObj.hash || "";
+      let query = urlObj.query || "";
+      let host = false;
+      auth = auth ? encodeURIComponent(auth).replace(/%3A/i, ":") + "@" : "";
+      if (urlObj.host) {
+        host = auth + urlObj.host;
+      } else if (hostname) {
+        host = auth + (~hostname.indexOf(":") ? `[${hostname}]` : hostname);
+        if (urlObj.port) {
+          host += ":" + urlObj.port;
+        }
+      }
+      if (query && typeof query === "object") {
+        query = String(_querystring.urlQueryToSearchParams(query));
+      }
+      let search = urlObj.search || query && `?${query}` || "";
+      if (protocol && !protocol.endsWith(":")) protocol += ":";
+      if (urlObj.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
+        host = "//" + (host || "");
+        if (pathname && pathname[0] !== "/") pathname = "/" + pathname;
+      } else if (!host) {
+        host = "";
+      }
+      if (hash && hash[0] !== "#") hash = "#" + hash;
+      if (search && search[0] !== "?") search = "?" + search;
+      pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+      search = search.replace("#", "%23");
+      return `${protocol}${host}${pathname}${search}${hash}`;
+    }
+    var urlObjectKeys = [
+      "auth",
+      "hash",
+      "host",
+      "hostname",
+      "href",
+      "path",
+      "pathname",
+      "port",
+      "protocol",
+      "query",
+      "search",
+      "slashes"
+    ];
+    function formatWithValidation(url) {
+      if (true) {
+        if (url !== null && typeof url === "object") {
+          Object.keys(url).forEach((key) => {
+            if (!urlObjectKeys.includes(key)) {
+              console.warn(`Unknown key passed via urlObject into url.format: ${key}`);
+            }
+          });
+        }
+      }
+      return formatUrl(url);
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/omit.js
+var require_omit = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/omit.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "omit", {
+      enumerable: true,
+      get: function() {
+        return omit;
+      }
+    });
+    function omit(object, keys) {
+      const omitted = {};
+      Object.keys(object).forEach((key) => {
+        if (!keys.includes(key)) {
+          omitted[key] = object[key];
+        }
+      });
+      return omitted;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/utils.js
+var require_utils = __commonJS({
+  "node_modules/next/dist/shared/lib/utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      DecodeError: function() {
+        return DecodeError;
+      },
+      MiddlewareNotFoundError: function() {
+        return MiddlewareNotFoundError;
+      },
+      MissingStaticPage: function() {
+        return MissingStaticPage;
+      },
+      NormalizeError: function() {
+        return NormalizeError;
+      },
+      PageNotFoundError: function() {
+        return PageNotFoundError;
+      },
+      SP: function() {
+        return SP;
+      },
+      ST: function() {
+        return ST;
+      },
+      WEB_VITALS: function() {
+        return WEB_VITALS;
+      },
+      execOnce: function() {
+        return execOnce;
+      },
+      getDisplayName: function() {
+        return getDisplayName;
+      },
+      getLocationOrigin: function() {
+        return getLocationOrigin;
+      },
+      getURL: function() {
+        return getURL;
+      },
+      isAbsoluteUrl: function() {
+        return isAbsoluteUrl;
+      },
+      isResSent: function() {
+        return isResSent;
+      },
+      loadGetInitialProps: function() {
+        return loadGetInitialProps;
+      },
+      normalizeRepeatedSlashes: function() {
+        return normalizeRepeatedSlashes;
+      },
+      stringifyError: function() {
+        return stringifyError;
+      }
+    });
+    var WEB_VITALS = [
+      "CLS",
+      "FCP",
+      "FID",
+      "INP",
+      "LCP",
+      "TTFB"
+    ];
+    function execOnce(fn) {
+      let used = false;
+      let result;
+      return (...args) => {
+        if (!used) {
+          used = true;
+          result = fn(...args);
+        }
+        return result;
+      };
+    }
+    var ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
+    var isAbsoluteUrl = (url) => ABSOLUTE_URL_REGEX.test(url);
+    function getLocationOrigin() {
+      const { protocol, hostname, port } = window.location;
+      return `${protocol}//${hostname}${port ? ":" + port : ""}`;
+    }
+    function getURL() {
+      const { href } = window.location;
+      const origin = getLocationOrigin();
+      return href.substring(origin.length);
+    }
+    function getDisplayName(Component) {
+      return typeof Component === "string" ? Component : Component.displayName || Component.name || "Unknown";
+    }
+    function isResSent(res) {
+      return res.finished || res.headersSent;
+    }
+    function normalizeRepeatedSlashes(url) {
+      const urlParts = url.split("?");
+      const urlNoQuery = urlParts[0];
+      return urlNoQuery.replace(/\\/g, "/").replace(/\/\/+/g, "/") + (urlParts[1] ? `?${urlParts.slice(1).join("?")}` : "");
+    }
+    async function loadGetInitialProps(App, ctx) {
+      if (true) {
+        if (App.prototype?.getInitialProps) {
+          const message = `"${getDisplayName(App)}.getInitialProps()" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.`;
+          throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+            value: "E394",
+            enumerable: false,
+            configurable: true
+          });
+        }
+      }
+      const res = ctx.res || ctx.ctx && ctx.ctx.res;
+      if (!App.getInitialProps) {
+        if (ctx.ctx && ctx.Component) {
+          return {
+            pageProps: await loadGetInitialProps(ctx.Component, ctx.ctx)
+          };
+        }
+        return {};
+      }
+      const props = await App.getInitialProps(ctx);
+      if (res && isResSent(res)) {
+        return props;
+      }
+      if (!props) {
+        const message = `"${getDisplayName(App)}.getInitialProps()" should resolve to an object. But found "${props}" instead.`;
+        throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+          value: "E394",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      if (true) {
+        if (Object.keys(props).length === 0 && !ctx.ctx) {
+          console.warn(`${getDisplayName(App)} returned an empty object from \`getInitialProps\`. This de-optimizes and prevents automatic static optimization. https://nextjs.org/docs/messages/empty-object-getInitialProps`);
+        }
+      }
+      return props;
+    }
+    var SP = typeof performance !== "undefined";
+    var ST = SP && [
+      "mark",
+      "measure",
+      "getEntriesByName"
+    ].every((method) => typeof performance[method] === "function");
+    var DecodeError = class extends Error {
+    };
+    var NormalizeError = class extends Error {
+    };
+    var PageNotFoundError = class extends Error {
+      constructor(page) {
+        super();
+        this.code = "ENOENT";
+        this.name = "PageNotFoundError";
+        this.message = `Cannot find module for page: ${page}`;
+      }
+    };
+    var MissingStaticPage = class extends Error {
+      constructor(page, message) {
+        super();
+        this.message = `Failed to load static file for page: ${page} ${message}`;
+      }
+    };
+    var MiddlewareNotFoundError = class extends Error {
+      constructor() {
+        super();
+        this.code = "ENOENT";
+        this.message = `Cannot find the middleware module`;
+      }
+    };
+    function stringifyError(error) {
+      return JSON.stringify({
+        message: error.message,
+        stack: error.stack
+      });
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js
+var require_remove_trailing_slash = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "removeTrailingSlash", {
+      enumerable: true,
+      get: function() {
+        return removeTrailingSlash;
+      }
+    });
+    function removeTrailingSlash(route) {
+      return route.replace(/\/$/, "") || "/";
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/parse-path.js
+var require_parse_path = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/parse-path.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "parsePath", {
+      enumerable: true,
+      get: function() {
+        return parsePath;
+      }
+    });
+    function parsePath(path) {
+      const hashIndex = path.indexOf("#");
+      const queryIndex = path.indexOf("?");
+      const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+      if (hasQuery || hashIndex > -1) {
+        return {
+          pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+          query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : void 0) : "",
+          hash: hashIndex > -1 ? path.slice(hashIndex) : ""
+        };
+      }
+      return {
+        pathname: path,
+        query: "",
+        hash: ""
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/client/normalize-trailing-slash.js
+var require_normalize_trailing_slash = __commonJS({
+  "node_modules/next/dist/client/normalize-trailing-slash.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "normalizePathTrailingSlash", {
+      enumerable: true,
+      get: function() {
+        return normalizePathTrailingSlash;
+      }
+    });
+    var _removetrailingslash = require_remove_trailing_slash();
+    var _parsepath = require_parse_path();
+    var normalizePathTrailingSlash = (path) => {
+      if (!path.startsWith("/") || process.env.__NEXT_MANUAL_TRAILING_SLASH) {
+        return path;
+      }
+      const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+      if (process.env.__NEXT_TRAILING_SLASH) {
+        if (/\.[^/]+\/?$/.test(pathname)) {
+          return `${(0, _removetrailingslash.removeTrailingSlash)(pathname)}${query}${hash}`;
+        } else if (pathname.endsWith("/")) {
+          return `${pathname}${query}${hash}`;
+        } else {
+          return `${pathname}/${query}${hash}`;
+        }
+      }
+      return `${(0, _removetrailingslash.removeTrailingSlash)(pathname)}${query}${hash}`;
+    };
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js
+var require_path_has_prefix = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "pathHasPrefix", {
+      enumerable: true,
+      get: function() {
+        return pathHasPrefix;
+      }
+    });
+    var _parsepath = require_parse_path();
+    function pathHasPrefix(path, prefix) {
+      if (typeof path !== "string") {
+        return false;
+      }
+      const { pathname } = (0, _parsepath.parsePath)(path);
+      return pathname === prefix || pathname.startsWith(prefix + "/");
+    }
+  }
+});
+
+// node_modules/next/dist/client/has-base-path.js
+var require_has_base_path = __commonJS({
+  "node_modules/next/dist/client/has-base-path.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "hasBasePath", {
+      enumerable: true,
+      get: function() {
+        return hasBasePath;
+      }
+    });
+    var _pathhasprefix = require_path_has_prefix();
+    var basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+    function hasBasePath(path) {
+      return (0, _pathhasprefix.pathHasPrefix)(path, basePath);
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/is-local-url.js
+var require_is_local_url = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/is-local-url.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "isLocalURL", {
+      enumerable: true,
+      get: function() {
+        return isLocalURL;
+      }
+    });
+    var _utils = require_utils();
+    var _hasbasepath = require_has_base_path();
+    function isLocalURL(url) {
+      if (!(0, _utils.isAbsoluteUrl)(url)) return true;
+      try {
+        const locationOrigin = (0, _utils.getLocationOrigin)();
+        const resolved = new URL(url, locationOrigin);
+        return resolved.origin === locationOrigin && (0, _hasbasepath.hasBasePath)(resolved.pathname);
+      } catch (_) {
+        return false;
+      }
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/sorted-routes.js
+var require_sorted_routes = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/sorted-routes.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      getSortedRouteObjects: function() {
+        return getSortedRouteObjects;
+      },
+      getSortedRoutes: function() {
+        return getSortedRoutes;
+      }
+    });
+    var UrlNode = class _UrlNode {
+      insert(urlPath) {
+        this._insert(urlPath.split("/").filter(Boolean), [], false);
+      }
+      smoosh() {
+        return this._smoosh();
+      }
+      _smoosh(prefix = "/") {
+        const childrenPaths = [
+          ...this.children.keys()
+        ].sort();
+        if (this.slugName !== null) {
+          childrenPaths.splice(childrenPaths.indexOf("[]"), 1);
+        }
+        if (this.restSlugName !== null) {
+          childrenPaths.splice(childrenPaths.indexOf("[...]"), 1);
+        }
+        if (this.optionalRestSlugName !== null) {
+          childrenPaths.splice(childrenPaths.indexOf("[[...]]"), 1);
+        }
+        const routes = childrenPaths.map((c) => this.children.get(c)._smoosh(`${prefix}${c}/`)).reduce((prev, curr) => [
+          ...prev,
+          ...curr
+        ], []);
+        if (this.slugName !== null) {
+          routes.push(...this.children.get("[]")._smoosh(`${prefix}[${this.slugName}]/`));
+        }
+        if (!this.placeholder) {
+          const r = prefix === "/" ? "/" : prefix.slice(0, -1);
+          if (this.optionalRestSlugName != null) {
+            throw Object.defineProperty(new Error(`You cannot define a route with the same specificity as a optional catch-all route ("${r}" and "${r}[[...${this.optionalRestSlugName}]]").`), "__NEXT_ERROR_CODE", {
+              value: "E458",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          routes.unshift(r);
+        }
+        if (this.restSlugName !== null) {
+          routes.push(...this.children.get("[...]")._smoosh(`${prefix}[...${this.restSlugName}]/`));
+        }
+        if (this.optionalRestSlugName !== null) {
+          routes.push(...this.children.get("[[...]]")._smoosh(`${prefix}[[...${this.optionalRestSlugName}]]/`));
+        }
+        return routes;
+      }
+      _insert(urlPaths, slugNames, isCatchAll) {
+        if (urlPaths.length === 0) {
+          this.placeholder = false;
+          return;
+        }
+        if (isCatchAll) {
+          throw Object.defineProperty(new Error(`Catch-all must be the last part of the URL.`), "__NEXT_ERROR_CODE", {
+            value: "E392",
+            enumerable: false,
+            configurable: true
+          });
+        }
+        let nextSegment = urlPaths[0];
+        if (nextSegment.startsWith("[") && nextSegment.endsWith("]")) {
+          let handleSlug = function(previousSlug, nextSlug) {
+            if (previousSlug !== null) {
+              if (previousSlug !== nextSlug) {
+                throw Object.defineProperty(new Error(`You cannot use different slug names for the same dynamic path ('${previousSlug}' !== '${nextSlug}').`), "__NEXT_ERROR_CODE", {
+                  value: "E337",
+                  enumerable: false,
+                  configurable: true
+                });
+              }
+            }
+            slugNames.forEach((slug) => {
+              if (slug === nextSlug) {
+                throw Object.defineProperty(new Error(`You cannot have the same slug name "${nextSlug}" repeat within a single dynamic path`), "__NEXT_ERROR_CODE", {
+                  value: "E247",
+                  enumerable: false,
+                  configurable: true
+                });
+              }
+              if (slug.replace(/\W/g, "") === nextSegment.replace(/\W/g, "")) {
+                throw Object.defineProperty(new Error(`You cannot have the slug names "${slug}" and "${nextSlug}" differ only by non-word symbols within a single dynamic path`), "__NEXT_ERROR_CODE", {
+                  value: "E499",
+                  enumerable: false,
+                  configurable: true
+                });
+              }
+            });
+            slugNames.push(nextSlug);
+          };
+          let segmentName = nextSegment.slice(1, -1);
+          let isOptional = false;
+          if (segmentName.startsWith("[") && segmentName.endsWith("]")) {
+            segmentName = segmentName.slice(1, -1);
+            isOptional = true;
+          }
+          if (segmentName.startsWith("\u2026")) {
+            throw Object.defineProperty(new Error(`Detected a three-dot character ('\u2026') at ('${segmentName}'). Did you mean ('...')?`), "__NEXT_ERROR_CODE", {
+              value: "E147",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          if (segmentName.startsWith("...")) {
+            segmentName = segmentName.substring(3);
+            isCatchAll = true;
+          }
+          if (segmentName.startsWith("[") || segmentName.endsWith("]")) {
+            throw Object.defineProperty(new Error(`Segment names may not start or end with extra brackets ('${segmentName}').`), "__NEXT_ERROR_CODE", {
+              value: "E421",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          if (segmentName.startsWith(".")) {
+            throw Object.defineProperty(new Error(`Segment names may not start with erroneous periods ('${segmentName}').`), "__NEXT_ERROR_CODE", {
+              value: "E288",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          if (isCatchAll) {
+            if (isOptional) {
+              if (this.restSlugName != null) {
+                throw Object.defineProperty(new Error(`You cannot use both an required and optional catch-all route at the same level ("[...${this.restSlugName}]" and "${urlPaths[0]}" ).`), "__NEXT_ERROR_CODE", {
+                  value: "E299",
+                  enumerable: false,
+                  configurable: true
+                });
+              }
+              handleSlug(this.optionalRestSlugName, segmentName);
+              this.optionalRestSlugName = segmentName;
+              nextSegment = "[[...]]";
+            } else {
+              if (this.optionalRestSlugName != null) {
+                throw Object.defineProperty(new Error(`You cannot use both an optional and required catch-all route at the same level ("[[...${this.optionalRestSlugName}]]" and "${urlPaths[0]}").`), "__NEXT_ERROR_CODE", {
+                  value: "E300",
+                  enumerable: false,
+                  configurable: true
+                });
+              }
+              handleSlug(this.restSlugName, segmentName);
+              this.restSlugName = segmentName;
+              nextSegment = "[...]";
+            }
+          } else {
+            if (isOptional) {
+              throw Object.defineProperty(new Error(`Optional route parameters are not yet supported ("${urlPaths[0]}").`), "__NEXT_ERROR_CODE", {
+                value: "E435",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            handleSlug(this.slugName, segmentName);
+            this.slugName = segmentName;
+            nextSegment = "[]";
+          }
+        }
+        if (!this.children.has(nextSegment)) {
+          this.children.set(nextSegment, new _UrlNode());
+        }
+        this.children.get(nextSegment)._insert(urlPaths.slice(1), slugNames, isCatchAll);
+      }
+      constructor() {
+        this.placeholder = true;
+        this.children = /* @__PURE__ */ new Map();
+        this.slugName = null;
+        this.restSlugName = null;
+        this.optionalRestSlugName = null;
+      }
+    };
+    function getSortedRoutes(normalizedPages) {
+      const root = new UrlNode();
+      normalizedPages.forEach((pagePath) => root.insert(pagePath));
+      return root.smoosh();
+    }
+    function getSortedRouteObjects(objects, getter) {
+      const indexes = {};
+      const pathnames = [];
+      for (let i = 0; i < objects.length; i++) {
+        const pathname = getter(objects[i]);
+        indexes[pathname] = i;
+        pathnames[i] = pathname;
+      }
+      const sorted = getSortedRoutes(pathnames);
+      return sorted.map((pathname) => objects[indexes[pathname]]);
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/page-path/ensure-leading-slash.js
+var require_ensure_leading_slash = __commonJS({
+  "node_modules/next/dist/shared/lib/page-path/ensure-leading-slash.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "ensureLeadingSlash", {
+      enumerable: true,
+      get: function() {
+        return ensureLeadingSlash;
+      }
+    });
+    function ensureLeadingSlash(path) {
+      return path.startsWith("/") ? path : `/${path}`;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/segment.js
+var require_segment = __commonJS({
+  "node_modules/next/dist/shared/lib/segment.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      DEFAULT_SEGMENT_KEY: function() {
+        return DEFAULT_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__";
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/app-paths.js
+var require_app_paths = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/app-paths.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      normalizeAppPath: function() {
+        return normalizeAppPath;
+      },
+      normalizeRscURL: function() {
+        return normalizeRscURL;
+      }
+    });
+    var _ensureleadingslash = require_ensure_leading_slash();
+    var _segment = require_segment();
+    function normalizeAppPath(route) {
+      return (0, _ensureleadingslash.ensureLeadingSlash)(route.split("/").reduce((pathname, segment, index, segments) => {
+        if (!segment) {
+          return pathname;
+        }
+        if ((0, _segment.isGroupSegment)(segment)) {
+          return pathname;
+        }
+        if (segment[0] === "@") {
+          return pathname;
+        }
+        if ((segment === "page" || segment === "route") && index === segments.length - 1) {
+          return pathname;
+        }
+        return `${pathname}/${segment}`;
+      }, ""));
+    }
+    function normalizeRscURL(url) {
+      return url.replace(
+        /\.rsc($|\?)/,
+        // $1 ensures `?` is preserved
+        "$1"
+      );
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/interception-routes.js
+var require_interception_routes = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/interception-routes.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      INTERCEPTION_ROUTE_MARKERS: function() {
+        return INTERCEPTION_ROUTE_MARKERS;
+      },
+      extractInterceptionRouteInformation: function() {
+        return extractInterceptionRouteInformation;
+      },
+      isInterceptionRouteAppPath: function() {
+        return isInterceptionRouteAppPath;
+      }
+    });
+    var _apppaths = require_app_paths();
+    var INTERCEPTION_ROUTE_MARKERS = [
+      "(..)(..)",
+      "(.)",
+      "(..)",
+      "(...)"
+    ];
+    function isInterceptionRouteAppPath(path) {
+      return path.split("/").find((segment) => INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m))) !== void 0;
+    }
+    function extractInterceptionRouteInformation(path) {
+      let interceptingRoute;
+      let marker;
+      let interceptedRoute;
+      for (const segment of path.split("/")) {
+        marker = INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m));
+        if (marker) {
+          ;
+          [interceptingRoute, interceptedRoute] = path.split(marker, 2);
+          break;
+        }
+      }
+      if (!interceptingRoute || !marker || !interceptedRoute) {
+        throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`), "__NEXT_ERROR_CODE", {
+          value: "E269",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      interceptingRoute = (0, _apppaths.normalizeAppPath)(interceptingRoute);
+      switch (marker) {
+        case "(.)":
+          if (interceptingRoute === "/") {
+            interceptedRoute = `/${interceptedRoute}`;
+          } else {
+            interceptedRoute = interceptingRoute + "/" + interceptedRoute;
+          }
+          break;
+        case "(..)":
+          if (interceptingRoute === "/") {
+            throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`), "__NEXT_ERROR_CODE", {
+              value: "E207",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          interceptedRoute = interceptingRoute.split("/").slice(0, -1).concat(interceptedRoute).join("/");
+          break;
+        case "(...)":
+          interceptedRoute = "/" + interceptedRoute;
+          break;
+        case "(..)(..)":
+          const splitInterceptingRoute = interceptingRoute.split("/");
+          if (splitInterceptingRoute.length <= 2) {
+            throw Object.defineProperty(new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`), "__NEXT_ERROR_CODE", {
+              value: "E486",
+              enumerable: false,
+              configurable: true
+            });
+          }
+          interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join("/");
+          break;
+        default:
+          throw Object.defineProperty(new Error("Invariant: unexpected marker"), "__NEXT_ERROR_CODE", {
+            value: "E112",
+            enumerable: false,
+            configurable: true
+          });
+      }
+      return {
+        interceptingRoute,
+        interceptedRoute
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/is-dynamic.js
+var require_is_dynamic = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/is-dynamic.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "isDynamicRoute", {
+      enumerable: true,
+      get: function() {
+        return isDynamicRoute;
+      }
+    });
+    var _interceptionroutes = require_interception_routes();
+    var TEST_ROUTE = /\/[^/]*\[[^/]+\][^/]*(?=\/|$)/;
+    var TEST_STRICT_ROUTE = /\/\[[^/]+\](?=\/|$)/;
+    function isDynamicRoute(route, strict = true) {
+      if ((0, _interceptionroutes.isInterceptionRouteAppPath)(route)) {
+        route = (0, _interceptionroutes.extractInterceptionRouteInformation)(route).interceptedRoute;
+      }
+      if (strict) {
+        return TEST_STRICT_ROUTE.test(route);
+      }
+      return TEST_ROUTE.test(route);
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/index.js
+var require_utils2 = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      getSortedRouteObjects: function() {
+        return _sortedroutes.getSortedRouteObjects;
+      },
+      getSortedRoutes: function() {
+        return _sortedroutes.getSortedRoutes;
+      },
+      isDynamicRoute: function() {
+        return _isdynamic.isDynamicRoute;
+      }
+    });
+    var _sortedroutes = require_sorted_routes();
+    var _isdynamic = require_is_dynamic();
+  }
+});
+
+// node_modules/next/dist/compiled/path-to-regexp/index.js
+var require_path_to_regexp = __commonJS({
+  "node_modules/next/dist/compiled/path-to-regexp/index.js"(exports, module) {
+    (() => {
+      "use strict";
+      if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = __dirname + "/";
+      var e = {};
+      (() => {
+        var n = e;
+        Object.defineProperty(n, "__esModule", { value: true });
+        n.pathToRegexp = n.tokensToRegexp = n.regexpToFunction = n.match = n.tokensToFunction = n.compile = n.parse = void 0;
+        function lexer(e2) {
+          var n2 = [];
+          var r = 0;
+          while (r < e2.length) {
+            var t = e2[r];
+            if (t === "*" || t === "+" || t === "?") {
+              n2.push({ type: "MODIFIER", index: r, value: e2[r++] });
+              continue;
+            }
+            if (t === "\\") {
+              n2.push({ type: "ESCAPED_CHAR", index: r++, value: e2[r++] });
+              continue;
+            }
+            if (t === "{") {
+              n2.push({ type: "OPEN", index: r, value: e2[r++] });
+              continue;
+            }
+            if (t === "}") {
+              n2.push({ type: "CLOSE", index: r, value: e2[r++] });
+              continue;
+            }
+            if (t === ":") {
+              var a = "";
+              var i = r + 1;
+              while (i < e2.length) {
+                var o = e2.charCodeAt(i);
+                if (o >= 48 && o <= 57 || o >= 65 && o <= 90 || o >= 97 && o <= 122 || o === 95) {
+                  a += e2[i++];
+                  continue;
+                }
+                break;
+              }
+              if (!a) throw new TypeError("Missing parameter name at ".concat(r));
+              n2.push({ type: "NAME", index: r, value: a });
+              r = i;
+              continue;
+            }
+            if (t === "(") {
+              var c = 1;
+              var f = "";
+              var i = r + 1;
+              if (e2[i] === "?") {
+                throw new TypeError('Pattern cannot start with "?" at '.concat(i));
+              }
+              while (i < e2.length) {
+                if (e2[i] === "\\") {
+                  f += e2[i++] + e2[i++];
+                  continue;
+                }
+                if (e2[i] === ")") {
+                  c--;
+                  if (c === 0) {
+                    i++;
+                    break;
+                  }
+                } else if (e2[i] === "(") {
+                  c++;
+                  if (e2[i + 1] !== "?") {
+                    throw new TypeError("Capturing groups are not allowed at ".concat(i));
+                  }
+                }
+                f += e2[i++];
+              }
+              if (c) throw new TypeError("Unbalanced pattern at ".concat(r));
+              if (!f) throw new TypeError("Missing pattern at ".concat(r));
+              n2.push({ type: "PATTERN", index: r, value: f });
+              r = i;
+              continue;
+            }
+            n2.push({ type: "CHAR", index: r, value: e2[r++] });
+          }
+          n2.push({ type: "END", index: r, value: "" });
+          return n2;
+        }
+        function parse(e2, n2) {
+          if (n2 === void 0) {
+            n2 = {};
+          }
+          var r = lexer(e2);
+          var t = n2.prefixes, a = t === void 0 ? "./" : t, i = n2.delimiter, o = i === void 0 ? "/#?" : i;
+          var c = [];
+          var f = 0;
+          var u = 0;
+          var p = "";
+          var tryConsume = function(e3) {
+            if (u < r.length && r[u].type === e3) return r[u++].value;
+          };
+          var mustConsume = function(e3) {
+            var n3 = tryConsume(e3);
+            if (n3 !== void 0) return n3;
+            var t2 = r[u], a2 = t2.type, i2 = t2.index;
+            throw new TypeError("Unexpected ".concat(a2, " at ").concat(i2, ", expected ").concat(e3));
+          };
+          var consumeText = function() {
+            var e3 = "";
+            var n3;
+            while (n3 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+              e3 += n3;
+            }
+            return e3;
+          };
+          var isSafe = function(e3) {
+            for (var n3 = 0, r2 = o; n3 < r2.length; n3++) {
+              var t2 = r2[n3];
+              if (e3.indexOf(t2) > -1) return true;
+            }
+            return false;
+          };
+          var safePattern = function(e3) {
+            var n3 = c[c.length - 1];
+            var r2 = e3 || (n3 && typeof n3 === "string" ? n3 : "");
+            if (n3 && !r2) {
+              throw new TypeError('Must have text between two parameters, missing text after "'.concat(n3.name, '"'));
+            }
+            if (!r2 || isSafe(r2)) return "[^".concat(escapeString(o), "]+?");
+            return "(?:(?!".concat(escapeString(r2), ")[^").concat(escapeString(o), "])+?");
+          };
+          while (u < r.length) {
+            var v = tryConsume("CHAR");
+            var s = tryConsume("NAME");
+            var d = tryConsume("PATTERN");
+            if (s || d) {
+              var g = v || "";
+              if (a.indexOf(g) === -1) {
+                p += g;
+                g = "";
+              }
+              if (p) {
+                c.push(p);
+                p = "";
+              }
+              c.push({ name: s || f++, prefix: g, suffix: "", pattern: d || safePattern(g), modifier: tryConsume("MODIFIER") || "" });
+              continue;
+            }
+            var x = v || tryConsume("ESCAPED_CHAR");
+            if (x) {
+              p += x;
+              continue;
+            }
+            if (p) {
+              c.push(p);
+              p = "";
+            }
+            var h = tryConsume("OPEN");
+            if (h) {
+              var g = consumeText();
+              var l = tryConsume("NAME") || "";
+              var m = tryConsume("PATTERN") || "";
+              var T = consumeText();
+              mustConsume("CLOSE");
+              c.push({ name: l || (m ? f++ : ""), pattern: l && !m ? safePattern(g) : m, prefix: g, suffix: T, modifier: tryConsume("MODIFIER") || "" });
+              continue;
+            }
+            mustConsume("END");
+          }
+          return c;
+        }
+        n.parse = parse;
+        function compile(e2, n2) {
+          return tokensToFunction(parse(e2, n2), n2);
+        }
+        n.compile = compile;
+        function tokensToFunction(e2, n2) {
+          if (n2 === void 0) {
+            n2 = {};
+          }
+          var r = flags(n2);
+          var t = n2.encode, a = t === void 0 ? function(e3) {
+            return e3;
+          } : t, i = n2.validate, o = i === void 0 ? true : i;
+          var c = e2.map((function(e3) {
+            if (typeof e3 === "object") {
+              return new RegExp("^(?:".concat(e3.pattern, ")$"), r);
+            }
+          }));
+          return function(n3) {
+            var r2 = "";
+            for (var t2 = 0; t2 < e2.length; t2++) {
+              var i2 = e2[t2];
+              if (typeof i2 === "string") {
+                r2 += i2;
+                continue;
+              }
+              var f = n3 ? n3[i2.name] : void 0;
+              var u = i2.modifier === "?" || i2.modifier === "*";
+              var p = i2.modifier === "*" || i2.modifier === "+";
+              if (Array.isArray(f)) {
+                if (!p) {
+                  throw new TypeError('Expected "'.concat(i2.name, '" to not repeat, but got an array'));
+                }
+                if (f.length === 0) {
+                  if (u) continue;
+                  throw new TypeError('Expected "'.concat(i2.name, '" to not be empty'));
+                }
+                for (var v = 0; v < f.length; v++) {
+                  var s = a(f[v], i2);
+                  if (o && !c[t2].test(s)) {
+                    throw new TypeError('Expected all "'.concat(i2.name, '" to match "').concat(i2.pattern, '", but got "').concat(s, '"'));
+                  }
+                  r2 += i2.prefix + s + i2.suffix;
+                }
+                continue;
+              }
+              if (typeof f === "string" || typeof f === "number") {
+                var s = a(String(f), i2);
+                if (o && !c[t2].test(s)) {
+                  throw new TypeError('Expected "'.concat(i2.name, '" to match "').concat(i2.pattern, '", but got "').concat(s, '"'));
+                }
+                r2 += i2.prefix + s + i2.suffix;
+                continue;
+              }
+              if (u) continue;
+              var d = p ? "an array" : "a string";
+              throw new TypeError('Expected "'.concat(i2.name, '" to be ').concat(d));
+            }
+            return r2;
+          };
+        }
+        n.tokensToFunction = tokensToFunction;
+        function match(e2, n2) {
+          var r = [];
+          var t = pathToRegexp(e2, r, n2);
+          return regexpToFunction(t, r, n2);
+        }
+        n.match = match;
+        function regexpToFunction(e2, n2, r) {
+          if (r === void 0) {
+            r = {};
+          }
+          var t = r.decode, a = t === void 0 ? function(e3) {
+            return e3;
+          } : t;
+          return function(r2) {
+            var t2 = e2.exec(r2);
+            if (!t2) return false;
+            var i = t2[0], o = t2.index;
+            var c = /* @__PURE__ */ Object.create(null);
+            var _loop_1 = function(e3) {
+              if (t2[e3] === void 0) return "continue";
+              var r3 = n2[e3 - 1];
+              if (r3.modifier === "*" || r3.modifier === "+") {
+                c[r3.name] = t2[e3].split(r3.prefix + r3.suffix).map((function(e4) {
+                  return a(e4, r3);
+                }));
+              } else {
+                c[r3.name] = a(t2[e3], r3);
+              }
+            };
+            for (var f = 1; f < t2.length; f++) {
+              _loop_1(f);
+            }
+            return { path: i, index: o, params: c };
+          };
+        }
+        n.regexpToFunction = regexpToFunction;
+        function escapeString(e2) {
+          return e2.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+        }
+        function flags(e2) {
+          return e2 && e2.sensitive ? "" : "i";
+        }
+        function regexpToRegexp(e2, n2) {
+          if (!n2) return e2;
+          var r = /\((?:\?<(.*?)>)?(?!\?)/g;
+          var t = 0;
+          var a = r.exec(e2.source);
+          while (a) {
+            n2.push({ name: a[1] || t++, prefix: "", suffix: "", modifier: "", pattern: "" });
+            a = r.exec(e2.source);
+          }
+          return e2;
+        }
+        function arrayToRegexp(e2, n2, r) {
+          var t = e2.map((function(e3) {
+            return pathToRegexp(e3, n2, r).source;
+          }));
+          return new RegExp("(?:".concat(t.join("|"), ")"), flags(r));
+        }
+        function stringToRegexp(e2, n2, r) {
+          return tokensToRegexp(parse(e2, r), n2, r);
+        }
+        function tokensToRegexp(e2, n2, r) {
+          if (r === void 0) {
+            r = {};
+          }
+          var t = r.strict, a = t === void 0 ? false : t, i = r.start, o = i === void 0 ? true : i, c = r.end, f = c === void 0 ? true : c, u = r.encode, p = u === void 0 ? function(e3) {
+            return e3;
+          } : u, v = r.delimiter, s = v === void 0 ? "/#?" : v, d = r.endsWith, g = d === void 0 ? "" : d;
+          var x = "[".concat(escapeString(g), "]|$");
+          var h = "[".concat(escapeString(s), "]");
+          var l = o ? "^" : "";
+          for (var m = 0, T = e2; m < T.length; m++) {
+            var E = T[m];
+            if (typeof E === "string") {
+              l += escapeString(p(E));
+            } else {
+              var w = escapeString(p(E.prefix));
+              var y = escapeString(p(E.suffix));
+              if (E.pattern) {
+                if (n2) n2.push(E);
+                if (w || y) {
+                  if (E.modifier === "+" || E.modifier === "*") {
+                    var R = E.modifier === "*" ? "?" : "";
+                    l += "(?:".concat(w, "((?:").concat(E.pattern, ")(?:").concat(y).concat(w, "(?:").concat(E.pattern, "))*)").concat(y, ")").concat(R);
+                  } else {
+                    l += "(?:".concat(w, "(").concat(E.pattern, ")").concat(y, ")").concat(E.modifier);
+                  }
+                } else {
+                  if (E.modifier === "+" || E.modifier === "*") {
+                    throw new TypeError('Can not repeat "'.concat(E.name, '" without a prefix and suffix'));
+                  }
+                  l += "(".concat(E.pattern, ")").concat(E.modifier);
+                }
+              } else {
+                l += "(?:".concat(w).concat(y, ")").concat(E.modifier);
+              }
+            }
+          }
+          if (f) {
+            if (!a) l += "".concat(h, "?");
+            l += !r.endsWith ? "$" : "(?=".concat(x, ")");
+          } else {
+            var A = e2[e2.length - 1];
+            var _ = typeof A === "string" ? h.indexOf(A[A.length - 1]) > -1 : A === void 0;
+            if (!a) {
+              l += "(?:".concat(h, "(?=").concat(x, "))?");
+            }
+            if (!_) {
+              l += "(?=".concat(h, "|").concat(x, ")");
+            }
+          }
+          return new RegExp(l, flags(r));
+        }
+        n.tokensToRegexp = tokensToRegexp;
+        function pathToRegexp(e2, n2, r) {
+          if (e2 instanceof RegExp) return regexpToRegexp(e2, n2);
+          if (Array.isArray(e2)) return arrayToRegexp(e2, n2, r);
+          return stringToRegexp(e2, n2, r);
+        }
+        n.pathToRegexp = pathToRegexp;
+      })();
+      module.exports = e;
+    })();
+  }
+});
+
+// node_modules/next/dist/lib/route-pattern-normalizer.js
+var require_route_pattern_normalizer = __commonJS({
+  "node_modules/next/dist/lib/route-pattern-normalizer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      PARAM_SEPARATOR: function() {
+        return PARAM_SEPARATOR;
+      },
+      hasAdjacentParameterIssues: function() {
+        return hasAdjacentParameterIssues;
+      },
+      normalizeAdjacentParameters: function() {
+        return normalizeAdjacentParameters;
+      },
+      normalizeTokensForRegexp: function() {
+        return normalizeTokensForRegexp;
+      },
+      stripNormalizedSeparators: function() {
+        return stripNormalizedSeparators;
+      },
+      stripParameterSeparators: function() {
+        return stripParameterSeparators;
+      }
+    });
+    var PARAM_SEPARATOR = "_NEXTSEP_";
+    function hasAdjacentParameterIssues(route) {
+      if (typeof route !== "string") return false;
+      if (/\/\(\.{1,3}\):[^/\s]+/.test(route)) {
+        return true;
+      }
+      if (/:[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*/.test(route)) {
+        return true;
+      }
+      return false;
+    }
+    function normalizeAdjacentParameters(route) {
+      let normalized = route;
+      normalized = normalized.replace(/(\([^)]*\)):([^/\s]+)/g, `$1${PARAM_SEPARATOR}:$2`);
+      normalized = normalized.replace(/:([^:/\s)]+)(?=:)/g, `:$1${PARAM_SEPARATOR}`);
+      return normalized;
+    }
+    function normalizeTokensForRegexp(tokens) {
+      return tokens.map((token) => {
+        if (typeof token === "object" && token !== null && // Not all token objects have 'modifier' property (e.g., simple text tokens)
+        "modifier" in token && // Only repeating modifiers (* or +) cause the validation error
+        // Other modifiers like '?' (optional) are fine
+        (token.modifier === "*" || token.modifier === "+") && // Token objects can have different shapes depending on route pattern
+        "prefix" in token && "suffix" in token && // Both prefix and suffix must be empty strings
+        // This is what causes the validation error in path-to-regexp
+        token.prefix === "" && token.suffix === "") {
+          return {
+            ...token,
+            prefix: "/"
+          };
+        }
+        return token;
+      });
+    }
+    function stripNormalizedSeparators(pathname) {
+      return pathname.replace(new RegExp(`\\)${PARAM_SEPARATOR}`, "g"), ")");
+    }
+    function stripParameterSeparators(params) {
+      const cleaned = {};
+      for (const [key, value] of Object.entries(params)) {
+        if (typeof value === "string") {
+          cleaned[key] = value.replace(new RegExp(`^${PARAM_SEPARATOR}`), "");
+        } else if (Array.isArray(value)) {
+          cleaned[key] = value.map((item) => typeof item === "string" ? item.replace(new RegExp(`^${PARAM_SEPARATOR}`), "") : item);
+        } else {
+          cleaned[key] = value;
+        }
+      }
+      return cleaned;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/route-match-utils.js
+var require_route_match_utils = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/route-match-utils.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      safeCompile: function() {
+        return safeCompile;
+      },
+      safePathToRegexp: function() {
+        return safePathToRegexp;
+      },
+      safeRegexpToFunction: function() {
+        return safeRegexpToFunction;
+      },
+      safeRouteMatcher: function() {
+        return safeRouteMatcher;
+      }
+    });
+    var _pathtoregexp = require_path_to_regexp();
+    var _routepatternnormalizer = require_route_pattern_normalizer();
+    function safePathToRegexp(route, keys, options) {
+      if (typeof route !== "string") {
+        return (0, _pathtoregexp.pathToRegexp)(route, keys, options);
+      }
+      const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
+      const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
+      try {
+        return (0, _pathtoregexp.pathToRegexp)(routeToUse, keys, options);
+      } catch (error) {
+        if (!needsNormalization) {
+          try {
+            const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
+            return (0, _pathtoregexp.pathToRegexp)(normalizedRoute, keys, options);
+          } catch (retryError) {
+            throw error;
+          }
+        }
+        throw error;
+      }
+    }
+    function safeCompile(route, options) {
+      const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
+      const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
+      try {
+        const compiler = (0, _pathtoregexp.compile)(routeToUse, options);
+        if (needsNormalization) {
+          return (params) => {
+            return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
+          };
+        }
+        return compiler;
+      } catch (error) {
+        if (!needsNormalization) {
+          try {
+            const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
+            const compiler = (0, _pathtoregexp.compile)(normalizedRoute, options);
+            return (params) => {
+              return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
+            };
+          } catch (retryError) {
+            throw error;
+          }
+        }
+        throw error;
+      }
+    }
+    function safeRegexpToFunction(regexp, keys) {
+      const originalMatcher = (0, _pathtoregexp.regexpToFunction)(regexp, keys || []);
+      return (pathname) => {
+        const result = originalMatcher(pathname);
+        if (!result) return false;
+        return {
+          ...result,
+          params: (0, _routepatternnormalizer.stripParameterSeparators)(result.params)
+        };
+      };
+    }
+    function safeRouteMatcher(matcherFn) {
+      return (pathname) => {
+        const result = matcherFn(pathname);
+        if (!result) return false;
+        return (0, _routepatternnormalizer.stripParameterSeparators)(result);
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/route-matcher.js
+var require_route_matcher = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/route-matcher.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "getRouteMatcher", {
+      enumerable: true,
+      get: function() {
+        return getRouteMatcher;
+      }
+    });
+    var _utils = require_utils();
+    var _routematchutils = require_route_match_utils();
+    function getRouteMatcher({ re, groups }) {
+      const rawMatcher = (pathname) => {
+        const routeMatch = re.exec(pathname);
+        if (!routeMatch) return false;
+        const decode = (param) => {
+          try {
+            return decodeURIComponent(param);
+          } catch {
+            throw Object.defineProperty(new _utils.DecodeError("failed to decode param"), "__NEXT_ERROR_CODE", {
+              value: "E528",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        };
+        const params = {};
+        for (const [key, group] of Object.entries(groups)) {
+          const match = routeMatch[group.pos];
+          if (match !== void 0) {
+            if (group.repeat) {
+              params[key] = match.split("/").map((entry) => decode(entry));
+            } else {
+              params[key] = decode(match);
+            }
+          }
+        }
+        return params;
+      };
+      return (0, _routematchutils.safeRouteMatcher)(rawMatcher);
+    }
+  }
+});
+
+// node_modules/next/dist/lib/constants.js
+var require_constants = __commonJS({
+  "node_modules/next/dist/lib/constants.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      ACTION_SUFFIX: function() {
+        return ACTION_SUFFIX;
+      },
+      APP_DIR_ALIAS: function() {
+        return APP_DIR_ALIAS;
+      },
+      CACHE_ONE_YEAR: function() {
+        return CACHE_ONE_YEAR;
+      },
+      DOT_NEXT_ALIAS: function() {
+        return DOT_NEXT_ALIAS;
+      },
+      ESLINT_DEFAULT_DIRS: function() {
+        return ESLINT_DEFAULT_DIRS;
+      },
+      GSP_NO_RETURNED_VALUE: function() {
+        return GSP_NO_RETURNED_VALUE;
+      },
+      GSSP_COMPONENT_MEMBER_ERROR: function() {
+        return GSSP_COMPONENT_MEMBER_ERROR;
+      },
+      GSSP_NO_RETURNED_VALUE: function() {
+        return GSSP_NO_RETURNED_VALUE;
+      },
+      HTML_CONTENT_TYPE_HEADER: function() {
+        return HTML_CONTENT_TYPE_HEADER;
+      },
+      INFINITE_CACHE: function() {
+        return INFINITE_CACHE;
+      },
+      INSTRUMENTATION_HOOK_FILENAME: function() {
+        return INSTRUMENTATION_HOOK_FILENAME;
+      },
+      JSON_CONTENT_TYPE_HEADER: function() {
+        return JSON_CONTENT_TYPE_HEADER;
+      },
+      MATCHED_PATH_HEADER: function() {
+        return MATCHED_PATH_HEADER;
+      },
+      MIDDLEWARE_FILENAME: function() {
+        return MIDDLEWARE_FILENAME;
+      },
+      MIDDLEWARE_LOCATION_REGEXP: function() {
+        return MIDDLEWARE_LOCATION_REGEXP;
+      },
+      NEXT_BODY_SUFFIX: function() {
+        return NEXT_BODY_SUFFIX;
+      },
+      NEXT_CACHE_IMPLICIT_TAG_ID: function() {
+        return NEXT_CACHE_IMPLICIT_TAG_ID;
+      },
+      NEXT_CACHE_REVALIDATED_TAGS_HEADER: function() {
+        return NEXT_CACHE_REVALIDATED_TAGS_HEADER;
+      },
+      NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER: function() {
+        return NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER;
+      },
+      NEXT_CACHE_SOFT_TAG_MAX_LENGTH: function() {
+        return NEXT_CACHE_SOFT_TAG_MAX_LENGTH;
+      },
+      NEXT_CACHE_TAGS_HEADER: function() {
+        return NEXT_CACHE_TAGS_HEADER;
+      },
+      NEXT_CACHE_TAG_MAX_ITEMS: function() {
+        return NEXT_CACHE_TAG_MAX_ITEMS;
+      },
+      NEXT_CACHE_TAG_MAX_LENGTH: function() {
+        return NEXT_CACHE_TAG_MAX_LENGTH;
+      },
+      NEXT_DATA_SUFFIX: function() {
+        return NEXT_DATA_SUFFIX;
+      },
+      NEXT_INTERCEPTION_MARKER_PREFIX: function() {
+        return NEXT_INTERCEPTION_MARKER_PREFIX;
+      },
+      NEXT_META_SUFFIX: function() {
+        return NEXT_META_SUFFIX;
+      },
+      NEXT_QUERY_PARAM_PREFIX: function() {
+        return NEXT_QUERY_PARAM_PREFIX;
+      },
+      NEXT_RESUME_HEADER: function() {
+        return NEXT_RESUME_HEADER;
+      },
+      NON_STANDARD_NODE_ENV: function() {
+        return NON_STANDARD_NODE_ENV;
+      },
+      PAGES_DIR_ALIAS: function() {
+        return PAGES_DIR_ALIAS;
+      },
+      PRERENDER_REVALIDATE_HEADER: function() {
+        return PRERENDER_REVALIDATE_HEADER;
+      },
+      PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER: function() {
+        return PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER;
+      },
+      PROXY_FILENAME: function() {
+        return PROXY_FILENAME;
+      },
+      PROXY_LOCATION_REGEXP: function() {
+        return PROXY_LOCATION_REGEXP;
+      },
+      PUBLIC_DIR_MIDDLEWARE_CONFLICT: function() {
+        return PUBLIC_DIR_MIDDLEWARE_CONFLICT;
+      },
+      ROOT_DIR_ALIAS: function() {
+        return ROOT_DIR_ALIAS;
+      },
+      RSC_ACTION_CLIENT_WRAPPER_ALIAS: function() {
+        return RSC_ACTION_CLIENT_WRAPPER_ALIAS;
+      },
+      RSC_ACTION_ENCRYPTION_ALIAS: function() {
+        return RSC_ACTION_ENCRYPTION_ALIAS;
+      },
+      RSC_ACTION_PROXY_ALIAS: function() {
+        return RSC_ACTION_PROXY_ALIAS;
+      },
+      RSC_ACTION_VALIDATE_ALIAS: function() {
+        return RSC_ACTION_VALIDATE_ALIAS;
+      },
+      RSC_CACHE_WRAPPER_ALIAS: function() {
+        return RSC_CACHE_WRAPPER_ALIAS;
+      },
+      RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS: function() {
+        return RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS;
+      },
+      RSC_MOD_REF_PROXY_ALIAS: function() {
+        return RSC_MOD_REF_PROXY_ALIAS;
+      },
+      RSC_PREFETCH_SUFFIX: function() {
+        return RSC_PREFETCH_SUFFIX;
+      },
+      RSC_SEGMENTS_DIR_SUFFIX: function() {
+        return RSC_SEGMENTS_DIR_SUFFIX;
+      },
+      RSC_SEGMENT_SUFFIX: function() {
+        return RSC_SEGMENT_SUFFIX;
+      },
+      RSC_SUFFIX: function() {
+        return RSC_SUFFIX;
+      },
+      SERVER_PROPS_EXPORT_ERROR: function() {
+        return SERVER_PROPS_EXPORT_ERROR;
+      },
+      SERVER_PROPS_GET_INIT_PROPS_CONFLICT: function() {
+        return SERVER_PROPS_GET_INIT_PROPS_CONFLICT;
+      },
+      SERVER_PROPS_SSG_CONFLICT: function() {
+        return SERVER_PROPS_SSG_CONFLICT;
+      },
+      SERVER_RUNTIME: function() {
+        return SERVER_RUNTIME;
+      },
+      SSG_FALLBACK_EXPORT_ERROR: function() {
+        return SSG_FALLBACK_EXPORT_ERROR;
+      },
+      SSG_GET_INITIAL_PROPS_CONFLICT: function() {
+        return SSG_GET_INITIAL_PROPS_CONFLICT;
+      },
+      STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR: function() {
+        return STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR;
+      },
+      TEXT_PLAIN_CONTENT_TYPE_HEADER: function() {
+        return TEXT_PLAIN_CONTENT_TYPE_HEADER;
+      },
+      UNSTABLE_REVALIDATE_RENAME_ERROR: function() {
+        return UNSTABLE_REVALIDATE_RENAME_ERROR;
+      },
+      WEBPACK_LAYERS: function() {
+        return WEBPACK_LAYERS;
+      },
+      WEBPACK_RESOURCE_QUERIES: function() {
+        return WEBPACK_RESOURCE_QUERIES;
+      },
+      WEB_SOCKET_MAX_RECONNECTIONS: function() {
+        return WEB_SOCKET_MAX_RECONNECTIONS;
+      }
+    });
+    var TEXT_PLAIN_CONTENT_TYPE_HEADER = "text/plain";
+    var HTML_CONTENT_TYPE_HEADER = "text/html; charset=utf-8";
+    var JSON_CONTENT_TYPE_HEADER = "application/json; charset=utf-8";
+    var NEXT_QUERY_PARAM_PREFIX = "nxtP";
+    var NEXT_INTERCEPTION_MARKER_PREFIX = "nxtI";
+    var MATCHED_PATH_HEADER = "x-matched-path";
+    var PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+    var PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = "x-prerender-revalidate-if-generated";
+    var RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
+    var RSC_SEGMENTS_DIR_SUFFIX = ".segments";
+    var RSC_SEGMENT_SUFFIX = ".segment.rsc";
+    var RSC_SUFFIX = ".rsc";
+    var ACTION_SUFFIX = ".action";
+    var NEXT_DATA_SUFFIX = ".json";
+    var NEXT_META_SUFFIX = ".meta";
+    var NEXT_BODY_SUFFIX = ".body";
+    var NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
+    var NEXT_CACHE_REVALIDATED_TAGS_HEADER = "x-next-revalidated-tags";
+    var NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER = "x-next-revalidate-tag-token";
+    var NEXT_RESUME_HEADER = "next-resume";
+    var NEXT_CACHE_TAG_MAX_ITEMS = 128;
+    var NEXT_CACHE_TAG_MAX_LENGTH = 256;
+    var NEXT_CACHE_SOFT_TAG_MAX_LENGTH = 1024;
+    var NEXT_CACHE_IMPLICIT_TAG_ID = "_N_T_";
+    var CACHE_ONE_YEAR = 31536e3;
+    var INFINITE_CACHE = 4294967294;
+    var MIDDLEWARE_FILENAME = "middleware";
+    var MIDDLEWARE_LOCATION_REGEXP = `(?:src/)?${MIDDLEWARE_FILENAME}`;
+    var PROXY_FILENAME = "proxy";
+    var PROXY_LOCATION_REGEXP = `(?:src/)?${PROXY_FILENAME}`;
+    var INSTRUMENTATION_HOOK_FILENAME = "instrumentation";
+    var PAGES_DIR_ALIAS = "private-next-pages";
+    var DOT_NEXT_ALIAS = "private-dot-next";
+    var ROOT_DIR_ALIAS = "private-next-root-dir";
+    var APP_DIR_ALIAS = "private-next-app-dir";
+    var RSC_MOD_REF_PROXY_ALIAS = "private-next-rsc-mod-ref-proxy";
+    var RSC_ACTION_VALIDATE_ALIAS = "private-next-rsc-action-validate";
+    var RSC_ACTION_PROXY_ALIAS = "private-next-rsc-server-reference";
+    var RSC_CACHE_WRAPPER_ALIAS = "private-next-rsc-cache-wrapper";
+    var RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS = "private-next-rsc-track-dynamic-import";
+    var RSC_ACTION_ENCRYPTION_ALIAS = "private-next-rsc-action-encryption";
+    var RSC_ACTION_CLIENT_WRAPPER_ALIAS = "private-next-rsc-action-client-wrapper";
+    var PUBLIC_DIR_MIDDLEWARE_CONFLICT = `You can not have a '_next' folder inside of your public folder. This conflicts with the internal '/_next' route. https://nextjs.org/docs/messages/public-next-folder-conflict`;
+    var SSG_GET_INITIAL_PROPS_CONFLICT = `You can not use getInitialProps with getStaticProps. To use SSG, please remove your getInitialProps`;
+    var SERVER_PROPS_GET_INIT_PROPS_CONFLICT = `You can not use getInitialProps with getServerSideProps. Please remove getInitialProps.`;
+    var SERVER_PROPS_SSG_CONFLICT = `You can not use getStaticProps or getStaticPaths with getServerSideProps. To use SSG, please remove getServerSideProps`;
+    var STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR = `can not have getInitialProps/getServerSideProps, https://nextjs.org/docs/messages/404-get-initial-props`;
+    var SERVER_PROPS_EXPORT_ERROR = `pages with \`getServerSideProps\` can not be exported. See more info here: https://nextjs.org/docs/messages/gssp-export`;
+    var GSP_NO_RETURNED_VALUE = "Your `getStaticProps` function did not return an object. Did you forget to add a `return`?";
+    var GSSP_NO_RETURNED_VALUE = "Your `getServerSideProps` function did not return an object. Did you forget to add a `return`?";
+    var UNSTABLE_REVALIDATE_RENAME_ERROR = "The `unstable_revalidate` property is available for general use.\nPlease use `revalidate` instead.";
+    var GSSP_COMPONENT_MEMBER_ERROR = `can not be attached to a page's component and must be exported from the page. See more info here: https://nextjs.org/docs/messages/gssp-component-member`;
+    var NON_STANDARD_NODE_ENV = `You are using a non-standard "NODE_ENV" value in your environment. This creates inconsistencies in the project and is strongly advised against. Read more: https://nextjs.org/docs/messages/non-standard-node-env`;
+    var SSG_FALLBACK_EXPORT_ERROR = `Pages with \`fallback\` enabled in \`getStaticPaths\` can not be exported. See more info here: https://nextjs.org/docs/messages/ssg-fallback-true-export`;
+    var ESLINT_DEFAULT_DIRS = [
+      "app",
+      "pages",
+      "components",
+      "lib",
+      "src"
+    ];
+    var SERVER_RUNTIME = {
+      edge: "edge",
+      experimentalEdge: "experimental-edge",
+      nodejs: "nodejs"
+    };
+    var WEB_SOCKET_MAX_RECONNECTIONS = 12;
+    var WEBPACK_LAYERS_NAMES = {
+      /**
+      * The layer for the shared code between the client and server bundles.
+      */
+      shared: "shared",
+      /**
+      * The layer for server-only runtime and picking up `react-server` export conditions.
+      * Including app router RSC pages and app router custom routes and metadata routes.
+      */
+      reactServerComponents: "rsc",
+      /**
+      * Server Side Rendering layer for app (ssr).
+      */
+      serverSideRendering: "ssr",
+      /**
+      * The browser client bundle layer for actions.
+      */
+      actionBrowser: "action-browser",
+      /**
+      * The Node.js bundle layer for the API routes.
+      */
+      apiNode: "api-node",
+      /**
+      * The Edge Lite bundle layer for the API routes.
+      */
+      apiEdge: "api-edge",
+      /**
+      * The layer for the middleware code.
+      */
+      middleware: "middleware",
+      /**
+      * The layer for the instrumentation hooks.
+      */
+      instrument: "instrument",
+      /**
+      * The layer for assets on the edge.
+      */
+      edgeAsset: "edge-asset",
+      /**
+      * The browser client bundle layer for App directory.
+      */
+      appPagesBrowser: "app-pages-browser",
+      /**
+      * The browser client bundle layer for Pages directory.
+      */
+      pagesDirBrowser: "pages-dir-browser",
+      /**
+      * The Edge Lite bundle layer for Pages directory.
+      */
+      pagesDirEdge: "pages-dir-edge",
+      /**
+      * The Node.js bundle layer for Pages directory.
+      */
+      pagesDirNode: "pages-dir-node"
+    };
+    var WEBPACK_LAYERS = {
+      ...WEBPACK_LAYERS_NAMES,
+      GROUP: {
+        builtinReact: [
+          WEBPACK_LAYERS_NAMES.reactServerComponents,
+          WEBPACK_LAYERS_NAMES.actionBrowser
+        ],
+        serverOnly: [
+          WEBPACK_LAYERS_NAMES.reactServerComponents,
+          WEBPACK_LAYERS_NAMES.actionBrowser,
+          WEBPACK_LAYERS_NAMES.instrument,
+          WEBPACK_LAYERS_NAMES.middleware
+        ],
+        neutralTarget: [
+          // pages api
+          WEBPACK_LAYERS_NAMES.apiNode,
+          WEBPACK_LAYERS_NAMES.apiEdge
+        ],
+        clientOnly: [
+          WEBPACK_LAYERS_NAMES.serverSideRendering,
+          WEBPACK_LAYERS_NAMES.appPagesBrowser
+        ],
+        bundled: [
+          WEBPACK_LAYERS_NAMES.reactServerComponents,
+          WEBPACK_LAYERS_NAMES.actionBrowser,
+          WEBPACK_LAYERS_NAMES.serverSideRendering,
+          WEBPACK_LAYERS_NAMES.appPagesBrowser,
+          WEBPACK_LAYERS_NAMES.shared,
+          WEBPACK_LAYERS_NAMES.instrument,
+          WEBPACK_LAYERS_NAMES.middleware
+        ],
+        appPages: [
+          // app router pages and layouts
+          WEBPACK_LAYERS_NAMES.reactServerComponents,
+          WEBPACK_LAYERS_NAMES.serverSideRendering,
+          WEBPACK_LAYERS_NAMES.appPagesBrowser,
+          WEBPACK_LAYERS_NAMES.actionBrowser
+        ]
+      }
+    };
+    var WEBPACK_RESOURCE_QUERIES = {
+      edgeSSREntry: "__next_edge_ssr_entry__",
+      metadata: "__next_metadata__",
+      metadataRoute: "__next_metadata_route__",
+      metadataImageMeta: "__next_metadata_image_meta__"
+    };
+  }
+});
+
+// node_modules/next/dist/shared/lib/escape-regexp.js
+var require_escape_regexp = __commonJS({
+  "node_modules/next/dist/shared/lib/escape-regexp.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "escapeStringRegexp", {
+      enumerable: true,
+      get: function() {
+        return escapeStringRegexp;
+      }
+    });
+    var reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+    var reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+    function escapeStringRegexp(str) {
+      if (reHasRegExp.test(str)) {
+        return str.replace(reReplaceRegExp, "\\$&");
+      }
+      return str;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/invariant-error.js
+var require_invariant_error = __commonJS({
+  "node_modules/next/dist/shared/lib/invariant-error.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "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/shared/lib/router/utils/parse-loader-tree.js
+var require_parse_loader_tree = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/parse-loader-tree.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "parseLoaderTree", {
+      enumerable: true,
+      get: function() {
+        return parseLoaderTree;
+      }
+    });
+    var _segment = require_segment();
+    function parseLoaderTree(tree) {
+      const [segment, parallelRoutes, modules] = tree;
+      const { layout, template } = modules;
+      let { page } = modules;
+      page = segment === _segment.DEFAULT_SEGMENT_KEY ? modules.defaultPage : page;
+      const conventionPath = layout?.[1] || template?.[1] || page?.[1];
+      return {
+        page,
+        segment,
+        modules,
+        /* it can be either layout / template / page */
+        conventionPath,
+        parallelRoutes
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/get-segment-param.js
+var require_get_segment_param = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/get-segment-param.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      getParamProperties: function() {
+        return getParamProperties;
+      },
+      getSegmentParam: function() {
+        return getSegmentParam;
+      },
+      isCatchAll: function() {
+        return isCatchAll;
+      }
+    });
+    var _interceptionroutes = require_interception_routes();
+    function getSegmentParam(segment) {
+      const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((marker) => segment.startsWith(marker));
+      if (interceptionMarker) {
+        segment = segment.slice(interceptionMarker.length);
+      }
+      if (segment.startsWith("[[...") && segment.endsWith("]]")) {
+        return {
+          // TODO-APP: Optional catchall does not currently work with parallel routes,
+          // so for now aren't handling a potential interception marker.
+          type: "optional-catchall",
+          param: segment.slice(5, -2)
+        };
+      }
+      if (segment.startsWith("[...") && segment.endsWith("]")) {
+        return {
+          type: interceptionMarker ? `catchall-intercepted-${interceptionMarker}` : "catchall",
+          param: segment.slice(4, -1)
+        };
+      }
+      if (segment.startsWith("[") && segment.endsWith("]")) {
+        return {
+          type: interceptionMarker ? `dynamic-intercepted-${interceptionMarker}` : "dynamic",
+          param: segment.slice(1, -1)
+        };
+      }
+      return null;
+    }
+    function isCatchAll(type) {
+      return type === "catchall" || type === "catchall-intercepted-(..)(..)" || type === "catchall-intercepted-(.)" || type === "catchall-intercepted-(..)" || type === "catchall-intercepted-(...)" || type === "optional-catchall";
+    }
+    function getParamProperties(paramType) {
+      let repeat = false;
+      let optional = false;
+      switch (paramType) {
+        case "catchall":
+        case "catchall-intercepted-(..)(..)":
+        case "catchall-intercepted-(.)":
+        case "catchall-intercepted-(..)":
+        case "catchall-intercepted-(...)":
+          repeat = true;
+          break;
+        case "optional-catchall":
+          repeat = true;
+          optional = true;
+          break;
+        case "dynamic":
+        case "dynamic-intercepted-(..)(..)":
+        case "dynamic-intercepted-(.)":
+        case "dynamic-intercepted-(..)":
+        case "dynamic-intercepted-(...)":
+          break;
+        default:
+          paramType;
+      }
+      return {
+        repeat,
+        optional
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js
+var require_get_dynamic_param = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      PARAMETER_PATTERN: function() {
+        return PARAMETER_PATTERN;
+      },
+      getDynamicParam: function() {
+        return getDynamicParam;
+      },
+      interpolateParallelRouteParams: function() {
+        return interpolateParallelRouteParams;
+      },
+      parseMatchedParameter: function() {
+        return parseMatchedParameter;
+      },
+      parseParameter: function() {
+        return parseParameter;
+      }
+    });
+    var _invarianterror = require_invariant_error();
+    var _parseloadertree = require_parse_loader_tree();
+    var _getsegmentparam = require_get_segment_param();
+    function getParamValue(interpolatedParams, segmentKey, fallbackRouteParams) {
+      let value = interpolatedParams[segmentKey];
+      if (fallbackRouteParams?.has(segmentKey)) {
+        const [searchValue] = fallbackRouteParams.get(segmentKey);
+        value = searchValue;
+      } else if (Array.isArray(value)) {
+        value = value.map((i) => encodeURIComponent(i));
+      } else if (typeof value === "string") {
+        value = encodeURIComponent(value);
+      }
+      return value;
+    }
+    function interpolateParallelRouteParams(loaderTree, params, pagePath, fallbackRouteParams) {
+      const interpolated = structuredClone(params);
+      const stack = [
+        {
+          tree: loaderTree,
+          depth: 0
+        }
+      ];
+      const pathSegments = pagePath.split("/").slice(1);
+      while (stack.length > 0) {
+        const { tree, depth } = stack.pop();
+        const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+        const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
+        if (segmentParam && !interpolated.hasOwnProperty(segmentParam.param) && // If the param is in the fallback route params, we don't need to
+        // interpolate it because it's already marked as being unknown.
+        !fallbackRouteParams?.has(segmentParam.param)) {
+          switch (segmentParam.type) {
+            case "catchall":
+            case "optional-catchall":
+            case "catchall-intercepted-(..)(..)":
+            case "catchall-intercepted-(.)":
+            case "catchall-intercepted-(..)":
+            case "catchall-intercepted-(...)":
+              const remainingSegments = pathSegments.slice(depth);
+              const processedSegments = remainingSegments.flatMap((pathSegment) => {
+                const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+                return param ? interpolated[param.param] : pathSegment;
+              }).filter((s) => s !== void 0);
+              if (processedSegments.length > 0) {
+                interpolated[segmentParam.param] = processedSegments;
+              }
+              break;
+            case "dynamic":
+            case "dynamic-intercepted-(..)(..)":
+            case "dynamic-intercepted-(.)":
+            case "dynamic-intercepted-(..)":
+            case "dynamic-intercepted-(...)":
+              if (depth < pathSegments.length) {
+                const pathSegment = pathSegments[depth];
+                const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+                interpolated[segmentParam.param] = param ? interpolated[param.param] : pathSegment;
+              }
+              break;
+            default:
+              segmentParam.type;
+          }
+        }
+        let nextDepth = depth;
+        const isRouteGroup = segment.startsWith("(") && segment.endsWith(")");
+        if (!isRouteGroup && segment !== "") {
+          nextDepth++;
+        }
+        for (const route of Object.values(parallelRoutes)) {
+          stack.push({
+            tree: route,
+            depth: nextDepth
+          });
+        }
+      }
+      return interpolated;
+    }
+    function getDynamicParam(interpolatedParams, segmentKey, dynamicParamType, fallbackRouteParams) {
+      let value = getParamValue(interpolatedParams, segmentKey, fallbackRouteParams);
+      if (!value || value.length === 0) {
+        if (dynamicParamType === "oc") {
+          return {
+            param: segmentKey,
+            value: null,
+            type: dynamicParamType,
+            treeSegment: [
+              segmentKey,
+              "",
+              dynamicParamType
+            ]
+          };
+        }
+        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing value for segment key: "${segmentKey}" with dynamic param type: ${dynamicParamType}`), "__NEXT_ERROR_CODE", {
+          value: "E864",
+          enumerable: false,
+          configurable: true
+        });
+      }
+      return {
+        param: segmentKey,
+        // The value that is passed to user code.
+        value,
+        // The value that is rendered in the router tree.
+        treeSegment: [
+          segmentKey,
+          Array.isArray(value) ? value.join("/") : value,
+          dynamicParamType
+        ],
+        type: dynamicParamType
+      };
+    }
+    var PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+    function parseParameter(param) {
+      const match = param.match(PARAMETER_PATTERN);
+      if (!match) {
+        return parseMatchedParameter(param);
+      }
+      return parseMatchedParameter(match[2]);
+    }
+    function parseMatchedParameter(param) {
+      const optional = param.startsWith("[") && param.endsWith("]");
+      if (optional) {
+        param = param.slice(1, -1);
+      }
+      const repeat = param.startsWith("...");
+      if (repeat) {
+        param = param.slice(3);
+      }
+      return {
+        key: param,
+        repeat,
+        optional
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/route-regex.js
+var require_route_regex = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/route-regex.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      getNamedMiddlewareRegex: function() {
+        return getNamedMiddlewareRegex;
+      },
+      getNamedRouteRegex: function() {
+        return getNamedRouteRegex;
+      },
+      getRouteRegex: function() {
+        return getRouteRegex;
+      }
+    });
+    var _constants = require_constants();
+    var _interceptionroutes = require_interception_routes();
+    var _escaperegexp = require_escape_regexp();
+    var _removetrailingslash = require_remove_trailing_slash();
+    var _getdynamicparam = require_get_dynamic_param();
+    function getParametrizedRoute(route, includeSuffix, includePrefix) {
+      const groups = {};
+      let groupIndex = 1;
+      const segments = [];
+      for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+        const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m));
+        const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN);
+        if (markerMatch && paramMatches && paramMatches[2]) {
+          const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
+          groups[key] = {
+            pos: groupIndex++,
+            repeat,
+            optional
+          };
+          segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(markerMatch)}([^/]+?)`);
+        } else if (paramMatches && paramMatches[2]) {
+          const { key, repeat, optional } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
+          groups[key] = {
+            pos: groupIndex++,
+            repeat,
+            optional
+          };
+          if (includePrefix && paramMatches[1]) {
+            segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(paramMatches[1])}`);
+          }
+          let s = repeat ? optional ? "(?:/(.+?))?" : "/(.+?)" : "/([^/]+?)";
+          if (includePrefix && paramMatches[1]) {
+            s = s.substring(1);
+          }
+          segments.push(s);
+        } else {
+          segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(segment)}`);
+        }
+        if (includeSuffix && paramMatches && paramMatches[3]) {
+          segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+        }
+      }
+      return {
+        parameterizedRoute: segments.join(""),
+        groups
+      };
+    }
+    function getRouteRegex(normalizedRoute, { includeSuffix = false, includePrefix = false, excludeOptionalTrailingSlash = false } = {}) {
+      const { parameterizedRoute, groups } = getParametrizedRoute(normalizedRoute, includeSuffix, includePrefix);
+      let re = parameterizedRoute;
+      if (!excludeOptionalTrailingSlash) {
+        re += "(?:/)?";
+      }
+      return {
+        re: new RegExp(`^${re}$`),
+        groups
+      };
+    }
+    function buildGetSafeRouteKey() {
+      let i = 0;
+      return () => {
+        let routeKey = "";
+        let j = ++i;
+        while (j > 0) {
+          routeKey += String.fromCharCode(97 + (j - 1) % 26);
+          j = Math.floor((j - 1) / 26);
+        }
+        return routeKey;
+      };
+    }
+    function getSafeKeyFromSegment({ interceptionMarker, getSafeRouteKey, segment, routeKeys, keyPrefix, backreferenceDuplicateKeys }) {
+      const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(segment);
+      let cleanedKey = key.replace(/\W/g, "");
+      if (keyPrefix) {
+        cleanedKey = `${keyPrefix}${cleanedKey}`;
+      }
+      let invalidKey = false;
+      if (cleanedKey.length === 0 || cleanedKey.length > 30) {
+        invalidKey = true;
+      }
+      if (!isNaN(parseInt(cleanedKey.slice(0, 1)))) {
+        invalidKey = true;
+      }
+      if (invalidKey) {
+        cleanedKey = getSafeRouteKey();
+      }
+      const duplicateKey = cleanedKey in routeKeys;
+      if (keyPrefix) {
+        routeKeys[cleanedKey] = `${keyPrefix}${key}`;
+      } else {
+        routeKeys[cleanedKey] = key;
+      }
+      const interceptionPrefix = interceptionMarker ? (0, _escaperegexp.escapeStringRegexp)(interceptionMarker) : "";
+      let pattern;
+      if (duplicateKey && backreferenceDuplicateKeys) {
+        pattern = `\\k<${cleanedKey}>`;
+      } else if (repeat) {
+        pattern = `(?<${cleanedKey}>.+?)`;
+      } else {
+        pattern = `(?<${cleanedKey}>[^/]+?)`;
+      }
+      return {
+        key,
+        pattern: optional ? `(?:/${interceptionPrefix}${pattern})?` : `/${interceptionPrefix}${pattern}`,
+        cleanedKey,
+        optional,
+        repeat
+      };
+    }
+    function getNamedParametrizedRoute(route, prefixRouteKeys, includeSuffix, includePrefix, backreferenceDuplicateKeys, reference = {
+      names: {},
+      intercepted: {}
+    }) {
+      const getSafeRouteKey = buildGetSafeRouteKey();
+      const routeKeys = {};
+      const segments = [];
+      const inverseParts = [];
+      reference = structuredClone(reference);
+      for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+        const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m) => segment.startsWith(m));
+        const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN);
+        const interceptionMarker = hasInterceptionMarker ? paramMatches?.[1] : void 0;
+        let keyPrefix;
+        if (interceptionMarker && paramMatches?.[2]) {
+          keyPrefix = prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : void 0;
+          reference.intercepted[paramMatches[2]] = interceptionMarker;
+        } else if (paramMatches?.[2] && reference.intercepted[paramMatches[2]]) {
+          keyPrefix = prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : void 0;
+        } else {
+          keyPrefix = prefixRouteKeys ? _constants.NEXT_QUERY_PARAM_PREFIX : void 0;
+        }
+        if (interceptionMarker && paramMatches && paramMatches[2]) {
+          const { key, pattern, cleanedKey, repeat, optional } = getSafeKeyFromSegment({
+            getSafeRouteKey,
+            interceptionMarker,
+            segment: paramMatches[2],
+            routeKeys,
+            keyPrefix,
+            backreferenceDuplicateKeys
+          });
+          segments.push(pattern);
+          inverseParts.push(`/${paramMatches[1]}:${reference.names[key] ?? cleanedKey}${repeat ? optional ? "*" : "+" : ""}`);
+          reference.names[key] ??= cleanedKey;
+        } else if (paramMatches && paramMatches[2]) {
+          if (includePrefix && paramMatches[1]) {
+            segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(paramMatches[1])}`);
+            inverseParts.push(`/${paramMatches[1]}`);
+          }
+          const { key, pattern, cleanedKey, repeat, optional } = getSafeKeyFromSegment({
+            getSafeRouteKey,
+            segment: paramMatches[2],
+            routeKeys,
+            keyPrefix,
+            backreferenceDuplicateKeys
+          });
+          let s = pattern;
+          if (includePrefix && paramMatches[1]) {
+            s = s.substring(1);
+          }
+          segments.push(s);
+          inverseParts.push(`/:${reference.names[key] ?? cleanedKey}${repeat ? optional ? "*" : "+" : ""}`);
+          reference.names[key] ??= cleanedKey;
+        } else {
+          segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(segment)}`);
+          inverseParts.push(`/${segment}`);
+        }
+        if (includeSuffix && paramMatches && paramMatches[3]) {
+          segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+          inverseParts.push(paramMatches[3]);
+        }
+      }
+      return {
+        namedParameterizedRoute: segments.join(""),
+        routeKeys,
+        pathToRegexpPattern: inverseParts.join(""),
+        reference
+      };
+    }
+    function getNamedRouteRegex(normalizedRoute, options) {
+      const result = getNamedParametrizedRoute(normalizedRoute, options.prefixRouteKeys, options.includeSuffix ?? false, options.includePrefix ?? false, options.backreferenceDuplicateKeys ?? false, options.reference);
+      let namedRegex = result.namedParameterizedRoute;
+      if (!options.excludeOptionalTrailingSlash) {
+        namedRegex += "(?:/)?";
+      }
+      return {
+        ...getRouteRegex(normalizedRoute, options),
+        namedRegex: `^${namedRegex}$`,
+        routeKeys: result.routeKeys,
+        pathToRegexpPattern: result.pathToRegexpPattern,
+        reference: result.reference
+      };
+    }
+    function getNamedMiddlewareRegex(normalizedRoute, options) {
+      const { parameterizedRoute } = getParametrizedRoute(normalizedRoute, false, false);
+      const { catchAll = true } = options;
+      if (parameterizedRoute === "/") {
+        let catchAllRegex = catchAll ? ".*" : "";
+        return {
+          namedRegex: `^/${catchAllRegex}$`
+        };
+      }
+      const { namedParameterizedRoute } = getNamedParametrizedRoute(normalizedRoute, false, false, false, false, void 0);
+      let catchAllGroupedRegex = catchAll ? "(?:(/.*)?)" : "";
+      return {
+        namedRegex: `^${namedParameterizedRoute}${catchAllGroupedRegex}$`
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/interpolate-as.js
+var require_interpolate_as = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/interpolate-as.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "interpolateAs", {
+      enumerable: true,
+      get: function() {
+        return interpolateAs;
+      }
+    });
+    var _routematcher = require_route_matcher();
+    var _routeregex = require_route_regex();
+    function interpolateAs(route, asPathname, query) {
+      let interpolatedRoute = "";
+      const dynamicRegex = (0, _routeregex.getRouteRegex)(route);
+      const dynamicGroups = dynamicRegex.groups;
+      const dynamicMatches = (
+        // Try to match the dynamic route against the asPath
+        (asPathname !== route ? (0, _routematcher.getRouteMatcher)(dynamicRegex)(asPathname) : "") || // Fall back to reading the values from the href
+        // TODO: should this take priority; also need to change in the router.
+        query
+      );
+      interpolatedRoute = route;
+      const params = Object.keys(dynamicGroups);
+      if (!params.every((param) => {
+        let value = dynamicMatches[param] || "";
+        const { repeat, optional } = dynamicGroups[param];
+        let replaced = `[${repeat ? "..." : ""}${param}]`;
+        if (optional) {
+          replaced = `${!value ? "/" : ""}[${replaced}]`;
+        }
+        if (repeat && !Array.isArray(value)) value = [
+          value
+        ];
+        return (optional || param in dynamicMatches) && // Interpolate group into data URL if present
+        (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map(
+          // these values should be fully encoded instead of just
+          // path delimiter escaped since they are being inserted
+          // into the URL and we expect URL encoded segments
+          // when parsing dynamic route params
+          (segment) => encodeURIComponent(segment)
+        ).join("/") : encodeURIComponent(value)) || "/");
+      })) {
+        interpolatedRoute = "";
+      }
+      return {
+        params,
+        result: interpolatedRoute
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/client/resolve-href.js
+var require_resolve_href = __commonJS({
+  "node_modules/next/dist/client/resolve-href.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "resolveHref", {
+      enumerable: true,
+      get: function() {
+        return resolveHref;
+      }
+    });
+    var _querystring = require_querystring();
+    var _formaturl = require_format_url();
+    var _omit = require_omit();
+    var _utils = require_utils();
+    var _normalizetrailingslash = require_normalize_trailing_slash();
+    var _islocalurl = require_is_local_url();
+    var _utils1 = require_utils2();
+    var _interpolateas = require_interpolate_as();
+    var _routeregex = require_route_regex();
+    var _routematcher = require_route_matcher();
+    function resolveHref(router, href, resolveAs) {
+      let base;
+      let urlAsString = typeof href === "string" ? href : (0, _formaturl.formatWithValidation)(href);
+      const urlProtoMatch = urlAsString.match(/^[a-z][a-z0-9+.-]*:\/\//i);
+      const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
+      const urlParts = urlAsStringNoProto.split("?", 1);
+      if ((urlParts[0] || "").match(/(\/\/|\\)/)) {
+        console.error(`Invalid href '${urlAsString}' passed to next/router in page: '${router.pathname}'. Repeated forward-slashes (//) or backslashes \\ are not valid in the href.`);
+        const normalizedUrl = (0, _utils.normalizeRepeatedSlashes)(urlAsStringNoProto);
+        urlAsString = (urlProtoMatch ? urlProtoMatch[0] : "") + normalizedUrl;
+      }
+      if (!(0, _islocalurl.isLocalURL)(urlAsString)) {
+        return resolveAs ? [
+          urlAsString
+        ] : urlAsString;
+      }
+      try {
+        let baseBase = urlAsString.startsWith("#") ? router.asPath : router.pathname;
+        if (urlAsString.startsWith("?")) {
+          baseBase = router.asPath;
+          if ((0, _utils1.isDynamicRoute)(router.pathname)) {
+            baseBase = router.pathname;
+            const routeRegex = (0, _routeregex.getRouteRegex)(router.pathname);
+            const match = (0, _routematcher.getRouteMatcher)(routeRegex)(router.asPath);
+            if (!match) {
+              baseBase = router.asPath;
+            }
+          }
+        }
+        base = new URL(baseBase, "http://n");
+      } catch (_) {
+        base = new URL("/", "http://n");
+      }
+      try {
+        const finalUrl = new URL(urlAsString, base);
+        finalUrl.pathname = (0, _normalizetrailingslash.normalizePathTrailingSlash)(finalUrl.pathname);
+        let interpolatedAs = "";
+        if ((0, _utils1.isDynamicRoute)(finalUrl.pathname) && finalUrl.searchParams && resolveAs) {
+          const query = (0, _querystring.searchParamsToUrlQuery)(finalUrl.searchParams);
+          const { result, params } = (0, _interpolateas.interpolateAs)(finalUrl.pathname, finalUrl.pathname, query);
+          if (result) {
+            interpolatedAs = (0, _formaturl.formatWithValidation)({
+              pathname: result,
+              hash: finalUrl.hash,
+              query: (0, _omit.omit)(query, params)
+            });
+          }
+        }
+        const resolvedHref = finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
+        return resolveAs ? [
+          resolvedHref,
+          interpolatedAs || resolvedHref
+        ] : resolvedHref;
+      } catch (_) {
+        return resolveAs ? [
+          urlAsString
+        ] : urlAsString;
+      }
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js
+var require_add_path_prefix = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "addPathPrefix", {
+      enumerable: true,
+      get: function() {
+        return addPathPrefix;
+      }
+    });
+    var _parsepath = require_parse_path();
+    function addPathPrefix(path, prefix) {
+      if (!path.startsWith("/") || !prefix) {
+        return path;
+      }
+      const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+      return `${prefix}${pathname}${query}${hash}`;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/router/utils/add-locale.js
+var require_add_locale = __commonJS({
+  "node_modules/next/dist/shared/lib/router/utils/add-locale.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "addLocale", {
+      enumerable: true,
+      get: function() {
+        return addLocale;
+      }
+    });
+    var _addpathprefix = require_add_path_prefix();
+    var _pathhasprefix = require_path_has_prefix();
+    function addLocale(path, locale, defaultLocale, ignorePrefix) {
+      if (!locale || locale === defaultLocale) return path;
+      const lower = path.toLowerCase();
+      if (!ignorePrefix) {
+        if ((0, _pathhasprefix.pathHasPrefix)(lower, "/api")) return path;
+        if ((0, _pathhasprefix.pathHasPrefix)(lower, `/${locale.toLowerCase()}`)) return path;
+      }
+      return (0, _addpathprefix.addPathPrefix)(path, `/${locale}`);
+    }
+  }
+});
+
+// node_modules/next/dist/client/add-locale.js
+var require_add_locale2 = __commonJS({
+  "node_modules/next/dist/client/add-locale.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "addLocale", {
+      enumerable: true,
+      get: function() {
+        return addLocale;
+      }
+    });
+    var _normalizetrailingslash = require_normalize_trailing_slash();
+    var addLocale = (path, ...args) => {
+      if (process.env.__NEXT_I18N_SUPPORT) {
+        return (0, _normalizetrailingslash.normalizePathTrailingSlash)(require_add_locale().addLocale(path, ...args));
+      }
+      return path;
+    };
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/@swc/helpers/cjs/_interop_require_default.cjs
+var require_interop_require_default = __commonJS({
+  "node_modules/@swc/helpers/cjs/_interop_require_default.cjs"(exports) {
+    "use strict";
+    function _interop_require_default(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    exports._ = _interop_require_default;
+  }
+});
+
+// node_modules/next/dist/shared/lib/router-context.shared-runtime.js
+var require_router_context_shared_runtime = __commonJS({
+  "node_modules/next/dist/shared/lib/router-context.shared-runtime.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "RouterContext", {
+      enumerable: true,
+      get: function() {
+        return RouterContext;
+      }
+    });
+    var _interop_require_default = require_interop_require_default();
+    var _react = /* @__PURE__ */ _interop_require_default._(__require("react"));
+    var RouterContext = _react.default.createContext(null);
+    if (true) {
+      RouterContext.displayName = "RouterContext";
+    }
+  }
+});
+
+// node_modules/next/dist/client/request-idle-callback.js
+var require_request_idle_callback = __commonJS({
+  "node_modules/next/dist/client/request-idle-callback.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      cancelIdleCallback: function() {
+        return cancelIdleCallback;
+      },
+      requestIdleCallback: function() {
+        return requestIdleCallback;
+      }
+    });
+    var requestIdleCallback = typeof self !== "undefined" && self.requestIdleCallback && self.requestIdleCallback.bind(window) || function(cb) {
+      let start = Date.now();
+      return self.setTimeout(function() {
+        cb({
+          didTimeout: false,
+          timeRemaining: function() {
+            return Math.max(0, 50 - (Date.now() - start));
+          }
+        });
+      }, 1);
+    };
+    var cancelIdleCallback = typeof self !== "undefined" && self.cancelIdleCallback && self.cancelIdleCallback.bind(window) || function(id) {
+      return clearTimeout(id);
+    };
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/use-intersection.js
+var require_use_intersection = __commonJS({
+  "node_modules/next/dist/client/use-intersection.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "useIntersection", {
+      enumerable: true,
+      get: function() {
+        return useIntersection;
+      }
+    });
+    var _react = __require("react");
+    var _requestidlecallback = require_request_idle_callback();
+    var hasIntersectionObserver = typeof IntersectionObserver === "function";
+    var observers = /* @__PURE__ */ new Map();
+    var idList = [];
+    function createObserver(options) {
+      const id = {
+        root: options.root || null,
+        margin: options.rootMargin || ""
+      };
+      const existing = idList.find((obj) => obj.root === id.root && obj.margin === id.margin);
+      let instance;
+      if (existing) {
+        instance = observers.get(existing);
+        if (instance) {
+          return instance;
+        }
+      }
+      const elements = /* @__PURE__ */ new Map();
+      const observer = new IntersectionObserver((entries) => {
+        entries.forEach((entry) => {
+          const callback = elements.get(entry.target);
+          const isVisible = entry.isIntersecting || entry.intersectionRatio > 0;
+          if (callback && isVisible) {
+            callback(isVisible);
+          }
+        });
+      }, options);
+      instance = {
+        id,
+        observer,
+        elements
+      };
+      idList.push(id);
+      observers.set(id, instance);
+      return instance;
+    }
+    function observe(element, callback, options) {
+      const { id, observer, elements } = createObserver(options);
+      elements.set(element, callback);
+      observer.observe(element);
+      return function unobserve() {
+        elements.delete(element);
+        observer.unobserve(element);
+        if (elements.size === 0) {
+          observer.disconnect();
+          observers.delete(id);
+          const index = idList.findIndex((obj) => obj.root === id.root && obj.margin === id.margin);
+          if (index > -1) {
+            idList.splice(index, 1);
+          }
+        }
+      };
+    }
+    function useIntersection({ rootRef, rootMargin, disabled }) {
+      const isDisabled = disabled || !hasIntersectionObserver;
+      const [visible, setVisible] = (0, _react.useState)(false);
+      const elementRef = (0, _react.useRef)(null);
+      const setElement = (0, _react.useCallback)((element) => {
+        elementRef.current = element;
+      }, []);
+      (0, _react.useEffect)(() => {
+        if (hasIntersectionObserver) {
+          if (isDisabled || visible) return;
+          const element = elementRef.current;
+          if (element && element.tagName) {
+            const unobserve = observe(element, (isVisible) => isVisible && setVisible(isVisible), {
+              root: rootRef?.current,
+              rootMargin
+            });
+            return unobserve;
+          }
+        } else {
+          if (!visible) {
+            const idleCallback = (0, _requestidlecallback.requestIdleCallback)(() => setVisible(true));
+            return () => (0, _requestidlecallback.cancelIdleCallback)(idleCallback);
+          }
+        }
+      }, [
+        isDisabled,
+        rootMargin,
+        rootRef,
+        visible,
+        elementRef.current
+      ]);
+      const resetVisible = (0, _react.useCallback)(() => {
+        setVisible(false);
+      }, []);
+      return [
+        setElement,
+        visible,
+        resetVisible
+      ];
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js
+var require_normalize_locale_path = __commonJS({
+  "node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "normalizeLocalePath", {
+      enumerable: true,
+      get: function() {
+        return normalizeLocalePath;
+      }
+    });
+    var cache = /* @__PURE__ */ new WeakMap();
+    function normalizeLocalePath(pathname, locales) {
+      if (!locales) return {
+        pathname
+      };
+      let lowercasedLocales = cache.get(locales);
+      if (!lowercasedLocales) {
+        lowercasedLocales = locales.map((locale) => locale.toLowerCase());
+        cache.set(locales, lowercasedLocales);
+      }
+      let detectedLocale;
+      const segments = pathname.split("/", 2);
+      if (!segments[1]) return {
+        pathname
+      };
+      const segment = segments[1].toLowerCase();
+      const index = lowercasedLocales.indexOf(segment);
+      if (index < 0) return {
+        pathname
+      };
+      detectedLocale = locales[index];
+      pathname = pathname.slice(detectedLocale.length + 1) || "/";
+      return {
+        pathname,
+        detectedLocale
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/client/normalize-locale-path.js
+var require_normalize_locale_path2 = __commonJS({
+  "node_modules/next/dist/client/normalize-locale-path.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "normalizeLocalePath", {
+      enumerable: true,
+      get: function() {
+        return normalizeLocalePath;
+      }
+    });
+    var normalizeLocalePath = (pathname, locales) => {
+      if (process.env.__NEXT_I18N_SUPPORT) {
+        return require_normalize_locale_path().normalizeLocalePath(pathname, locales);
+      }
+      return {
+        pathname,
+        detectedLocale: void 0
+      };
+    };
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js
+var require_detect_domain_locale = __commonJS({
+  "node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "detectDomainLocale", {
+      enumerable: true,
+      get: function() {
+        return detectDomainLocale;
+      }
+    });
+    function detectDomainLocale(domainItems, hostname, detectedLocale) {
+      if (!domainItems) return;
+      if (detectedLocale) {
+        detectedLocale = detectedLocale.toLowerCase();
+      }
+      for (const item of domainItems) {
+        const domainHostname = item.domain?.split(":", 1)[0].toLowerCase();
+        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || item.locales?.some((locale) => locale.toLowerCase() === detectedLocale)) {
+          return item;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/next/dist/client/detect-domain-locale.js
+var require_detect_domain_locale2 = __commonJS({
+  "node_modules/next/dist/client/detect-domain-locale.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "detectDomainLocale", {
+      enumerable: true,
+      get: function() {
+        return detectDomainLocale;
+      }
+    });
+    var detectDomainLocale = (...args) => {
+      if (process.env.__NEXT_I18N_SUPPORT) {
+        return require_detect_domain_locale().detectDomainLocale(...args);
+      }
+    };
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/get-domain-locale.js
+var require_get_domain_locale = __commonJS({
+  "node_modules/next/dist/client/get-domain-locale.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "getDomainLocale", {
+      enumerable: true,
+      get: function() {
+        return getDomainLocale;
+      }
+    });
+    var _normalizetrailingslash = require_normalize_trailing_slash();
+    var basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+    function getDomainLocale(path, locale, locales, domainLocales) {
+      if (process.env.__NEXT_I18N_SUPPORT) {
+        const normalizeLocalePath = require_normalize_locale_path2().normalizeLocalePath;
+        const detectDomainLocale = require_detect_domain_locale2().detectDomainLocale;
+        const target = locale || normalizeLocalePath(path, locales).detectedLocale;
+        const domain = detectDomainLocale(domainLocales, void 0, target);
+        if (domain) {
+          const proto = `http${domain.http ? "" : "s"}://`;
+          const finalLocale = target === domain.defaultLocale ? "" : `/${target}`;
+          return `${proto}${domain.domain}${(0, _normalizetrailingslash.normalizePathTrailingSlash)(`${basePath}${finalLocale}${path}`)}`;
+        }
+        return false;
+      } else {
+        return false;
+      }
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/add-base-path.js
+var require_add_base_path = __commonJS({
+  "node_modules/next/dist/client/add-base-path.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "addBasePath", {
+      enumerable: true,
+      get: function() {
+        return addBasePath;
+      }
+    });
+    var _addpathprefix = require_add_path_prefix();
+    var _normalizetrailingslash = require_normalize_trailing_slash();
+    var basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+    function addBasePath(path, required) {
+      return (0, _normalizetrailingslash.normalizePathTrailingSlash)(process.env.__NEXT_MANUAL_CLIENT_BASE_PATH && !required ? path : (0, _addpathprefix.addPathPrefix)(path, basePath));
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/client/use-merged-ref.js
+var require_use_merged_ref = __commonJS({
+  "node_modules/next/dist/client/use-merged-ref.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "useMergedRef", {
+      enumerable: true,
+      get: function() {
+        return useMergedRef;
+      }
+    });
+    var _react = __require("react");
+    function useMergedRef(refA, refB) {
+      const cleanupA = (0, _react.useRef)(null);
+      const cleanupB = (0, _react.useRef)(null);
+      return (0, _react.useCallback)((current) => {
+        if (current === null) {
+          const cleanupFnA = cleanupA.current;
+          if (cleanupFnA) {
+            cleanupA.current = null;
+            cleanupFnA();
+          }
+          const cleanupFnB = cleanupB.current;
+          if (cleanupFnB) {
+            cleanupB.current = null;
+            cleanupFnB();
+          }
+        } else {
+          if (refA) {
+            cleanupA.current = applyRef(refA, current);
+          }
+          if (refB) {
+            cleanupB.current = applyRef(refB, current);
+          }
+        }
+      }, [
+        refA,
+        refB
+      ]);
+    }
+    function applyRef(refA, current) {
+      if (typeof refA === "function") {
+        const cleanup = refA(current);
+        if (typeof cleanup === "function") {
+          return cleanup;
+        } else {
+          return () => refA(null);
+        }
+      } else {
+        refA.current = current;
+        return () => {
+          refA.current = null;
+        };
+      }
+    }
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/dist/shared/lib/utils/error-once.js
+var require_error_once = __commonJS({
+  "node_modules/next/dist/shared/lib/utils/error-once.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "errorOnce", {
+      enumerable: true,
+      get: function() {
+        return errorOnce;
+      }
+    });
+    var errorOnce = (_) => {
+    };
+    if (true) {
+      const errors = /* @__PURE__ */ new Set();
+      errorOnce = (msg) => {
+        if (!errors.has(msg)) {
+          console.error(msg);
+        }
+        errors.add(msg);
+      };
+    }
+  }
+});
+
+// node_modules/next/dist/client/link.js
+var require_link = __commonJS({
+  "node_modules/next/dist/client/link.js"(exports, module) {
+    "use client";
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    function _export(target, all) {
+      for (var name in all) Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+      });
+    }
+    _export(exports, {
+      default: function() {
+        return _default;
+      },
+      useLinkStatus: function() {
+        return useLinkStatus;
+      }
+    });
+    var _interop_require_wildcard = require_interop_require_wildcard();
+    var _jsxruntime = __require("react/jsx-runtime");
+    var _react = /* @__PURE__ */ _interop_require_wildcard._(__require("react"));
+    var _resolvehref = require_resolve_href();
+    var _islocalurl = require_is_local_url();
+    var _formaturl = require_format_url();
+    var _utils = require_utils();
+    var _addlocale = require_add_locale2();
+    var _routercontextsharedruntime = require_router_context_shared_runtime();
+    var _useintersection = require_use_intersection();
+    var _getdomainlocale = require_get_domain_locale();
+    var _addbasepath = require_add_base_path();
+    var _usemergedref = require_use_merged_ref();
+    var _erroronce = require_error_once();
+    var prefetched = /* @__PURE__ */ new Set();
+    function prefetch(router, href, as, options) {
+      if (typeof window === "undefined") {
+        return;
+      }
+      if (!(0, _islocalurl.isLocalURL)(href)) {
+        return;
+      }
+      if (!options.bypassPrefetchedCheck) {
+        const locale = (
+          // Let the link's locale prop override the default router locale.
+          typeof options.locale !== "undefined" ? options.locale : "locale" in router ? router.locale : void 0
+        );
+        const prefetchedKey = href + "%" + as + "%" + locale;
+        if (prefetched.has(prefetchedKey)) {
+          return;
+        }
+        prefetched.add(prefetchedKey);
+      }
+      router.prefetch(href, as, options).catch((err) => {
+        if (true) {
+          throw err;
+        }
+      });
+    }
+    function isModifiedEvent(event) {
+      const eventTarget = event.currentTarget;
+      const target = eventTarget.getAttribute("target");
+      return target && target !== "_self" || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || // triggers resource download
+      event.nativeEvent && event.nativeEvent.which === 2;
+    }
+    function linkClicked(e, router, href, as, replace, shallow, scroll, locale, onNavigate) {
+      const { nodeName } = e.currentTarget;
+      const isAnchorNodeName = nodeName.toUpperCase() === "A";
+      if (isAnchorNodeName && isModifiedEvent(e) || e.currentTarget.hasAttribute("download")) {
+        return;
+      }
+      if (!(0, _islocalurl.isLocalURL)(href)) {
+        if (replace) {
+          e.preventDefault();
+          location.replace(href);
+        }
+        return;
+      }
+      e.preventDefault();
+      const navigate = () => {
+        if (onNavigate) {
+          let isDefaultPrevented = false;
+          onNavigate({
+            preventDefault: () => {
+              isDefaultPrevented = true;
+            }
+          });
+          if (isDefaultPrevented) {
+            return;
+          }
+        }
+        const routerScroll = scroll ?? true;
+        if ("beforePopState" in router) {
+          router[replace ? "replace" : "push"](href, as, {
+            shallow,
+            locale,
+            scroll: routerScroll
+          });
+        } else {
+          router[replace ? "replace" : "push"](as || href, {
+            scroll: routerScroll
+          });
+        }
+      };
+      navigate();
+    }
+    function formatStringOrUrl(urlObjOrString) {
+      if (typeof urlObjOrString === "string") {
+        return urlObjOrString;
+      }
+      return (0, _formaturl.formatUrl)(urlObjOrString);
+    }
+    var Link2 = /* @__PURE__ */ _react.default.forwardRef(function LinkComponent(props, forwardedRef) {
+      let children;
+      const { href: hrefProp, as: asProp, children: childrenProp, prefetch: prefetchProp = null, passHref, replace, shallow, scroll, locale, onClick, onNavigate, onMouseEnter: onMouseEnterProp, onTouchStart: onTouchStartProp, legacyBehavior = false, ...restProps } = props;
+      children = childrenProp;
+      if (legacyBehavior && (typeof children === "string" || typeof children === "number")) {
+        children = /* @__PURE__ */ (0, _jsxruntime.jsx)("a", {
+          children
+        });
+      }
+      const router = _react.default.useContext(_routercontextsharedruntime.RouterContext);
+      const prefetchEnabled = prefetchProp !== false;
+      if (true) {
+        let createPropError = function(args) {
+          return Object.defineProperty(new Error(`Failed prop type: The prop \`${args.key}\` expects a ${args.expected} in \`<Link>\`, but got \`${args.actual}\` instead.` + (typeof window !== "undefined" ? "\nOpen your browser's console to view the Component stack trace." : "")), "__NEXT_ERROR_CODE", {
+            value: "E319",
+            enumerable: false,
+            configurable: true
+          });
+        };
+        const requiredPropsGuard = {
+          href: true
+        };
+        const requiredProps = Object.keys(requiredPropsGuard);
+        requiredProps.forEach((key) => {
+          if (key === "href") {
+            if (props[key] == null || typeof props[key] !== "string" && typeof props[key] !== "object") {
+              throw createPropError({
+                key,
+                expected: "`string` or `object`",
+                actual: props[key] === null ? "null" : typeof props[key]
+              });
+            }
+          } else {
+            const _ = key;
+          }
+        });
+        const optionalPropsGuard = {
+          as: true,
+          replace: true,
+          scroll: true,
+          shallow: true,
+          passHref: true,
+          prefetch: true,
+          locale: true,
+          onClick: true,
+          onMouseEnter: true,
+          onTouchStart: true,
+          legacyBehavior: true,
+          onNavigate: true
+        };
+        const optionalProps = Object.keys(optionalPropsGuard);
+        optionalProps.forEach((key) => {
+          const valType = typeof props[key];
+          if (key === "as") {
+            if (props[key] && valType !== "string" && valType !== "object") {
+              throw createPropError({
+                key,
+                expected: "`string` or `object`",
+                actual: valType
+              });
+            }
+          } else if (key === "locale") {
+            if (props[key] && valType !== "string") {
+              throw createPropError({
+                key,
+                expected: "`string`",
+                actual: valType
+              });
+            }
+          } else if (key === "onClick" || key === "onMouseEnter" || key === "onTouchStart" || key === "onNavigate") {
+            if (props[key] && valType !== "function") {
+              throw createPropError({
+                key,
+                expected: "`function`",
+                actual: valType
+              });
+            }
+          } else if (key === "replace" || key === "scroll" || key === "shallow" || key === "passHref" || key === "legacyBehavior") {
+            if (props[key] != null && valType !== "boolean") {
+              throw createPropError({
+                key,
+                expected: "`boolean`",
+                actual: valType
+              });
+            }
+          } else if (key === "prefetch") {
+            if (props[key] != null && valType !== "boolean" && props[key] !== "auto") {
+              throw createPropError({
+                key,
+                expected: '`boolean | "auto"`',
+                actual: valType
+              });
+            }
+          } else {
+            const _ = key;
+          }
+        });
+      }
+      const { href, as } = _react.default.useMemo(() => {
+        if (!router) {
+          const resolvedHref2 = formatStringOrUrl(hrefProp);
+          return {
+            href: resolvedHref2,
+            as: asProp ? formatStringOrUrl(asProp) : resolvedHref2
+          };
+        }
+        const [resolvedHref, resolvedAs] = (0, _resolvehref.resolveHref)(router, hrefProp, true);
+        return {
+          href: resolvedHref,
+          as: asProp ? (0, _resolvehref.resolveHref)(router, asProp) : resolvedAs || resolvedHref
+        };
+      }, [
+        router,
+        hrefProp,
+        asProp
+      ]);
+      const previousHref = _react.default.useRef(href);
+      const previousAs = _react.default.useRef(as);
+      let child;
+      if (legacyBehavior) {
+        if (true) {
+          if (onClick) {
+            console.warn(`"onClick" was passed to <Link> with \`href\` of \`${hrefProp}\` but "legacyBehavior" was set. The legacy behavior requires onClick be set on the child of next/link`);
+          }
+          if (onMouseEnterProp) {
+            console.warn(`"onMouseEnter" was passed to <Link> with \`href\` of \`${hrefProp}\` but "legacyBehavior" was set. The legacy behavior requires onMouseEnter be set on the child of next/link`);
+          }
+          try {
+            child = _react.default.Children.only(children);
+          } catch (err) {
+            if (!children) {
+              throw Object.defineProperty(new Error(`No children were passed to <Link> with \`href\` of \`${hrefProp}\` but one child is required https://nextjs.org/docs/messages/link-no-children`), "__NEXT_ERROR_CODE", {
+                value: "E320",
+                enumerable: false,
+                configurable: true
+              });
+            }
+            throw Object.defineProperty(new Error(`Multiple children were passed to <Link> with \`href\` of \`${hrefProp}\` but only one child is supported https://nextjs.org/docs/messages/link-multiple-children` + (typeof window !== "undefined" ? " \nOpen your browser's console to view the Component stack trace." : "")), "__NEXT_ERROR_CODE", {
+              value: "E266",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        } else {
+          child = _react.default.Children.only(children);
+        }
+      } else {
+        if (true) {
+          if (children?.type === "a") {
+            throw Object.defineProperty(new Error("Invalid <Link> with <a> child. Please remove <a> or use <Link legacyBehavior>.\nLearn more: https://nextjs.org/docs/messages/invalid-new-link-with-extra-anchor"), "__NEXT_ERROR_CODE", {
+              value: "E209",
+              enumerable: false,
+              configurable: true
+            });
+          }
+        }
+      }
+      const childRef = legacyBehavior ? child && typeof child === "object" && child.ref : forwardedRef;
+      const [setIntersectionRef, isVisible, resetVisible] = (0, _useintersection.useIntersection)({
+        rootMargin: "200px"
+      });
+      const setIntersectionWithResetRef = _react.default.useCallback((el) => {
+        if (previousAs.current !== as || previousHref.current !== href) {
+          resetVisible();
+          previousAs.current = as;
+          previousHref.current = href;
+        }
+        setIntersectionRef(el);
+      }, [
+        as,
+        href,
+        resetVisible,
+        setIntersectionRef
+      ]);
+      const setRef = (0, _usemergedref.useMergedRef)(setIntersectionWithResetRef, childRef);
+      _react.default.useEffect(() => {
+        if (true) {
+          return;
+        }
+        if (!router) {
+          return;
+        }
+        if (!isVisible || !prefetchEnabled) {
+          return;
+        }
+        prefetch(router, href, as, {
+          locale
+        });
+      }, [
+        as,
+        href,
+        isVisible,
+        locale,
+        prefetchEnabled,
+        router?.locale,
+        router
+      ]);
+      const childProps = {
+        ref: setRef,
+        onClick(e) {
+          if (true) {
+            if (!e) {
+              throw Object.defineProperty(new Error(`Component rendered inside next/link has to pass click event to "onClick" prop.`), "__NEXT_ERROR_CODE", {
+                value: "E312",
+                enumerable: false,
+                configurable: true
+              });
+            }
+          }
+          if (!legacyBehavior && typeof onClick === "function") {
+            onClick(e);
+          }
+          if (legacyBehavior && child.props && typeof child.props.onClick === "function") {
+            child.props.onClick(e);
+          }
+          if (!router) {
+            return;
+          }
+          if (e.defaultPrevented) {
+            return;
+          }
+          linkClicked(e, router, href, as, replace, shallow, scroll, locale, onNavigate);
+        },
+        onMouseEnter(e) {
+          if (!legacyBehavior && typeof onMouseEnterProp === "function") {
+            onMouseEnterProp(e);
+          }
+          if (legacyBehavior && child.props && typeof child.props.onMouseEnter === "function") {
+            child.props.onMouseEnter(e);
+          }
+          if (!router) {
+            return;
+          }
+          prefetch(router, href, as, {
+            locale,
+            priority: true,
+            // @see {https://github.com/vercel/next.js/discussions/40268?sort=top#discussioncomment-3572642}
+            bypassPrefetchedCheck: true
+          });
+        },
+        onTouchStart: process.env.__NEXT_LINK_NO_TOUCH_START ? void 0 : function onTouchStart(e) {
+          if (!legacyBehavior && typeof onTouchStartProp === "function") {
+            onTouchStartProp(e);
+          }
+          if (legacyBehavior && child.props && typeof child.props.onTouchStart === "function") {
+            child.props.onTouchStart(e);
+          }
+          if (!router) {
+            return;
+          }
+          prefetch(router, href, as, {
+            locale,
+            priority: true,
+            // @see {https://github.com/vercel/next.js/discussions/40268?sort=top#discussioncomment-3572642}
+            bypassPrefetchedCheck: true
+          });
+        }
+      };
+      if ((0, _utils.isAbsoluteUrl)(as)) {
+        childProps.href = as;
+      } else if (!legacyBehavior || passHref || child.type === "a" && !("href" in child.props)) {
+        const curLocale = typeof locale !== "undefined" ? locale : router?.locale;
+        const localeDomain = router?.isLocaleDomain && (0, _getdomainlocale.getDomainLocale)(as, curLocale, router?.locales, router?.domainLocales);
+        childProps.href = localeDomain || (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(as, curLocale, router?.defaultLocale));
+      }
+      if (legacyBehavior) {
+        if (true) {
+          (0, _erroronce.errorOnce)("`legacyBehavior` is deprecated and will be removed in a future release. A codemod is available to upgrade your components:\n\nnpx @next/codemod@latest new-link .\n\nLearn more: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#remove-a-tags-from-link-components");
+        }
+        return /* @__PURE__ */ _react.default.cloneElement(child, childProps);
+      }
+      return /* @__PURE__ */ (0, _jsxruntime.jsx)("a", {
+        ...restProps,
+        ...childProps,
+        children
+      });
+    });
+    var LinkStatusContext = /* @__PURE__ */ (0, _react.createContext)({
+      // We do not support link status in the Pages Router, so we always return false
+      pending: false
+    });
+    var useLinkStatus = () => {
+      return (0, _react.useContext)(LinkStatusContext);
+    };
+    var _default = Link2;
+    if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+      Object.defineProperty(exports.default, "__esModule", { value: true });
+      Object.assign(exports.default, exports);
+      module.exports = exports.default;
+    }
+  }
+});
+
+// node_modules/next/link.js
+var require_link2 = __commonJS({
+  "node_modules/next/link.js"(exports, module) {
+    module.exports = require_link();
+  }
+});
+
 // src/provider.js
 import React, { createContext, useContext, useEffect, useState, useCallback, useRef } from "react";
 
@@ -249,9 +4013,9 @@ function SignIn({ onSuccess } = {}) {
         },
         body: JSON.stringify({ email, password })
       });
-      const ct2 = res.headers.get("content-type") || "";
+      const ct = res.headers.get("content-type") || "";
       let data = {};
-      if (ct2.includes("application/json")) data = await res.json();
+      if (ct.includes("application/json")) data = await res.json();
       else {
         const text = await res.text();
         throw new Error(`Unexpected response (status ${res.status}): ${text.slice(0, 200)}`);
@@ -359,440 +4123,9 @@ var errorBox = { marginTop: 10, color: "#ffb4b4", fontSize: 13 };
 var successBox = { marginTop: 10, color: "#bef264", fontSize: 13 };
 
 // src/SignUp.jsx
+var import_link = __toESM(require_link2(), 1);
 import React3, { useState as useState3, useRef as useRef2, useEffect as useEffect2 } from "react";
-
-// ../node_modules/react-toastify/dist/index.mjs
-import { isValidElement as $t } from "react";
-import ut, { useEffect as Rt, useLayoutEffect as Bt, useRef as zt } from "react";
-import { cloneElement as Ft, isValidElement as Ut } from "react";
-import ot from "react";
-import et from "react";
-
-// ../node_modules/clsx/dist/clsx.mjs
-function r(e) {
-  var t, f, n = "";
-  if ("string" == typeof e || "number" == typeof e) n += e;
-  else if ("object" == typeof e) if (Array.isArray(e)) {
-    var o = e.length;
-    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
-  } else for (f in e) e[f] && (n && (n += " "), n += f);
-  return n;
-}
-function clsx() {
-  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
-  return n;
-}
-var clsx_default = clsx;
-
-// ../node_modules/react-toastify/dist/index.mjs
-import ct, { useEffect as yo, useRef as To, useState as go } from "react";
-import { useRef as Kt, useSyncExternalStore as Yt } from "react";
-import { useEffect as Zt, useRef as St, useState as kt } from "react";
-import { useEffect as Jt, useLayoutEffect as to } from "react";
-import q, { cloneElement as co, isValidElement as fo } from "react";
-import O, { cloneElement as oo, isValidElement as eo } from "react";
-function Mt(t) {
-  if (!t || typeof document == "undefined") return;
-  let o = document.head || document.getElementsByTagName("head")[0], e = document.createElement("style");
-  e.type = "text/css", o.firstChild ? o.insertBefore(e, o.firstChild) : o.appendChild(e), e.styleSheet ? e.styleSheet.cssText = t : e.appendChild(document.createTextNode(t));
-}
-Mt(`:root{--toastify-color-light: #fff;--toastify-color-dark: #121212;--toastify-color-info: #3498db;--toastify-color-success: #07bc0c;--toastify-color-warning: #f1c40f;--toastify-color-error: hsl(6, 78%, 57%);--toastify-color-transparent: rgba(255, 255, 255, .7);--toastify-icon-color-info: var(--toastify-color-info);--toastify-icon-color-success: var(--toastify-color-success);--toastify-icon-color-warning: var(--toastify-color-warning);--toastify-icon-color-error: var(--toastify-color-error);--toastify-container-width: fit-content;--toastify-toast-width: 320px;--toastify-toast-offset: 16px;--toastify-toast-top: max(var(--toastify-toast-offset), env(safe-area-inset-top));--toastify-toast-right: max(var(--toastify-toast-offset), env(safe-area-inset-right));--toastify-toast-left: max(var(--toastify-toast-offset), env(safe-area-inset-left));--toastify-toast-bottom: max(var(--toastify-toast-offset), env(safe-area-inset-bottom));--toastify-toast-background: #fff;--toastify-toast-padding: 14px;--toastify-toast-min-height: 64px;--toastify-toast-max-height: 800px;--toastify-toast-bd-radius: 6px;--toastify-toast-shadow: 0px 4px 12px rgba(0, 0, 0, .1);--toastify-font-family: sans-serif;--toastify-z-index: 9999;--toastify-text-color-light: #757575;--toastify-text-color-dark: #fff;--toastify-text-color-info: #fff;--toastify-text-color-success: #fff;--toastify-text-color-warning: #fff;--toastify-text-color-error: #fff;--toastify-spinner-color: #616161;--toastify-spinner-color-empty-area: #e0e0e0;--toastify-color-progress-light: linear-gradient(to right, #4cd964, #5ac8fa, #007aff, #34aadc, #5856d6, #ff2d55);--toastify-color-progress-dark: #bb86fc;--toastify-color-progress-info: var(--toastify-color-info);--toastify-color-progress-success: var(--toastify-color-success);--toastify-color-progress-warning: var(--toastify-color-warning);--toastify-color-progress-error: var(--toastify-color-error);--toastify-color-progress-bgo: .2}.Toastify__toast-container{z-index:var(--toastify-z-index);-webkit-transform:translate3d(0,0,var(--toastify-z-index));position:fixed;width:var(--toastify-container-width);box-sizing:border-box;color:#fff;display:flex;flex-direction:column}.Toastify__toast-container--top-left{top:var(--toastify-toast-top);left:var(--toastify-toast-left)}.Toastify__toast-container--top-center{top:var(--toastify-toast-top);left:50%;transform:translate(-50%);align-items:center}.Toastify__toast-container--top-right{top:var(--toastify-toast-top);right:var(--toastify-toast-right);align-items:end}.Toastify__toast-container--bottom-left{bottom:var(--toastify-toast-bottom);left:var(--toastify-toast-left)}.Toastify__toast-container--bottom-center{bottom:var(--toastify-toast-bottom);left:50%;transform:translate(-50%);align-items:center}.Toastify__toast-container--bottom-right{bottom:var(--toastify-toast-bottom);right:var(--toastify-toast-right);align-items:end}.Toastify__toast{--y: 0;position:relative;touch-action:none;width:var(--toastify-toast-width);min-height:var(--toastify-toast-min-height);box-sizing:border-box;margin-bottom:1rem;padding:var(--toastify-toast-padding);border-radius:var(--toastify-toast-bd-radius);box-shadow:var(--toastify-toast-shadow);max-height:var(--toastify-toast-max-height);font-family:var(--toastify-font-family);z-index:0;display:flex;flex:1 auto;align-items:center;word-break:break-word}@media only screen and (max-width: 480px){.Toastify__toast-container{width:100vw;left:env(safe-area-inset-left);margin:0}.Toastify__toast-container--top-left,.Toastify__toast-container--top-center,.Toastify__toast-container--top-right{top:env(safe-area-inset-top);transform:translate(0)}.Toastify__toast-container--bottom-left,.Toastify__toast-container--bottom-center,.Toastify__toast-container--bottom-right{bottom:env(safe-area-inset-bottom);transform:translate(0)}.Toastify__toast-container--rtl{right:env(safe-area-inset-right);left:initial}.Toastify__toast{--toastify-toast-width: 100%;margin-bottom:0;border-radius:0}}.Toastify__toast-container[data-stacked=true]{width:var(--toastify-toast-width)}.Toastify__toast--stacked{position:absolute;width:100%;transform:translate3d(0,var(--y),0) scale(var(--s));transition:transform .3s}.Toastify__toast--stacked[data-collapsed] .Toastify__toast-body,.Toastify__toast--stacked[data-collapsed] .Toastify__close-button{transition:opacity .1s}.Toastify__toast--stacked[data-collapsed=false]{overflow:visible}.Toastify__toast--stacked[data-collapsed=true]:not(:last-child)>*{opacity:0}.Toastify__toast--stacked:after{content:"";position:absolute;left:0;right:0;height:calc(var(--g) * 1px);bottom:100%}.Toastify__toast--stacked[data-pos=top]{top:0}.Toastify__toast--stacked[data-pos=bot]{bottom:0}.Toastify__toast--stacked[data-pos=bot].Toastify__toast--stacked:before{transform-origin:top}.Toastify__toast--stacked[data-pos=top].Toastify__toast--stacked:before{transform-origin:bottom}.Toastify__toast--stacked:before{content:"";position:absolute;left:0;right:0;bottom:0;height:100%;transform:scaleY(3);z-index:-1}.Toastify__toast--rtl{direction:rtl}.Toastify__toast--close-on-click{cursor:pointer}.Toastify__toast-icon{margin-inline-end:10px;width:22px;flex-shrink:0;display:flex}.Toastify--animate{animation-fill-mode:both;animation-duration:.5s}.Toastify--animate-icon{animation-fill-mode:both;animation-duration:.3s}.Toastify__toast-theme--dark{background:var(--toastify-color-dark);color:var(--toastify-text-color-dark)}.Toastify__toast-theme--light,.Toastify__toast-theme--colored.Toastify__toast--default{background:var(--toastify-color-light);color:var(--toastify-text-color-light)}.Toastify__toast-theme--colored.Toastify__toast--info{color:var(--toastify-text-color-info);background:var(--toastify-color-info)}.Toastify__toast-theme--colored.Toastify__toast--success{color:var(--toastify-text-color-success);background:var(--toastify-color-success)}.Toastify__toast-theme--colored.Toastify__toast--warning{color:var(--toastify-text-color-warning);background:var(--toastify-color-warning)}.Toastify__toast-theme--colored.Toastify__toast--error{color:var(--toastify-text-color-error);background:var(--toastify-color-error)}.Toastify__progress-bar-theme--light{background:var(--toastify-color-progress-light)}.Toastify__progress-bar-theme--dark{background:var(--toastify-color-progress-dark)}.Toastify__progress-bar--info{background:var(--toastify-color-progress-info)}.Toastify__progress-bar--success{background:var(--toastify-color-progress-success)}.Toastify__progress-bar--warning{background:var(--toastify-color-progress-warning)}.Toastify__progress-bar--error{background:var(--toastify-color-progress-error)}.Toastify__progress-bar-theme--colored.Toastify__progress-bar--info,.Toastify__progress-bar-theme--colored.Toastify__progress-bar--success,.Toastify__progress-bar-theme--colored.Toastify__progress-bar--warning,.Toastify__progress-bar-theme--colored.Toastify__progress-bar--error{background:var(--toastify-color-transparent)}.Toastify__close-button{color:#fff;position:absolute;top:6px;right:6px;background:transparent;outline:none;border:none;padding:0;cursor:pointer;opacity:.7;transition:.3s ease;z-index:1}.Toastify__toast--rtl .Toastify__close-button{left:6px;right:unset}.Toastify__close-button--light{color:#000;opacity:.3}.Toastify__close-button>svg{fill:currentColor;height:16px;width:14px}.Toastify__close-button:hover,.Toastify__close-button:focus{opacity:1}@keyframes Toastify__trackProgress{0%{transform:scaleX(1)}to{transform:scaleX(0)}}.Toastify__progress-bar{position:absolute;bottom:0;left:0;width:100%;height:100%;z-index:1;opacity:.7;transform-origin:left}.Toastify__progress-bar--animated{animation:Toastify__trackProgress linear 1 forwards}.Toastify__progress-bar--controlled{transition:transform .2s}.Toastify__progress-bar--rtl{right:0;left:initial;transform-origin:right;border-bottom-left-radius:initial}.Toastify__progress-bar--wrp{position:absolute;overflow:hidden;bottom:0;left:0;width:100%;height:5px;border-bottom-left-radius:var(--toastify-toast-bd-radius);border-bottom-right-radius:var(--toastify-toast-bd-radius)}.Toastify__progress-bar--wrp[data-hidden=true]{opacity:0}.Toastify__progress-bar--bg{opacity:var(--toastify-color-progress-bgo);width:100%;height:100%}.Toastify__spinner{width:20px;height:20px;box-sizing:border-box;border:2px solid;border-radius:100%;border-color:var(--toastify-spinner-color-empty-area);border-right-color:var(--toastify-spinner-color);animation:Toastify__spin .65s linear infinite}@keyframes Toastify__bounceInRight{0%,60%,75%,90%,to{animation-timing-function:cubic-bezier(.215,.61,.355,1)}0%{opacity:0;transform:translate3d(3000px,0,0)}60%{opacity:1;transform:translate3d(-25px,0,0)}75%{transform:translate3d(10px,0,0)}90%{transform:translate3d(-5px,0,0)}to{transform:none}}@keyframes Toastify__bounceOutRight{20%{opacity:1;transform:translate3d(-20px,var(--y),0)}to{opacity:0;transform:translate3d(2000px,var(--y),0)}}@keyframes Toastify__bounceInLeft{0%,60%,75%,90%,to{animation-timing-function:cubic-bezier(.215,.61,.355,1)}0%{opacity:0;transform:translate3d(-3000px,0,0)}60%{opacity:1;transform:translate3d(25px,0,0)}75%{transform:translate3d(-10px,0,0)}90%{transform:translate3d(5px,0,0)}to{transform:none}}@keyframes Toastify__bounceOutLeft{20%{opacity:1;transform:translate3d(20px,var(--y),0)}to{opacity:0;transform:translate3d(-2000px,var(--y),0)}}@keyframes Toastify__bounceInUp{0%,60%,75%,90%,to{animation-timing-function:cubic-bezier(.215,.61,.355,1)}0%{opacity:0;transform:translate3d(0,3000px,0)}60%{opacity:1;transform:translate3d(0,-20px,0)}75%{transform:translate3d(0,10px,0)}90%{transform:translate3d(0,-5px,0)}to{transform:translateZ(0)}}@keyframes Toastify__bounceOutUp{20%{transform:translate3d(0,calc(var(--y) - 10px),0)}40%,45%{opacity:1;transform:translate3d(0,calc(var(--y) + 20px),0)}to{opacity:0;transform:translate3d(0,-2000px,0)}}@keyframes Toastify__bounceInDown{0%,60%,75%,90%,to{animation-timing-function:cubic-bezier(.215,.61,.355,1)}0%{opacity:0;transform:translate3d(0,-3000px,0)}60%{opacity:1;transform:translate3d(0,25px,0)}75%{transform:translate3d(0,-10px,0)}90%{transform:translate3d(0,5px,0)}to{transform:none}}@keyframes Toastify__bounceOutDown{20%{transform:translate3d(0,calc(var(--y) - 10px),0)}40%,45%{opacity:1;transform:translate3d(0,calc(var(--y) + 20px),0)}to{opacity:0;transform:translate3d(0,2000px,0)}}.Toastify__bounce-enter--top-left,.Toastify__bounce-enter--bottom-left{animation-name:Toastify__bounceInLeft}.Toastify__bounce-enter--top-right,.Toastify__bounce-enter--bottom-right{animation-name:Toastify__bounceInRight}.Toastify__bounce-enter--top-center{animation-name:Toastify__bounceInDown}.Toastify__bounce-enter--bottom-center{animation-name:Toastify__bounceInUp}.Toastify__bounce-exit--top-left,.Toastify__bounce-exit--bottom-left{animation-name:Toastify__bounceOutLeft}.Toastify__bounce-exit--top-right,.Toastify__bounce-exit--bottom-right{animation-name:Toastify__bounceOutRight}.Toastify__bounce-exit--top-center{animation-name:Toastify__bounceOutUp}.Toastify__bounce-exit--bottom-center{animation-name:Toastify__bounceOutDown}@keyframes Toastify__zoomIn{0%{opacity:0;transform:scale3d(.3,.3,.3)}50%{opacity:1}}@keyframes Toastify__zoomOut{0%{opacity:1}50%{opacity:0;transform:translate3d(0,var(--y),0) scale3d(.3,.3,.3)}to{opacity:0}}.Toastify__zoom-enter{animation-name:Toastify__zoomIn}.Toastify__zoom-exit{animation-name:Toastify__zoomOut}@keyframes Toastify__flipIn{0%{transform:perspective(400px) rotateX(90deg);animation-timing-function:ease-in;opacity:0}40%{transform:perspective(400px) rotateX(-20deg);animation-timing-function:ease-in}60%{transform:perspective(400px) rotateX(10deg);opacity:1}80%{transform:perspective(400px) rotateX(-5deg)}to{transform:perspective(400px)}}@keyframes Toastify__flipOut{0%{transform:translate3d(0,var(--y),0) perspective(400px)}30%{transform:translate3d(0,var(--y),0) perspective(400px) rotateX(-20deg);opacity:1}to{transform:translate3d(0,var(--y),0) perspective(400px) rotateX(90deg);opacity:0}}.Toastify__flip-enter{animation-name:Toastify__flipIn}.Toastify__flip-exit{animation-name:Toastify__flipOut}@keyframes Toastify__slideInRight{0%{transform:translate3d(110%,0,0);visibility:visible}to{transform:translate3d(0,var(--y),0)}}@keyframes Toastify__slideInLeft{0%{transform:translate3d(-110%,0,0);visibility:visible}to{transform:translate3d(0,var(--y),0)}}@keyframes Toastify__slideInUp{0%{transform:translate3d(0,110%,0);visibility:visible}to{transform:translate3d(0,var(--y),0)}}@keyframes Toastify__slideInDown{0%{transform:translate3d(0,-110%,0);visibility:visible}to{transform:translate3d(0,var(--y),0)}}@keyframes Toastify__slideOutRight{0%{transform:translate3d(0,var(--y),0)}to{visibility:hidden;transform:translate3d(110%,var(--y),0)}}@keyframes Toastify__slideOutLeft{0%{transform:translate3d(0,var(--y),0)}to{visibility:hidden;transform:translate3d(-110%,var(--y),0)}}@keyframes Toastify__slideOutDown{0%{transform:translate3d(0,var(--y),0)}to{visibility:hidden;transform:translate3d(0,500px,0)}}@keyframes Toastify__slideOutUp{0%{transform:translate3d(0,var(--y),0)}to{visibility:hidden;transform:translate3d(0,-500px,0)}}.Toastify__slide-enter--top-left,.Toastify__slide-enter--bottom-left{animation-name:Toastify__slideInLeft}.Toastify__slide-enter--top-right,.Toastify__slide-enter--bottom-right{animation-name:Toastify__slideInRight}.Toastify__slide-enter--top-center{animation-name:Toastify__slideInDown}.Toastify__slide-enter--bottom-center{animation-name:Toastify__slideInUp}.Toastify__slide-exit--top-left,.Toastify__slide-exit--bottom-left{animation-name:Toastify__slideOutLeft;animation-timing-function:ease-in;animation-duration:.3s}.Toastify__slide-exit--top-right,.Toastify__slide-exit--bottom-right{animation-name:Toastify__slideOutRight;animation-timing-function:ease-in;animation-duration:.3s}.Toastify__slide-exit--top-center{animation-name:Toastify__slideOutUp;animation-timing-function:ease-in;animation-duration:.3s}.Toastify__slide-exit--bottom-center{animation-name:Toastify__slideOutDown;animation-timing-function:ease-in;animation-duration:.3s}@keyframes Toastify__spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}
-`);
-var L = (t) => typeof t == "number" && !isNaN(t);
-var N = (t) => typeof t == "string";
-var P = (t) => typeof t == "function";
-var mt = (t) => N(t) || L(t);
-var B = (t) => N(t) || P(t) ? t : null;
-var pt = (t, o) => t === false || L(t) && t > 0 ? t : o;
-var z = (t) => $t(t) || N(t) || P(t) || L(t);
-function Z(t, o, e = 300) {
-  let { scrollHeight: r2, style: s } = t;
-  requestAnimationFrame(() => {
-    s.minHeight = "initial", s.height = r2 + "px", s.transition = `all ${e}ms`, requestAnimationFrame(() => {
-      s.height = "0", s.padding = "0", s.margin = "0", setTimeout(o, e);
-    });
-  });
-}
-function $({ enter: t, exit: o, appendPosition: e = false, collapse: r2 = true, collapseDuration: s = 300 }) {
-  return function({ children: a, position: d, preventExitTransition: c, done: T, nodeRef: g, isIn: v, playToast: x }) {
-    let C = e ? `${t}--${d}` : t, S = e ? `${o}--${d}` : o, E = zt(0);
-    return Bt(() => {
-      let f = g.current, p = C.split(" "), b = (n) => {
-        n.target === g.current && (x(), f.removeEventListener("animationend", b), f.removeEventListener("animationcancel", b), E.current === 0 && n.type !== "animationcancel" && f.classList.remove(...p));
-      };
-      (() => {
-        f.classList.add(...p), f.addEventListener("animationend", b), f.addEventListener("animationcancel", b);
-      })();
-    }, []), Rt(() => {
-      let f = g.current, p = () => {
-        f.removeEventListener("animationend", p), r2 ? Z(f, T, s) : T();
-      };
-      v || (c ? p() : (() => {
-        E.current = 1, f.className += ` ${S}`, f.addEventListener("animationend", p);
-      })());
-    }, [v]), ut.createElement(ut.Fragment, null, a);
-  };
-}
-function J(t, o) {
-  return { content: tt(t.content, t.props), containerId: t.props.containerId, id: t.props.toastId, theme: t.props.theme, type: t.props.type, data: t.props.data || {}, isLoading: t.props.isLoading, icon: t.props.icon, reason: t.removalReason, status: o };
-}
-function tt(t, o, e = false) {
-  return Ut(t) && !N(t.type) ? Ft(t, { closeToast: o.closeToast, toastProps: o, data: o.data, isPaused: e }) : P(t) ? t({ closeToast: o.closeToast, toastProps: o, data: o.data, isPaused: e }) : t;
-}
-function yt({ closeToast: t, theme: o, ariaLabel: e = "close" }) {
-  return ot.createElement("button", { className: `Toastify__close-button Toastify__close-button--${o}`, type: "button", onClick: (r2) => {
-    r2.stopPropagation(), t(true);
-  }, "aria-label": e }, ot.createElement("svg", { "aria-hidden": "true", viewBox: "0 0 14 16" }, ot.createElement("path", { fillRule: "evenodd", d: "M7.71 8.23l3.75 3.75-1.48 1.48-3.75-3.75-3.75 3.75L1 11.98l3.75-3.75L1 4.48 2.48 3l3.75 3.75L9.98 3l1.48 1.48-3.75 3.75z" })));
-}
-function gt({ delay: t, isRunning: o, closeToast: e, type: r2 = "default", hide: s, className: l, controlledProgress: a, progress: d, rtl: c, isIn: T, theme: g }) {
-  let v = s || a && d === 0, x = { animationDuration: `${t}ms`, animationPlayState: o ? "running" : "paused" };
-  a && (x.transform = `scaleX(${d})`);
-  let C = clsx_default("Toastify__progress-bar", a ? "Toastify__progress-bar--controlled" : "Toastify__progress-bar--animated", `Toastify__progress-bar-theme--${g}`, `Toastify__progress-bar--${r2}`, { ["Toastify__progress-bar--rtl"]: c }), S = P(l) ? l({ rtl: c, type: r2, defaultClassName: C }) : clsx_default(C, l), E = { [a && d >= 1 ? "onTransitionEnd" : "onAnimationEnd"]: a && d < 1 ? null : () => {
-    T && e();
-  } };
-  return et.createElement("div", { className: "Toastify__progress-bar--wrp", "data-hidden": v }, et.createElement("div", { className: `Toastify__progress-bar--bg Toastify__progress-bar-theme--${g} Toastify__progress-bar--${r2}` }), et.createElement("div", { role: "progressbar", "aria-hidden": v ? "true" : "false", "aria-label": "notification timer", className: S, style: x, ...E }));
-}
-var Xt = 1;
-var at = () => `${Xt++}`;
-function _t(t, o, e) {
-  let r2 = 1, s = 0, l = [], a = [], d = o, c = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Set(), g = (i) => (T.add(i), () => T.delete(i)), v = () => {
-    a = Array.from(c.values()), T.forEach((i) => i());
-  }, x = ({ containerId: i, toastId: n, updateId: u }) => {
-    let h = i ? i !== t : t !== 1, m = c.has(n) && u == null;
-    return h || m;
-  }, C = (i, n) => {
-    c.forEach((u) => {
-      var h;
-      (n == null || n === u.props.toastId) && ((h = u.toggle) == null || h.call(u, i));
-    });
-  }, S = (i) => {
-    var n, u;
-    (u = (n = i.props) == null ? void 0 : n.onClose) == null || u.call(n, i.removalReason), i.isActive = false;
-  }, E = (i) => {
-    if (i == null) c.forEach(S);
-    else {
-      let n = c.get(i);
-      n && S(n);
-    }
-    v();
-  }, f = () => {
-    s -= l.length, l = [];
-  }, p = (i) => {
-    var m, _;
-    let { toastId: n, updateId: u } = i.props, h = u == null;
-    i.staleId && c.delete(i.staleId), i.isActive = true, c.set(n, i), v(), e(J(i, h ? "added" : "updated")), h && ((_ = (m = i.props).onOpen) == null || _.call(m));
-  };
-  return { id: t, props: d, observe: g, toggle: C, removeToast: E, toasts: c, clearQueue: f, buildToast: (i, n) => {
-    if (x(n)) return;
-    let { toastId: u, updateId: h, data: m, staleId: _, delay: k } = n, M = h == null;
-    M && s++;
-    let A = { ...d, style: d.toastStyle, key: r2++, ...Object.fromEntries(Object.entries(n).filter(([D, Y]) => Y != null)), toastId: u, updateId: h, data: m, isIn: false, className: B(n.className || d.toastClassName), progressClassName: B(n.progressClassName || d.progressClassName), autoClose: n.isLoading ? false : pt(n.autoClose, d.autoClose), closeToast(D) {
-      c.get(u).removalReason = D, E(u);
-    }, deleteToast() {
-      let D = c.get(u);
-      if (D != null) {
-        if (e(J(D, "removed")), c.delete(u), s--, s < 0 && (s = 0), l.length > 0) {
-          p(l.shift());
-          return;
-        }
-        v();
-      }
-    } };
-    A.closeButton = d.closeButton, n.closeButton === false || z(n.closeButton) ? A.closeButton = n.closeButton : n.closeButton === true && (A.closeButton = z(d.closeButton) ? d.closeButton : true);
-    let R = { content: i, props: A, staleId: _ };
-    d.limit && d.limit > 0 && s > d.limit && M ? l.push(R) : L(k) ? setTimeout(() => {
-      p(R);
-    }, k) : p(R);
-  }, setProps(i) {
-    d = i;
-  }, setToggle: (i, n) => {
-    let u = c.get(i);
-    u && (u.toggle = n);
-  }, isToastActive: (i) => {
-    var n;
-    return (n = c.get(i)) == null ? void 0 : n.isActive;
-  }, getSnapshot: () => a };
-}
-var I = /* @__PURE__ */ new Map();
-var F = [];
-var st = /* @__PURE__ */ new Set();
-var Vt = (t) => st.forEach((o) => o(t));
-var bt = () => I.size > 0;
-function Qt() {
-  F.forEach((t) => nt(t.content, t.options)), F = [];
-}
-var vt = (t, { containerId: o }) => {
-  var e;
-  return (e = I.get(o || 1)) == null ? void 0 : e.toasts.get(t);
-};
-function X(t, o) {
-  var r2;
-  if (o) return !!((r2 = I.get(o)) != null && r2.isToastActive(t));
-  let e = false;
-  return I.forEach((s) => {
-    s.isToastActive(t) && (e = true);
-  }), e;
-}
-function ht(t) {
-  if (!bt()) {
-    F = F.filter((o) => t != null && o.options.toastId !== t);
-    return;
-  }
-  if (t == null || mt(t)) I.forEach((o) => {
-    o.removeToast(t);
-  });
-  else if (t && ("containerId" in t || "id" in t)) {
-    let o = I.get(t.containerId);
-    o ? o.removeToast(t.id) : I.forEach((e) => {
-      e.removeToast(t.id);
-    });
-  }
-}
-var Ct = (t = {}) => {
-  I.forEach((o) => {
-    o.props.limit && (!t.containerId || o.id === t.containerId) && o.clearQueue();
-  });
-};
-function nt(t, o) {
-  z(t) && (bt() || F.push({ content: t, options: o }), I.forEach((e) => {
-    e.buildToast(t, o);
-  }));
-}
-function xt(t) {
-  var o;
-  (o = I.get(t.containerId || 1)) == null || o.setToggle(t.id, t.fn);
-}
-function rt(t, o) {
-  I.forEach((e) => {
-    (o == null || !(o != null && o.containerId) || (o == null ? void 0 : o.containerId) === e.id) && e.toggle(t, o == null ? void 0 : o.id);
-  });
-}
-function Et(t) {
-  let o = t.containerId || 1;
-  return { subscribe(e) {
-    let r2 = _t(o, t, Vt);
-    I.set(o, r2);
-    let s = r2.observe(e);
-    return Qt(), () => {
-      s(), I.delete(o);
-    };
-  }, setProps(e) {
-    var r2;
-    (r2 = I.get(o)) == null || r2.setProps(e);
-  }, getSnapshot() {
-    var e;
-    return (e = I.get(o)) == null ? void 0 : e.getSnapshot();
-  } };
-}
-function Pt(t) {
-  return st.add(t), () => {
-    st.delete(t);
-  };
-}
-function Wt(t) {
-  return t && (N(t.toastId) || L(t.toastId)) ? t.toastId : at();
-}
-function U(t, o) {
-  return nt(t, o), o.toastId;
-}
-function V(t, o) {
-  return { ...o, type: o && o.type || t, toastId: Wt(o) };
-}
-function Q(t) {
-  return (o, e) => U(o, V(t, e));
-}
-function y(t, o) {
-  return U(t, V("default", o));
-}
-y.loading = (t, o) => U(t, V("default", { isLoading: true, autoClose: false, closeOnClick: false, closeButton: false, draggable: false, ...o }));
-function Gt(t, { pending: o, error: e, success: r2 }, s) {
-  let l;
-  o && (l = N(o) ? y.loading(o, s) : y.loading(o.render, { ...s, ...o }));
-  let a = { isLoading: null, autoClose: null, closeOnClick: null, closeButton: null, draggable: null }, d = (T, g, v) => {
-    if (g == null) {
-      y.dismiss(l);
-      return;
-    }
-    let x = { type: T, ...a, ...s, data: v }, C = N(g) ? { render: g } : g;
-    return l ? y.update(l, { ...x, ...C }) : y(C.render, { ...x, ...C }), v;
-  }, c = P(t) ? t() : t;
-  return c.then((T) => d("success", r2, T)).catch((T) => d("error", e, T)), c;
-}
-y.promise = Gt;
-y.success = Q("success");
-y.info = Q("info");
-y.error = Q("error");
-y.warning = Q("warning");
-y.warn = y.warning;
-y.dark = (t, o) => U(t, V("default", { theme: "dark", ...o }));
-function qt(t) {
-  ht(t);
-}
-y.dismiss = qt;
-y.clearWaitingQueue = Ct;
-y.isActive = X;
-y.update = (t, o = {}) => {
-  let e = vt(t, o);
-  if (e) {
-    let { props: r2, content: s } = e, l = { delay: 100, ...r2, ...o, toastId: o.toastId || t, updateId: at() };
-    l.toastId !== t && (l.staleId = t);
-    let a = l.render || s;
-    delete l.render, U(a, l);
-  }
-};
-y.done = (t) => {
-  y.update(t, { progress: 1 });
-};
-y.onChange = Pt;
-y.play = (t) => rt(true, t);
-y.pause = (t) => rt(false, t);
-function It(t) {
-  var a;
-  let { subscribe: o, getSnapshot: e, setProps: r2 } = Kt(Et(t)).current;
-  r2(t);
-  let s = (a = Yt(o, e, e)) == null ? void 0 : a.slice();
-  function l(d) {
-    if (!s) return [];
-    let c = /* @__PURE__ */ new Map();
-    return t.newestOnTop && s.reverse(), s.forEach((T) => {
-      let { position: g } = T.props;
-      c.has(g) || c.set(g, []), c.get(g).push(T);
-    }), Array.from(c, (T) => d(T[0], T[1]));
-  }
-  return { getToastToRender: l, isToastActive: X, count: s == null ? void 0 : s.length };
-}
-function At(t) {
-  let [o, e] = kt(false), [r2, s] = kt(false), l = St(null), a = St({ start: 0, delta: 0, removalDistance: 0, canCloseOnClick: true, canDrag: false, didMove: false }).current, { autoClose: d, pauseOnHover: c, closeToast: T, onClick: g, closeOnClick: v } = t;
-  xt({ id: t.toastId, containerId: t.containerId, fn: e }), Zt(() => {
-    if (t.pauseOnFocusLoss) return x(), () => {
-      C();
-    };
-  }, [t.pauseOnFocusLoss]);
-  function x() {
-    document.hasFocus() || p(), window.addEventListener("focus", f), window.addEventListener("blur", p);
-  }
-  function C() {
-    window.removeEventListener("focus", f), window.removeEventListener("blur", p);
-  }
-  function S(m) {
-    if (t.draggable === true || t.draggable === m.pointerType) {
-      b();
-      let _ = l.current;
-      a.canCloseOnClick = true, a.canDrag = true, _.style.transition = "none", t.draggableDirection === "x" ? (a.start = m.clientX, a.removalDistance = _.offsetWidth * (t.draggablePercent / 100)) : (a.start = m.clientY, a.removalDistance = _.offsetHeight * (t.draggablePercent === 80 ? t.draggablePercent * 1.5 : t.draggablePercent) / 100);
-    }
-  }
-  function E(m) {
-    let { top: _, bottom: k, left: M, right: A } = l.current.getBoundingClientRect();
-    m.nativeEvent.type !== "touchend" && t.pauseOnHover && m.clientX >= M && m.clientX <= A && m.clientY >= _ && m.clientY <= k ? p() : f();
-  }
-  function f() {
-    e(true);
-  }
-  function p() {
-    e(false);
-  }
-  function b() {
-    a.didMove = false, document.addEventListener("pointermove", n), document.addEventListener("pointerup", u);
-  }
-  function i() {
-    document.removeEventListener("pointermove", n), document.removeEventListener("pointerup", u);
-  }
-  function n(m) {
-    let _ = l.current;
-    if (a.canDrag && _) {
-      a.didMove = true, o && p(), t.draggableDirection === "x" ? a.delta = m.clientX - a.start : a.delta = m.clientY - a.start, a.start !== m.clientX && (a.canCloseOnClick = false);
-      let k = t.draggableDirection === "x" ? `${a.delta}px, var(--y)` : `0, calc(${a.delta}px + var(--y))`;
-      _.style.transform = `translate3d(${k},0)`, _.style.opacity = `${1 - Math.abs(a.delta / a.removalDistance)}`;
-    }
-  }
-  function u() {
-    i();
-    let m = l.current;
-    if (a.canDrag && a.didMove && m) {
-      if (a.canDrag = false, Math.abs(a.delta) > a.removalDistance) {
-        s(true), t.closeToast(true), t.collapseAll();
-        return;
-      }
-      m.style.transition = "transform 0.2s, opacity 0.2s", m.style.removeProperty("transform"), m.style.removeProperty("opacity");
-    }
-  }
-  let h = { onPointerDown: S, onPointerUp: E };
-  return d && c && (h.onMouseEnter = p, t.stacked || (h.onMouseLeave = f)), v && (h.onClick = (m) => {
-    g && g(m), a.canCloseOnClick && T(true);
-  }), { playToast: f, pauseToast: p, isRunning: o, preventExitTransition: r2, toastRef: l, eventHandlers: h };
-}
-var Ot = typeof window != "undefined" ? to : Jt;
-var G = ({ theme: t, type: o, isLoading: e, ...r2 }) => O.createElement("svg", { viewBox: "0 0 24 24", width: "100%", height: "100%", fill: t === "colored" ? "currentColor" : `var(--toastify-icon-color-${o})`, ...r2 });
-function ao(t) {
-  return O.createElement(G, { ...t }, O.createElement("path", { d: "M23.32 17.191L15.438 2.184C14.728.833 13.416 0 11.996 0c-1.42 0-2.733.833-3.443 2.184L.533 17.448a4.744 4.744 0 000 4.368C1.243 23.167 2.555 24 3.975 24h16.05C22.22 24 24 22.044 24 19.632c0-.904-.251-1.746-.68-2.44zm-9.622 1.46c0 1.033-.724 1.823-1.698 1.823s-1.698-.79-1.698-1.822v-.043c0-1.028.724-1.822 1.698-1.822s1.698.79 1.698 1.822v.043zm.039-12.285l-.84 8.06c-.057.581-.408.943-.897.943-.49 0-.84-.367-.896-.942l-.84-8.065c-.057-.624.25-1.095.779-1.095h1.91c.528.005.84.476.784 1.1z" }));
-}
-function so(t) {
-  return O.createElement(G, { ...t }, O.createElement("path", { d: "M12 0a12 12 0 1012 12A12.013 12.013 0 0012 0zm.25 5a1.5 1.5 0 11-1.5 1.5 1.5 1.5 0 011.5-1.5zm2.25 13.5h-4a1 1 0 010-2h.75a.25.25 0 00.25-.25v-4.5a.25.25 0 00-.25-.25h-.75a1 1 0 010-2h1a2 2 0 012 2v4.75a.25.25 0 00.25.25h.75a1 1 0 110 2z" }));
-}
-function no(t) {
-  return O.createElement(G, { ...t }, O.createElement("path", { d: "M12 0a12 12 0 1012 12A12.014 12.014 0 0012 0zm6.927 8.2l-6.845 9.289a1.011 1.011 0 01-1.43.188l-4.888-3.908a1 1 0 111.25-1.562l4.076 3.261 6.227-8.451a1 1 0 111.61 1.183z" }));
-}
-function ro(t) {
-  return O.createElement(G, { ...t }, O.createElement("path", { d: "M11.983 0a12.206 12.206 0 00-8.51 3.653A11.8 11.8 0 000 12.207 11.779 11.779 0 0011.8 24h.214A12.111 12.111 0 0024 11.791 11.766 11.766 0 0011.983 0zM10.5 16.542a1.476 1.476 0 011.449-1.53h.027a1.527 1.527 0 011.523 1.47 1.475 1.475 0 01-1.449 1.53h-.027a1.529 1.529 0 01-1.523-1.47zM11 12.5v-6a1 1 0 012 0v6a1 1 0 11-2 0z" }));
-}
-function io() {
-  return O.createElement("div", { className: "Toastify__spinner" });
-}
-var W = { info: so, warning: ao, success: no, error: ro, spinner: io };
-var lo = (t) => t in W;
-function Nt({ theme: t, type: o, isLoading: e, icon: r2 }) {
-  let s = null, l = { theme: t, type: o };
-  return r2 === false || (P(r2) ? s = r2({ ...l, isLoading: e }) : eo(r2) ? s = oo(r2, l) : e ? s = W.spinner() : lo(o) && (s = W[o](l))), s;
-}
-var wt = (t) => {
-  let { isRunning: o, preventExitTransition: e, toastRef: r2, eventHandlers: s, playToast: l } = At(t), { closeButton: a, children: d, autoClose: c, onClick: T, type: g, hideProgressBar: v, closeToast: x, transition: C, position: S, className: E, style: f, progressClassName: p, updateId: b, role: i, progress: n, rtl: u, toastId: h, deleteToast: m, isIn: _, isLoading: k, closeOnClick: M, theme: A, ariaLabel: R } = t, D = clsx_default("Toastify__toast", `Toastify__toast-theme--${A}`, `Toastify__toast--${g}`, { ["Toastify__toast--rtl"]: u }, { ["Toastify__toast--close-on-click"]: M }), Y = P(E) ? E({ rtl: u, position: S, type: g, defaultClassName: D }) : clsx_default(D, E), ft = Nt(t), dt = !!n || !c, j = { closeToast: x, type: g, theme: A }, H = null;
-  return a === false || (P(a) ? H = a(j) : fo(a) ? H = co(a, j) : H = yt(j)), q.createElement(C, { isIn: _, done: m, position: S, preventExitTransition: e, nodeRef: r2, playToast: l }, q.createElement("div", { id: h, tabIndex: 0, onClick: T, "data-in": _, className: Y, ...s, style: f, ref: r2, ..._ && { role: i, "aria-label": R } }, ft != null && q.createElement("div", { className: clsx_default("Toastify__toast-icon", { ["Toastify--animate-icon Toastify__zoom-enter"]: !k }) }, ft), tt(d, t, !o), H, !t.customProgressBar && q.createElement(gt, { ...b && !dt ? { key: `p-${b}` } : {}, rtl: u, theme: A, delay: c, isRunning: o, isIn: _, closeToast: x, hide: v, type: g, className: p, controlledProgress: dt, progress: n || 0 })));
-};
-var K = (t, o = false) => ({ enter: `Toastify--animate Toastify__${t}-enter`, exit: `Toastify--animate Toastify__${t}-exit`, appendPosition: o });
-var lt = $(K("bounce", true));
-var mo = $(K("slide", true));
-var po = $(K("zoom"));
-var uo = $(K("flip"));
-var _o = { position: "top-right", transition: lt, autoClose: 5e3, closeButton: true, pauseOnHover: true, pauseOnFocusLoss: true, draggable: "touch", draggablePercent: 80, draggableDirection: "x", role: "alert", theme: "light", "aria-label": "Notifications Alt+T", hotKeys: (t) => t.altKey && t.code === "KeyT" };
-function Lt(t) {
-  let o = { ..._o, ...t }, e = t.stacked, [r2, s] = go(true), l = To(null), { getToastToRender: a, isToastActive: d, count: c } = It(o), { className: T, style: g, rtl: v, containerId: x, hotKeys: C } = o;
-  function S(f) {
-    let p = clsx_default("Toastify__toast-container", `Toastify__toast-container--${f}`, { ["Toastify__toast-container--rtl"]: v });
-    return P(T) ? T({ position: f, rtl: v, defaultClassName: p }) : clsx_default(p, B(T));
-  }
-  function E() {
-    e && (s(true), y.play());
-  }
-  return Ot(() => {
-    var f;
-    if (e) {
-      let p = l.current.querySelectorAll('[data-in="true"]'), b = 12, i = (f = o.position) == null ? void 0 : f.includes("top"), n = 0, u = 0;
-      Array.from(p).reverse().forEach((h, m) => {
-        let _ = h;
-        _.classList.add("Toastify__toast--stacked"), m > 0 && (_.dataset.collapsed = `${r2}`), _.dataset.pos || (_.dataset.pos = i ? "top" : "bot");
-        let k = n * (r2 ? 0.2 : 1) + (r2 ? 0 : b * m);
-        _.style.setProperty("--y", `${i ? k : k * -1}px`), _.style.setProperty("--g", `${b}`), _.style.setProperty("--s", `${1 - (r2 ? u : 0)}`), n += _.offsetHeight, u += 0.025;
-      });
-    }
-  }, [r2, c, e]), yo(() => {
-    function f(p) {
-      var i;
-      let b = l.current;
-      C(p) && ((i = b.querySelector('[tabIndex="0"]')) == null || i.focus(), s(false), y.pause()), p.key === "Escape" && (document.activeElement === b || b != null && b.contains(document.activeElement)) && (s(true), y.play());
-    }
-    return document.addEventListener("keydown", f), () => {
-      document.removeEventListener("keydown", f);
-    };
-  }, [C]), ct.createElement("section", { ref: l, className: "Toastify", id: x, onMouseEnter: () => {
-    e && (s(false), y.pause());
-  }, onMouseLeave: E, "aria-live": "polite", "aria-atomic": "false", "aria-relevant": "additions text", "aria-label": o["aria-label"] }, a((f, p) => {
-    let b = p.length ? { ...g } : { ...g, pointerEvents: "none" };
-    return ct.createElement("div", { tabIndex: -1, className: S(f), "data-stacked": e, style: b, key: `c-${f}` }, p.map(({ content: i, props: n }) => ct.createElement(wt, { ...n, stacked: e, collapseAll: E, isIn: d(n.toastId, n.containerId), key: `t-${n.key}` }, i)));
-  }));
-}
-
-// src/SignUp.jsx
-function SignUp() {
+function SignUp({ agency = { name: "MyApp", logo: "" } }) {
   const {
     publishableKey,
     baseUrl,
@@ -802,18 +4135,42 @@ function SignUp() {
     loadingUser,
     fetchMe,
     setUser
-  } = useAuth();
+  } = (typeof useAuth === "function" ? useAuth() : {}) || {};
   const [name, setName] = useState3("");
   const [email, setEmail] = useState3("");
   const [password, setPassword] = useState3("");
   const [loading, setLoading] = useState3(false);
-  const [message, setMessage] = useState3(null);
+  const [loadingOauth, setLoadingOauth] = useState3({ google: false, github: false });
   const redirectTimer = useRef2(null);
+  const toastId = useRef2(0);
+  const [toasts, setToasts] = useState3([]);
   useEffect2(() => {
     return () => {
       if (redirectTimer.current) clearTimeout(redirectTimer.current);
+      toasts.forEach((t) => clearTimeout(t._timer));
     };
   }, []);
+  function showToast(type, message, ms = 5e3) {
+    const id = ++toastId.current;
+    const created = Date.now();
+    const t = { id, type, message, created, _timer: null };
+    setToasts((prev) => {
+      const next = [t, ...prev].slice(0, 6);
+      return next;
+    });
+    const timer = setTimeout(() => {
+      setToasts((prev) => prev.filter((x) => x.id !== id));
+    }, ms);
+    t._timer = timer;
+  }
+  function removeToast(id) {
+    setToasts((prev) => {
+      prev.forEach((t) => {
+        if (t.id === id) clearTimeout(t._timer);
+      });
+      return prev.filter((x) => x.id !== id);
+    });
+  }
   if (loadingUser) return null;
   if (user && redirect) {
     if (typeof redirectTo === "function") redirectTo(redirect);
@@ -823,8 +4180,22 @@ function SignUp() {
   async function submit(e) {
     e.preventDefault();
     if (loading) return;
-    setMessage(null);
     setLoading(true);
+    if (!name.trim()) {
+      showToast("error", "Please enter your name.");
+      setLoading(false);
+      return;
+    }
+    if (!email.includes("@")) {
+      showToast("error", "Please enter a valid email address.");
+      setLoading(false);
+      return;
+    }
+    if (password.length < 8) {
+      showToast("error", "Password must be at least 8 characters.");
+      setLoading(false);
+      return;
+    }
     const url = `${(baseUrl || "").replace(/\/+$/, "")}/api/sdk/signup`;
     try {
       const res = await fetch(url, {
@@ -834,7 +4205,7 @@ function SignUp() {
           "Content-Type": "application/json",
           "x-publishable-key": publishableKey || ""
         },
-        body: JSON.stringify({ name, email, password })
+        body: JSON.stringify({ name: name.trim(), email: email.trim(), password })
       });
       const data = await res.json().catch(async () => {
         const text = await res.text().catch(() => "");
@@ -846,51 +4217,44 @@ function SignUp() {
       }
       if (data.user && typeof setUser === "function") setUser(data.user);
       if (typeof fetchMe === "function") await fetchMe();
-      setMessage("Account created. Redirecting\u2026");
-      y.success("Account created. Redirecting\u2026");
+      showToast("success", "Account created. Redirecting\u2026");
       if (redirect) {
         redirectTimer.current = setTimeout(() => {
           if (typeof redirectTo === "function") redirectTo(redirect);
           else if (typeof window !== "undefined") window.location.assign(redirect);
-        }, 300);
+        }, 450);
       }
     } catch (err) {
       const text = err?.message ?? "Network error";
-      y.error(text);
+      showToast("error", text);
       console.error("Signup error:", err);
     } finally {
       setLoading(false);
     }
   }
   async function startOAuthFlow(provider) {
-    if (loading) return;
-    setLoading(true);
+    if (loading || loadingOauth[provider]) return;
+    setLoadingOauth((prev) => ({ ...prev, [provider]: true }));
     try {
       const rid = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-      const callbackUrl = encodeURIComponent(`${window.location.origin}/signup`);
-      const sdkBase = baseUrl || window.location.origin.replace(/\/+$/, "");
+      const callbackUrl = encodeURIComponent(`${typeof window !== "undefined" ? window.location.origin : ""}/signup`);
+      const sdkBase = baseUrl || (typeof window !== "undefined" ? window.location.origin.replace(/\/+$/, "") : "");
       const startUrl = `${sdkBase}/sdk/auth/start?rid=${rid}&source=${encodeURIComponent(provider)}&callbackUrl=${callbackUrl}`;
       if (!publishableKey) {
-        throw new Error("Missing publishable key (client side). Set NEXT_PUBLIC_FLOWLINK_PUBLISHABLE_KEY or provide publishableKey in provider.");
+        throw new Error("Missing publishable key (client side).");
       }
       const res = await fetch(startUrl, {
         method: "GET",
-        headers: {
-          "x-publishable-key": publishableKey
-        }
+        headers: { "x-publishable-key": publishableKey }
       });
       const data = await res.json().catch(() => null);
-      if (!res.ok) {
-        throw new Error(data?.error || `OAuth start failed (${res.status})`);
-      }
-      if (!data?.oauthUrl) {
-        throw new Error("SDK start did not return oauthUrl");
-      }
-      window.location.href = data.oauthUrl;
+      if (!res.ok) throw new Error(data?.error || `OAuth start failed (${res.status})`);
+      if (!data?.oauthUrl) throw new Error("SDK start did not return oauthUrl");
+      if (typeof window !== "undefined") window.location.href = data.oauthUrl;
     } catch (err) {
+      showToast("error", err?.message || "OAuth start failed");
       console.error("OAuth start error:", err);
-      y.error(err?.message || "OAuth start failed");
-      setLoading(false);
+      setLoadingOauth((prev) => ({ ...prev, [provider]: false }));
     }
   }
   const handleGoogle = (e) => {
@@ -901,28 +4265,48 @@ function SignUp() {
     if (e && typeof e.preventDefault === "function") e.preventDefault();
     startOAuthFlow("github");
   };
-  return /* @__PURE__ */ React3.createElement("div", { style: page }, /* @__PURE__ */ React3.createElement(Lt, { position: "top-right", autoClose: 5e3 }), /* @__PURE__ */ React3.createElement("div", { style: card }, /* @__PURE__ */ React3.createElement("div", { style: cardInner }, /* @__PURE__ */ React3.createElement("div", { style: brand }, /* @__PURE__ */ React3.createElement("div", { style: brandRow }, /* @__PURE__ */ React3.createElement("div", { style: logoPlaceholder, "aria-hidden": true }), /* @__PURE__ */ React3.createElement("h1", { style: brandTitle }, "Create account")), /* @__PURE__ */ React3.createElement("div", { style: brandSub }, /* @__PURE__ */ React3.createElement("div", { style: brandLead }, "Sign up to continue"), /* @__PURE__ */ React3.createElement("div", { style: brandMuted }, "Welcome! Create your account."))), /* @__PURE__ */ React3.createElement("div", { style: oauthRow }, /* @__PURE__ */ React3.createElement(
+  return /* @__PURE__ */ React3.createElement("div", { style: overlay2 }, /* @__PURE__ */ React3.createElement("div", { style: toastContainer }, toasts.map((t) => /* @__PURE__ */ React3.createElement(
+    "div",
+    {
+      key: t.id,
+      role: "status",
+      "aria-live": "polite",
+      style: {
+        ...toastBase,
+        ...t.type === "error" ? toastError : t.type === "success" ? toastSuccess : toastInfo
+      },
+      onMouseEnter: () => {
+        clearTimeout(t._timer);
+      },
+      onMouseLeave: () => {
+        const timer = setTimeout(() => removeToast(t.id), 3e3);
+        setToasts((prev) => prev.map((x) => x.id === t.id ? { ...x, _timer: timer } : x));
+      }
+    },
+    /* @__PURE__ */ React3.createElement("div", { style: { flex: 1 } }, t.message),
+    /* @__PURE__ */ React3.createElement("button", { "aria-label": "Dismiss", onClick: () => removeToast(t.id), style: toastCloseBtn }, "\u2715")
+  ))), /* @__PURE__ */ React3.createElement("div", { style: modal2 }, /* @__PURE__ */ React3.createElement("div", { style: modalInner }, /* @__PURE__ */ React3.createElement("header", { style: header }, /* @__PURE__ */ React3.createElement("div", { style: brandRow }, /* @__PURE__ */ React3.createElement("div", { style: logo }, /* @__PURE__ */ React3.createElement("div", { style: logoCircle, "aria-hidden": true })), /* @__PURE__ */ React3.createElement("div", null, /* @__PURE__ */ React3.createElement("h1", { style: title2 }, "Sign up to ", agency?.name || "App"), /* @__PURE__ */ React3.createElement("div", { style: subtitle2 }, "Welcome! Create your account.")))), /* @__PURE__ */ React3.createElement("section", { style: oauthSection }, /* @__PURE__ */ React3.createElement(
     "button",
     {
       onClick: handleGoogle,
       type: "button",
       style: { ...oauthButton, ...oauthGoogle },
-      disabled: loading,
-      "aria-disabled": loading
+      disabled: loading || loadingOauth.google,
+      "aria-disabled": loading || loadingOauth.google
     },
     /* @__PURE__ */ React3.createElement("svg", { width: 18, style: { marginRight: 10 }, viewBox: "-3 0 262 262", xmlns: "http://www.w3.org/2000/svg", fill: "#000000", "aria-hidden": true }, /* @__PURE__ */ React3.createElement("path", { d: "M255.878 133.451c0-10.734-.871-18.567-2.756-26.69H130.55v48.448h71.947c-1.45 12.04-9.283 30.172-26.69 42.356l-.244 1.622 38.755 30.023 2.685.268c24.659-22.774 38.875-56.282 38.875-96.027", fill: "#4285F4" }), /* @__PURE__ */ React3.createElement("path", { d: "M130.55 261.1c35.248 0 64.839-11.605 86.453-31.622l-41.196-31.913c-11.024 7.688-25.82 13.055-45.257 13.055-34.523 0-63.824-22.773-74.269-54.25l-1.531.13-40.298 31.187-.527 1.465C35.393 231.798 79.49 261.1 130.55 261.1", fill: "#34A853" }), /* @__PURE__ */ React3.createElement("path", { d: "M56.281 156.37c-2.756-8.123-4.351-16.827-4.351-25.82 0-8.994 1.595-17.697 4.206-25.82l-.073-1.73L15.26 71.312l-1.335.635C5.077 89.644 0 109.517 0 130.55s5.077 40.905 13.925 58.602l42.356-32.782", fill: "#FBBC05" }), /* @__PURE__ */ React3.createElement("path", { d: "M130.55 50.479c24.514 0 41.05 10.589 50.479 19.438l36.844-35.974C195.245 12.91 165.798 0 130.55 0 79.49 0 35.393 29.301 13.925 71.947l42.211 32.783c10.59-31.477 39.891-54.251 74.414-54.251", fill: "#EB4335" })),
-    /* @__PURE__ */ React3.createElement("span", null, loading ? "Loading..." : "Continue with Google")
+    /* @__PURE__ */ React3.createElement("span", null, loadingOauth.google ? "Loading..." : "Continue with Google")
   ), /* @__PURE__ */ React3.createElement(
     "button",
     {
       onClick: handleGithub,
       type: "button",
       style: { ...oauthButton, ...oauthGithub },
-      disabled: loading,
-      "aria-disabled": loading
+      disabled: loading || loadingOauth.github,
+      "aria-disabled": loading || loadingOauth.github
     },
     /* @__PURE__ */ React3.createElement("svg", { width: 18, style: { marginRight: 10 }, xmlns: "http://www.w3.org/2000/svg", fill: "white", viewBox: "0 0 20 20", "aria-hidden": true }, /* @__PURE__ */ React3.createElement("path", { fillRule: "evenodd", d: "M10 .333A9.911 9.911 0 0 0 6.866 19.65c.5.092.678-.215.678-.477 0-.237-.01-1.017-.014-1.845-2.757.6-3.338-1.169-3.338-1.169a2.627 2.627 0 0 0-1.1-1.451c-.9-.615.07-.6.07-.6a2.084 2.084 0 0 1 1.518 1.021 2.11 2.11 0 0 0 2.884.823c.044-.503.268-.973.63-1.325-2.2-.25-4.516-1.1-4.516-4.9A3.832 3.832 0 0 1 4.7 7.068a3.56 3.56 0 0 1 .095-2.623s.832-.266 2.726 1.016a9.409 9.409 0 0 1 4.962 0c1.89-1.282 2.717-1.016 2.717-1.016.366.83.402 1.768.1 2.623a3.827 3.827 0 0 1 1.02 2.659c0 3.807-2.319 4.644-4.525 4.889a2.366 2.366 0 0 1 .673 1.834c0 1.326-.012 2.394-.012 2.72 0 .263.18.572.681.475A9.911 9.911 0 0 0 10 .333Z", clipRule: "evenodd" })),
-    /* @__PURE__ */ React3.createElement("span", null, loading ? "Loading..." : "Continue with GitHub")
+    /* @__PURE__ */ React3.createElement("span", null, loadingOauth.github ? "Loading..." : "Continue with GitHub")
   )), /* @__PURE__ */ React3.createElement("div", { style: dividerRow }, /* @__PURE__ */ React3.createElement("div", { style: line }), /* @__PURE__ */ React3.createElement("div", { style: orText }, "or"), /* @__PURE__ */ React3.createElement("div", { style: line })), /* @__PURE__ */ React3.createElement("form", { onSubmit: submit, style: form }, /* @__PURE__ */ React3.createElement("label", { style: label2, htmlFor: "name" }, /* @__PURE__ */ React3.createElement("span", { style: labelText }, "Name"), /* @__PURE__ */ React3.createElement(
     "input",
     {
@@ -967,78 +4351,78 @@ function SignUp() {
       "aria-disabled": loading
     },
     loading ? "Signing up..." : "Sign Up"
-  ))), /* @__PURE__ */ React3.createElement("div", { style: below }, /* @__PURE__ */ React3.createElement("div", { style: belowRow }, /* @__PURE__ */ React3.createElement("span", { style: muted }, "Already have an account? "), /* @__PURE__ */ React3.createElement("a", { href: "/sign-in", style: link }, "Sign in")), /* @__PURE__ */ React3.createElement("div", { style: dividerThin }), /* @__PURE__ */ React3.createElement("div", { style: secured }, /* @__PURE__ */ React3.createElement("div", { style: securedText }, "Secured by auth")))));
+  ))), /* @__PURE__ */ React3.createElement("div", { style: modalFooter }, /* @__PURE__ */ React3.createElement("div", { style: belowRow }, /* @__PURE__ */ React3.createElement("span", { style: muted }, "Already have an account? "), /* @__PURE__ */ React3.createElement(import_link.default, { href: "/sign-in", style: link }, "Sign in")), /* @__PURE__ */ React3.createElement("div", { style: dividerThin }), /* @__PURE__ */ React3.createElement("div", { style: secured }, /* @__PURE__ */ React3.createElement("div", { style: securedText }, "Secured by auth")))));
 }
-var page = {
+var overlay2 = {
   position: "fixed",
   inset: 0,
   display: "flex",
   alignItems: "center",
   justifyContent: "center",
-  padding: 24,
-  background: "linear-gradient(to bottom, #0b1220 0%, #071023 40%, #02040a 100%)",
-  color: "#f8e9d3",
+  padding: 20,
+  background: "linear-gradient(180deg, rgba(2,6,23,0.22), rgba(2,6,23,0.32))",
+  backdropFilter: "blur(6px)",
   minHeight: "100vh",
   zIndex: 9999
 };
-var card = {
+var modal2 = {
   width: "100%",
-  maxWidth: 520,
-  borderRadius: 18,
-  background: "linear-gradient(180deg, rgba(15,19,36,0.9) 0%, rgba(6,10,18,0.95) 100%)",
-  border: "1px solid rgba(148,163,184,0.06)",
-  boxShadow: "0 10px 30px rgba(2,6,23,0.6)",
+  maxWidth: 560,
+  borderRadius: 14,
+  background: "linear-gradient(180deg, rgba(15,19,24,0.6), rgba(10,12,16,0.6))",
+  // translucent neutral so background peeks through
+  border: "1px solid rgba(99,102,106,0.12)",
+  // slightly stronger neutral border
+  boxShadow: "0 20px 50px rgba(2,6,23,0.55), inset 0 1px 0 rgba(255,255,255,0.02)",
   overflow: "hidden",
   display: "flex",
   flexDirection: "column",
-  gap: 12
+  transform: "translateY(-6px)"
 };
-var cardInner = {
-  padding: 26,
+var modalInner = {
+  padding: 18,
   display: "flex",
   flexDirection: "column",
-  gap: 18
+  gap: 12
 };
-var brand = {
-  display: "flex",
-  flexDirection: "column",
-  gap: 8
+var header = {
+  paddingBottom: 6,
+  borderBottom: "1px solid rgba(148,163,184,0.04)"
 };
 var brandRow = {
   display: "flex",
   alignItems: "center",
   gap: 12
 };
-var logoPlaceholder = {
+var logo = {
+  width: 44,
+  height: 44,
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center"
+};
+var logoCircle = {
   width: 36,
   height: 36,
   borderRadius: 999,
-  background: "linear-gradient(135deg,#2b313a,#0f1724)"
+  background: "linear-gradient(135deg,#2f3438,#11151a)",
+  boxShadow: "0 4px 12px rgba(2,6,23,0.6)"
 };
-var brandTitle = {
+var title2 = {
   margin: 0,
-  fontSize: 20,
+  fontSize: 18,
   fontWeight: 600,
-  color: "#fff"
-};
-var brandSub = {
-  display: "flex",
-  flexDirection: "column",
-  gap: 4
-};
-var brandLead = {
-  fontSize: 15,
-  color: "rgba(255,255,255,0.95)"
+  color: "#e6e6e6"
 };
-var brandMuted = {
+var subtitle2 = {
   fontSize: 13,
-  color: "rgba(255,255,255,0.65)",
-  marginTop: 2
+  color: "rgba(230,230,230,0.72)",
+  marginTop: 4
 };
-var oauthRow = {
+var oauthSection = {
+  marginTop: 8,
   display: "flex",
-  gap: 10,
-  marginTop: 8
+  gap: 8
 };
 var oauthButton = {
   flex: 1,
@@ -1051,21 +4435,22 @@ var oauthButton = {
   fontSize: 14,
   cursor: "pointer",
   userSelect: "none",
-  gap: 8
+  gap: 8,
+  minHeight: 40
 };
 var oauthGoogle = {
-  background: "rgba(255,255,255,0.06)",
+  background: "linear-gradient(180deg, rgba(255,255,255,0.03), rgba(255,255,255,0.01))",
   color: "#fff"
 };
 var oauthGithub = {
-  background: "rgba(255,255,255,0.03)",
+  background: "linear-gradient(180deg, rgba(255,255,255,0.02), rgba(255,255,255,0.00))",
   color: "#fff"
 };
 var dividerRow = {
   display: "flex",
   alignItems: "center",
-  gap: 12,
-  marginTop: 14
+  gap: 10,
+  marginTop: 12
 };
 var line = {
   flex: 1,
@@ -1074,13 +4459,13 @@ var line = {
 };
 var orText = {
   fontSize: 13,
-  color: "rgba(255,255,255,0.6)",
+  color: "rgba(230,230,230,0.65)",
   padding: "0 8px"
 };
 var form = {
   display: "flex",
   flexDirection: "column",
-  gap: 12,
+  gap: 10,
   marginTop: 6
 };
 var label2 = {
@@ -1090,25 +4475,26 @@ var label2 = {
 };
 var labelText = {
   fontSize: 13,
-  color: "rgba(255,255,255,0.66)"
+  color: "rgba(230,230,230,0.68)"
 };
 var input2 = {
   width: "100%",
   padding: "10px 12px",
   borderRadius: 10,
-  background: "rgba(11,18,32,0.5)",
-  color: "#f8e9d3",
-  border: "1px solid rgba(148,163,184,0.06)",
+  background: "rgba(255,255,255,0.02)",
+  color: "#e6e6e6",
+  border: "1px solid rgba(148,163,184,0.10)",
   fontSize: 14,
   outline: "none",
-  boxSizing: "border-box"
+  boxSizing: "border-box",
+  transition: "box-shadow 120ms, border-color 120ms"
 };
 var submitButton = {
   marginTop: 6,
   width: "100%",
   padding: "10px 12px",
   borderRadius: 10,
-  background: "linear-gradient(180deg,#2563eb,#60a5fa)",
+  background: "linear-gradient(180deg,#475569,#94a3b8)",
   border: "none",
   color: "#fff",
   fontWeight: 600,
@@ -1116,14 +4502,15 @@ var submitButton = {
   fontSize: 15,
   display: "inline-flex",
   alignItems: "center",
-  justifyContent: "center"
+  justifyContent: "center",
+  minHeight: 44
 };
-var below = {
-  padding: "12px 20px 20px 20px",
+var modalFooter = {
+  padding: "12px 18px 18px 18px",
   borderTop: "1px solid rgba(148,163,184,0.03)",
   display: "flex",
   flexDirection: "column",
-  gap: 10
+  gap: 8
 };
 var belowRow = {
   textAlign: "center",
@@ -1133,17 +4520,17 @@ var belowRow = {
   alignItems: "center"
 };
 var muted = {
-  color: "rgba(255,255,255,0.65)",
+  color: "rgba(230,230,230,0.66)",
   fontSize: 13
 };
 var link = {
-  color: "#3b82f6",
+  color: "#9fb0d9",
   textDecoration: "none",
   fontWeight: 600
 };
 var dividerThin = {
   height: 1,
-  background: "rgba(148,163,184,0.05)",
+  background: "rgba(148,163,184,0.04)",
   marginTop: 6,
   marginBottom: 6
 };
@@ -1151,10 +4538,53 @@ var secured = {
   textAlign: "center"
 };
 var securedText = {
-  color: "rgba(255,255,255,0.9)",
+  color: "rgba(230,230,230,0.9)",
   fontSize: 13,
   fontWeight: 600
 };
+var toastContainer = {
+  position: "fixed",
+  top: 18,
+  right: 18,
+  width: 360,
+  maxWidth: "calc(100% - 36px)",
+  display: "flex",
+  flexDirection: "column",
+  gap: 10,
+  zIndex: 6e4
+};
+var toastBase = {
+  display: "flex",
+  gap: 10,
+  alignItems: "center",
+  padding: "10px 12px",
+  borderRadius: 10,
+  boxShadow: "0 8px 20px rgba(2,6,23,0.6)",
+  color: "#fff",
+  fontSize: 13,
+  minWidth: 120
+};
+var toastError = {
+  background: "#000000",
+  border: "1px solid rgba(255,255,255,0.06)"
+};
+var toastSuccess = {
+  background: "#000000",
+  border: "1px solid rgba(255,255,255,0.06)"
+};
+var toastInfo = {
+  background: "#000000",
+  border: "1px solid rgba(255,255,255,0.06)"
+};
+var toastCloseBtn = {
+  marginLeft: 8,
+  background: "transparent",
+  border: "none",
+  color: "rgba(255,255,255,0.7)",
+  cursor: "pointer",
+  fontSize: 14,
+  lineHeight: 1
+};
 export {
   provider_default as FlowlinkAuthProvider,
   SignIn,