lkd-web-kit 0.0.0 → 0.0.1

package/dist/index9.js

@@ -0,0 +1,3395 @@
+import require$$1, { jsx, jsxs } from 'react/jsx-runtime';
+import { Center, Loader, useCombobox, Combobox, InputBase, Input, ScrollArea, Stack, NavLink } from '@mantine/core';
+import require$$0, { useRef } from 'react';
+import { u as useFetchNextPageOnScroll } from './useFetchNextPageOnScroll-08q9N5OE.js';
+import { r as require_interop_require_wildcard, a as requireSegment, b as require_interop_require_default, n as navigationExports } from './navigation-sZaWnl2V.js';
+
+function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
+
+const Icon = ({
+  i: I,
+  size = "md",
+  style,
+  rotate,
+  className,
+  ...rest
+}) => {
+  return /* @__PURE__ */ jsx(
+    I,
+    {
+      ...typeof size === "number" ? {
+        height: size,
+        width: size
+      } : stylesBySize[size],
+      viewBox: "0 0 24 24",
+      style: {
+        ...style,
+        transform: `rotate(${rotate}deg)`
+      },
+      className: clsx("shrink-0", className),
+      ...rest
+    }
+  );
+};
+const stylesBySize = {
+  xs: {
+    height: 16,
+    width: 16
+  },
+  sm: {
+    height: 20,
+    width: 20
+  },
+  md: {
+    height: 24,
+    width: 24
+  },
+  lg: {
+    height: 28,
+    width: 28
+  },
+  xl: {
+    height: 32,
+    width: 32
+  },
+  ["2xl"]: {
+    height: 40,
+    width: 40
+  }
+};
+
+const pxBySize = {
+  sm: 48,
+  md: 60,
+  lg: 84
+};
+const EmptyState = ({
+  label,
+  action,
+  icon,
+  className,
+  size = "md",
+  ...props
+}) => {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: clsx("justfiy-center flex flex-col items-center gap-1", className),
+      ...props,
+      children: [
+        /* @__PURE__ */ jsx(
+          Icon,
+          {
+            i: icon,
+            size: pxBySize[size],
+            className: "text-gray-2"
+          }
+        ),
+        /* @__PURE__ */ jsx("p", { className: "text-gray-6 text-sm font-semibold", children: label }),
+        /* @__PURE__ */ jsx("div", { children: action })
+      ]
+    }
+  );
+};
+
+const InfinityLoader = ({ infinity, loaderProps, ...props }) => {
+  return /* @__PURE__ */ jsx(Center, { ...props, children: infinity.isFetching ? /* @__PURE__ */ jsx(Loader, { ...loaderProps }) : !infinity.hasNextPage && (infinity.data?.pages.length ?? 0) > 1 && /* @__PURE__ */ jsx("p", { children: "No hay más resultados" }) });
+};
+
+function SelectInfinity({
+  value,
+  onChange,
+  data = [],
+  searchValue,
+  onSearchChange,
+  renderOption,
+  onOptionSubmit,
+  nothingFoundMessage,
+  infinity,
+  placeholder,
+  ...props
+}) {
+  const combobox = useCombobox({
+    onDropdownClose: () => {
+      combobox.resetSelectedOption();
+      combobox.focusTarget();
+      onSearchChange?.("");
+    },
+    onDropdownOpen: () => {
+      combobox.focusSearchInput();
+    }
+  });
+  const options = data.map((i) => /* @__PURE__ */ jsx(
+    Combobox.Option,
+    {
+      value: i.value,
+      children: renderOption ? renderOption({ option: i }) : i.label
+    },
+    i.value
+  ));
+  const selectedOption = data.find((i) => i.value === value);
+  const scrollAreaRef = useRef(null);
+  useFetchNextPageOnScroll(infinity, scrollAreaRef);
+  return /* @__PURE__ */ jsxs(
+    Combobox,
+    {
+      store: combobox,
+      middlewares: {
+        shift: {
+          crossAxis: true
+        }
+      },
+      onOptionSubmit: (val) => {
+        onChange?.(val);
+        onOptionSubmit?.(val);
+        combobox.closeDropdown();
+      },
+      children: [
+        /* @__PURE__ */ jsx(Combobox.Target, { children: /* @__PURE__ */ jsx(
+          InputBase,
+          {
+            component: "button",
+            type: "button",
+            pointer: true,
+            rightSection: /* @__PURE__ */ jsx(Combobox.Chevron, {}),
+            onClick: () => combobox.toggleDropdown(),
+            rightSectionPointerEvents: "none",
+            ...props,
+            children: selectedOption?.label || /* @__PURE__ */ jsx(Input.Placeholder, { children: placeholder })
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(Combobox.Dropdown, { children: [
+          /* @__PURE__ */ jsx(
+            Combobox.Search,
+            {
+              value: searchValue,
+              onChange: (event) => onSearchChange?.(event.currentTarget.value),
+              placeholder: "Escribe para buscar"
+            }
+          ),
+          /* @__PURE__ */ jsx(Combobox.Options, { children: /* @__PURE__ */ jsxs(
+            ScrollArea.Autosize,
+            {
+              mah: 200,
+              type: "scroll",
+              viewportRef: scrollAreaRef,
+              children: [
+                options.length > 0 ? options : !infinity.isFetching ? /* @__PURE__ */ jsx(
+                  Combobox.Empty,
+                  {
+                    onClick: () => combobox.closeDropdown(),
+                    className: "min-h-6",
+                    children: nothingFoundMessage ?? "Sin resultados"
+                  }
+                ) : null,
+                /* @__PURE__ */ jsx(
+                  InfinityLoader,
+                  {
+                    className: "text-sm",
+                    infinity,
+                    loaderProps: {
+                      size: "sm",
+                      className: "mt-1 mb-2"
+                    }
+                  }
+                )
+              ]
+            }
+          ) })
+        ] })
+      ]
+    }
+  );
+}
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+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 formatUrl;
+		    },
+		    formatWithValidation: function() {
+		        return formatWithValidation;
+		    },
+		    urlObjectKeys: function() {
+		        return urlObjectKeys;
+		    }
+		});
+		const _interop_require_wildcard = /*@__PURE__*/ require_interop_require_wildcard();
+		const _querystring = /*#__PURE__*/ _interop_require_wildcard._(requireQuerystring());
+		const slashedProtocols = /https?|ftp|gopher|file/;
+		function formatUrl(urlObj) {
+		    let { auth, hostname } = urlObj;
+		    let protocol = urlObj.protocol || '';
+		    let pathname = urlObj.pathname || '';
+		    let hash = urlObj.hash || '';
+		    let query = urlObj.query || '';
+		    let host = false;
+		    auth = auth ? encodeURIComponent(auth).replace(/%3A/i, ':') + '@' : '';
+		    if (urlObj.host) {
+		        host = auth + urlObj.host;
+		    } else if (hostname) {
+		        host = auth + (~hostname.indexOf(':') ? "[" + hostname + "]" : hostname);
+		        if (urlObj.port) {
+		            host += ':' + urlObj.port;
+		        }
+		    }
+		    if (query && typeof query === 'object') {
+		        query = String(_querystring.urlQueryToSearchParams(query));
+		    }
+		    let search = urlObj.search || query && "?" + query || '';
+		    if (protocol && !protocol.endsWith(':')) protocol += ':';
+		    if (urlObj.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
+		        host = '//' + (host || '');
+		        if (pathname && pathname[0] !== '/') pathname = '/' + pathname;
+		    } else if (!host) {
+		        host = '';
+		    }
+		    if (hash && hash[0] !== '#') hash = '#' + hash;
+		    if (search && search[0] !== '?') search = '?' + search;
+		    pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+		    search = search.replace('#', '%23');
+		    return "" + protocol + host + pathname + search + hash;
+		}
+		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 formatUrl(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 omit;
+		    }
+		});
+		function omit(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;
+		    };
+		}
+		// Scheme: https://tools.ietf.org/html/rfc3986#section-3.1
+		// Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3
+		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// first we replace any non-encoded backslashes with forward
+		    // then normalize repeated forward slashes
+		    .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
+		            });
+		        }
+		    }
+		    // when called from _app `ctx` is nested in `ctx`
+		    const res = ctx.res || ctx.ctx && ctx.ctx.res;
+		    if (!App.getInitialProps) {
+		        if (ctx.ctx && ctx.Component) {
+		            // @ts-ignore pageProps default
+		            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 = {};
+
+/**
+ * Removes the trailing slash for a given route or page path. Preserves the
+ * root page. Examples:
+ *   - `/foo/bar/` -> `/foo/bar`
+ *   - `/foo/bar` -> `/foo/bar`
+ *   - `/` -> `/`
+ */
+
+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 removeTrailingSlash;
+		    }
+		});
+		function removeTrailingSlash(route) {
+		    return route.replace(/\/$/, '') || '/';
+		}
+
+		
+	} (removeTrailingSlash));
+	return removeTrailingSlash;
+}
+
+var parsePath = {};
+
+/**
+ * Given a path this function will find the pathname, query and hash and return
+ * them. This is useful to parse full paths on the client side.
+ * @param path A path to parse e.g. /foo/bar?id=1#hash
+ */
+
+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 parsePath;
+		    }
+		});
+		function parsePath(path) {
+		    const hashIndex = path.indexOf('#');
+		    const queryIndex = path.indexOf('?');
+		    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
+		    if (hasQuery || hashIndex > -1) {
+		        return {
+		            pathname: path.substring(0, hasQuery ? queryIndex : hashIndex),
+		            query: hasQuery ? path.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined) : '',
+		            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 pathHasPrefix;
+		    }
+		});
+		const _parsepath = requireParsePath();
+		function pathHasPrefix(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 hasBasePath;
+		    }
+		});
+		const _pathhasprefix = requirePathHasPrefix();
+		const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+		function hasBasePath(path) {
+		    return (0, _pathhasprefix.pathHasPrefix)(path, basePath);
+		}
+
+		if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports.default, '__esModule', { value: true });
+		  Object.assign(exports.default, exports);
+		  module.exports = exports.default;
+		}
+
+		
+	} (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) {
+		    // prevent a hydration mismatch on href for url with anchor refs
+		    if (!(0, _utils.isAbsoluteUrl)(url)) return true;
+		    try {
+		        // absolute urls can be local if they are on the same origin
+		        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
+		            });
+		        }
+		        // The next segment in the urlPaths list
+		        let nextSegment = urlPaths[0];
+		        // Check if the segment matches `[something]`
+		        if (nextSegment.startsWith('[') && nextSegment.endsWith(']')) {
+		            // Strip `[` and `]`, leaving only `something`
+		            let segmentName = nextSegment.slice(1, -1);
+		            let isOptional = false;
+		            if (segmentName.startsWith('[') && segmentName.endsWith(']')) {
+		                // Strip optional `[` and `]`, leaving only `something`
+		                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('...')) {
+		                // Strip `...`, leaving only `something`
+		                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
+		                });
+		            }
+		            function handleSlug(previousSlug, nextSlug) {
+		                if (previousSlug !== null) {
+		                    // If the specific segment already has a slug but the slug is not `something`
+		                    // This prevents collisions like:
+		                    // pages/[post]/index.js
+		                    // pages/[id]/index.js
+		                    // Because currently multiple dynamic params on the same segment level are not supported
+		                    if (previousSlug !== nextSlug) {
+		                        // TODO: This error seems to be confusing for users, needs an error link, the description can be based on above comment.
+		                        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);
+		            }
+		            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);
+		                    // slugName is kept as it can only be one particular slugName
+		                    this.optionalRestSlugName = segmentName;
+		                    // nextSegment is overwritten to [[...]] so that it can later be sorted specifically
+		                    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);
+		                    // slugName is kept as it can only be one particular slugName
+		                    this.restSlugName = segmentName;
+		                    // nextSegment is overwritten to [...] so that it can later be sorted specifically
+		                    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);
+		                // slugName is kept as it can only be one particular slugName
+		                this.slugName = segmentName;
+		                // nextSegment is overwritten to [] so that it can later be sorted specifically
+		                nextSegment = '[]';
+		            }
+		        }
+		        // If this UrlNode doesn't have the nextSegment yet we create a new child UrlNode
+		        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 = new Map();
+		        this.slugName = null;
+		        this.restSlugName = null;
+		        this.optionalRestSlugName = null;
+		    }
+		}
+		function getSortedRoutes(normalizedPages) {
+		    // First the UrlNode is created, and every UrlNode can have only 1 dynamic segment
+		    // Eg you can't have pages/[post]/abc.js and pages/[hello]/something-else.js
+		    // Only 1 dynamic segment per nesting level
+		    // So in the case that is test/integration/dynamic-routing it'll be this:
+		    // pages/[post]/comments.js
+		    // pages/blog/[post]/comment/[id].js
+		    // Both are fine because `pages/[post]` and `pages/blog` are on the same level
+		    // So in this case `UrlNode` created here has `this.slugName === 'post'`
+		    // And since your PR passed through `slugName` as an array basically it'd including it in too many possibilities
+		    // Instead what has to be passed through is the upwards path's dynamic names
+		    const root = new UrlNode();
+		    // Here the `root` gets injected multiple paths, and insert will break them up into sublevels
+		    normalizedPages.forEach((pagePath)=>root.insert(pagePath));
+		    // Smoosh will then sort those sublevels up to the point where you get the correct route definition priority
+		    return root.smoosh();
+		}
+		function getSortedRouteObjects(objects, getter) {
+		    // We're assuming here that all the pathnames are unique, that way we can
+		    // sort the list and use the index as the key.
+		    const indexes = {};
+		    const pathnames = [];
+		    for(let i = 0; i < objects.length; i++){
+		        const pathname = getter(objects[i]);
+		        indexes[pathname] = i;
+		        pathnames[i] = pathname;
+		    }
+		    // Sort the pathnames.
+		    const sorted = getSortedRoutes(pathnames);
+		    // Map the sorted pathnames back to the original objects using the new sorted
+		    // index.
+		    return sorted.map((pathname)=>objects[indexes[pathname]]);
+		}
+
+		
+	} (sortedRoutes));
+	return sortedRoutes;
+}
+
+var isDynamic = {};
+
+var interceptionRoutes = {};
+
+var appPaths = {};
+
+var ensureLeadingSlash = {};
+
+/**
+ * For a given page path, this function ensures that there is a leading slash.
+ * If there is not a leading slash, one is added, otherwise it is noop.
+ */
+
+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 ensureLeadingSlash;
+		    }
+		});
+		function ensureLeadingSlash(path) {
+		    return path.startsWith('/') ? path : "/" + path;
+		}
+
+		
+	} (ensureLeadingSlash));
+	return ensureLeadingSlash;
+}
+
+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 = requireSegment();
+		function normalizeAppPath(route) {
+		    return (0, _ensureleadingslash.ensureLeadingSlash)(route.split('/').reduce((pathname, segment, index, segments)=>{
+		        // Empty segments are ignored.
+		        if (!segment) {
+		            return pathname;
+		        }
+		        // Groups are ignored.
+		        if ((0, _segment.isGroupSegment)(segment)) {
+		            return pathname;
+		        }
+		        // Parallel segments are ignored.
+		        if (segment[0] === '@') {
+		            return pathname;
+		        }
+		        // The last segment (if it's a leaf) should be ignored.
+		        if ((segment === 'page' || segment === 'route') && index === segments.length - 1) {
+		            return pathname;
+		        }
+		        return pathname + "/" + segment;
+		    }, ''));
+		}
+		function normalizeRscURL(url) {
+		    return url.replace(/\.rsc($|\?)/, // $1 ensures `?` is preserved
+		    '$1');
+		}
+
+		
+	} (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) {
+		    // TODO-APP: add more serious validation
+		    return path.split('/').find((segment)=>INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m))) !== undefined;
+		}
+		function extractInterceptionRouteInformation(path) {
+		    let interceptingRoute, marker, interceptedRoute;
+		    for (const segment of path.split('/')){
+		        marker = INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+		        if (marker) {
+		            [interceptingRoute, interceptedRoute] = path.split(marker, 2);
+		            break;
+		        }
+		    }
+		    if (!interceptingRoute || !marker || !interceptedRoute) {
+		        throw Object.defineProperty(new Error("Invalid interception route: " + path + ". Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>"), "__NEXT_ERROR_CODE", {
+		            value: "E269",
+		            enumerable: false,
+		            configurable: true
+		        });
+		    }
+		    interceptingRoute = (0, _apppaths.normalizeAppPath)(interceptingRoute) // normalize the path, e.g. /(blog)/feed -> /feed
+		    ;
+		    switch(marker){
+		        case '(.)':
+		            // (.) indicates that we should match with sibling routes, so we just need to append the intercepted route to the intercepting route
+		            if (interceptingRoute === '/') {
+		                interceptedRoute = "/" + interceptedRoute;
+		            } else {
+		                interceptedRoute = interceptingRoute + '/' + interceptedRoute;
+		            }
+		            break;
+		        case '(..)':
+		            // (..) indicates that we should match at one level up, so we need to remove the last segment of the intercepting route
+		            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 '(...)':
+		            // (...) will match the route segment in the root directory, so we need to use the root directory to prepend the intercepted route
+		            interceptedRoute = '/' + interceptedRoute;
+		            break;
+		        case '(..)(..)':
+		            // (..)(..) indicates that we should match at two levels up, so we need to remove the last two segments of the intercepting route
+		            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();
+		// Identify /.*[param].*/ in route string
+		const TEST_ROUTE = /\/[^/]*\[[^/]+\][^/]*(?=\/|$)/;
+		// Identify /[param]/ in route string
+		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 = (param)=>{
+		            try {
+		                return decodeURIComponent(param);
+		            } 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 !== undefined) {
+		                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 = 31536000;
+		const INFINITE_CACHE = 0xfffffffe;
+		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.\n' + 'Please 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'
+		};
+		/**
+		 * The names of the webpack layers. These layers are the primitives for the
+		 * webpack chunks.
+		 */ 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) {
+		    // see also: https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/escapeRegExp.js#L23
+		    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();
+		/**
+		 * Regular expression pattern used to match route parameters.
+		 * Matches both single parameters and parameter groups.
+		 * Examples:
+		 *   - `[[...slug]]` matches parameter group with key 'slug', repeat: true, optional: true
+		 *   - `[...slug]` matches parameter group with key 'slug', repeat: true, optional: false
+		 *   - `[[foo]]` matches parameter with key 'foo', repeat: false, optional: true
+		 *   - `[bar]` matches parameter with key 'bar', repeat: false, optional: false
+		 */ const PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+		function parseParameter(param) {
+		    const match = param.match(PARAMETER_PATTERN);
+		    if (!match) {
+		        return parseMatchedParameter(param);
+		    }
+		    return parseMatchedParameter(match[2]);
+		}
+		/**
+		 * Parses a matched parameter from the PARAMETER_PATTERN regex to a data structure that can be used
+		 * to generate the parametrized route.
+		 * Examples:
+		 *   - `[...slug]` -> `{ key: 'slug', repeat: true, optional: true }`
+		 *   - `...slug` -> `{ key: 'slug', repeat: true, optional: false }`
+		 *   - `[foo]` -> `{ key: 'foo', repeat: false, optional: true }`
+		 *   - `bar` -> `{ key: 'bar', repeat: false, optional: false }`
+		 * @param param - The matched parameter to parse.
+		 * @returns The parsed parameter as a data structure.
+		 */ 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 segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split('/')){
+		        const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+		        const paramMatches = segment.match(PARAMETER_PATTERN) // Check for parameters
+		        ;
+		        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 ? '(?:/(.+?))?' : '/(.+?)' : '/([^/]+?)';
+		            // Remove the leading slash if includePrefix already added it.
+		            if (includePrefix && paramMatches[1]) {
+		                s = s.substring(1);
+		            }
+		            segments.push(s);
+		        } else {
+		            segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(segment));
+		        }
+		        // If there's a suffix, add it to the segments if it's enabled.
+		        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: groups
+		    };
+		}
+		/**
+		 * Builds a function to generate a minimal routeKey using only a-z and minimal
+		 * number of characters.
+		 */ 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, routeKeys, keyPrefix, backreferenceDuplicateKeys } = param;
+		    const { key, optional, repeat } = parseMatchedParameter(segment);
+		    // replace any non-word characters since they can break
+		    // the named regex
+		    let cleanedKey = key.replace(/\W/g, '');
+		    if (keyPrefix) {
+		        cleanedKey = "" + keyPrefix + cleanedKey;
+		    }
+		    let invalidKey = false;
+		    // check if the key is still invalid and fallback to using a known
+		    // safe key
+		    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;
+		    }
+		    // if the segment has an interception marker, make sure that's part of the regex pattern
+		    // this is to ensure that the route with the interception marker doesn't incorrectly match
+		    // the non-intercepted route (ie /app/(.)[username] should not match /app/[username])
+		    const interceptionPrefix = interceptionMarker ? (0, _escaperegexp.escapeStringRegexp)(interceptionMarker) : '';
+		    let pattern;
+		    if (duplicateKey && backreferenceDuplicateKeys) {
+		        // Use a backreference to the key to ensure that the key is the same value
+		        // in each of the placeholders.
+		        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 segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split('/')){
+		        const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m)=>segment.startsWith(m));
+		        const paramMatches = segment.match(PARAMETER_PATTERN) // Check for parameters
+		        ;
+		        if (hasInterceptionMarker && paramMatches && paramMatches[2]) {
+		            // If there's an interception marker, add it to the segments.
+		            segments.push(getSafeKeyFromSegment({
+		                getSafeRouteKey,
+		                interceptionMarker: paramMatches[1],
+		                segment: paramMatches[2],
+		                routeKeys,
+		                keyPrefix: prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : undefined,
+		                backreferenceDuplicateKeys
+		            }));
+		        } else if (paramMatches && paramMatches[2]) {
+		            // If there's a prefix, add it to the segments if it's enabled.
+		            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 : undefined,
+		                backreferenceDuplicateKeys
+		            });
+		            // Remove the leading slash if includePrefix already added it.
+		            if (includePrefix && paramMatches[1]) {
+		                s = s.substring(1);
+		            }
+		            segments.push(s);
+		        } else {
+		            segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(segment));
+		        }
+		        // If there's a suffix, add it to the segments if it's enabled.
+		        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 interpolateAs;
+		    }
+		});
+		const _routematcher = requireRouteMatcher();
+		const _routeregex = requireRouteRegex();
+		function interpolateAs(route, asPathname, query) {
+		    let interpolatedRoute = '';
+		    const dynamicRegex = (0, _routeregex.getRouteRegex)(route);
+		    const dynamicGroups = dynamicRegex.groups;
+		    const dynamicMatches = // Try to match the dynamic route against the asPath
+		    (asPathname !== route ? (0, _routematcher.getRouteMatcher)(dynamicRegex)(asPathname) : '') || // Fall back to reading the values from the href
+		    // TODO: should this take priority; also need to change in the router.
+		    query;
+		    interpolatedRoute = route;
+		    const params = Object.keys(dynamicGroups);
+		    if (!params.every((param)=>{
+		        let value = dynamicMatches[param] || '';
+		        const { repeat, optional } = dynamicGroups[param];
+		        // support single-level catch-all
+		        // TODO: more robust handling for user-error (passing `/`)
+		        let replaced = "[" + (repeat ? '...' : '') + param + "]";
+		        if (optional) {
+		            replaced = (!value ? '/' : '') + "[" + replaced + "]";
+		        }
+		        if (repeat && !Array.isArray(value)) value = [
+		            value
+		        ];
+		        return (optional || param in dynamicMatches) && // Interpolate group into data URL if present
+		        (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map(// these values should be fully encoded instead of just
+		        // path delimiter escaped since they are being inserted
+		        // into the URL and we expect URL encoded segments
+		        // when parsing dynamic route params
+		        (segment)=>encodeURIComponent(segment)).join('/') : encodeURIComponent(value)) || '/');
+		    })) {
+		        interpolatedRoute = '' // did not satisfy all requirements
+		        ;
+		    // n.b. We ignore this error because we handle warning for this case in
+		    // development in the `<Link>` component directly.
+		    }
+		    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 resolveHref;
+		    }
+		});
+		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 resolveHref(router, href, resolveAs) {
+		    // we use a dummy base url for relative urls
+		    let base;
+		    let urlAsString = typeof href === 'string' ? href : (0, _formaturl.formatWithValidation)(href);
+		    // repeated slashes and backslashes in the URL are considered
+		    // invalid and will never match a Next.js page/file
+		    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;
+		    }
+		    // Return because it cannot be routed by the Next.js router
+		    if (!(0, _islocalurl.isLocalURL)(urlAsString)) {
+		        return resolveAs ? [
+		            urlAsString
+		        ] : urlAsString;
+		    }
+		    try {
+		        base = new URL(urlAsString.startsWith('#') ? router.asPath : router.pathname, 'http://n');
+		    } catch (_) {
+		        // fallback to / for invalid asPath values e.g. //
+		        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)
+		                });
+		            }
+		        }
+		        // if the origin didn't change, it means we received a relative href
+		        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 addPathPrefix;
+		    }
+		});
+		const _parsepath = requireParsePath();
+		function addPathPrefix(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 addLocale;
+		    }
+		});
+		const _addpathprefix = requireAddPathPrefix();
+		const _pathhasprefix = requirePathHasPrefix();
+		function addLocale(path, locale, defaultLocale, ignorePrefix) {
+		    // If no locale was given or the locale is the default locale, we don't need
+		    // to prefix the path.
+		    if (!locale || locale === defaultLocale) return path;
+		    const lower = path.toLowerCase();
+		    // If the path is an API path or the path already has the locale prefix, we
+		    // don't need to prefix the path.
+		    if (!ignorePrefix) {
+		        if ((0, _pathhasprefix.pathHasPrefix)(lower, '/api')) return path;
+		        if ((0, _pathhasprefix.pathHasPrefix)(lower, "/" + locale.toLowerCase())) return path;
+		    }
+		    // Add the locale prefix to the 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 addLocale;
+		    }
+		});
+		const _normalizetrailingslash = requireNormalizeTrailingSlash();
+		const addLocale = 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 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_default = /*@__PURE__*/ require_interop_require_default();
+		const _react = /*#__PURE__*/ _interop_require_default._(require$$0);
+		const RouterContext = _react.default.createContext(null);
+		if (process.env.NODE_ENV !== 'production') {
+		    RouterContext.displayName = 'RouterContext';
+		}
+
+		
+	} (routerContext_sharedRuntime));
+	return routerContext_sharedRuntime;
+}
+
+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 requestIdleCallback;
+		    }
+		});
+		const requestIdleCallback = typeof self !== 'undefined' && self.requestIdleCallback && self.requestIdleCallback.bind(window) || function(cb) {
+		    let start = Date.now();
+		    return self.setTimeout(function() {
+		        cb({
+		            didTimeout: false,
+		            timeRemaining: function() {
+		                return Math.max(0, 50 - (Date.now() - start));
+		            }
+		        });
+		    }, 1);
+		};
+		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 useIntersection;
+		    }
+		});
+		const _react = require$$0;
+		const _requestidlecallback = requireRequestIdleCallback();
+		const hasIntersectionObserver = typeof IntersectionObserver === 'function';
+		const observers = 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 = 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);
+		        // Destroy observer when there's nothing left to watch:
+		        if (elements.size === 0) {
+		            observer.disconnect();
+		            observers.delete(id);
+		            const index = idList.findIndex((obj)=>obj.root === id.root && obj.margin === id.margin);
+		            if (index > -1) {
+		                idList.splice(index, 1);
+		            }
+		        }
+		    };
+		}
+		function useIntersection(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);
+		            }
+		        }
+		    // eslint-disable-next-line react-hooks/exhaustive-deps
+		    }, [
+		        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 normalizeLocalePath;
+		    }
+		});
+		/**
+		 * A cache of lowercased locales for each list of locales. This is stored as a
+		 * WeakMap so if the locales are garbage collected, the cache entry will be
+		 * removed as well.
+		 */ const cache = new WeakMap();
+		function normalizeLocalePath(pathname, locales) {
+		    // If locales is undefined, return the pathname as is.
+		    if (!locales) return {
+		        pathname
+		    };
+		    // Get the cached lowercased locales or create a new cache entry.
+		    let lowercasedLocales = cache.get(locales);
+		    if (!lowercasedLocales) {
+		        lowercasedLocales = locales.map((locale)=>locale.toLowerCase());
+		        cache.set(locales, lowercasedLocales);
+		    }
+		    let detectedLocale;
+		    // The first segment will be empty, because it has a leading `/`. If
+		    // there is no further segment, there is no locale (or it's the default).
+		    const segments = pathname.split('/', 2);
+		    // If there's no second segment (ie, the pathname is just `/`), there's no
+		    // locale.
+		    if (!segments[1]) return {
+		        pathname
+		    };
+		    // The second segment will contain the locale part if any.
+		    const segment = segments[1].toLowerCase();
+		    // See if the segment matches one of the locales. If it doesn't, there is
+		    // no locale (or it's the default).
+		    const index = lowercasedLocales.indexOf(segment);
+		    if (index < 0) return {
+		        pathname
+		    };
+		    // Return the case-sensitive locale.
+		    detectedLocale = locales[index];
+		    // Remove the `/${locale}` part of the pathname.
+		    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 normalizeLocalePath;
+		    }
+		});
+		const normalizeLocalePath = (pathname, locales)=>{
+		    if (process.env.__NEXT_I18N_SUPPORT) {
+		        return requireNormalizeLocalePath$1().normalizeLocalePath(pathname, locales);
+		    }
+		    return {
+		        pathname,
+		        detectedLocale: undefined
+		    };
+		};
+
+		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 detectDomainLocale;
+		    }
+		});
+		function detectDomainLocale(domainItems, hostname, detectedLocale) {
+		    if (!domainItems) return;
+		    if (detectedLocale) {
+		        detectedLocale = detectedLocale.toLowerCase();
+		    }
+		    for (const item of domainItems){
+		        var _item_domain, _item_locales;
+		        // remove port if present
+		        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 detectDomainLocale;
+		    }
+		});
+		const detectDomainLocale = 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 getDomainLocale;
+		    }
+		});
+		const _normalizetrailingslash = requireNormalizeTrailingSlash();
+		const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+		function getDomainLocale(path, locale, locales, domainLocales) {
+		    if (process.env.__NEXT_I18N_SUPPORT) {
+		        const normalizeLocalePath = requireNormalizeLocalePath().normalizeLocalePath;
+		        const detectDomainLocale = requireDetectDomainLocale().detectDomainLocale;
+		        const target = locale || normalizeLocalePath(path, locales).detectedLocale;
+		        const domain = detectDomainLocale(domainLocales, undefined, 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 addBasePath;
+		    }
+		});
+		const _addpathprefix = requireAddPathPrefix();
+		const _normalizetrailingslash = requireNormalizeTrailingSlash();
+		const basePath = process.env.__NEXT_ROUTER_BASEPATH || '';
+		function addBasePath(path, required) {
+		    return (0, _normalizetrailingslash.normalizePathTrailingSlash)(process.env.__NEXT_MANUAL_CLIENT_BASE_PATH && !required ? path : (0, _addpathprefix.addPathPrefix)(path, basePath));
+		}
+
+		if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+		  Object.defineProperty(exports.default, '__esModule', { value: true });
+		  Object.assign(exports.default, exports);
+		  module.exports = exports.default;
+		}
+
+		
+	} (addBasePath, addBasePath.exports));
+	return addBasePath.exports;
+}
+
+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 useMergedRef;
+		    }
+		});
+		const _react = require$$0;
+		function useMergedRef(refA, refB) {
+		    const cleanupA = (0, _react.useRef)(null);
+		    const cleanupB = (0, _react.useRef)(null);
+		    // NOTE: In theory, we could skip the wrapping if only one of the refs is non-null.
+		    // (this happens often if the user doesn't pass a ref to Link/Form/Image)
+		    // But this can cause us to leak a cleanup-ref into user code (e.g. via `<Link legacyBehavior>`),
+		    // and the user might pass that ref into ref-merging library that doesn't support cleanup refs
+		    // (because it hasn't been updated for React 19)
+		    // which can then cause things to blow up, because a cleanup-returning ref gets called with `null`.
+		    // So in practice, it's safer to be defensive and always wrap the ref, even on React 19.
+		    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 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 errorOnce;
+		    }
+		});
+		let errorOnce = (_)=>{};
+		if (process.env.NODE_ENV !== 'production') {
+		    const errors = new Set();
+		    errorOnce = (msg)=>{
+		        if (!errors.has(msg)) {
+		            console.error(msg);
+		        }
+		        errors.add(msg);
+		    };
+		}
+
+		
+	} (errorOnce));
+	return errorOnce;
+}
+
+var hasRequiredLink$1;
+
+function requireLink$1 () {
+	if (hasRequiredLink$1) return link$1.exports;
+	hasRequiredLink$1 = 1;
+	(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_wildcard = /*@__PURE__*/ require_interop_require_wildcard();
+		const _jsxruntime = require$$1;
+		const _react = /*#__PURE__*/ _interop_require_wildcard._(require$$0);
+		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 = new Set();
+		function prefetch(router, href, as, options) {
+		    if (typeof window === 'undefined') {
+		        return;
+		    }
+		    if (!(0, _islocalurl.isLocalURL)(href)) {
+		        return;
+		    }
+		    // We should only dedupe requests when experimental.optimisticClientCache is
+		    // disabled.
+		    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 : undefined;
+		        const prefetchedKey = href + '%' + as + '%' + locale;
+		        // If we've already fetched the key, then don't prefetch it again!
+		        if (prefetched.has(prefetchedKey)) {
+		            return;
+		        }
+		        // Mark this URL as prefetched.
+		        prefetched.add(prefetchedKey);
+		    }
+		    // Prefetch the JSON page if asked (only in the client)
+		    // We need to handle a prefetch error here since we may be
+		    // loading with priority which can reject but we don't
+		    // want to force navigation since this is only a prefetch
+		    router.prefetch(href, as, options).catch((err)=>{
+		        if (process.env.NODE_ENV !== 'production') {
+		            // rethrow to show invalid URL errors
+		            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;
+		    // anchors inside an svg have a lowercase nodeName
+		    const isAnchorNodeName = nodeName.toUpperCase() === 'A';
+		    if (isAnchorNodeName && isModifiedEvent(e) || e.currentTarget.hasAttribute('download')) {
+		        // ignore click for browser’s default behavior
+		        return;
+		    }
+		    if (!(0, _islocalurl.isLocalURL)(href)) {
+		        if (replace) {
+		            // browser default behavior does not replace the history state
+		            // so we need to do it manually
+		            e.preventDefault();
+		            location.replace(href);
+		        }
+		        // ignore click for browser’s default behavior
+		        return;
+		    }
+		    e.preventDefault();
+		    const navigate = ()=>{
+		        if (onNavigate) {
+		            let isDefaultPrevented = false;
+		            onNavigate({
+		                preventDefault: ()=>{
+		                    isDefaultPrevented = true;
+		                }
+		            });
+		            if (isDefaultPrevented) {
+		                return;
+		            }
+		        }
+		        // If the router is an NextRouter instance it will have `beforePopState`
+		        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);
+		}
+		/**
+		 * A React component that extends the HTML `<a>` element to provide [prefetching](https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating#2-prefetching)
+		 * and client-side navigation between routes.
+		 *
+		 * It is the primary way to navigate between routes in Next.js.
+		 *
+		 * Read more: [Next.js docs: `<Link>`](https://nextjs.org/docs/app/api-reference/components/link)
+		 */ const Link = /*#__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: children
+		        });
+		    }
+		    const router = _react.default.useContext(_routercontextsharedruntime.RouterContext);
+		    const prefetchEnabled = prefetchProp !== false;
+		    if (process.env.NODE_ENV !== 'production') {
+		        function createPropError(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
+		            });
+		        }
+		        // TypeScript trick for type-guarding:
+		        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]
+		                    });
+		                }
+		            }
+		        });
+		        // TypeScript trick for type-guarding:
+		        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 resolvedHref = formatStringOrUrl(hrefProp);
+		            return {
+		                href: resolvedHref,
+		                as: asProp ? formatStringOrUrl(asProp) : resolvedHref
+		            };
+		        }
+		        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);
+		    // This will return the first child, if multiple are provided it will throw an error
+		    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)=>{
+		        // Before the link getting observed, check if visible state need to be reset
+		        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);
+		    // Prefetch the URL if we haven't already and it's visible.
+		    _react.default.useEffect(()=>{
+		        // in dev, we only prefetch on hover to avoid wasting resources as the prefetch will trigger compiling the page.
+		        if (process.env.NODE_ENV !== 'production') {
+		            return;
+		        }
+		        if (!router) {
+		            return;
+		        }
+		        // If we don't need to prefetch the URL, don't do prefetch.
+		        if (!isVisible || !prefetchEnabled) {
+		            return;
+		        }
+		        // Prefetch the URL.
+		        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 ? undefined : 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 child is an <a> tag and doesn't have a href attribute, or if the 'passHref' property is
+		    // defined, we specify the current 'href', so that repetition is not needed by the user.
+		    // If the url is absolute, we can bypass the logic to prepend the domain and locale.
+		    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;
+		        // we only render domain locales if we are currently on a domain locale
+		        // so that locale links are still visitable in development/preview envs
+		        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\n' + 'npx @next/codemod@latest new-link .\n\n' + 'Learn 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: 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 = ()=>{
+		    // This behaviour is like React's useFormStatus. When the component is not under
+		    // a <form> tag, it will get the default value, instead of throwing an error.
+		    return (0, _react.useContext)(LinkStatusContext);
+		};
+		const _default = Link;
+
+		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));
+	return link$1.exports;
+}
+
+var link;
+var hasRequiredLink;
+
+function requireLink () {
+	if (hasRequiredLink) return link;
+	hasRequiredLink = 1;
+	link = requireLink$1();
+	return link;
+}
+
+var linkExports = requireLink();
+const Link = /*@__PURE__*/getDefaultExportFromCjs(linkExports);
+
+const NavItems = ({ items }) => {
+  const pathname = navigationExports.usePathname();
+  return /* @__PURE__ */ jsx(Stack, { gap: 0, children: items.map(({ href, isActive, ...navLinkProps }) => {
+    if (href) {
+      const active = isActive ?? href.includes(pathname);
+      return /* @__PURE__ */ jsx(
+        NavLink,
+        {
+          active,
+          component: Link,
+          prefetch: false,
+          href,
+          ...navLinkProps
+        },
+        navLinkProps.label
+      );
+    }
+    return /* @__PURE__ */ jsx(
+      NavLink,
+      {
+        active: isActive,
+        component: "button",
+        ...navLinkProps
+      },
+      navLinkProps.label
+    );
+  }) });
+};
+
+export { EmptyState, InfinityLoader, NavItems, SelectInfinity };