boreal-ui 0.0.1

package/dist/next/link-CX77u6b-.js

@@ -0,0 +1,2866 @@
+import require$$2 from "react/jsx-runtime";
+import React from "react";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var _interop_require_default$1 = {};
+function _interop_require_default(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+_interop_require_default$1._ = _interop_require_default;
+var _interop_require_wildcard$1 = {};
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) return obj;
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { default: obj };
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) return cache.get(obj);
+  var newObj = { __proto__: null };
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+      else newObj[key] = obj[key];
+    }
+  }
+  newObj.default = obj;
+  if (cache) cache.set(obj, newObj);
+  return newObj;
+}
+_interop_require_wildcard$1._ = _interop_require_wildcard;
+var routerContext_sharedRuntime = {};
+var hasRequiredRouterContext_sharedRuntime;
+function requireRouterContext_sharedRuntime() {
+  if (hasRequiredRouterContext_sharedRuntime) return routerContext_sharedRuntime;
+  hasRequiredRouterContext_sharedRuntime = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "RouterContext", {
+      enumerable: true,
+      get: function() {
+        return RouterContext;
+      }
+    });
+    const _interop_require_default2 = _interop_require_default$1;
+    const _react = /* @__PURE__ */ _interop_require_default2._(React);
+    const RouterContext = _react.default.createContext(null);
+    if (process.env.NODE_ENV !== "production") {
+      RouterContext.displayName = "RouterContext";
+    }
+  })(routerContext_sharedRuntime);
+  return routerContext_sharedRuntime;
+}
+var useMergedRef = { exports: {} };
+var hasRequiredUseMergedRef;
+function requireUseMergedRef() {
+  if (hasRequiredUseMergedRef) return useMergedRef.exports;
+  hasRequiredUseMergedRef = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "useMergedRef", {
+      enumerable: true,
+      get: function() {
+        return useMergedRef2;
+      }
+    });
+    const _react = React;
+    function useMergedRef2(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;
+    }
+  })(useMergedRef, useMergedRef.exports);
+  return useMergedRef.exports;
+}
+var link$1 = { exports: {} };
+var resolveHref = { exports: {} };
+var querystring = {};
+var hasRequiredQuerystring;
+function requireQuerystring() {
+  if (hasRequiredQuerystring) return querystring;
+  hasRequiredQuerystring = 1;
+  (function(exports) {
+    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) {
+      for (var _len = arguments.length, searchParamsList = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        searchParamsList[_key - 1] = arguments[_key];
+      }
+      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;
+    }
+  })(querystring);
+  return querystring;
+}
+var formatUrl = {};
+var hasRequiredFormatUrl;
+function requireFormatUrl() {
+  if (hasRequiredFormatUrl) return formatUrl;
+  hasRequiredFormatUrl = 1;
+  (function(exports) {
+    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 formatUrl2;
+      },
+      formatWithValidation: function() {
+        return formatWithValidation;
+      },
+      urlObjectKeys: function() {
+        return urlObjectKeys;
+      }
+    });
+    const _interop_require_wildcard2 = _interop_require_wildcard$1;
+    const _querystring = /* @__PURE__ */ _interop_require_wildcard2._(requireQuerystring());
+    const slashedProtocols = /https?|ftp|gopher|file/;
+    function formatUrl2(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;
+    }
+    const urlObjectKeys = [
+      "auth",
+      "hash",
+      "host",
+      "hostname",
+      "href",
+      "path",
+      "pathname",
+      "port",
+      "protocol",
+      "query",
+      "search",
+      "slashes"
+    ];
+    function formatWithValidation(url) {
+      if (process.env.NODE_ENV === "development") {
+        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 formatUrl2(url);
+    }
+  })(formatUrl);
+  return formatUrl;
+}
+var omit = {};
+var hasRequiredOmit;
+function requireOmit() {
+  if (hasRequiredOmit) return omit;
+  hasRequiredOmit = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "omit", {
+      enumerable: true,
+      get: function() {
+        return omit2;
+      }
+    });
+    function omit2(object, keys) {
+      const omitted = {};
+      Object.keys(object).forEach((key) => {
+        if (!keys.includes(key)) {
+          omitted[key] = object[key];
+        }
+      });
+      return omitted;
+    }
+  })(omit);
+  return omit;
+}
+var utils$1 = {};
+var hasRequiredUtils$1;
+function requireUtils$1() {
+  if (hasRequiredUtils$1) return utils$1;
+  hasRequiredUtils$1 = 1;
+  (function(exports) {
+    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;
+      }
+    });
+    const WEB_VITALS = [
+      "CLS",
+      "FCP",
+      "FID",
+      "INP",
+      "LCP",
+      "TTFB"
+    ];
+    function execOnce(fn) {
+      let used = false;
+      let result;
+      return function() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        if (!used) {
+          used = true;
+          result = fn(...args);
+        }
+        return result;
+      };
+    }
+    const ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
+    const 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 (process.env.NODE_ENV !== "production") {
+        var _App_prototype;
+        if ((_App_prototype = App.prototype) == null ? void 0 : _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 (process.env.NODE_ENV !== "production") {
+        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;
+    }
+    const SP = typeof performance !== "undefined";
+    const ST = SP && [
+      "mark",
+      "measure",
+      "getEntriesByName"
+    ].every((method) => typeof performance[method] === "function");
+    class DecodeError extends Error {
+    }
+    class NormalizeError extends Error {
+    }
+    class PageNotFoundError extends Error {
+      constructor(page) {
+        super();
+        this.code = "ENOENT";
+        this.name = "PageNotFoundError";
+        this.message = "Cannot find module for page: " + page;
+      }
+    }
+    class MissingStaticPage extends Error {
+      constructor(page, message) {
+        super();
+        this.message = "Failed to load static file for page: " + page + " " + message;
+      }
+    }
+    class MiddlewareNotFoundError 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
+      });
+    }
+  })(utils$1);
+  return utils$1;
+}
+var normalizeTrailingSlash = { exports: {} };
+var removeTrailingSlash = {};
+var hasRequiredRemoveTrailingSlash;
+function requireRemoveTrailingSlash() {
+  if (hasRequiredRemoveTrailingSlash) return removeTrailingSlash;
+  hasRequiredRemoveTrailingSlash = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "removeTrailingSlash", {
+      enumerable: true,
+      get: function() {
+        return removeTrailingSlash2;
+      }
+    });
+    function removeTrailingSlash2(route) {
+      return route.replace(/\/$/, "") || "/";
+    }
+  })(removeTrailingSlash);
+  return removeTrailingSlash;
+}
+var parsePath = {};
+var hasRequiredParsePath;
+function requireParsePath() {
+  if (hasRequiredParsePath) return parsePath;
+  hasRequiredParsePath = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "parsePath", {
+      enumerable: true,
+      get: function() {
+        return parsePath2;
+      }
+    });
+    function parsePath2(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: ""
+      };
+    }
+  })(parsePath);
+  return parsePath;
+}
+var hasRequiredNormalizeTrailingSlash;
+function requireNormalizeTrailingSlash() {
+  if (hasRequiredNormalizeTrailingSlash) return normalizeTrailingSlash.exports;
+  hasRequiredNormalizeTrailingSlash = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "normalizePathTrailingSlash", {
+      enumerable: true,
+      get: function() {
+        return normalizePathTrailingSlash;
+      }
+    });
+    const _removetrailingslash = requireRemoveTrailingSlash();
+    const _parsepath = requireParsePath();
+    const 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;
+    }
+  })(normalizeTrailingSlash, normalizeTrailingSlash.exports);
+  return normalizeTrailingSlash.exports;
+}
+var isLocalUrl = {};
+var hasBasePath = { exports: {} };
+var pathHasPrefix = {};
+var hasRequiredPathHasPrefix;
+function requirePathHasPrefix() {
+  if (hasRequiredPathHasPrefix) return pathHasPrefix;
+  hasRequiredPathHasPrefix = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "pathHasPrefix", {
+      enumerable: true,
+      get: function() {
+        return pathHasPrefix2;
+      }
+    });
+    const _parsepath = requireParsePath();
+    function pathHasPrefix2(path, prefix) {
+      if (typeof path !== "string") {
+        return false;
+      }
+      const { pathname } = (0, _parsepath.parsePath)(path);
+      return pathname === prefix || pathname.startsWith(prefix + "/");
+    }
+  })(pathHasPrefix);
+  return pathHasPrefix;
+}
+var hasRequiredHasBasePath;
+function requireHasBasePath() {
+  if (hasRequiredHasBasePath) return hasBasePath.exports;
+  hasRequiredHasBasePath = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "hasBasePath", {
+      enumerable: true,
+      get: function() {
+        return hasBasePath2;
+      }
+    });
+    const _pathhasprefix = requirePathHasPrefix();
+    const basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+    function hasBasePath2(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;
+    }
+  })(hasBasePath, hasBasePath.exports);
+  return hasBasePath.exports;
+}
+var hasRequiredIsLocalUrl;
+function requireIsLocalUrl() {
+  if (hasRequiredIsLocalUrl) return isLocalUrl;
+  hasRequiredIsLocalUrl = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "isLocalURL", {
+      enumerable: true,
+      get: function() {
+        return isLocalURL;
+      }
+    });
+    const _utils = requireUtils$1();
+    const _hasbasepath = requireHasBasePath();
+    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;
+      }
+    }
+  })(isLocalUrl);
+  return isLocalUrl;
+}
+var utils = {};
+var sortedRoutes = {};
+var hasRequiredSortedRoutes;
+function requireSortedRoutes() {
+  if (hasRequiredSortedRoutes) return sortedRoutes;
+  hasRequiredSortedRoutes = 1;
+  (function(exports) {
+    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;
+      }
+    });
+    class UrlNode {
+      insert(urlPath) {
+        this._insert(urlPath.split("/").filter(Boolean), [], false);
+      }
+      smoosh() {
+        return this._smoosh();
+      }
+      _smoosh(prefix) {
+        if (prefix === void 0) 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("…")) {
+            throw Object.defineProperty(new Error("Detected a three-dot character ('…') 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]]);
+    }
+  })(sortedRoutes);
+  return sortedRoutes;
+}
+var isDynamic = {};
+var interceptionRoutes = {};
+var appPaths = {};
+var ensureLeadingSlash = {};
+var hasRequiredEnsureLeadingSlash;
+function requireEnsureLeadingSlash() {
+  if (hasRequiredEnsureLeadingSlash) return ensureLeadingSlash;
+  hasRequiredEnsureLeadingSlash = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "ensureLeadingSlash", {
+      enumerable: true,
+      get: function() {
+        return ensureLeadingSlash2;
+      }
+    });
+    function ensureLeadingSlash2(path) {
+      return path.startsWith("/") ? path : "/" + path;
+    }
+  })(ensureLeadingSlash);
+  return ensureLeadingSlash;
+}
+var segment = {};
+(function(exports) {
+  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;
+    },
+    isGroupSegment: function() {
+      return isGroupSegment;
+    },
+    isParallelRouteSegment: function() {
+      return isParallelRouteSegment;
+    }
+  });
+  function isGroupSegment(segment2) {
+    return segment2[0] === "(" && segment2.endsWith(")");
+  }
+  function isParallelRouteSegment(segment2) {
+    return segment2.startsWith("@") && segment2 !== "@children";
+  }
+  function addSearchParamsIfPageSegment(segment2, searchParams) {
+    const isPageSegment = segment2.includes(PAGE_SEGMENT_KEY);
+    if (isPageSegment) {
+      const stringifiedQuery = JSON.stringify(searchParams);
+      return stringifiedQuery !== "{}" ? PAGE_SEGMENT_KEY + "?" + stringifiedQuery : PAGE_SEGMENT_KEY;
+    }
+    return segment2;
+  }
+  const PAGE_SEGMENT_KEY = "__PAGE__";
+  const DEFAULT_SEGMENT_KEY = "__DEFAULT__";
+})(segment);
+var hasRequiredAppPaths;
+function requireAppPaths() {
+  if (hasRequiredAppPaths) return appPaths;
+  hasRequiredAppPaths = 1;
+  (function(exports) {
+    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;
+      }
+    });
+    const _ensureleadingslash = requireEnsureLeadingSlash();
+    const _segment = segment;
+    function normalizeAppPath(route) {
+      return (0, _ensureleadingslash.ensureLeadingSlash)(route.split("/").reduce((pathname, segment2, index, segments) => {
+        if (!segment2) {
+          return pathname;
+        }
+        if ((0, _segment.isGroupSegment)(segment2)) {
+          return pathname;
+        }
+        if (segment2[0] === "@") {
+          return pathname;
+        }
+        if ((segment2 === "page" || segment2 === "route") && index === segments.length - 1) {
+          return pathname;
+        }
+        return pathname + "/" + segment2;
+      }, ""));
+    }
+    function normalizeRscURL(url) {
+      return url.replace(
+        /\.rsc($|\?)/,
+        // $1 ensures `?` is preserved
+        "$1"
+      );
+    }
+  })(appPaths);
+  return appPaths;
+}
+var hasRequiredInterceptionRoutes;
+function requireInterceptionRoutes() {
+  if (hasRequiredInterceptionRoutes) return interceptionRoutes;
+  hasRequiredInterceptionRoutes = 1;
+  (function(exports) {
+    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;
+      }
+    });
+    const _apppaths = requireAppPaths();
+    const INTERCEPTION_ROUTE_MARKERS = [
+      "(..)(..)",
+      "(.)",
+      "(..)",
+      "(...)"
+    ];
+    function isInterceptionRouteAppPath(path) {
+      return path.split("/").find((segment2) => INTERCEPTION_ROUTE_MARKERS.find((m) => segment2.startsWith(m))) !== void 0;
+    }
+    function extractInterceptionRouteInformation(path) {
+      let interceptingRoute, marker, interceptedRoute;
+      for (const segment2 of path.split("/")) {
+        marker = INTERCEPTION_ROUTE_MARKERS.find((m) => segment2.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
+      };
+    }
+  })(interceptionRoutes);
+  return interceptionRoutes;
+}
+var hasRequiredIsDynamic;
+function requireIsDynamic() {
+  if (hasRequiredIsDynamic) return isDynamic;
+  hasRequiredIsDynamic = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "isDynamicRoute", {
+      enumerable: true,
+      get: function() {
+        return isDynamicRoute;
+      }
+    });
+    const _interceptionroutes = requireInterceptionRoutes();
+    const TEST_ROUTE = /\/[^/]*\[[^/]+\][^/]*(?=\/|$)/;
+    const TEST_STRICT_ROUTE = /\/\[[^/]+\](?=\/|$)/;
+    function isDynamicRoute(route, strict) {
+      if (strict === void 0) 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);
+    }
+  })(isDynamic);
+  return isDynamic;
+}
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (function(exports) {
+    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;
+      }
+    });
+    const _sortedroutes = requireSortedRoutes();
+    const _isdynamic = requireIsDynamic();
+  })(utils);
+  return utils;
+}
+var interpolateAs = {};
+var routeMatcher = {};
+var hasRequiredRouteMatcher;
+function requireRouteMatcher() {
+  if (hasRequiredRouteMatcher) return routeMatcher;
+  hasRequiredRouteMatcher = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "getRouteMatcher", {
+      enumerable: true,
+      get: function() {
+        return getRouteMatcher;
+      }
+    });
+    const _utils = requireUtils$1();
+    function getRouteMatcher(param) {
+      let { re, groups } = param;
+      return (pathname) => {
+        const routeMatch = re.exec(pathname);
+        if (!routeMatch) return false;
+        const decode = (param2) => {
+          try {
+            return decodeURIComponent(param2);
+          } catch (e) {
+            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;
+      };
+    }
+  })(routeMatcher);
+  return routeMatcher;
+}
+var routeRegex = {};
+var constants = {};
+var hasRequiredConstants;
+function requireConstants() {
+  if (hasRequiredConstants) return constants;
+  hasRequiredConstants = 1;
+  (function(exports) {
+    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;
+      },
+      INFINITE_CACHE: function() {
+        return INFINITE_CACHE;
+      },
+      INSTRUMENTATION_HOOK_FILENAME: function() {
+        return INSTRUMENTATION_HOOK_FILENAME;
+      },
+      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;
+      },
+      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_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;
+      },
+      UNSTABLE_REVALIDATE_RENAME_ERROR: function() {
+        return UNSTABLE_REVALIDATE_RENAME_ERROR;
+      },
+      WEBPACK_LAYERS: function() {
+        return WEBPACK_LAYERS;
+      },
+      WEBPACK_RESOURCE_QUERIES: function() {
+        return WEBPACK_RESOURCE_QUERIES;
+      }
+    });
+    const NEXT_QUERY_PARAM_PREFIX = "nxtP";
+    const NEXT_INTERCEPTION_MARKER_PREFIX = "nxtI";
+    const MATCHED_PATH_HEADER = "x-matched-path";
+    const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+    const PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = "x-prerender-revalidate-if-generated";
+    const RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
+    const RSC_SEGMENTS_DIR_SUFFIX = ".segments";
+    const RSC_SEGMENT_SUFFIX = ".segment.rsc";
+    const RSC_SUFFIX = ".rsc";
+    const ACTION_SUFFIX = ".action";
+    const NEXT_DATA_SUFFIX = ".json";
+    const NEXT_META_SUFFIX = ".meta";
+    const NEXT_BODY_SUFFIX = ".body";
+    const NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
+    const NEXT_CACHE_REVALIDATED_TAGS_HEADER = "x-next-revalidated-tags";
+    const NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER = "x-next-revalidate-tag-token";
+    const NEXT_RESUME_HEADER = "next-resume";
+    const NEXT_CACHE_TAG_MAX_ITEMS = 128;
+    const NEXT_CACHE_TAG_MAX_LENGTH = 256;
+    const NEXT_CACHE_SOFT_TAG_MAX_LENGTH = 1024;
+    const NEXT_CACHE_IMPLICIT_TAG_ID = "_N_T_";
+    const CACHE_ONE_YEAR = 31536e3;
+    const INFINITE_CACHE = 4294967294;
+    const MIDDLEWARE_FILENAME = "middleware";
+    const MIDDLEWARE_LOCATION_REGEXP = `(?:src/)?${MIDDLEWARE_FILENAME}`;
+    const INSTRUMENTATION_HOOK_FILENAME = "instrumentation";
+    const PAGES_DIR_ALIAS = "private-next-pages";
+    const DOT_NEXT_ALIAS = "private-dot-next";
+    const ROOT_DIR_ALIAS = "private-next-root-dir";
+    const APP_DIR_ALIAS = "private-next-app-dir";
+    const RSC_MOD_REF_PROXY_ALIAS = "private-next-rsc-mod-ref-proxy";
+    const RSC_ACTION_VALIDATE_ALIAS = "private-next-rsc-action-validate";
+    const RSC_ACTION_PROXY_ALIAS = "private-next-rsc-server-reference";
+    const RSC_CACHE_WRAPPER_ALIAS = "private-next-rsc-cache-wrapper";
+    const RSC_ACTION_ENCRYPTION_ALIAS = "private-next-rsc-action-encryption";
+    const RSC_ACTION_CLIENT_WRAPPER_ALIAS = "private-next-rsc-action-client-wrapper";
+    const 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`;
+    const SSG_GET_INITIAL_PROPS_CONFLICT = `You can not use getInitialProps with getStaticProps. To use SSG, please remove your getInitialProps`;
+    const SERVER_PROPS_GET_INIT_PROPS_CONFLICT = `You can not use getInitialProps with getServerSideProps. Please remove getInitialProps.`;
+    const SERVER_PROPS_SSG_CONFLICT = `You can not use getStaticProps or getStaticPaths with getServerSideProps. To use SSG, please remove getServerSideProps`;
+    const STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR = `can not have getInitialProps/getServerSideProps, https://nextjs.org/docs/messages/404-get-initial-props`;
+    const SERVER_PROPS_EXPORT_ERROR = `pages with \`getServerSideProps\` can not be exported. See more info here: https://nextjs.org/docs/messages/gssp-export`;
+    const GSP_NO_RETURNED_VALUE = "Your `getStaticProps` function did not return an object. Did you forget to add a `return`?";
+    const GSSP_NO_RETURNED_VALUE = "Your `getServerSideProps` function did not return an object. Did you forget to add a `return`?";
+    const UNSTABLE_REVALIDATE_RENAME_ERROR = "The `unstable_revalidate` property is available for general use.\nPlease use `revalidate` instead.";
+    const 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`;
+    const 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`;
+    const 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`;
+    const ESLINT_DEFAULT_DIRS = [
+      "app",
+      "pages",
+      "components",
+      "lib",
+      "src"
+    ];
+    const SERVER_RUNTIME = {
+      edge: "edge",
+      experimentalEdge: "experimental-edge",
+      nodejs: "nodejs"
+    };
+    const 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"
+    };
+    const 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
+        ]
+      }
+    };
+    const WEBPACK_RESOURCE_QUERIES = {
+      edgeSSREntry: "__next_edge_ssr_entry__",
+      metadata: "__next_metadata__",
+      metadataRoute: "__next_metadata_route__",
+      metadataImageMeta: "__next_metadata_image_meta__"
+    };
+  })(constants);
+  return constants;
+}
+var escapeRegexp = {};
+var hasRequiredEscapeRegexp;
+function requireEscapeRegexp() {
+  if (hasRequiredEscapeRegexp) return escapeRegexp;
+  hasRequiredEscapeRegexp = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "escapeStringRegexp", {
+      enumerable: true,
+      get: function() {
+        return escapeStringRegexp;
+      }
+    });
+    const reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+    const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+    function escapeStringRegexp(str) {
+      if (reHasRegExp.test(str)) {
+        return str.replace(reReplaceRegExp, "\\$&");
+      }
+      return str;
+    }
+  })(escapeRegexp);
+  return escapeRegexp;
+}
+var hasRequiredRouteRegex;
+function requireRouteRegex() {
+  if (hasRequiredRouteRegex) return routeRegex;
+  hasRequiredRouteRegex = 1;
+  (function(exports) {
+    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;
+      },
+      parseParameter: function() {
+        return parseParameter;
+      }
+    });
+    const _constants = requireConstants();
+    const _interceptionroutes = requireInterceptionRoutes();
+    const _escaperegexp = requireEscapeRegexp();
+    const _removetrailingslash = requireRemoveTrailingSlash();
+    const 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
+      };
+    }
+    function getParametrizedRoute(route, includeSuffix, includePrefix) {
+      const groups = {};
+      let groupIndex = 1;
+      const segments = [];
+      for (const segment2 of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+        const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m) => segment2.startsWith(m));
+        const paramMatches = segment2.match(PARAMETER_PATTERN);
+        if (markerMatch && paramMatches && paramMatches[2]) {
+          const { key, optional, repeat } = parseMatchedParameter(paramMatches[2]);
+          groups[key] = {
+            pos: groupIndex++,
+            repeat,
+            optional
+          };
+          segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(markerMatch) + "([^/]+?)");
+        } else if (paramMatches && paramMatches[2]) {
+          const { key, repeat, optional } = 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)(segment2));
+        }
+        if (includeSuffix && paramMatches && paramMatches[3]) {
+          segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+        }
+      }
+      return {
+        parameterizedRoute: segments.join(""),
+        groups
+      };
+    }
+    function getRouteRegex(normalizedRoute, param) {
+      let { includeSuffix = false, includePrefix = false, excludeOptionalTrailingSlash = false } = param === void 0 ? {} : param;
+      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(param) {
+      let { interceptionMarker, getSafeRouteKey, segment: segment2, routeKeys, keyPrefix, backreferenceDuplicateKeys } = param;
+      const { key, optional, repeat } = parseMatchedParameter(segment2);
+      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 optional ? "(?:/" + interceptionPrefix + pattern + ")?" : "/" + interceptionPrefix + pattern;
+    }
+    function getNamedParametrizedRoute(route, prefixRouteKeys, includeSuffix, includePrefix, backreferenceDuplicateKeys) {
+      const getSafeRouteKey = buildGetSafeRouteKey();
+      const routeKeys = {};
+      const segments = [];
+      for (const segment2 of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+        const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m) => segment2.startsWith(m));
+        const paramMatches = segment2.match(PARAMETER_PATTERN);
+        if (hasInterceptionMarker && paramMatches && paramMatches[2]) {
+          segments.push(getSafeKeyFromSegment({
+            getSafeRouteKey,
+            interceptionMarker: paramMatches[1],
+            segment: paramMatches[2],
+            routeKeys,
+            keyPrefix: prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : void 0,
+            backreferenceDuplicateKeys
+          }));
+        } else if (paramMatches && paramMatches[2]) {
+          if (includePrefix && paramMatches[1]) {
+            segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(paramMatches[1]));
+          }
+          let s = getSafeKeyFromSegment({
+            getSafeRouteKey,
+            segment: paramMatches[2],
+            routeKeys,
+            keyPrefix: prefixRouteKeys ? _constants.NEXT_QUERY_PARAM_PREFIX : void 0,
+            backreferenceDuplicateKeys
+          });
+          if (includePrefix && paramMatches[1]) {
+            s = s.substring(1);
+          }
+          segments.push(s);
+        } else {
+          segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(segment2));
+        }
+        if (includeSuffix && paramMatches && paramMatches[3]) {
+          segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+        }
+      }
+      return {
+        namedParameterizedRoute: segments.join(""),
+        routeKeys
+      };
+    }
+    function getNamedRouteRegex(normalizedRoute, options) {
+      var _options_includeSuffix, _options_includePrefix, _options_backreferenceDuplicateKeys;
+      const result = getNamedParametrizedRoute(normalizedRoute, options.prefixRouteKeys, (_options_includeSuffix = options.includeSuffix) != null ? _options_includeSuffix : false, (_options_includePrefix = options.includePrefix) != null ? _options_includePrefix : false, (_options_backreferenceDuplicateKeys = options.backreferenceDuplicateKeys) != null ? _options_backreferenceDuplicateKeys : false);
+      let namedRegex = result.namedParameterizedRoute;
+      if (!options.excludeOptionalTrailingSlash) {
+        namedRegex += "(?:/)?";
+      }
+      return {
+        ...getRouteRegex(normalizedRoute, options),
+        namedRegex: "^" + namedRegex + "$",
+        routeKeys: result.routeKeys
+      };
+    }
+    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);
+      let catchAllGroupedRegex = catchAll ? "(?:(/.*)?)" : "";
+      return {
+        namedRegex: "^" + namedParameterizedRoute + catchAllGroupedRegex + "$"
+      };
+    }
+  })(routeRegex);
+  return routeRegex;
+}
+var hasRequiredInterpolateAs;
+function requireInterpolateAs() {
+  if (hasRequiredInterpolateAs) return interpolateAs;
+  hasRequiredInterpolateAs = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "interpolateAs", {
+      enumerable: true,
+      get: function() {
+        return interpolateAs2;
+      }
+    });
+    const _routematcher = requireRouteMatcher();
+    const _routeregex = requireRouteRegex();
+    function interpolateAs2(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
+          (segment2) => encodeURIComponent(segment2)
+        ).join("/") : encodeURIComponent(value)) || "/");
+      })) {
+        interpolatedRoute = "";
+      }
+      return {
+        params,
+        result: interpolatedRoute
+      };
+    }
+  })(interpolateAs);
+  return interpolateAs;
+}
+var hasRequiredResolveHref;
+function requireResolveHref() {
+  if (hasRequiredResolveHref) return resolveHref.exports;
+  hasRequiredResolveHref = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "resolveHref", {
+      enumerable: true,
+      get: function() {
+        return resolveHref2;
+      }
+    });
+    const _querystring = requireQuerystring();
+    const _formaturl = requireFormatUrl();
+    const _omit = requireOmit();
+    const _utils = requireUtils$1();
+    const _normalizetrailingslash = requireNormalizeTrailingSlash();
+    const _islocalurl = requireIsLocalUrl();
+    const _utils1 = requireUtils();
+    const _interpolateas = requireInterpolateAs();
+    function resolveHref2(router, href, resolveAs) {
+      let base;
+      let urlAsString = typeof href === "string" ? href : (0, _formaturl.formatWithValidation)(href);
+      const urlProtoMatch = urlAsString.match(/^[a-zA-Z]{1,}:\/\//);
+      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 {
+        base = new URL(urlAsString.startsWith("#") ? router.asPath : router.pathname, "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;
+    }
+  })(resolveHref, resolveHref.exports);
+  return resolveHref.exports;
+}
+var addLocale$1 = { exports: {} };
+var addLocale = {};
+var addPathPrefix = {};
+var hasRequiredAddPathPrefix;
+function requireAddPathPrefix() {
+  if (hasRequiredAddPathPrefix) return addPathPrefix;
+  hasRequiredAddPathPrefix = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "addPathPrefix", {
+      enumerable: true,
+      get: function() {
+        return addPathPrefix2;
+      }
+    });
+    const _parsepath = requireParsePath();
+    function addPathPrefix2(path, prefix) {
+      if (!path.startsWith("/") || !prefix) {
+        return path;
+      }
+      const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+      return "" + prefix + pathname + query + hash;
+    }
+  })(addPathPrefix);
+  return addPathPrefix;
+}
+var hasRequiredAddLocale$1;
+function requireAddLocale$1() {
+  if (hasRequiredAddLocale$1) return addLocale;
+  hasRequiredAddLocale$1 = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "addLocale", {
+      enumerable: true,
+      get: function() {
+        return addLocale2;
+      }
+    });
+    const _addpathprefix = requireAddPathPrefix();
+    const _pathhasprefix = requirePathHasPrefix();
+    function addLocale2(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);
+    }
+  })(addLocale);
+  return addLocale;
+}
+var hasRequiredAddLocale;
+function requireAddLocale() {
+  if (hasRequiredAddLocale) return addLocale$1.exports;
+  hasRequiredAddLocale = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "addLocale", {
+      enumerable: true,
+      get: function() {
+        return addLocale2;
+      }
+    });
+    const _normalizetrailingslash = requireNormalizeTrailingSlash();
+    const addLocale2 = function(path) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      if (process.env.__NEXT_I18N_SUPPORT) {
+        return (0, _normalizetrailingslash.normalizePathTrailingSlash)(requireAddLocale$1().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;
+    }
+  })(addLocale$1, addLocale$1.exports);
+  return addLocale$1.exports;
+}
+var useIntersection = { exports: {} };
+var requestIdleCallback = { exports: {} };
+var hasRequiredRequestIdleCallback;
+function requireRequestIdleCallback() {
+  if (hasRequiredRequestIdleCallback) return requestIdleCallback.exports;
+  hasRequiredRequestIdleCallback = 1;
+  (function(module, exports) {
+    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 requestIdleCallback2;
+      }
+    });
+    const requestIdleCallback2 = 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);
+    };
+    const 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;
+    }
+  })(requestIdleCallback, requestIdleCallback.exports);
+  return requestIdleCallback.exports;
+}
+var hasRequiredUseIntersection;
+function requireUseIntersection() {
+  if (hasRequiredUseIntersection) return useIntersection.exports;
+  hasRequiredUseIntersection = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "useIntersection", {
+      enumerable: true,
+      get: function() {
+        return useIntersection2;
+      }
+    });
+    const _react = React;
+    const _requestidlecallback = requireRequestIdleCallback();
+    const hasIntersectionObserver = typeof IntersectionObserver === "function";
+    const observers = /* @__PURE__ */ new Map();
+    const 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 useIntersection2(param) {
+      let { rootRef, rootMargin, disabled } = param;
+      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 == null ? void 0 : 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;
+    }
+  })(useIntersection, useIntersection.exports);
+  return useIntersection.exports;
+}
+var getDomainLocale = { exports: {} };
+var normalizeLocalePath$1 = { exports: {} };
+var normalizeLocalePath = {};
+var hasRequiredNormalizeLocalePath$1;
+function requireNormalizeLocalePath$1() {
+  if (hasRequiredNormalizeLocalePath$1) return normalizeLocalePath;
+  hasRequiredNormalizeLocalePath$1 = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "normalizeLocalePath", {
+      enumerable: true,
+      get: function() {
+        return normalizeLocalePath2;
+      }
+    });
+    const cache = /* @__PURE__ */ new WeakMap();
+    function normalizeLocalePath2(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 segment2 = segments[1].toLowerCase();
+      const index = lowercasedLocales.indexOf(segment2);
+      if (index < 0) return {
+        pathname
+      };
+      detectedLocale = locales[index];
+      pathname = pathname.slice(detectedLocale.length + 1) || "/";
+      return {
+        pathname,
+        detectedLocale
+      };
+    }
+  })(normalizeLocalePath);
+  return normalizeLocalePath;
+}
+var hasRequiredNormalizeLocalePath;
+function requireNormalizeLocalePath() {
+  if (hasRequiredNormalizeLocalePath) return normalizeLocalePath$1.exports;
+  hasRequiredNormalizeLocalePath = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "normalizeLocalePath", {
+      enumerable: true,
+      get: function() {
+        return normalizeLocalePath2;
+      }
+    });
+    const normalizeLocalePath2 = (pathname, locales) => {
+      if (process.env.__NEXT_I18N_SUPPORT) {
+        return requireNormalizeLocalePath$1().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;
+    }
+  })(normalizeLocalePath$1, normalizeLocalePath$1.exports);
+  return normalizeLocalePath$1.exports;
+}
+var detectDomainLocale$1 = { exports: {} };
+var detectDomainLocale = {};
+var hasRequiredDetectDomainLocale$1;
+function requireDetectDomainLocale$1() {
+  if (hasRequiredDetectDomainLocale$1) return detectDomainLocale;
+  hasRequiredDetectDomainLocale$1 = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "detectDomainLocale", {
+      enumerable: true,
+      get: function() {
+        return detectDomainLocale2;
+      }
+    });
+    function detectDomainLocale2(domainItems, hostname, detectedLocale) {
+      if (!domainItems) return;
+      if (detectedLocale) {
+        detectedLocale = detectedLocale.toLowerCase();
+      }
+      for (const item of domainItems) {
+        var _item_domain, _item_locales;
+        const domainHostname = (_item_domain = item.domain) == null ? void 0 : _item_domain.split(":", 1)[0].toLowerCase();
+        if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || ((_item_locales = item.locales) == null ? void 0 : _item_locales.some((locale) => locale.toLowerCase() === detectedLocale))) {
+          return item;
+        }
+      }
+    }
+  })(detectDomainLocale);
+  return detectDomainLocale;
+}
+var hasRequiredDetectDomainLocale;
+function requireDetectDomainLocale() {
+  if (hasRequiredDetectDomainLocale) return detectDomainLocale$1.exports;
+  hasRequiredDetectDomainLocale = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "detectDomainLocale", {
+      enumerable: true,
+      get: function() {
+        return detectDomainLocale2;
+      }
+    });
+    const detectDomainLocale2 = function() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (process.env.__NEXT_I18N_SUPPORT) {
+        return requireDetectDomainLocale$1().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;
+    }
+  })(detectDomainLocale$1, detectDomainLocale$1.exports);
+  return detectDomainLocale$1.exports;
+}
+var hasRequiredGetDomainLocale;
+function requireGetDomainLocale() {
+  if (hasRequiredGetDomainLocale) return getDomainLocale.exports;
+  hasRequiredGetDomainLocale = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "getDomainLocale", {
+      enumerable: true,
+      get: function() {
+        return getDomainLocale2;
+      }
+    });
+    const _normalizetrailingslash = requireNormalizeTrailingSlash();
+    const basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+    function getDomainLocale2(path, locale, locales, domainLocales) {
+      if (process.env.__NEXT_I18N_SUPPORT) {
+        const normalizeLocalePath2 = requireNormalizeLocalePath().normalizeLocalePath;
+        const detectDomainLocale2 = requireDetectDomainLocale().detectDomainLocale;
+        const target = locale || normalizeLocalePath2(path, locales).detectedLocale;
+        const domain = detectDomainLocale2(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;
+    }
+  })(getDomainLocale, getDomainLocale.exports);
+  return getDomainLocale.exports;
+}
+var addBasePath = { exports: {} };
+var hasRequiredAddBasePath;
+function requireAddBasePath() {
+  if (hasRequiredAddBasePath) return addBasePath.exports;
+  hasRequiredAddBasePath = 1;
+  (function(module, exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "addBasePath", {
+      enumerable: true,
+      get: function() {
+        return addBasePath2;
+      }
+    });
+    const _addpathprefix = requireAddPathPrefix();
+    const _normalizetrailingslash = requireNormalizeTrailingSlash();
+    const basePath = process.env.__NEXT_ROUTER_BASEPATH || "";
+    function addBasePath2(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;
+    }
+  })(addBasePath, addBasePath.exports);
+  return addBasePath.exports;
+}
+var errorOnce = {};
+var hasRequiredErrorOnce;
+function requireErrorOnce() {
+  if (hasRequiredErrorOnce) return errorOnce;
+  hasRequiredErrorOnce = 1;
+  (function(exports) {
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    Object.defineProperty(exports, "errorOnce", {
+      enumerable: true,
+      get: function() {
+        return errorOnce2;
+      }
+    });
+    let errorOnce2 = (_) => {
+    };
+    if (process.env.NODE_ENV !== "production") {
+      const errors = /* @__PURE__ */ new Set();
+      errorOnce2 = (msg) => {
+        if (!errors.has(msg)) {
+          console.error(msg);
+        }
+        errors.add(msg);
+      };
+    }
+  })(errorOnce);
+  return errorOnce;
+}
+(function(module, exports) {
+  "use client";
+  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;
+    }
+  });
+  const _interop_require_wildcard2 = _interop_require_wildcard$1;
+  const _jsxruntime = require$$2;
+  const _react = /* @__PURE__ */ _interop_require_wildcard2._(React);
+  const _resolvehref = requireResolveHref();
+  const _islocalurl = requireIsLocalUrl();
+  const _formaturl = requireFormatUrl();
+  const _utils = requireUtils$1();
+  const _addlocale = requireAddLocale();
+  const _routercontextsharedruntime = requireRouterContext_sharedRuntime();
+  const _useintersection = requireUseIntersection();
+  const _getdomainlocale = requireGetDomainLocale();
+  const _addbasepath = requireAddBasePath();
+  const _usemergedref = requireUseMergedRef();
+  const _erroronce = requireErrorOnce();
+  const 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 (process.env.NODE_ENV !== "production") {
+        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 != null ? 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);
+  }
+  const 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 (process.env.NODE_ENV !== "production") {
+      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]
+            });
+          }
+        }
+      });
+      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 === "prefetch" || key === "legacyBehavior") {
+          if (props[key] != null && valType !== "boolean") {
+            throw createPropError({
+              key,
+              expected: "`boolean`",
+              actual: valType
+            });
+          }
+        } else ;
+      });
+    }
+    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 (process.env.NODE_ENV === "development") {
+        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 (process.env.NODE_ENV === "development") {
+        if ((children == null ? void 0 : 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 (process.env.NODE_ENV !== "production") {
+        return;
+      }
+      if (!router) {
+        return;
+      }
+      if (!isVisible || !prefetchEnabled) {
+        return;
+      }
+      prefetch(router, href, as, {
+        locale
+      });
+    }, [
+      as,
+      href,
+      isVisible,
+      locale,
+      prefetchEnabled,
+      router == null ? void 0 : router.locale,
+      router
+    ]);
+    const childProps = {
+      ref: setRef,
+      onClick(e) {
+        if (process.env.NODE_ENV !== "production") {
+          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 == null ? void 0 : router.locale;
+      const localeDomain = (router == null ? void 0 : router.isLocaleDomain) && (0, _getdomainlocale.getDomainLocale)(as, curLocale, router == null ? void 0 : router.locales, router == null ? void 0 : router.domainLocales);
+      childProps.href = localeDomain || (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(as, curLocale, router == null ? void 0 : router.defaultLocale));
+    }
+    if (legacyBehavior) {
+      if (process.env.NODE_ENV === "development") {
+        (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
+    });
+  });
+  const LinkStatusContext = /* @__PURE__ */ (0, _react.createContext)({
+    // We do not support link status in the Pages Router, so we always return false
+    pending: false
+  });
+  const useLinkStatus = () => {
+    return (0, _react.useContext)(LinkStatusContext);
+  };
+  const _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;
+  }
+})(link$1, link$1.exports);
+var linkExports = link$1.exports;
+var link = linkExports;
+const Link = /* @__PURE__ */ getDefaultExportFromCjs(link);
+export {
+  Link as L,
+  _interop_require_default$1 as _,
+  _interop_require_wildcard$1 as a,
+  requireUseMergedRef as b,
+  getDefaultExportFromCjs as g,
+  requireRouterContext_sharedRuntime as r,
+  segment as s
+};
+//# sourceMappingURL=link-CX77u6b-.js.map