@dust-tt/sparkle 0.2.213 → 0.2.214-pr

package/dist/esm/index.js

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import React__default, { createContext, useRef, useState, useEffect, useContext, useCallback, Children, cloneElement, useLayoutEffect, useMemo, forwardRef, Fragment, isValidElement, createElement, useReducer, createRef } from 'react';
 import url from 'url';
-import { Fragment as Fragment$1, jsx, jsxs } from 'react/jsx-runtime';
+import require$$1, { Fragment as Fragment$1, jsx, jsxs } from 'react/jsx-runtime';
 
 function styleInject(css, ref) {
   if ( ref === void 0 ) ref = {};
@@ -39777,7 +39777,7 @@ function createEmojiAndBackgroundUrlSuffix(_a) {
     return "emojis/".concat(backgroundColor, "/").concat(id, "/").concat(unified);
 }
 
-var utils = /*#__PURE__*/Object.freeze({
+var utils$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createEmojiAndBackgroundUrlSuffix: createEmojiAndBackgroundUrlSuffix,
   getEmojiAndBackgroundFromUrl: getEmojiAndBackgroundFromUrl
@@ -120050,7 +120050,7 @@ function linkReference(state, node) {
  * @returns {Element}
  *   hast node.
  */
-function link(state, node) {
+function link$2(state, node) {
   /** @type {Properties} */
   const properties = {href: normalizeUri(node.url)};
 
@@ -120633,7 +120633,7 @@ const handlers = {
   image,
   inlineCode,
   linkReference,
-  link,
+  link: link$2,
   listItem,
   list,
   paragraph,
@@ -129162,6 +129162,2744 @@ DataTable.Caption = function Caption(_a) {
     return (React__default.createElement("caption", __assign({ className: className }, props), children));
 };
 
+var link$1 = {exports: {}};
+
+var _interop_require_default$1 = {};
+
+_interop_require_default$1._ = _interop_require_default$1._interop_require_default = _interop_require_default;
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : { default: obj };
+}
+
+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 = {};
+		    searchParams.forEach((value, key)=>{
+		        if (typeof query[key] === "undefined") {
+		            query[key] = value;
+		        } else if (Array.isArray(query[key])) {
+		            query[key].push(value);
+		        } else {
+		            query[key] = [
+		                query[key],
+		                value
+		            ];
+		        }
+		    });
+		    return query;
+		}
+		function stringifyUrlQueryParam(param) {
+		    if (typeof param === "string" || typeof param === "number" && !isNaN(param) || typeof param === "boolean") {
+		        return String(param);
+		    } else {
+		        return "";
+		    }
+		}
+		function urlQueryToSearchParams(urlQuery) {
+		    const result = new URLSearchParams();
+		    Object.entries(urlQuery).forEach((param)=>{
+		        let [key, value] = param;
+		        if (Array.isArray(value)) {
+		            value.forEach((item)=>result.append(key, stringifyUrlQueryParam(item)));
+		        } else {
+		            result.set(key, stringifyUrlQueryParam(value));
+		        }
+		    });
+		    return result;
+		}
+		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];
+		    }
+		    searchParamsList.forEach((searchParams)=>{
+		        Array.from(searchParams.keys()).forEach((key)=>target.delete(key));
+		        searchParams.forEach((value, key)=>target.append(key, value));
+		    });
+		    return target;
+		}
+
+		
+	} (querystring));
+	return querystring;
+}
+
+var formatUrl = {};
+
+var _interop_require_wildcard = {};
+
+var hasRequired_interop_require_wildcard;
+
+function require_interop_require_wildcard () {
+	if (hasRequired_interop_require_wildcard) return _interop_require_wildcard;
+	hasRequired_interop_require_wildcard = 1;
+
+	function _getRequireWildcardCache(nodeInterop) {
+	    if (typeof WeakMap !== "function") return null;
+
+	    var cacheBabelInterop = new WeakMap();
+	    var cacheNodeInterop = new WeakMap();
+
+	    return (_getRequireWildcardCache = function(nodeInterop) {
+	        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+	    })(nodeInterop);
+	}
+	_interop_require_wildcard._ = _interop_require_wildcard._interop_require_wildcard = _interop_require_wildcard$1;
+	function _interop_require_wildcard$1(obj, nodeInterop) {
+	    if (!nodeInterop && obj && obj.__esModule) return obj;
+	    if (obj === null || typeof obj !== "object" && typeof obj !== "function") return { default: obj };
+
+	    var cache = _getRequireWildcardCache(nodeInterop);
+
+	    if (cache && cache.has(obj)) return cache.get(obj);
+
+	    var newObj = { __proto__: null };
+	    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+
+	    for (var key in obj) {
+	        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+	            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+	            if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+	            else newObj[key] = obj[key];
+	        }
+	    }
+
+	    newObj.default = obj;
+
+	    if (cache) cache.set(obj, newObj);
+
+	    return newObj;
+	}
+	return _interop_require_wildcard;
+}
+
+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 = 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 new Error(message);
+		        }
+		    }
+		    // 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 new Error(message);
+		    }
+		    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
+		});
+		Object.defineProperty(exports, "getSortedRoutes", {
+		    enumerable: true,
+		    get: 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 new Error('You cannot define a route with the same specificity as a optional catch-all route ("' + r + '" and "' + r + "[[..." + this.optionalRestSlugName + ']]").');
+		            }
+		            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 new Error("Catch-all must be the last part of the URL.");
+		        }
+		        // 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("...")) {
+		                // Strip `...`, leaving only `something`
+		                segmentName = segmentName.substring(3);
+		                isCatchAll = true;
+		            }
+		            if (segmentName.startsWith("[") || segmentName.endsWith("]")) {
+		                throw new Error("Segment names may not start or end with extra brackets ('" + segmentName + "').");
+		            }
+		            if (segmentName.startsWith(".")) {
+		                throw new Error("Segment names may not start with erroneous periods ('" + segmentName + "').");
+		            }
+		            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 new Error("You cannot use different slug names for the same dynamic path ('" + previousSlug + "' !== '" + nextSlug + "').");
+		                    }
+		                }
+		                slugNames.forEach((slug)=>{
+		                    if (slug === nextSlug) {
+		                        throw new Error('You cannot have the same slug name "' + nextSlug + '" repeat within a single dynamic path');
+		                    }
+		                    if (slug.replace(/\W/g, "") === nextSegment.replace(/\W/g, "")) {
+		                        throw new Error('You cannot have the slug names "' + slug + '" and "' + nextSlug + '" differ only by non-word symbols within a single dynamic path');
+		                    }
+		                });
+		                slugNames.push(nextSlug);
+		            }
+		            if (isCatchAll) {
+		                if (isOptional) {
+		                    if (this.restSlugName != null) {
+		                        throw new Error('You cannot use both an required and optional catch-all route at the same level ("[...' + this.restSlugName + ']" and "' + urlPaths[0] + '" ).');
+		                    }
+		                    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 new Error('You cannot use both an optional and required catch-all route at the same level ("[[...' + this.optionalRestSlugName + ']]" and "' + urlPaths[0] + '").');
+		                    }
+		                    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 new Error('Optional route parameters are not yet supported ("' + urlPaths[0] + '").');
+		                }
+		                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();
+		}
+
+		
+	} (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 segment = {};
+
+var hasRequiredSegment;
+
+function requireSegment () {
+	if (hasRequiredSegment) return segment;
+	hasRequiredSegment = 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, {
+		    DEFAULT_SEGMENT_KEY: function() {
+		        return DEFAULT_SEGMENT_KEY;
+		    },
+		    PAGE_SEGMENT_KEY: function() {
+		        return PAGE_SEGMENT_KEY;
+		    },
+		    isGroupSegment: function() {
+		        return isGroupSegment;
+		    }
+		});
+		function isGroupSegment(segment) {
+		    // Use array[0] for performant purpose
+		    return segment[0] === "(" && segment.endsWith(")");
+		}
+		const PAGE_SEGMENT_KEY = "__PAGE__";
+		const DEFAULT_SEGMENT_KEY = "__DEFAULT__";
+
+		
+	} (segment));
+	return segment;
+}
+
+var hasRequiredAppPaths;
+
+function requireAppPaths () {
+	if (hasRequiredAppPaths) return appPaths;
+	hasRequiredAppPaths = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "__esModule", {
+		    value: true
+		});
+		function _export(target, all) {
+		    for(var name in all)Object.defineProperty(target, name, {
+		        enumerable: true,
+		        get: all[name]
+		    });
+		}
+		_export(exports, {
+		    normalizeAppPath: function() {
+		        return normalizeAppPath;
+		    },
+		    normalizeRscURL: function() {
+		        return normalizeRscURL;
+		    }
+		});
+		const _ensureleadingslash = requireEnsureLeadingSlash();
+		const _segment = 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 new Error(`Invalid interception route: ${path}. Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>`);
+		    }
+		    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 new Error(`Invalid interception route: ${path}. Cannot use (..) marker at the root level, use (.) instead.`);
+		            }
+		            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 new Error(`Invalid interception route: ${path}. Cannot use (..)(..) marker at the root level or one level up.`);
+		            }
+		            interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join("/");
+		            break;
+		        default:
+		            throw new Error("Invariant: unexpected marker");
+		    }
+		    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 = /\/\[[^/]+?\](?=\/|$)/;
+		function isDynamicRoute(route) {
+		    if ((0, _interceptionroutes.isInterceptionRouteAppPath)(route)) {
+		        route = (0, _interceptionroutes.extractInterceptionRouteInformation)(route).interceptedRoute;
+		    }
+		    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, {
+		    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 (_) {
+		                throw new _utils.DecodeError("failed to decode param");
+		            }
+		        };
+		        const params = {};
+		        Object.keys(groups).forEach((slugName)=>{
+		            const g = groups[slugName];
+		            const m = routeMatch[g.pos];
+		            if (m !== undefined) {
+		                params[slugName] = ~m.indexOf("/") ? m.split("/").map((entry)=>decode(entry)) : g.repeat ? [
+		                    decode(m)
+		                ] : decode(m);
+		            }
+		        });
+		        return params;
+		    };
+		}
+
+		
+	} (routeMatcher));
+	return routeMatcher;
+}
+
+var routeRegex = {};
+
+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;
+		    }
+		});
+		const _interceptionroutes = requireInterceptionRoutes();
+		const _escaperegexp = requireEscapeRegexp();
+		const _removetrailingslash = requireRemoveTrailingSlash();
+		const NEXT_QUERY_PARAM_PREFIX = "nxtP";
+		const NEXT_INTERCEPTION_MARKER_PREFIX = "nxtI";
+		/**
+		 * Parses a given parameter from a route 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 }`
+		 */ function parseParameter(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) {
+		    const segments = (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/");
+		    const groups = {};
+		    let groupIndex = 1;
+		    return {
+		        parameterizedRoute: segments.map((segment)=>{
+		            const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m)=>segment.startsWith(m));
+		            const paramMatches = segment.match(/\[((?:\[.*\])|.+)\]/) // Check for parameters
+		            ;
+		            if (markerMatch && paramMatches) {
+		                const { key, optional, repeat } = parseParameter(paramMatches[1]);
+		                groups[key] = {
+		                    pos: groupIndex++,
+		                    repeat,
+		                    optional
+		                };
+		                return "/" + (0, _escaperegexp.escapeStringRegexp)(markerMatch) + "([^/]+?)";
+		            } else if (paramMatches) {
+		                const { key, repeat, optional } = parseParameter(paramMatches[1]);
+		                groups[key] = {
+		                    pos: groupIndex++,
+		                    repeat,
+		                    optional
+		                };
+		                return repeat ? optional ? "(?:/(.+?))?" : "/(.+?)" : "/([^/]+?)";
+		            } else {
+		                return "/" + (0, _escaperegexp.escapeStringRegexp)(segment);
+		            }
+		        }).join(""),
+		        groups
+		    };
+		}
+		function getRouteRegex(normalizedRoute) {
+		    const { parameterizedRoute, groups } = getParametrizedRoute(normalizedRoute);
+		    return {
+		        re: new RegExp("^" + parameterizedRoute + "(?:/)?$"),
+		        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 } = param;
+		    const { key, optional, repeat } = parseParameter(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();
+		    }
+		    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) : "";
+		    return repeat ? optional ? "(?:/" + interceptionPrefix + "(?<" + cleanedKey + ">.+?))?" : "/" + interceptionPrefix + "(?<" + cleanedKey + ">.+?)" : "/" + interceptionPrefix + "(?<" + cleanedKey + ">[^/]+?)";
+		}
+		function getNamedParametrizedRoute(route, prefixRouteKeys) {
+		    const segments = (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/");
+		    const getSafeRouteKey = buildGetSafeRouteKey();
+		    const routeKeys = {};
+		    return {
+		        namedParameterizedRoute: segments.map((segment)=>{
+		            const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m)=>segment.startsWith(m));
+		            const paramMatches = segment.match(/\[((?:\[.*\])|.+)\]/) // Check for parameters
+		            ;
+		            if (hasInterceptionMarker && paramMatches) {
+		                const [usedMarker] = segment.split(paramMatches[0]);
+		                return getSafeKeyFromSegment({
+		                    getSafeRouteKey,
+		                    interceptionMarker: usedMarker,
+		                    segment: paramMatches[1],
+		                    routeKeys,
+		                    keyPrefix: prefixRouteKeys ? NEXT_INTERCEPTION_MARKER_PREFIX : undefined
+		                });
+		            } else if (paramMatches) {
+		                return getSafeKeyFromSegment({
+		                    getSafeRouteKey,
+		                    segment: paramMatches[1],
+		                    routeKeys,
+		                    keyPrefix: prefixRouteKeys ? NEXT_QUERY_PARAM_PREFIX : undefined
+		                });
+		            } else {
+		                return "/" + (0, _escaperegexp.escapeStringRegexp)(segment);
+		            }
+		        }).join(""),
+		        routeKeys
+		    };
+		}
+		function getNamedRouteRegex(normalizedRoute, prefixRouteKey) {
+		    const result = getNamedParametrizedRoute(normalizedRoute, prefixRouteKey);
+		    return {
+		        ...getRouteRegex(normalizedRoute),
+		        namedRegex: "^" + result.namedParameterizedRoute + "(?:/)?$",
+		        routeKeys: result.routeKeys
+		    };
+		}
+		function getNamedMiddlewareRegex(normalizedRoute, options) {
+		    const { parameterizedRoute } = getParametrizedRoute(normalizedRoute);
+		    const { catchAll = true } = options;
+		    if (parameterizedRoute === "/") {
+		        let catchAllRegex = catchAll ? ".*" : "";
+		        return {
+		            namedRegex: "^/" + catchAllRegex + "$"
+		        };
+		    }
+		    const { namedParameterizedRoute } = getNamedParametrizedRoute(normalizedRoute, 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 = _interop_require_default$1;
+		const _react = /*#__PURE__*/ _interop_require_default._(React__default);
+		const RouterContext = _react.default.createContext(null);
+		if (process.env.NODE_ENV !== "production") {
+		    RouterContext.displayName = "RouterContext";
+		}
+
+		
+	} (routerContext_sharedRuntime));
+	return routerContext_sharedRuntime;
+}
+
+var appRouterContext_sharedRuntime = {};
+
+var hasRequiredAppRouterContext_sharedRuntime;
+
+function requireAppRouterContext_sharedRuntime () {
+	if (hasRequiredAppRouterContext_sharedRuntime) return appRouterContext_sharedRuntime;
+	hasRequiredAppRouterContext_sharedRuntime = 1;
+	(function (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, {
+		    AppRouterContext: function() {
+		        return AppRouterContext;
+		    },
+		    GlobalLayoutRouterContext: function() {
+		        return GlobalLayoutRouterContext;
+		    },
+		    LayoutRouterContext: function() {
+		        return LayoutRouterContext;
+		    },
+		    MissingSlotContext: function() {
+		        return MissingSlotContext;
+		    },
+		    TemplateContext: function() {
+		        return TemplateContext;
+		    }
+		});
+		const _interop_require_default = _interop_require_default$1;
+		const _react = /*#__PURE__*/ _interop_require_default._(React__default);
+		const AppRouterContext = _react.default.createContext(null);
+		const LayoutRouterContext = _react.default.createContext(null);
+		const GlobalLayoutRouterContext = _react.default.createContext(null);
+		const TemplateContext = _react.default.createContext(null);
+		if (process.env.NODE_ENV !== "production") {
+		    AppRouterContext.displayName = "AppRouterContext";
+		    LayoutRouterContext.displayName = "LayoutRouterContext";
+		    GlobalLayoutRouterContext.displayName = "GlobalLayoutRouterContext";
+		    TemplateContext.displayName = "TemplateContext";
+		}
+		const MissingSlotContext = _react.default.createContext(new Set());
+
+		
+	} (appRouterContext_sharedRuntime));
+	return appRouterContext_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 = React__default;
+		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;
+		    }
+		});
+		function normalizeLocalePath(pathname, locales) {
+		    let detectedLocale;
+		    // first item will be empty string from splitting at first char
+		    const pathnameParts = pathname.split("/");
+		    (locales || []).some((locale)=>{
+		        if (pathnameParts[1] && pathnameParts[1].toLowerCase() === locale.toLowerCase()) {
+		            detectedLocale = locale;
+		            pathnameParts.splice(1, 1);
+		            pathname = pathnameParts.join("/") || "/";
+		            return true;
+		        }
+		        return false;
+		    });
+		    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 routerReducerTypes = {exports: {}};
+
+var hasRequiredRouterReducerTypes;
+
+function requireRouterReducerTypes () {
+	if (hasRequiredRouterReducerTypes) return routerReducerTypes.exports;
+	hasRequiredRouterReducerTypes = 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, {
+		    ACTION_FAST_REFRESH: function() {
+		        return ACTION_FAST_REFRESH;
+		    },
+		    ACTION_NAVIGATE: function() {
+		        return ACTION_NAVIGATE;
+		    },
+		    ACTION_PREFETCH: function() {
+		        return ACTION_PREFETCH;
+		    },
+		    ACTION_REFRESH: function() {
+		        return ACTION_REFRESH;
+		    },
+		    ACTION_RESTORE: function() {
+		        return ACTION_RESTORE;
+		    },
+		    ACTION_SERVER_ACTION: function() {
+		        return ACTION_SERVER_ACTION;
+		    },
+		    ACTION_SERVER_PATCH: function() {
+		        return ACTION_SERVER_PATCH;
+		    },
+		    PrefetchCacheEntryStatus: function() {
+		        return PrefetchCacheEntryStatus;
+		    },
+		    PrefetchKind: function() {
+		        return PrefetchKind;
+		    },
+		    isThenable: function() {
+		        return isThenable;
+		    }
+		});
+		const ACTION_REFRESH = "refresh";
+		const ACTION_NAVIGATE = "navigate";
+		const ACTION_RESTORE = "restore";
+		const ACTION_SERVER_PATCH = "server-patch";
+		const ACTION_PREFETCH = "prefetch";
+		const ACTION_FAST_REFRESH = "fast-refresh";
+		const ACTION_SERVER_ACTION = "server-action";
+		var PrefetchKind;
+		(function(PrefetchKind) {
+		    PrefetchKind["AUTO"] = "auto";
+		    PrefetchKind["FULL"] = "full";
+		    PrefetchKind["TEMPORARY"] = "temporary";
+		})(PrefetchKind || (PrefetchKind = {}));
+		var PrefetchCacheEntryStatus;
+		(function(PrefetchCacheEntryStatus) {
+		    PrefetchCacheEntryStatus["fresh"] = "fresh";
+		    PrefetchCacheEntryStatus["reusable"] = "reusable";
+		    PrefetchCacheEntryStatus["expired"] = "expired";
+		    PrefetchCacheEntryStatus["stale"] = "stale";
+		})(PrefetchCacheEntryStatus || (PrefetchCacheEntryStatus = {}));
+		function isThenable(value) {
+		    // TODO: We don't gain anything from this abstraction. It's unsound, and only
+		    // makes sense in the specific places where we use it. So it's better to keep
+		    // the type coercion inline, instead of leaking this to other places in
+		    // the codebase.
+		    return value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+		}
+
+		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;
+		}
+
+		
+	} (routerReducerTypes, routerReducerTypes.exports));
+	return routerReducerTypes.exports;
+}
+
+(function (module, exports) {
+	"use client";
+	Object.defineProperty(exports, "__esModule", {
+	    value: true
+	});
+	Object.defineProperty(exports, "default", {
+	    enumerable: true,
+	    get: function() {
+	        return _default;
+	    }
+	});
+	const _interop_require_default = _interop_require_default$1;
+	const _jsxruntime = require$$1;
+	const _react = /*#__PURE__*/ _interop_require_default._(React__default);
+	const _resolvehref = requireResolveHref();
+	const _islocalurl = requireIsLocalUrl();
+	const _formaturl = requireFormatUrl();
+	const _utils = requireUtils$1();
+	const _addlocale = requireAddLocale();
+	const _routercontextsharedruntime = requireRouterContext_sharedRuntime();
+	const _approutercontextsharedruntime = requireAppRouterContext_sharedRuntime();
+	const _useintersection = requireUseIntersection();
+	const _getdomainlocale = requireGetDomainLocale();
+	const _addbasepath = requireAddBasePath();
+	const _routerreducertypes = requireRouterReducerTypes();
+	const prefetched = new Set();
+	function prefetch(router, href, as, options, appOptions, isAppRouter) {
+	    if (typeof window === "undefined") {
+	        return;
+	    }
+	    // app-router supports external urls out of the box so it shouldn't short-circuit here as support for e.g. `replace` is added in the app-router.
+	    if (!isAppRouter && !(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);
+	    }
+	    const doPrefetch = async ()=>{
+	        if (isAppRouter) {
+	            // note that `appRouter.prefetch()` is currently sync,
+	            // so we have to wrap this call in an async function to be able to catch() errors below.
+	            return router.prefetch(href, appOptions);
+	        } else {
+	            return router.prefetch(href, as, options);
+	        }
+	    };
+	    // 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
+	    doPrefetch().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, isAppRouter) {
+	    const { nodeName } = e.currentTarget;
+	    // anchors inside an svg have a lowercase nodeName
+	    const isAnchorNodeName = nodeName.toUpperCase() === "A";
+	    if (isAnchorNodeName && (isModifiedEvent(e) || // app-router supports external urls out of the box so it shouldn't short-circuit here as support for e.g. `replace` is added in the app-router.
+	    !isAppRouter && !(0, _islocalurl.isLocalURL)(href))) {
+	        // ignore click for browser’s default behavior
+	        return;
+	    }
+	    e.preventDefault();
+	    const navigate = ()=>{
+	        // 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
+	            });
+	        }
+	    };
+	    if (isAppRouter) {
+	        _react.default.startTransition(navigate);
+	    } else {
+	        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, 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 pagesRouter = _react.default.useContext(_routercontextsharedruntime.RouterContext);
+	    const appRouter = _react.default.useContext(_approutercontextsharedruntime.AppRouterContext);
+	    const router = pagesRouter != null ? pagesRouter : appRouter;
+	    // We're in the app directory if there is no pages router.
+	    const isAppRouter = !pagesRouter;
+	    const prefetchEnabled = prefetchProp !== false;
+	    /**
+	     * The possible states for prefetch are:
+	     * - null: this is the default "auto" mode, where we will prefetch partially if the link is in the viewport
+	     * - true: we will prefetch if the link is visible and prefetch the full page, not just partially
+	     * - false: we will not prefetch if in the viewport at all
+	     */ const appPrefetchKind = prefetchProp === null ? _routerreducertypes.PrefetchKind.AUTO : _routerreducertypes.PrefetchKind.FULL;
+	    if (process.env.NODE_ENV !== "production") {
+	        function createPropError(args) {
+	            return 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." : ""));
+	        }
+	        // 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
+	        };
+	        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") {
+	                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 ;
+	        });
+	        // This hook is in a conditional but that is ok because `process.env.NODE_ENV` never changes
+	        // eslint-disable-next-line react-hooks/rules-of-hooks
+	        const hasWarned = _react.default.useRef(false);
+	        if (props.prefetch && !hasWarned.current && !isAppRouter) {
+	            hasWarned.current = true;
+	            console.warn("Next.js auto-prefetches automatically based on viewport. The prefetch attribute is no longer needed. More: https://nextjs.org/docs/messages/prefetch-true-deprecated");
+	        }
+	    }
+	    if (process.env.NODE_ENV !== "production") {
+	        if (isAppRouter && !asProp) {
+	            let href;
+	            if (typeof hrefProp === "string") {
+	                href = hrefProp;
+	            } else if (typeof hrefProp === "object" && typeof hrefProp.pathname === "string") {
+	                href = hrefProp.pathname;
+	            }
+	            if (href) {
+	                const hasDynamicSegment = href.split("/").some((segment)=>segment.startsWith("[") && segment.endsWith("]"));
+	                if (hasDynamicSegment) {
+	                    throw new Error("Dynamic href `" + href + "` found in <Link> while using the `/app` router, this is not supported. Read more: https://nextjs.org/docs/messages/app-dir-dynamic-href");
+	                }
+	            }
+	        }
+	    }
+	    const { href, as } = _react.default.useMemo(()=>{
+	        if (!pagesRouter) {
+	            const resolvedHref = formatStringOrUrl(hrefProp);
+	            return {
+	                href: resolvedHref,
+	                as: asProp ? formatStringOrUrl(asProp) : resolvedHref
+	            };
+	        }
+	        const [resolvedHref, resolvedAs] = (0, _resolvehref.resolveHref)(pagesRouter, hrefProp, true);
+	        return {
+	            href: resolvedHref,
+	            as: asProp ? (0, _resolvehref.resolveHref)(pagesRouter, asProp) : resolvedAs || resolvedHref
+	        };
+	    }, [
+	        pagesRouter,
+	        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 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");
+	                }
+	                throw 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." : ""));
+	            }
+	        } else {
+	            child = _react.default.Children.only(children);
+	        }
+	    } else {
+	        if (process.env.NODE_ENV === "development") {
+	            if ((children == null ? void 0 : children.type) === "a") {
+	                throw 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");
+	            }
+	        }
+	    }
+	    const childRef = legacyBehavior ? child && typeof child === "object" && child.ref : forwardedRef;
+	    const [setIntersectionRef, isVisible, resetVisible] = (0, _useintersection.useIntersection)({
+	        rootMargin: "200px"
+	    });
+	    const setRef = _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);
+	        if (childRef) {
+	            if (typeof childRef === "function") childRef(el);
+	            else if (typeof childRef === "object") {
+	                childRef.current = el;
+	            }
+	        }
+	    }, [
+	        as,
+	        childRef,
+	        href,
+	        resetVisible,
+	        setIntersectionRef
+	    ]);
+	    // 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
+	        }, {
+	            kind: appPrefetchKind
+	        }, isAppRouter);
+	    }, [
+	        as,
+	        href,
+	        isVisible,
+	        locale,
+	        prefetchEnabled,
+	        pagesRouter == null ? void 0 : pagesRouter.locale,
+	        router,
+	        isAppRouter,
+	        appPrefetchKind
+	    ]);
+	    const childProps = {
+	        ref: setRef,
+	        onClick (e) {
+	            if (process.env.NODE_ENV !== "production") {
+	                if (!e) {
+	                    throw new Error('Component rendered inside next/link has to pass click event to "onClick" prop.');
+	                }
+	            }
+	            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, isAppRouter);
+	        },
+	        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;
+	            }
+	            if ((!prefetchEnabled || process.env.NODE_ENV === "development") && isAppRouter) {
+	                return;
+	            }
+	            prefetch(router, href, as, {
+	                locale,
+	                priority: true,
+	                // @see {https://github.com/vercel/next.js/discussions/40268?sort=top#discussioncomment-3572642}
+	                bypassPrefetchedCheck: true
+	            }, {
+	                kind: appPrefetchKind
+	            }, isAppRouter);
+	        },
+	        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;
+	            }
+	            if (!prefetchEnabled && isAppRouter) {
+	                return;
+	            }
+	            prefetch(router, href, as, {
+	                locale,
+	                priority: true,
+	                // @see {https://github.com/vercel/next.js/discussions/40268?sort=top#discussioncomment-3572642}
+	                bypassPrefetchedCheck: true
+	            }, {
+	                kind: appPrefetchKind
+	            }, isAppRouter);
+	        }
+	    };
+	    // 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 : pagesRouter == null ? void 0 : pagesRouter.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 = (pagesRouter == null ? void 0 : pagesRouter.isLocaleDomain) && (0, _getdomainlocale.getDomainLocale)(as, curLocale, pagesRouter == null ? void 0 : pagesRouter.locales, pagesRouter == null ? void 0 : pagesRouter.domainLocales);
+	        childProps.href = localeDomain || (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(as, curLocale, pagesRouter == null ? void 0 : pagesRouter.defaultLocale));
+	    }
+	    return legacyBehavior ? /*#__PURE__*/ _react.default.cloneElement(child, childProps) : /*#__PURE__*/ (0, _jsxruntime.jsx)("a", {
+	        ...restProps,
+	        ...childProps,
+	        children: children
+	    });
+	});
+	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));
+
+var linkExports = link$1.exports;
+
+var link = linkExports;
+
+var Link = /*@__PURE__*/getDefaultExportFromCjs(link);
+
+function Breadcrumbs(_a) {
+    var items = _a.items;
+    return (React__default.createElement("div", { className: "gap-2 s-flex s-flex-row s-items-center" }, items.map(function (item, index) { return (React__default.createElement("div", { key: index, className: "s-flex s-flex-row s-items-center s-gap-1" },
+        React__default.createElement(Icon, { visual: item.icon, className: "s-text-brand" }),
+        React__default.createElement("div", null, item.href ? (React__default.createElement(Link, { href: item.href, className: index === items.length - 1
+                ? "s-text-element-900"
+                : "s-text-element-700" }, item.label)) : (React__default.createElement("span", { className: index === items.length - 1
+                ? "s-text-element-900"
+                : "s-text-element-700" }, item.label))),
+        index === items.length - 1 ? null : (React__default.createElement(SvgChevronRight$1, { className: "s-text-element-500" })))); })));
+}
+
 var SvgLogoHorizontalColor = function (props) { return (React.createElement("svg", __assign({ xmlns: "http://www.w3.org/2000/svg", width: "1em", height: "1em", fill: "none", viewBox: "0 0 96 24" }, props),
     React.createElement("path", { fill: "#FCD34D", d: "M84 12H72v12h12V12Z" }),
     React.createElement("path", { fill: "#6EE7B7", d: "M12 24c6.627 0 12-5.373 12-12S18.627 0 12 0 0 5.373 0 12s5.373 12 12 12Z" }),
@@ -129218,5 +131956,5 @@ var SvgLogoSquareWhite = function (props) { return (React.createElement("svg", _
     React.createElement("path", { fill: "#fff", fillOpacity: 0.7, fillRule: "evenodd", d: "M12 24c6.627 0 12-5.373 12-12 0 6.627 5.373 12 12 12s12-5.373 12-12S42.627 0 36 0 24 5.373 24 12c0-6.627-5.373-12-12-12S0 5.373 0 12s5.373 12 12 12Zm24 12H24v12h12V36ZM12 48a6 6 0 0 0 0-12H0v12h12Z", clipRule: "evenodd" }),
     React.createElement("path", { fill: "#fff", fillRule: "evenodd", d: "M12 0H0v24h12a6 6 0 0 0 0 12h36V24H12V0Zm12 0h24v12H24V0Z", clipRule: "evenodd" }))); };
 
-export { SvgAi21 as Ai21Logo, SvgAnthropic as AnthropicLogo, SvgAnthropicWhite as AnthropicWhiteLogo, SvgArrowDownCircle$1 as ArrowDownCircleIcon, SvgArrowDownCircle as ArrowDownCircleStrokeIcon, SvgArrowDown$1 as ArrowDownIcon, SvgArrowDownOnSquare$1 as ArrowDownOnSquareIcon, SvgArrowDownOnSquare as ArrowDownOnSquareStrokeIcon, SvgArrowDownS$1 as ArrowDownSIcon, SvgArrowDownS as ArrowDownSStrokeIcon, SvgArrowDown as ArrowDownStrokeIcon, SvgArrowLeft$1 as ArrowLeftIcon, SvgArrowLeftS$1 as ArrowLeftSIcon, SvgArrowLeftS as ArrowLeftSStrokeIcon, SvgArrowLeft as ArrowLeftStrokeIcon, SvgArrowPath$1 as ArrowPathIcon, SvgArrowPath as ArrowPathStrokeIcon, SvgArrowRight$1 as ArrowRightIcon, SvgArrowRightS$1 as ArrowRightSIcon, SvgArrowRightS as ArrowRightSStrokeIcon, SvgArrowRight as ArrowRightStrokeIcon, SvgArrowUp$1 as ArrowUpIcon, SvgArrowUpOnSquare$1 as ArrowUpOnSquareIcon, SvgArrowUpOnSquare as ArrowUpOnSquareStrokeIcon, SvgArrowUpS$1 as ArrowUpSIcon, SvgArrowUpS as ArrowUpSStrokeIcon, SvgArrowUp as ArrowUpStrokeIcon, AssistantPreview, SvgAttachment$1 as AttachmentIcon, SvgAttachment as AttachmentStrokeIcon, Avatar, SvgBackspace$1 as BackspaceIcon, SvgBackspace as BackspaceStrokeIcon, Banner, BarHeader, SvgBookOpen$1 as BookOpenIcon, SvgBookOpen as BookOpenStrokeIcon, SvgBookmark$1 as BookmarkIcon, SvgBookmark as BookmarkStrokeIcon, SvgBraces$1 as BracesIcon, SvgBraces as BracesStrokeIcon, Button, CardButton, SvgCard$1 as CardIcon, SvgCard as CardStrokeIcon, SvgChatBubbleBottomCenterPlus$1 as ChatBubbleBottomCenterPlusIcon, SvgChatBubbleBottomCenterPlus as ChatBubbleBottomCenterPlusStrokeIcon, SvgChatBubbleBottomCenterText$1 as ChatBubbleBottomCenterTextIcon, SvgChatBubbleBottomCenterText as ChatBubbleBottomCenterTextStrokeIcon, SvgChatBubbleLeftRight$1 as ChatBubbleLeftRightIcon, SvgChatBubbleLeftRight as ChatBubbleLeftRightStrokeIcon, SvgChatBubbleThought$1 as ChatBubbleThoughtIcon, SvgChatBubbleThought as ChatBubbleThoughtStrokeIcon, SvgCheckCircle$1 as CheckCircleIcon, SvgCheckCircle as CheckCircleStrokeIcon, SvgCheck$1 as CheckIcon, SvgCheck as CheckStrokeIcon, Checkbox, SvgChevronDoubleLeft$1 as ChevronDoubleLeftIcon, SvgChevronDoubleLeft as ChevronDoubleLeftStrokeIcon, SvgChevronDoubleRight$1 as ChevronDoubleRightIcon, SvgChevronDoubleRight as ChevronDoubleRightStrokeIcon, SvgChevronDown$1 as ChevronDownIcon, SvgChevronDown as ChevronDownStrokeIcon, SvgChevronLeft$1 as ChevronLeftIcon, SvgChevronLeft as ChevronLeftStrokeIcon, SvgChevronRight$1 as ChevronRightIcon, SvgChevronRight as ChevronRightStrokeIcon, SvgChevronUpDown$1 as ChevronUpDownIcon, SvgChevronUpDown as ChevronUpDownStrokeIcon, SvgChevronUp$1 as ChevronUpIcon, SvgChevronUp as ChevronUpStrokeIcon, Chip, SvgCircle$1 as CircleIcon, SvgCircle as CircleStrokeIcon, Citation, SvgClaude as ClaudeLogo, SvgClipboardCheck$1 as ClipboardCheckIcon, SvgClipboardCheck as ClipboardCheckStrokeIcon, SvgClipboard$1 as ClipboardIcon, SvgClipboard as ClipboardStrokeIcon, SvgClock$1 as ClockIcon, SvgClock as ClockStrokeIcon, SvgCloudArrowDown$1 as CloudArrowDownIcon, SvgCloudArrowDown as CloudArrowDownStrokeIcon, SvgCloudArrowLeftRight$1 as CloudArrowLeftRightIcon, SvgCloudArrowLeftRight as CloudArrowLeftRightStrokeIcon, SvgCloudArrowUp$1 as CloudArrowUpIcon, SvgCloudArrowUp as CloudArrowUpStrokeIcon, SvgCloudX$1 as CloudXIcon, SvgCloudX as CloudXStrokeIcon, SvgCog6Tooth$1 as Cog6ToothIcon, SvgCog6Tooth as Cog6ToothStrokeIcon, SvgCohere as CohereLogo, CollapseButton, Collapsible, ColorPicker, SvgCommand$1 as CommandIcon, SvgCommandLine$1 as CommandLineIcon, SvgCommandLine as CommandLineStrokeIcon, SvgCommand as CommandStrokeIcon, SvgCompany$1 as CompanyIcon, SvgCompany as CompanyStrokeIcon, ConfettiBackground, SvgConfluence as ConfluenceLogo, ContentMessage, ContextItem, SvgCube$1 as CubeIcon, SvgCube as CubeStrokeIcon, SvgDash$1 as DashIcon, SvgDash as DashStrokeIcon, DataTable, Dialog, Div3D, SvgDocumentDuplicate$1 as DocumentDuplicateIcon, SvgDocumentDuplicate as DocumentDuplicateStrokeIcon, SvgDocument$1 as DocumentIcon, SvgDocumentPile$1 as DocumentPileIcon, SvgDocumentPile as DocumentPileStrokeIcon, SvgDocumentPlus$1 as DocumentPlusIcon, SvgDocumentPlus as DocumentPlusStrokeIcon, SvgDocument as DocumentStrokeIcon, SvgDocumentText$1 as DocumentTextIcon, SvgDocumentText as DocumentTextStrokeIcon, SvgDrive as DriveLogo, DropdownMenu, DropzoneOverlay, SvgDust$1 as DustIcon, SvgDust as DustStrokeIcon, ElementDialog, ElementModal, EmojiPicker, SvgEmotionLaugh$1 as EmotionLaughIcon, SvgEmotionLaugh as EmotionLaughStrokeIcon, SvgEqualizer$1 as EqualizerIcon, SvgEqualizer as EqualizerStrokeIcon, SvgExclamationCircle$1 as ExclamationCircleIcon, SvgExclamationCircle as ExclamationCircleStrokeIcon, SvgExternalLink$1 as ExternalLinkIcon, SvgExternalLink as ExternalLinkStrokeIcon, SvgEye$1 as EyeIcon, SvgEyeSlash$1 as EyeSlashIcon, SvgEyeSlash as EyeSlashStrokeIcon, SvgEye as EyeStrokeIcon, FilterChips, SvgFilter$1 as FilterIcon, SvgFilter as FilterStrokeIcon, SvgFire$1 as FireIcon, SvgFire as FireStrokeIcon, SvgFlag$1 as FlagIcon, SvgFlag as FlagStrokeIcon, SvgFolder$1 as FolderIcon, SvgFolderOpen$1 as FolderOpenIcon, SvgFolderOpen as FolderOpenStrokeIcon, SvgFolder as FolderStrokeIcon, SvgFullscreenExit$1 as FullscreenExitIcon, SvgFullscreenExit as FullscreenExitStrokeIcon, SvgFullscreen$1 as FullscreenIcon, SvgFullscreen as FullscreenStrokeIcon, SvgGemini as GeminiLogo, SvgGithub as GithubLogo, SvgGithubWhite as GithubWhiteLogo, SvgGlobeAlt$1 as GlobeAltIcon, SvgGlobeAlt as GlobeAltStrokeIcon, SvgGong as GongLogo, SvgGoogleDoc as GoogleDocLogo, SvgGoogle as GoogleLogo, SvgGooglePdf as GooglePdfLogo, SvgGoogleSlide as GoogleSlideLogo, SvgGoogleSpreadsheet as GoogleSpreadsheetLogo, SvgGpt3 as Gpt3Logo, SvgGpt4 as Gpt4Logo, SvgGrab$1 as GrabIcon, SvgGrab as GrabStrokeIcon, SvgHandThumbDown$1 as HandThumbDownIcon, SvgHandThumbDown as HandThumbDownStrokeIcon, SvgHandThumbUp$1 as HandThumbUpIcon, SvgHandThumbUp as HandThumbUpStrokeIcon, SvgHeartAlt$1 as HeartAltIcon, SvgHeartAlt as HeartAltStrokeIcon, SvgHeart$1 as HeartIcon, SvgHeart as HeartStrokeIcon, SvgHexagon$1 as HexagonIcon, SvgHexagon as HexagonStrokeIcon, SvgHistory$1 as HistoryIcon, SvgHistory as HistoryStrokeIcon, SvgHome$1 as HomeIcon, SvgHome as HomeStrokeIcon, Hover3D, Hoverable, SvgHuggingFace as HuggingFaceLogo, Icon, IconButton, IconToggleButton, SvgImage$1 as ImageIcon, SvgImage as ImageStrokeIcon, SvgInformationCircle$1 as InformationCircleIcon, SvgInformationCircle as InformationCircleStrokeIcon, Input, SvgIntercom as IntercomLogo, Item, SvgKey$1 as KeyIcon, SvgKey as KeyStrokeIcon, SvgLightbulb$1 as LightbulbIcon, SvgLightbulb as LightbulbStrokeIcon, SvgLink$1 as LinkIcon, SvgLink as LinkStrokeIcon, SvgListAdd$1 as ListAddIcon, SvgListAdd as ListAddStrokeIcon, SvgListCheck$1 as ListCheckIcon, SvgListCheck as ListCheckStrokeIcon, SvgList$1 as ListIcon, SvgListRemove$1 as ListRemoveIcon, SvgListRemove as ListRemoveStrokeIcon, SvgList as ListStrokeIcon, SvgLock$1 as LockIcon, SvgLock as LockStrokeIcon, SvgLogin$1 as LoginIcon, SvgLogin as LoginStrokeIcon, Logo, SvgLogoHorizontalColor as LogoHorizontalColorLogo, SvgLogoHorizontalColorLayer1 as LogoHorizontalColorLogoLayer1, SvgLogoHorizontalColorLayer2 as LogoHorizontalColorLogoLayer2, SvgLogoHorizontalDark as LogoHorizontalDarkLogo, SvgLogoHorizontalWhite as LogoHorizontalWhiteLogo, SvgLogoSquareColor as LogoSquareColorLogo, SvgLogoSquareColorLayer1 as LogoSquareColorLogoLayer1, SvgLogoSquareColorLayer2 as LogoSquareColorLogoLayer2, SvgLogoSquareDark as LogoSquareDarkLogo, SvgLogoSquareWhite as LogoSquareWhiteLogo, SvgLogout$1 as LogoutIcon, SvgLogout as LogoutStrokeIcon, SvgMagic$1 as MagicIcon, SvgMagic as MagicStrokeIcon, SvgMagnifyingGlass$1 as MagnifyingGlassIcon, SvgMagnifyingGlass as MagnifyingGlassStrokeIcon, SvgMarkPen$1 as MarkPenIcon, SvgMarkPen as MarkPenStrokeIcon, Markdown, SvgMenu$1 as MenuIcon, SvgMenu as MenuStrokeIcon, SvgMicrosoftExcel as MicrosoftExcelLogo, SvgMicrosoft as MicrosoftLogo, SvgMicrosoftPowerpoint as MicrosoftPowerpointLogo, SvgMicrosoftWord as MicrosoftWordLogo, SvgMistral as MistralLogo, Modal, SvgMore$1 as MoreIcon, SvgMore as MoreStrokeIcon, SvgMovingMail$1 as MovingMailIcon, SvgMovingMail as MovingMailStrokeIcon, Notification, SvgNotion as NotionLogo, SvgOffice as OfficeLogo, SvgOpenai as OpenaiLogo, SvgOpenaiWhite as OpenaiWhiteLogo, Page, PaginatedCitationsGrid, Pagination, SvgPaint$1 as PaintIcon, SvgPaint as PaintStrokeIcon, SvgPaperAirplane$1 as PaperAirplaneIcon, SvgPaperAirplane as PaperAirplaneStrokeIcon, SvgPause$1 as PauseIcon, SvgPause as PauseStrokeIcon, SvgPencilSquare$1 as PencilSquareIcon, SvgPencilSquare as PencilSquareStrokeIcon, SvgPlanet$1 as PlanetIcon, SvgPlanet as PlanetStrokeIcon, SvgPlay$1 as PlayIcon, SvgPlay as PlayStrokeIcon, SvgPlusCircle$1 as PlusCircleIcon, SvgPlusCircle as PlusCircleStrokeIcon, SvgPlus$1 as PlusIcon, SvgPlus as PlusStrokeIcon, Popup, PriceTable, SvgPushpin$1 as PushpinIcon, SvgPushpin as PushpinStrokeIcon, SvgPuzzle$1 as PuzzleIcon, SvgPuzzle as PuzzleStrokeIcon, SvgQuestionMarkCircle$1 as QuestionMarkCircleIcon, SvgQuestionMarkCircle as QuestionMarkCircleStrokeIcon, RadioButton, SvgReaction$1 as ReactionIcon, SvgReaction as ReactionStrokeIcon, SvgRectangle$1 as RectangleIcon, SvgRectangle as RectangleStrokeIcon, SvgReplicate as ReplicateLogo, SvgRobot$1 as RobotIcon, SvgRobot as RobotStrokeIcon, SvgRocket$1 as RocketIcon, SvgRocket as RocketStrokeIcon, SvgSalesforce as SalesforceLogo, SvgScan$1 as ScanIcon, SvgScan as ScanStrokeIcon, Searchbar, SvgServer$1 as ServerIcon, SvgServer as ServerStrokeIcon, SvgShakeHands$1 as ShakeHandsIcon, SvgShakeHands as ShakeHandsStrokeIcon, SvgShapes$1 as ShapesIcon, SvgShapes as ShapesStrokeIcon, SvgSlack as SlackLogo, SliderToggle, SparkleContext, SvgSparkles$1 as SparklesIcon, SvgSparkles as SparklesStrokeIcon, Spinner, SvgSquare3Stack3D$1 as Square3Stack3DIcon, SvgSquare3Stack3D as Square3Stack3DStrokeIcon, SvgSquare$1 as SquareIcon, SvgSquare as SquareStrokeIcon, SvgStar$1 as StarIcon, SvgStar as StarStrokeIcon, SvgStop$1 as StopIcon, SvgStop as StopStrokeIcon, Tab, SvgTable$1 as TableIcon, SvgTable as TableStrokeIcon, SvgTag$1 as TagIcon, SvgTag as TagStrokeIcon, SvgTemplate$1 as TemplateIcon, SvgTemplate as TemplateStrokeIcon, SvgTestTube$1 as TestTubeIcon, SvgTestTube as TestTubeStrokeIcon, TextArea, SvgTime$1 as TimeIcon, SvgTime as TimeStrokeIcon, Tooltip, SvgTranslate$1 as TranslateIcon, SvgTranslate as TranslateStrokeIcon, SvgTrash$1 as TrashIcon, SvgTrash as TrashStrokeIcon, Tree, SvgTriangle$1 as TriangleIcon, SvgTriangle as TriangleStrokeIcon, SvgUserArrow$1 as UserArrowIcon, SvgUserArrow as UserArrowStrokeIcon, SvgUserGroup$1 as UserGroupIcon, SvgUserGroup as UserGroupStrokeIcon, SvgUser$1 as UserIcon, SvgUserPlus$1 as UserPlusIcon, SvgUserPlus as UserPlusStrokeIcon, SvgUser as UserStrokeIcon, SvgWrench$1 as WrenchIcon, SvgWrench as WrenchStrokeIcon, SvgXCircle$1 as XCircleIcon, SvgXCircle as XCircleStrokeIcon, SvgXMark$1 as XMarkIcon, SvgXMark as XMarkStrokeIcon, SvgZapier$1 as ZapierLogo, SvgZapier as ZendeskLogo, ZoomableImageCitationWrapper, utils as avatarUtils };
+export { SvgAi21 as Ai21Logo, SvgAnthropic as AnthropicLogo, SvgAnthropicWhite as AnthropicWhiteLogo, SvgArrowDownCircle$1 as ArrowDownCircleIcon, SvgArrowDownCircle as ArrowDownCircleStrokeIcon, SvgArrowDown$1 as ArrowDownIcon, SvgArrowDownOnSquare$1 as ArrowDownOnSquareIcon, SvgArrowDownOnSquare as ArrowDownOnSquareStrokeIcon, SvgArrowDownS$1 as ArrowDownSIcon, SvgArrowDownS as ArrowDownSStrokeIcon, SvgArrowDown as ArrowDownStrokeIcon, SvgArrowLeft$1 as ArrowLeftIcon, SvgArrowLeftS$1 as ArrowLeftSIcon, SvgArrowLeftS as ArrowLeftSStrokeIcon, SvgArrowLeft as ArrowLeftStrokeIcon, SvgArrowPath$1 as ArrowPathIcon, SvgArrowPath as ArrowPathStrokeIcon, SvgArrowRight$1 as ArrowRightIcon, SvgArrowRightS$1 as ArrowRightSIcon, SvgArrowRightS as ArrowRightSStrokeIcon, SvgArrowRight as ArrowRightStrokeIcon, SvgArrowUp$1 as ArrowUpIcon, SvgArrowUpOnSquare$1 as ArrowUpOnSquareIcon, SvgArrowUpOnSquare as ArrowUpOnSquareStrokeIcon, SvgArrowUpS$1 as ArrowUpSIcon, SvgArrowUpS as ArrowUpSStrokeIcon, SvgArrowUp as ArrowUpStrokeIcon, AssistantPreview, SvgAttachment$1 as AttachmentIcon, SvgAttachment as AttachmentStrokeIcon, Avatar, SvgBackspace$1 as BackspaceIcon, SvgBackspace as BackspaceStrokeIcon, Banner, BarHeader, SvgBookOpen$1 as BookOpenIcon, SvgBookOpen as BookOpenStrokeIcon, SvgBookmark$1 as BookmarkIcon, SvgBookmark as BookmarkStrokeIcon, SvgBraces$1 as BracesIcon, SvgBraces as BracesStrokeIcon, Breadcrumbs, Button, CardButton, SvgCard$1 as CardIcon, SvgCard as CardStrokeIcon, SvgChatBubbleBottomCenterPlus$1 as ChatBubbleBottomCenterPlusIcon, SvgChatBubbleBottomCenterPlus as ChatBubbleBottomCenterPlusStrokeIcon, SvgChatBubbleBottomCenterText$1 as ChatBubbleBottomCenterTextIcon, SvgChatBubbleBottomCenterText as ChatBubbleBottomCenterTextStrokeIcon, SvgChatBubbleLeftRight$1 as ChatBubbleLeftRightIcon, SvgChatBubbleLeftRight as ChatBubbleLeftRightStrokeIcon, SvgChatBubbleThought$1 as ChatBubbleThoughtIcon, SvgChatBubbleThought as ChatBubbleThoughtStrokeIcon, SvgCheckCircle$1 as CheckCircleIcon, SvgCheckCircle as CheckCircleStrokeIcon, SvgCheck$1 as CheckIcon, SvgCheck as CheckStrokeIcon, Checkbox, SvgChevronDoubleLeft$1 as ChevronDoubleLeftIcon, SvgChevronDoubleLeft as ChevronDoubleLeftStrokeIcon, SvgChevronDoubleRight$1 as ChevronDoubleRightIcon, SvgChevronDoubleRight as ChevronDoubleRightStrokeIcon, SvgChevronDown$1 as ChevronDownIcon, SvgChevronDown as ChevronDownStrokeIcon, SvgChevronLeft$1 as ChevronLeftIcon, SvgChevronLeft as ChevronLeftStrokeIcon, SvgChevronRight$1 as ChevronRightIcon, SvgChevronRight as ChevronRightStrokeIcon, SvgChevronUpDown$1 as ChevronUpDownIcon, SvgChevronUpDown as ChevronUpDownStrokeIcon, SvgChevronUp$1 as ChevronUpIcon, SvgChevronUp as ChevronUpStrokeIcon, Chip, SvgCircle$1 as CircleIcon, SvgCircle as CircleStrokeIcon, Citation, SvgClaude as ClaudeLogo, SvgClipboardCheck$1 as ClipboardCheckIcon, SvgClipboardCheck as ClipboardCheckStrokeIcon, SvgClipboard$1 as ClipboardIcon, SvgClipboard as ClipboardStrokeIcon, SvgClock$1 as ClockIcon, SvgClock as ClockStrokeIcon, SvgCloudArrowDown$1 as CloudArrowDownIcon, SvgCloudArrowDown as CloudArrowDownStrokeIcon, SvgCloudArrowLeftRight$1 as CloudArrowLeftRightIcon, SvgCloudArrowLeftRight as CloudArrowLeftRightStrokeIcon, SvgCloudArrowUp$1 as CloudArrowUpIcon, SvgCloudArrowUp as CloudArrowUpStrokeIcon, SvgCloudX$1 as CloudXIcon, SvgCloudX as CloudXStrokeIcon, SvgCog6Tooth$1 as Cog6ToothIcon, SvgCog6Tooth as Cog6ToothStrokeIcon, SvgCohere as CohereLogo, CollapseButton, Collapsible, ColorPicker, SvgCommand$1 as CommandIcon, SvgCommandLine$1 as CommandLineIcon, SvgCommandLine as CommandLineStrokeIcon, SvgCommand as CommandStrokeIcon, SvgCompany$1 as CompanyIcon, SvgCompany as CompanyStrokeIcon, ConfettiBackground, SvgConfluence as ConfluenceLogo, ContentMessage, ContextItem, SvgCube$1 as CubeIcon, SvgCube as CubeStrokeIcon, SvgDash$1 as DashIcon, SvgDash as DashStrokeIcon, DataTable, Dialog, Div3D, SvgDocumentDuplicate$1 as DocumentDuplicateIcon, SvgDocumentDuplicate as DocumentDuplicateStrokeIcon, SvgDocument$1 as DocumentIcon, SvgDocumentPile$1 as DocumentPileIcon, SvgDocumentPile as DocumentPileStrokeIcon, SvgDocumentPlus$1 as DocumentPlusIcon, SvgDocumentPlus as DocumentPlusStrokeIcon, SvgDocument as DocumentStrokeIcon, SvgDocumentText$1 as DocumentTextIcon, SvgDocumentText as DocumentTextStrokeIcon, SvgDrive as DriveLogo, DropdownMenu, DropzoneOverlay, SvgDust$1 as DustIcon, SvgDust as DustStrokeIcon, ElementDialog, ElementModal, EmojiPicker, SvgEmotionLaugh$1 as EmotionLaughIcon, SvgEmotionLaugh as EmotionLaughStrokeIcon, SvgEqualizer$1 as EqualizerIcon, SvgEqualizer as EqualizerStrokeIcon, SvgExclamationCircle$1 as ExclamationCircleIcon, SvgExclamationCircle as ExclamationCircleStrokeIcon, SvgExternalLink$1 as ExternalLinkIcon, SvgExternalLink as ExternalLinkStrokeIcon, SvgEye$1 as EyeIcon, SvgEyeSlash$1 as EyeSlashIcon, SvgEyeSlash as EyeSlashStrokeIcon, SvgEye as EyeStrokeIcon, FilterChips, SvgFilter$1 as FilterIcon, SvgFilter as FilterStrokeIcon, SvgFire$1 as FireIcon, SvgFire as FireStrokeIcon, SvgFlag$1 as FlagIcon, SvgFlag as FlagStrokeIcon, SvgFolder$1 as FolderIcon, SvgFolderOpen$1 as FolderOpenIcon, SvgFolderOpen as FolderOpenStrokeIcon, SvgFolder as FolderStrokeIcon, SvgFullscreenExit$1 as FullscreenExitIcon, SvgFullscreenExit as FullscreenExitStrokeIcon, SvgFullscreen$1 as FullscreenIcon, SvgFullscreen as FullscreenStrokeIcon, SvgGemini as GeminiLogo, SvgGithub as GithubLogo, SvgGithubWhite as GithubWhiteLogo, SvgGlobeAlt$1 as GlobeAltIcon, SvgGlobeAlt as GlobeAltStrokeIcon, SvgGong as GongLogo, SvgGoogleDoc as GoogleDocLogo, SvgGoogle as GoogleLogo, SvgGooglePdf as GooglePdfLogo, SvgGoogleSlide as GoogleSlideLogo, SvgGoogleSpreadsheet as GoogleSpreadsheetLogo, SvgGpt3 as Gpt3Logo, SvgGpt4 as Gpt4Logo, SvgGrab$1 as GrabIcon, SvgGrab as GrabStrokeIcon, SvgHandThumbDown$1 as HandThumbDownIcon, SvgHandThumbDown as HandThumbDownStrokeIcon, SvgHandThumbUp$1 as HandThumbUpIcon, SvgHandThumbUp as HandThumbUpStrokeIcon, SvgHeartAlt$1 as HeartAltIcon, SvgHeartAlt as HeartAltStrokeIcon, SvgHeart$1 as HeartIcon, SvgHeart as HeartStrokeIcon, SvgHexagon$1 as HexagonIcon, SvgHexagon as HexagonStrokeIcon, SvgHistory$1 as HistoryIcon, SvgHistory as HistoryStrokeIcon, SvgHome$1 as HomeIcon, SvgHome as HomeStrokeIcon, Hover3D, Hoverable, SvgHuggingFace as HuggingFaceLogo, Icon, IconButton, IconToggleButton, SvgImage$1 as ImageIcon, SvgImage as ImageStrokeIcon, SvgInformationCircle$1 as InformationCircleIcon, SvgInformationCircle as InformationCircleStrokeIcon, Input, SvgIntercom as IntercomLogo, Item, SvgKey$1 as KeyIcon, SvgKey as KeyStrokeIcon, SvgLightbulb$1 as LightbulbIcon, SvgLightbulb as LightbulbStrokeIcon, SvgLink$1 as LinkIcon, SvgLink as LinkStrokeIcon, SvgListAdd$1 as ListAddIcon, SvgListAdd as ListAddStrokeIcon, SvgListCheck$1 as ListCheckIcon, SvgListCheck as ListCheckStrokeIcon, SvgList$1 as ListIcon, SvgListRemove$1 as ListRemoveIcon, SvgListRemove as ListRemoveStrokeIcon, SvgList as ListStrokeIcon, SvgLock$1 as LockIcon, SvgLock as LockStrokeIcon, SvgLogin$1 as LoginIcon, SvgLogin as LoginStrokeIcon, Logo, SvgLogoHorizontalColor as LogoHorizontalColorLogo, SvgLogoHorizontalColorLayer1 as LogoHorizontalColorLogoLayer1, SvgLogoHorizontalColorLayer2 as LogoHorizontalColorLogoLayer2, SvgLogoHorizontalDark as LogoHorizontalDarkLogo, SvgLogoHorizontalWhite as LogoHorizontalWhiteLogo, SvgLogoSquareColor as LogoSquareColorLogo, SvgLogoSquareColorLayer1 as LogoSquareColorLogoLayer1, SvgLogoSquareColorLayer2 as LogoSquareColorLogoLayer2, SvgLogoSquareDark as LogoSquareDarkLogo, SvgLogoSquareWhite as LogoSquareWhiteLogo, SvgLogout$1 as LogoutIcon, SvgLogout as LogoutStrokeIcon, SvgMagic$1 as MagicIcon, SvgMagic as MagicStrokeIcon, SvgMagnifyingGlass$1 as MagnifyingGlassIcon, SvgMagnifyingGlass as MagnifyingGlassStrokeIcon, SvgMarkPen$1 as MarkPenIcon, SvgMarkPen as MarkPenStrokeIcon, Markdown, SvgMenu$1 as MenuIcon, SvgMenu as MenuStrokeIcon, SvgMicrosoftExcel as MicrosoftExcelLogo, SvgMicrosoft as MicrosoftLogo, SvgMicrosoftPowerpoint as MicrosoftPowerpointLogo, SvgMicrosoftWord as MicrosoftWordLogo, SvgMistral as MistralLogo, Modal, SvgMore$1 as MoreIcon, SvgMore as MoreStrokeIcon, SvgMovingMail$1 as MovingMailIcon, SvgMovingMail as MovingMailStrokeIcon, Notification, SvgNotion as NotionLogo, SvgOffice as OfficeLogo, SvgOpenai as OpenaiLogo, SvgOpenaiWhite as OpenaiWhiteLogo, Page, PaginatedCitationsGrid, Pagination, SvgPaint$1 as PaintIcon, SvgPaint as PaintStrokeIcon, SvgPaperAirplane$1 as PaperAirplaneIcon, SvgPaperAirplane as PaperAirplaneStrokeIcon, SvgPause$1 as PauseIcon, SvgPause as PauseStrokeIcon, SvgPencilSquare$1 as PencilSquareIcon, SvgPencilSquare as PencilSquareStrokeIcon, SvgPlanet$1 as PlanetIcon, SvgPlanet as PlanetStrokeIcon, SvgPlay$1 as PlayIcon, SvgPlay as PlayStrokeIcon, SvgPlusCircle$1 as PlusCircleIcon, SvgPlusCircle as PlusCircleStrokeIcon, SvgPlus$1 as PlusIcon, SvgPlus as PlusStrokeIcon, Popup, PriceTable, SvgPushpin$1 as PushpinIcon, SvgPushpin as PushpinStrokeIcon, SvgPuzzle$1 as PuzzleIcon, SvgPuzzle as PuzzleStrokeIcon, SvgQuestionMarkCircle$1 as QuestionMarkCircleIcon, SvgQuestionMarkCircle as QuestionMarkCircleStrokeIcon, RadioButton, SvgReaction$1 as ReactionIcon, SvgReaction as ReactionStrokeIcon, SvgRectangle$1 as RectangleIcon, SvgRectangle as RectangleStrokeIcon, SvgReplicate as ReplicateLogo, SvgRobot$1 as RobotIcon, SvgRobot as RobotStrokeIcon, SvgRocket$1 as RocketIcon, SvgRocket as RocketStrokeIcon, SvgSalesforce as SalesforceLogo, SvgScan$1 as ScanIcon, SvgScan as ScanStrokeIcon, Searchbar, SvgServer$1 as ServerIcon, SvgServer as ServerStrokeIcon, SvgShakeHands$1 as ShakeHandsIcon, SvgShakeHands as ShakeHandsStrokeIcon, SvgShapes$1 as ShapesIcon, SvgShapes as ShapesStrokeIcon, SvgSlack as SlackLogo, SliderToggle, SparkleContext, SvgSparkles$1 as SparklesIcon, SvgSparkles as SparklesStrokeIcon, Spinner, SvgSquare3Stack3D$1 as Square3Stack3DIcon, SvgSquare3Stack3D as Square3Stack3DStrokeIcon, SvgSquare$1 as SquareIcon, SvgSquare as SquareStrokeIcon, SvgStar$1 as StarIcon, SvgStar as StarStrokeIcon, SvgStop$1 as StopIcon, SvgStop as StopStrokeIcon, Tab, SvgTable$1 as TableIcon, SvgTable as TableStrokeIcon, SvgTag$1 as TagIcon, SvgTag as TagStrokeIcon, SvgTemplate$1 as TemplateIcon, SvgTemplate as TemplateStrokeIcon, SvgTestTube$1 as TestTubeIcon, SvgTestTube as TestTubeStrokeIcon, TextArea, SvgTime$1 as TimeIcon, SvgTime as TimeStrokeIcon, Tooltip, SvgTranslate$1 as TranslateIcon, SvgTranslate as TranslateStrokeIcon, SvgTrash$1 as TrashIcon, SvgTrash as TrashStrokeIcon, Tree, SvgTriangle$1 as TriangleIcon, SvgTriangle as TriangleStrokeIcon, SvgUserArrow$1 as UserArrowIcon, SvgUserArrow as UserArrowStrokeIcon, SvgUserGroup$1 as UserGroupIcon, SvgUserGroup as UserGroupStrokeIcon, SvgUser$1 as UserIcon, SvgUserPlus$1 as UserPlusIcon, SvgUserPlus as UserPlusStrokeIcon, SvgUser as UserStrokeIcon, SvgWrench$1 as WrenchIcon, SvgWrench as WrenchStrokeIcon, SvgXCircle$1 as XCircleIcon, SvgXCircle as XCircleStrokeIcon, SvgXMark$1 as XMarkIcon, SvgXMark as XMarkStrokeIcon, SvgZapier$1 as ZapierLogo, SvgZapier as ZendeskLogo, ZoomableImageCitationWrapper, utils$2 as avatarUtils };
 //# sourceMappingURL=index.js.map