@twreporter/react-typescript-components 0.1.0-beta.6 → 0.1.0-beta.8

package/lib/internal-link-BLXTBMRq.js

@@ -0,0 +1,2278 @@
+const require_chunk = require('./chunk-BxBTb9qk.js');
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_chunk.__toESM(react_jsx_runtime);
+
+//#region ../../node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs
+var require__interop_require_wildcard = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/@swc/helpers/cjs/_interop_require_wildcard.cjs": ((exports) => {
+	function _getRequireWildcardCache(nodeInterop) {
+		if (typeof WeakMap !== "function") return null;
+		var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+		var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+		return (_getRequireWildcardCache = function(nodeInterop$1) {
+			return nodeInterop$1 ? cacheNodeInterop : cacheBabelInterop;
+		})(nodeInterop);
+	}
+	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$1 = _getRequireWildcardCache(nodeInterop);
+		if (cache$1 && cache$1.has(obj)) return cache$1.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$1) cache$1.set(obj, newObj);
+		return newObj;
+	}
+	exports._ = _interop_require_wildcard$1;
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/querystring.js
+var require_querystring = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/querystring.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$11(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$11(exports, {
+		assign: function() {
+			return assign;
+		},
+		searchParamsToUrlQuery: function() {
+			return searchParamsToUrlQuery;
+		},
+		urlQueryToSearchParams: function() {
+			return urlQueryToSearchParams;
+		}
+	});
+	function searchParamsToUrlQuery(searchParams) {
+		const query = {};
+		for (const [key, value] of searchParams.entries()) {
+			const existing = query[key];
+			if (typeof existing === "undefined") query[key] = value;
+			else if (Array.isArray(existing)) existing.push(value);
+			else query[key] = [existing, value];
+		}
+		return query;
+	}
+	function stringifyUrlQueryParam(param) {
+		if (typeof param === "string") return param;
+		if (typeof param === "number" && !isNaN(param) || typeof param === "boolean") return String(param);
+		else return "";
+	}
+	function urlQueryToSearchParams(query) {
+		const searchParams = new URLSearchParams();
+		for (const [key, value] of Object.entries(query)) if (Array.isArray(value)) for (const item of value) searchParams.append(key, stringifyUrlQueryParam(item));
+		else searchParams.set(key, stringifyUrlQueryParam(value));
+		return searchParams;
+	}
+	function assign(target) {
+		for (var _len = arguments.length, searchParamsList = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) searchParamsList[_key - 1] = arguments[_key];
+		for (const searchParams of searchParamsList) {
+			for (const key of searchParams.keys()) target.delete(key);
+			for (const [key, value] of searchParams.entries()) target.append(key, value);
+		}
+		return target;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/format-url.js
+var require_format_url = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/format-url.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$10(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$10(exports, {
+		formatUrl: function() {
+			return formatUrl;
+		},
+		formatWithValidation: function() {
+			return formatWithValidation;
+		},
+		urlObjectKeys: function() {
+			return urlObjectKeys;
+		}
+	});
+	const _querystring$1 = /* @__PURE__ */ require__interop_require_wildcard()._(require_querystring());
+	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$1.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);
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/omit.js
+var require_omit = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/omit.js": ((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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/utils.js
+var require_utils$1 = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/utils.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$9(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$9(exports, {
+		DecodeError: function() {
+			return DecodeError;
+		},
+		MiddlewareNotFoundError: function() {
+			return MiddlewareNotFoundError;
+		},
+		MissingStaticPage: function() {
+			return MissingStaticPage;
+		},
+		NormalizeError: function() {
+			return NormalizeError;
+		},
+		PageNotFoundError: function() {
+			return PageNotFoundError;
+		},
+		SP: function() {
+			return SP;
+		},
+		ST: function() {
+			return ST;
+		},
+		WEB_VITALS: function() {
+			return WEB_VITALS;
+		},
+		execOnce: function() {
+			return execOnce;
+		},
+		getDisplayName: function() {
+			return getDisplayName;
+		},
+		getLocationOrigin: function() {
+			return getLocationOrigin;
+		},
+		getURL: function() {
+			return getURL;
+		},
+		isAbsoluteUrl: function() {
+			return isAbsoluteUrl;
+		},
+		isResSent: function() {
+			return isResSent;
+		},
+		loadGetInitialProps: function() {
+			return loadGetInitialProps;
+		},
+		normalizeRepeatedSlashes: function() {
+			return normalizeRepeatedSlashes;
+		},
+		stringifyError: function() {
+			return stringifyError;
+		}
+	});
+	const WEB_VITALS = [
+		"CLS",
+		"FCP",
+		"FID",
+		"INP",
+		"LCP",
+		"TTFB"
+	];
+	function execOnce(fn) {
+		let used = false;
+		let result;
+		return function() {
+			for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+			if (!used) {
+				used = true;
+				result = fn(...args);
+			}
+			return result;
+		};
+	}
+	const ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;
+	const isAbsoluteUrl = (url) => ABSOLUTE_URL_REGEX.test(url);
+	function getLocationOrigin() {
+		const { protocol, hostname, port } = window.location;
+		return protocol + "//" + hostname + (port ? ":" + port : "");
+	}
+	function getURL() {
+		const { href } = window.location;
+		const origin = getLocationOrigin();
+		return href.substring(origin.length);
+	}
+	function getDisplayName(Component) {
+		return typeof Component === "string" ? Component : Component.displayName || Component.name || "Unknown";
+	}
+	function isResSent(res) {
+		return res.finished || res.headersSent;
+	}
+	function normalizeRepeatedSlashes(url) {
+		const urlParts = url.split("?");
+		return urlParts[0].replace(/\\/g, "/").replace(/\/\/+/g, "/") + (urlParts[1] ? "?" + urlParts.slice(1).join("?") : "");
+	}
+	async function loadGetInitialProps(App, ctx) {
+		if (process.env.NODE_ENV !== "production") {
+			var _App_prototype;
+			if ((_App_prototype = App.prototype) == null ? void 0 : _App_prototype.getInitialProps) {
+				const message = "\"" + getDisplayName(App) + ".getInitialProps()\" is defined as an instance method - visit https://nextjs.org/docs/messages/get-initial-props-as-an-instance-method for more information.";
+				throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+					value: "E394",
+					enumerable: false,
+					configurable: true
+				});
+			}
+		}
+		const res = ctx.res || ctx.ctx && ctx.ctx.res;
+		if (!App.getInitialProps) {
+			if (ctx.ctx && ctx.Component) return { pageProps: await loadGetInitialProps(ctx.Component, ctx.ctx) };
+			return {};
+		}
+		const props = await App.getInitialProps(ctx);
+		if (res && isResSent(res)) return props;
+		if (!props) {
+			const message = "\"" + getDisplayName(App) + ".getInitialProps()\" should resolve to an object. But found \"" + props + "\" instead.";
+			throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
+				value: "E394",
+				enumerable: false,
+				configurable: true
+			});
+		}
+		if (process.env.NODE_ENV !== "production") {
+			if (Object.keys(props).length === 0 && !ctx.ctx) console.warn("" + getDisplayName(App) + " returned an empty object from `getInitialProps`. This de-optimizes and prevents automatic static optimization. https://nextjs.org/docs/messages/empty-object-getInitialProps");
+		}
+		return props;
+	}
+	const SP = typeof performance !== "undefined";
+	const ST = SP && [
+		"mark",
+		"measure",
+		"getEntriesByName"
+	].every((method) => typeof performance[method] === "function");
+	var DecodeError = class extends Error {};
+	var NormalizeError = class extends Error {};
+	var PageNotFoundError = class extends Error {
+		constructor(page) {
+			super();
+			this.code = "ENOENT";
+			this.name = "PageNotFoundError";
+			this.message = "Cannot find module for page: " + page;
+		}
+	};
+	var MissingStaticPage = class extends Error {
+		constructor(page, message) {
+			super();
+			this.message = "Failed to load static file for page: " + page + " " + message;
+		}
+	};
+	var MiddlewareNotFoundError = class extends Error {
+		constructor() {
+			super();
+			this.code = "ENOENT";
+			this.message = "Cannot find the middleware module";
+		}
+	};
+	function stringifyError(error) {
+		return JSON.stringify({
+			message: error.message,
+			stack: error.stack
+		});
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js
+var require_remove_trailing_slash = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "removeTrailingSlash", {
+		enumerable: true,
+		get: function() {
+			return removeTrailingSlash;
+		}
+	});
+	function removeTrailingSlash(route) {
+		return route.replace(/\/$/, "") || "/";
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/parse-path.js
+var require_parse_path = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/parse-path.js": ((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 : void 0) : "",
+			hash: hashIndex > -1 ? path.slice(hashIndex) : ""
+		};
+		return {
+			pathname: path,
+			query: "",
+			hash: ""
+		};
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/normalize-trailing-slash.js
+var require_normalize_trailing_slash = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/normalize-trailing-slash.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "normalizePathTrailingSlash", {
+		enumerable: true,
+		get: function() {
+			return normalizePathTrailingSlash;
+		}
+	});
+	const _removetrailingslash$1 = require_remove_trailing_slash();
+	const _parsepath$2 = require_parse_path();
+	const normalizePathTrailingSlash = (path) => {
+		if (!path.startsWith("/") || process.env.__NEXT_MANUAL_TRAILING_SLASH) return path;
+		const { pathname, query, hash } = (0, _parsepath$2.parsePath)(path);
+		if (process.env.__NEXT_TRAILING_SLASH) if (/\.[^/]+\/?$/.test(pathname)) return "" + (0, _removetrailingslash$1.removeTrailingSlash)(pathname) + query + hash;
+		else if (pathname.endsWith("/")) return "" + pathname + query + hash;
+		else return pathname + "/" + query + hash;
+		return "" + (0, _removetrailingslash$1.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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js
+var require_path_has_prefix = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/path-has-prefix.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "pathHasPrefix", {
+		enumerable: true,
+		get: function() {
+			return pathHasPrefix;
+		}
+	});
+	const _parsepath$1 = require_parse_path();
+	function pathHasPrefix(path, prefix) {
+		if (typeof path !== "string") return false;
+		const { pathname } = (0, _parsepath$1.parsePath)(path);
+		return pathname === prefix || pathname.startsWith(prefix + "/");
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/has-base-path.js
+var require_has_base_path = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/has-base-path.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "hasBasePath", {
+		enumerable: true,
+		get: function() {
+			return hasBasePath;
+		}
+	});
+	const _pathhasprefix$1 = require_path_has_prefix();
+	const basePath$2 = process.env.__NEXT_ROUTER_BASEPATH || "";
+	function hasBasePath(path) {
+		return (0, _pathhasprefix$1.pathHasPrefix)(path, basePath$2);
+	}
+	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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/is-local-url.js
+var require_is_local_url = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/is-local-url.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "isLocalURL", {
+		enumerable: true,
+		get: function() {
+			return isLocalURL;
+		}
+	});
+	const _utils$3 = require_utils$1();
+	const _hasbasepath = require_has_base_path();
+	function isLocalURL(url) {
+		if (!(0, _utils$3.isAbsoluteUrl)(url)) return true;
+		try {
+			const locationOrigin = (0, _utils$3.getLocationOrigin)();
+			const resolved = new URL(url, locationOrigin);
+			return resolved.origin === locationOrigin && (0, _hasbasepath.hasBasePath)(resolved.pathname);
+		} catch (_) {
+			return false;
+		}
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/sorted-routes.js
+var require_sorted_routes = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/sorted-routes.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$8(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$8(exports, {
+		getSortedRouteObjects: function() {
+			return getSortedRouteObjects;
+		},
+		getSortedRoutes: function() {
+			return getSortedRoutes;
+		}
+	});
+	var UrlNode = class UrlNode {
+		insert(urlPath) {
+			this._insert(urlPath.split("/").filter(Boolean), [], false);
+		}
+		smoosh() {
+			return this._smoosh();
+		}
+		_smoosh(prefix) {
+			if (prefix === void 0) prefix = "/";
+			const childrenPaths = [...this.children.keys()].sort();
+			if (this.slugName !== null) childrenPaths.splice(childrenPaths.indexOf("[]"), 1);
+			if (this.restSlugName !== null) childrenPaths.splice(childrenPaths.indexOf("[...]"), 1);
+			if (this.optionalRestSlugName !== null) childrenPaths.splice(childrenPaths.indexOf("[[...]]"), 1);
+			const routes = childrenPaths.map((c) => this.children.get(c)._smoosh("" + prefix + c + "/")).reduce((prev, curr) => [...prev, ...curr], []);
+			if (this.slugName !== null) routes.push(...this.children.get("[]")._smoosh(prefix + "[" + this.slugName + "]/"));
+			if (!this.placeholder) {
+				const r = prefix === "/" ? "/" : prefix.slice(0, -1);
+				if (this.optionalRestSlugName != null) throw Object.defineProperty(/* @__PURE__ */ new Error("You cannot define a route with the same specificity as a optional catch-all route (\"" + r + "\" and \"" + r + "[[..." + this.optionalRestSlugName + "]]\")."), "__NEXT_ERROR_CODE", {
+					value: "E458",
+					enumerable: false,
+					configurable: true
+				});
+				routes.unshift(r);
+			}
+			if (this.restSlugName !== null) routes.push(...this.children.get("[...]")._smoosh(prefix + "[..." + this.restSlugName + "]/"));
+			if (this.optionalRestSlugName !== null) routes.push(...this.children.get("[[...]]")._smoosh(prefix + "[[..." + this.optionalRestSlugName + "]]/"));
+			return routes;
+		}
+		_insert(urlPaths, slugNames, isCatchAll) {
+			if (urlPaths.length === 0) {
+				this.placeholder = false;
+				return;
+			}
+			if (isCatchAll) throw Object.defineProperty(/* @__PURE__ */ new Error("Catch-all must be the last part of the URL."), "__NEXT_ERROR_CODE", {
+				value: "E392",
+				enumerable: false,
+				configurable: true
+			});
+			let nextSegment = urlPaths[0];
+			if (nextSegment.startsWith("[") && nextSegment.endsWith("]")) {
+				let segmentName = nextSegment.slice(1, -1);
+				let isOptional = false;
+				if (segmentName.startsWith("[") && segmentName.endsWith("]")) {
+					segmentName = segmentName.slice(1, -1);
+					isOptional = true;
+				}
+				if (segmentName.startsWith("…")) throw Object.defineProperty(/* @__PURE__ */ new Error("Detected a three-dot character ('…') at ('" + segmentName + "'). Did you mean ('...')?"), "__NEXT_ERROR_CODE", {
+					value: "E147",
+					enumerable: false,
+					configurable: true
+				});
+				if (segmentName.startsWith("...")) {
+					segmentName = segmentName.substring(3);
+					isCatchAll = true;
+				}
+				if (segmentName.startsWith("[") || segmentName.endsWith("]")) throw Object.defineProperty(/* @__PURE__ */ new Error("Segment names may not start or end with extra brackets ('" + segmentName + "')."), "__NEXT_ERROR_CODE", {
+					value: "E421",
+					enumerable: false,
+					configurable: true
+				});
+				if (segmentName.startsWith(".")) throw Object.defineProperty(/* @__PURE__ */ new Error("Segment names may not start with erroneous periods ('" + segmentName + "')."), "__NEXT_ERROR_CODE", {
+					value: "E288",
+					enumerable: false,
+					configurable: true
+				});
+				function handleSlug(previousSlug, nextSlug) {
+					if (previousSlug !== null) {
+						if (previousSlug !== nextSlug) throw Object.defineProperty(/* @__PURE__ */ new Error("You cannot use different slug names for the same dynamic path ('" + previousSlug + "' !== '" + nextSlug + "')."), "__NEXT_ERROR_CODE", {
+							value: "E337",
+							enumerable: false,
+							configurable: true
+						});
+					}
+					slugNames.forEach((slug) => {
+						if (slug === nextSlug) throw Object.defineProperty(/* @__PURE__ */ new Error("You cannot have the same slug name \"" + nextSlug + "\" repeat within a single dynamic path"), "__NEXT_ERROR_CODE", {
+							value: "E247",
+							enumerable: false,
+							configurable: true
+						});
+						if (slug.replace(/\W/g, "") === nextSegment.replace(/\W/g, "")) throw Object.defineProperty(/* @__PURE__ */ new Error("You cannot have the slug names \"" + slug + "\" and \"" + nextSlug + "\" differ only by non-word symbols within a single dynamic path"), "__NEXT_ERROR_CODE", {
+							value: "E499",
+							enumerable: false,
+							configurable: true
+						});
+					});
+					slugNames.push(nextSlug);
+				}
+				if (isCatchAll) if (isOptional) {
+					if (this.restSlugName != null) throw Object.defineProperty(/* @__PURE__ */ new Error("You cannot use both an required and optional catch-all route at the same level (\"[..." + this.restSlugName + "]\" and \"" + urlPaths[0] + "\" )."), "__NEXT_ERROR_CODE", {
+						value: "E299",
+						enumerable: false,
+						configurable: true
+					});
+					handleSlug(this.optionalRestSlugName, segmentName);
+					this.optionalRestSlugName = segmentName;
+					nextSegment = "[[...]]";
+				} else {
+					if (this.optionalRestSlugName != null) throw Object.defineProperty(/* @__PURE__ */ new Error("You cannot use both an optional and required catch-all route at the same level (\"[[..." + this.optionalRestSlugName + "]]\" and \"" + urlPaths[0] + "\")."), "__NEXT_ERROR_CODE", {
+						value: "E300",
+						enumerable: false,
+						configurable: true
+					});
+					handleSlug(this.restSlugName, segmentName);
+					this.restSlugName = segmentName;
+					nextSegment = "[...]";
+				}
+				else {
+					if (isOptional) throw Object.defineProperty(/* @__PURE__ */ new Error("Optional route parameters are not yet supported (\"" + urlPaths[0] + "\")."), "__NEXT_ERROR_CODE", {
+						value: "E435",
+						enumerable: false,
+						configurable: true
+					});
+					handleSlug(this.slugName, segmentName);
+					this.slugName = segmentName;
+					nextSegment = "[]";
+				}
+			}
+			if (!this.children.has(nextSegment)) this.children.set(nextSegment, new UrlNode());
+			this.children.get(nextSegment)._insert(urlPaths.slice(1), slugNames, isCatchAll);
+		}
+		constructor() {
+			this.placeholder = true;
+			this.children = /* @__PURE__ */ new Map();
+			this.slugName = null;
+			this.restSlugName = null;
+			this.optionalRestSlugName = null;
+		}
+	};
+	function getSortedRoutes(normalizedPages) {
+		const root = new UrlNode();
+		normalizedPages.forEach((pagePath) => root.insert(pagePath));
+		return root.smoosh();
+	}
+	function getSortedRouteObjects(objects, getter) {
+		const indexes = {};
+		const pathnames = [];
+		for (let i = 0; i < objects.length; i++) {
+			const pathname = getter(objects[i]);
+			indexes[pathname] = i;
+			pathnames[i] = pathname;
+		}
+		return getSortedRoutes(pathnames).map((pathname) => objects[indexes[pathname]]);
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/page-path/ensure-leading-slash.js
+var require_ensure_leading_slash = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/page-path/ensure-leading-slash.js": ((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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/segment.js
+var require_segment = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/segment.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$7(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$7(exports, {
+		DEFAULT_SEGMENT_KEY: function() {
+			return DEFAULT_SEGMENT_KEY;
+		},
+		PAGE_SEGMENT_KEY: function() {
+			return PAGE_SEGMENT_KEY;
+		},
+		addSearchParamsIfPageSegment: function() {
+			return addSearchParamsIfPageSegment;
+		},
+		isGroupSegment: function() {
+			return isGroupSegment;
+		},
+		isParallelRouteSegment: function() {
+			return isParallelRouteSegment;
+		}
+	});
+	function isGroupSegment(segment) {
+		return segment[0] === "(" && segment.endsWith(")");
+	}
+	function isParallelRouteSegment(segment) {
+		return segment.startsWith("@") && segment !== "@children";
+	}
+	function addSearchParamsIfPageSegment(segment, searchParams) {
+		if (segment.includes(PAGE_SEGMENT_KEY)) {
+			const stringifiedQuery = JSON.stringify(searchParams);
+			return stringifiedQuery !== "{}" ? PAGE_SEGMENT_KEY + "?" + stringifiedQuery : PAGE_SEGMENT_KEY;
+		}
+		return segment;
+	}
+	const PAGE_SEGMENT_KEY = "__PAGE__";
+	const DEFAULT_SEGMENT_KEY = "__DEFAULT__";
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/app-paths.js
+var require_app_paths = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/app-paths.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$6(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$6(exports, {
+		normalizeAppPath: function() {
+			return normalizeAppPath;
+		},
+		normalizeRscURL: function() {
+			return normalizeRscURL;
+		}
+	});
+	const _ensureleadingslash = require_ensure_leading_slash();
+	const _segment = require_segment();
+	function normalizeAppPath(route) {
+		return (0, _ensureleadingslash.ensureLeadingSlash)(route.split("/").reduce((pathname, segment, index, segments) => {
+			if (!segment) return pathname;
+			if ((0, _segment.isGroupSegment)(segment)) return pathname;
+			if (segment[0] === "@") return pathname;
+			if ((segment === "page" || segment === "route") && index === segments.length - 1) return pathname;
+			return pathname + "/" + segment;
+		}, ""));
+	}
+	function normalizeRscURL(url) {
+		return url.replace(/\.rsc($|\?)/, "$1");
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/interception-routes.js
+var require_interception_routes = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/interception-routes.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$5(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$5(exports, {
+		INTERCEPTION_ROUTE_MARKERS: function() {
+			return INTERCEPTION_ROUTE_MARKERS;
+		},
+		extractInterceptionRouteInformation: function() {
+			return extractInterceptionRouteInformation;
+		},
+		isInterceptionRouteAppPath: function() {
+			return isInterceptionRouteAppPath;
+		}
+	});
+	const _apppaths = require_app_paths();
+	const INTERCEPTION_ROUTE_MARKERS = [
+		"(..)(..)",
+		"(.)",
+		"(..)",
+		"(...)"
+	];
+	function isInterceptionRouteAppPath(path) {
+		return path.split("/").find((segment) => INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m))) !== void 0;
+	}
+	function extractInterceptionRouteInformation(path) {
+		let interceptingRoute, marker, interceptedRoute;
+		for (const segment of path.split("/")) {
+			marker = INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m));
+			if (marker) {
+				[interceptingRoute, interceptedRoute] = path.split(marker, 2);
+				break;
+			}
+		}
+		if (!interceptingRoute || !marker || !interceptedRoute) throw Object.defineProperty(/* @__PURE__ */ new Error("Invalid interception route: " + path + ". Must be in the format /<intercepting route>/(..|...|..)(..)/<intercepted route>"), "__NEXT_ERROR_CODE", {
+			value: "E269",
+			enumerable: false,
+			configurable: true
+		});
+		interceptingRoute = (0, _apppaths.normalizeAppPath)(interceptingRoute);
+		switch (marker) {
+			case "(.)":
+				if (interceptingRoute === "/") interceptedRoute = "/" + interceptedRoute;
+				else interceptedRoute = interceptingRoute + "/" + interceptedRoute;
+				break;
+			case "(..)":
+				if (interceptingRoute === "/") throw Object.defineProperty(/* @__PURE__ */ new Error("Invalid interception route: " + path + ". Cannot use (..) marker at the root level, use (.) instead."), "__NEXT_ERROR_CODE", {
+					value: "E207",
+					enumerable: false,
+					configurable: true
+				});
+				interceptedRoute = interceptingRoute.split("/").slice(0, -1).concat(interceptedRoute).join("/");
+				break;
+			case "(...)":
+				interceptedRoute = "/" + interceptedRoute;
+				break;
+			case "(..)(..)":
+				const splitInterceptingRoute = interceptingRoute.split("/");
+				if (splitInterceptingRoute.length <= 2) throw Object.defineProperty(/* @__PURE__ */ new Error("Invalid interception route: " + path + ". Cannot use (..)(..) marker at the root level or one level up."), "__NEXT_ERROR_CODE", {
+					value: "E486",
+					enumerable: false,
+					configurable: true
+				});
+				interceptedRoute = splitInterceptingRoute.slice(0, -2).concat(interceptedRoute).join("/");
+				break;
+			default: throw Object.defineProperty(/* @__PURE__ */ new Error("Invariant: unexpected marker"), "__NEXT_ERROR_CODE", {
+				value: "E112",
+				enumerable: false,
+				configurable: true
+			});
+		}
+		return {
+			interceptingRoute,
+			interceptedRoute
+		};
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/is-dynamic.js
+var require_is_dynamic = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/is-dynamic.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "isDynamicRoute", {
+		enumerable: true,
+		get: function() {
+			return isDynamicRoute;
+		}
+	});
+	const _interceptionroutes$1 = require_interception_routes();
+	const TEST_ROUTE = /\/[^/]*\[[^/]+\][^/]*(?=\/|$)/;
+	const TEST_STRICT_ROUTE = /\/\[[^/]+\](?=\/|$)/;
+	function isDynamicRoute(route, strict) {
+		if (strict === void 0) strict = true;
+		if ((0, _interceptionroutes$1.isInterceptionRouteAppPath)(route)) route = (0, _interceptionroutes$1.extractInterceptionRouteInformation)(route).interceptedRoute;
+		if (strict) return TEST_STRICT_ROUTE.test(route);
+		return TEST_ROUTE.test(route);
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/index.js
+var require_utils = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/index.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$4(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$4(exports, {
+		getSortedRouteObjects: function() {
+			return _sortedroutes.getSortedRouteObjects;
+		},
+		getSortedRoutes: function() {
+			return _sortedroutes.getSortedRoutes;
+		},
+		isDynamicRoute: function() {
+			return _isdynamic.isDynamicRoute;
+		}
+	});
+	const _sortedroutes = require_sorted_routes();
+	const _isdynamic = require_is_dynamic();
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/route-matcher.js
+var require_route_matcher = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/route-matcher.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "getRouteMatcher", {
+		enumerable: true,
+		get: function() {
+			return getRouteMatcher;
+		}
+	});
+	const _utils$2 = require_utils$1();
+	function getRouteMatcher(param) {
+		let { re, groups } = param;
+		return (pathname) => {
+			const routeMatch = re.exec(pathname);
+			if (!routeMatch) return false;
+			const decode = (param$1) => {
+				try {
+					return decodeURIComponent(param$1);
+				} catch (e) {
+					throw Object.defineProperty(new _utils$2.DecodeError("failed to decode param"), "__NEXT_ERROR_CODE", {
+						value: "E528",
+						enumerable: false,
+						configurable: true
+					});
+				}
+			};
+			const params = {};
+			for (const [key, group] of Object.entries(groups)) {
+				const match = routeMatch[group.pos];
+				if (match !== void 0) if (group.repeat) params[key] = match.split("/").map((entry) => decode(entry));
+				else params[key] = decode(match);
+			}
+			return params;
+		};
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/lib/constants.js
+var require_constants = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/lib/constants.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$3(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$3(exports, {
+		ACTION_SUFFIX: function() {
+			return ACTION_SUFFIX;
+		},
+		APP_DIR_ALIAS: function() {
+			return APP_DIR_ALIAS;
+		},
+		CACHE_ONE_YEAR: function() {
+			return CACHE_ONE_YEAR;
+		},
+		DOT_NEXT_ALIAS: function() {
+			return DOT_NEXT_ALIAS;
+		},
+		ESLINT_DEFAULT_DIRS: function() {
+			return ESLINT_DEFAULT_DIRS;
+		},
+		GSP_NO_RETURNED_VALUE: function() {
+			return GSP_NO_RETURNED_VALUE;
+		},
+		GSSP_COMPONENT_MEMBER_ERROR: function() {
+			return GSSP_COMPONENT_MEMBER_ERROR;
+		},
+		GSSP_NO_RETURNED_VALUE: function() {
+			return GSSP_NO_RETURNED_VALUE;
+		},
+		INFINITE_CACHE: function() {
+			return INFINITE_CACHE;
+		},
+		INSTRUMENTATION_HOOK_FILENAME: function() {
+			return INSTRUMENTATION_HOOK_FILENAME;
+		},
+		MATCHED_PATH_HEADER: function() {
+			return MATCHED_PATH_HEADER;
+		},
+		MIDDLEWARE_FILENAME: function() {
+			return MIDDLEWARE_FILENAME;
+		},
+		MIDDLEWARE_LOCATION_REGEXP: function() {
+			return MIDDLEWARE_LOCATION_REGEXP;
+		},
+		NEXT_BODY_SUFFIX: function() {
+			return NEXT_BODY_SUFFIX;
+		},
+		NEXT_CACHE_IMPLICIT_TAG_ID: function() {
+			return NEXT_CACHE_IMPLICIT_TAG_ID;
+		},
+		NEXT_CACHE_REVALIDATED_TAGS_HEADER: function() {
+			return NEXT_CACHE_REVALIDATED_TAGS_HEADER;
+		},
+		NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER: function() {
+			return NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER;
+		},
+		NEXT_CACHE_SOFT_TAG_MAX_LENGTH: function() {
+			return NEXT_CACHE_SOFT_TAG_MAX_LENGTH;
+		},
+		NEXT_CACHE_TAGS_HEADER: function() {
+			return NEXT_CACHE_TAGS_HEADER;
+		},
+		NEXT_CACHE_TAG_MAX_ITEMS: function() {
+			return NEXT_CACHE_TAG_MAX_ITEMS;
+		},
+		NEXT_CACHE_TAG_MAX_LENGTH: function() {
+			return NEXT_CACHE_TAG_MAX_LENGTH;
+		},
+		NEXT_DATA_SUFFIX: function() {
+			return NEXT_DATA_SUFFIX;
+		},
+		NEXT_INTERCEPTION_MARKER_PREFIX: function() {
+			return NEXT_INTERCEPTION_MARKER_PREFIX;
+		},
+		NEXT_META_SUFFIX: function() {
+			return NEXT_META_SUFFIX;
+		},
+		NEXT_QUERY_PARAM_PREFIX: function() {
+			return NEXT_QUERY_PARAM_PREFIX;
+		},
+		NEXT_RESUME_HEADER: function() {
+			return NEXT_RESUME_HEADER;
+		},
+		NON_STANDARD_NODE_ENV: function() {
+			return NON_STANDARD_NODE_ENV;
+		},
+		PAGES_DIR_ALIAS: function() {
+			return PAGES_DIR_ALIAS;
+		},
+		PRERENDER_REVALIDATE_HEADER: function() {
+			return PRERENDER_REVALIDATE_HEADER;
+		},
+		PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER: function() {
+			return PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER;
+		},
+		PUBLIC_DIR_MIDDLEWARE_CONFLICT: function() {
+			return PUBLIC_DIR_MIDDLEWARE_CONFLICT;
+		},
+		ROOT_DIR_ALIAS: function() {
+			return ROOT_DIR_ALIAS;
+		},
+		RSC_ACTION_CLIENT_WRAPPER_ALIAS: function() {
+			return RSC_ACTION_CLIENT_WRAPPER_ALIAS;
+		},
+		RSC_ACTION_ENCRYPTION_ALIAS: function() {
+			return RSC_ACTION_ENCRYPTION_ALIAS;
+		},
+		RSC_ACTION_PROXY_ALIAS: function() {
+			return RSC_ACTION_PROXY_ALIAS;
+		},
+		RSC_ACTION_VALIDATE_ALIAS: function() {
+			return RSC_ACTION_VALIDATE_ALIAS;
+		},
+		RSC_CACHE_WRAPPER_ALIAS: function() {
+			return RSC_CACHE_WRAPPER_ALIAS;
+		},
+		RSC_MOD_REF_PROXY_ALIAS: function() {
+			return RSC_MOD_REF_PROXY_ALIAS;
+		},
+		RSC_PREFETCH_SUFFIX: function() {
+			return RSC_PREFETCH_SUFFIX;
+		},
+		RSC_SEGMENTS_DIR_SUFFIX: function() {
+			return RSC_SEGMENTS_DIR_SUFFIX;
+		},
+		RSC_SEGMENT_SUFFIX: function() {
+			return RSC_SEGMENT_SUFFIX;
+		},
+		RSC_SUFFIX: function() {
+			return RSC_SUFFIX;
+		},
+		SERVER_PROPS_EXPORT_ERROR: function() {
+			return SERVER_PROPS_EXPORT_ERROR;
+		},
+		SERVER_PROPS_GET_INIT_PROPS_CONFLICT: function() {
+			return SERVER_PROPS_GET_INIT_PROPS_CONFLICT;
+		},
+		SERVER_PROPS_SSG_CONFLICT: function() {
+			return SERVER_PROPS_SSG_CONFLICT;
+		},
+		SERVER_RUNTIME: function() {
+			return SERVER_RUNTIME;
+		},
+		SSG_FALLBACK_EXPORT_ERROR: function() {
+			return SSG_FALLBACK_EXPORT_ERROR;
+		},
+		SSG_GET_INITIAL_PROPS_CONFLICT: function() {
+			return SSG_GET_INITIAL_PROPS_CONFLICT;
+		},
+		STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR: function() {
+			return STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR;
+		},
+		UNSTABLE_REVALIDATE_RENAME_ERROR: function() {
+			return UNSTABLE_REVALIDATE_RENAME_ERROR;
+		},
+		WEBPACK_LAYERS: function() {
+			return WEBPACK_LAYERS;
+		},
+		WEBPACK_RESOURCE_QUERIES: function() {
+			return WEBPACK_RESOURCE_QUERIES;
+		}
+	});
+	const NEXT_QUERY_PARAM_PREFIX = "nxtP";
+	const NEXT_INTERCEPTION_MARKER_PREFIX = "nxtI";
+	const MATCHED_PATH_HEADER = "x-matched-path";
+	const PRERENDER_REVALIDATE_HEADER = "x-prerender-revalidate";
+	const PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER = "x-prerender-revalidate-if-generated";
+	const RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
+	const RSC_SEGMENTS_DIR_SUFFIX = ".segments";
+	const RSC_SEGMENT_SUFFIX = ".segment.rsc";
+	const RSC_SUFFIX = ".rsc";
+	const ACTION_SUFFIX = ".action";
+	const NEXT_DATA_SUFFIX = ".json";
+	const NEXT_META_SUFFIX = ".meta";
+	const NEXT_BODY_SUFFIX = ".body";
+	const NEXT_CACHE_TAGS_HEADER = "x-next-cache-tags";
+	const NEXT_CACHE_REVALIDATED_TAGS_HEADER = "x-next-revalidated-tags";
+	const NEXT_CACHE_REVALIDATE_TAG_TOKEN_HEADER = "x-next-revalidate-tag-token";
+	const NEXT_RESUME_HEADER = "next-resume";
+	const NEXT_CACHE_TAG_MAX_ITEMS = 128;
+	const NEXT_CACHE_TAG_MAX_LENGTH = 256;
+	const NEXT_CACHE_SOFT_TAG_MAX_LENGTH = 1024;
+	const NEXT_CACHE_IMPLICIT_TAG_ID = "_N_T_";
+	const CACHE_ONE_YEAR = 31536e3;
+	const INFINITE_CACHE = 4294967294;
+	const MIDDLEWARE_FILENAME = "middleware";
+	const MIDDLEWARE_LOCATION_REGEXP = `(?:src/)?${MIDDLEWARE_FILENAME}`;
+	const INSTRUMENTATION_HOOK_FILENAME = "instrumentation";
+	const PAGES_DIR_ALIAS = "private-next-pages";
+	const DOT_NEXT_ALIAS = "private-dot-next";
+	const ROOT_DIR_ALIAS = "private-next-root-dir";
+	const APP_DIR_ALIAS = "private-next-app-dir";
+	const RSC_MOD_REF_PROXY_ALIAS = "private-next-rsc-mod-ref-proxy";
+	const RSC_ACTION_VALIDATE_ALIAS = "private-next-rsc-action-validate";
+	const RSC_ACTION_PROXY_ALIAS = "private-next-rsc-server-reference";
+	const RSC_CACHE_WRAPPER_ALIAS = "private-next-rsc-cache-wrapper";
+	const RSC_ACTION_ENCRYPTION_ALIAS = "private-next-rsc-action-encryption";
+	const RSC_ACTION_CLIENT_WRAPPER_ALIAS = "private-next-rsc-action-client-wrapper";
+	const PUBLIC_DIR_MIDDLEWARE_CONFLICT = `You can not have a '_next' folder inside of your public folder. This conflicts with the internal '/_next' route. https://nextjs.org/docs/messages/public-next-folder-conflict`;
+	const SSG_GET_INITIAL_PROPS_CONFLICT = `You can not use getInitialProps with getStaticProps. To use SSG, please remove your getInitialProps`;
+	const SERVER_PROPS_GET_INIT_PROPS_CONFLICT = `You can not use getInitialProps with getServerSideProps. Please remove getInitialProps.`;
+	const SERVER_PROPS_SSG_CONFLICT = `You can not use getStaticProps or getStaticPaths with getServerSideProps. To use SSG, please remove getServerSideProps`;
+	const STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR = `can not have getInitialProps/getServerSideProps, https://nextjs.org/docs/messages/404-get-initial-props`;
+	const SERVER_PROPS_EXPORT_ERROR = `pages with \`getServerSideProps\` can not be exported. See more info here: https://nextjs.org/docs/messages/gssp-export`;
+	const GSP_NO_RETURNED_VALUE = "Your `getStaticProps` function did not return an object. Did you forget to add a `return`?";
+	const GSSP_NO_RETURNED_VALUE = "Your `getServerSideProps` function did not return an object. Did you forget to add a `return`?";
+	const UNSTABLE_REVALIDATE_RENAME_ERROR = "The `unstable_revalidate` property is available for general use.\nPlease use `revalidate` instead.";
+	const GSSP_COMPONENT_MEMBER_ERROR = `can not be attached to a page's component and must be exported from the page. See more info here: https://nextjs.org/docs/messages/gssp-component-member`;
+	const NON_STANDARD_NODE_ENV = `You are using a non-standard "NODE_ENV" value in your environment. This creates inconsistencies in the project and is strongly advised against. Read more: https://nextjs.org/docs/messages/non-standard-node-env`;
+	const SSG_FALLBACK_EXPORT_ERROR = `Pages with \`fallback\` enabled in \`getStaticPaths\` can not be exported. See more info here: https://nextjs.org/docs/messages/ssg-fallback-true-export`;
+	const ESLINT_DEFAULT_DIRS = [
+		"app",
+		"pages",
+		"components",
+		"lib",
+		"src"
+	];
+	const SERVER_RUNTIME = {
+		edge: "edge",
+		experimentalEdge: "experimental-edge",
+		nodejs: "nodejs"
+	};
+	/**
+	* The names of the webpack layers. These layers are the primitives for the
+	* webpack chunks.
+	*/ const WEBPACK_LAYERS_NAMES = {
+		shared: "shared",
+		reactServerComponents: "rsc",
+		serverSideRendering: "ssr",
+		actionBrowser: "action-browser",
+		apiNode: "api-node",
+		apiEdge: "api-edge",
+		middleware: "middleware",
+		instrument: "instrument",
+		edgeAsset: "edge-asset",
+		appPagesBrowser: "app-pages-browser",
+		pagesDirBrowser: "pages-dir-browser",
+		pagesDirEdge: "pages-dir-edge",
+		pagesDirNode: "pages-dir-node"
+	};
+	const WEBPACK_LAYERS = {
+		...WEBPACK_LAYERS_NAMES,
+		GROUP: {
+			builtinReact: [WEBPACK_LAYERS_NAMES.reactServerComponents, WEBPACK_LAYERS_NAMES.actionBrowser],
+			serverOnly: [
+				WEBPACK_LAYERS_NAMES.reactServerComponents,
+				WEBPACK_LAYERS_NAMES.actionBrowser,
+				WEBPACK_LAYERS_NAMES.instrument,
+				WEBPACK_LAYERS_NAMES.middleware
+			],
+			neutralTarget: [WEBPACK_LAYERS_NAMES.apiNode, WEBPACK_LAYERS_NAMES.apiEdge],
+			clientOnly: [WEBPACK_LAYERS_NAMES.serverSideRendering, WEBPACK_LAYERS_NAMES.appPagesBrowser],
+			bundled: [
+				WEBPACK_LAYERS_NAMES.reactServerComponents,
+				WEBPACK_LAYERS_NAMES.actionBrowser,
+				WEBPACK_LAYERS_NAMES.serverSideRendering,
+				WEBPACK_LAYERS_NAMES.appPagesBrowser,
+				WEBPACK_LAYERS_NAMES.shared,
+				WEBPACK_LAYERS_NAMES.instrument,
+				WEBPACK_LAYERS_NAMES.middleware
+			],
+			appPages: [
+				WEBPACK_LAYERS_NAMES.reactServerComponents,
+				WEBPACK_LAYERS_NAMES.serverSideRendering,
+				WEBPACK_LAYERS_NAMES.appPagesBrowser,
+				WEBPACK_LAYERS_NAMES.actionBrowser
+			]
+		}
+	};
+	const WEBPACK_RESOURCE_QUERIES = {
+		edgeSSREntry: "__next_edge_ssr_entry__",
+		metadata: "__next_metadata__",
+		metadataRoute: "__next_metadata_route__",
+		metadataImageMeta: "__next_metadata_image_meta__"
+	};
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/escape-regexp.js
+var require_escape_regexp = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/escape-regexp.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "escapeStringRegexp", {
+		enumerable: true,
+		get: function() {
+			return escapeStringRegexp;
+		}
+	});
+	const reHasRegExp = /[|\\{}()[\]^$+*?.-]/;
+	const reReplaceRegExp = /[|\\{}()[\]^$+*?.-]/g;
+	function escapeStringRegexp(str) {
+		if (reHasRegExp.test(str)) return str.replace(reReplaceRegExp, "\\$&");
+		return str;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/route-regex.js
+var require_route_regex = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/route-regex.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$2(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$2(exports, {
+		getNamedMiddlewareRegex: function() {
+			return getNamedMiddlewareRegex;
+		},
+		getNamedRouteRegex: function() {
+			return getNamedRouteRegex;
+		},
+		getRouteRegex: function() {
+			return getRouteRegex;
+		},
+		parseParameter: function() {
+			return parseParameter;
+		}
+	});
+	const _constants = require_constants();
+	const _interceptionroutes = require_interception_routes();
+	const _escaperegexp = require_escape_regexp();
+	const _removetrailingslash = require_remove_trailing_slash();
+	/**
+	* Regular expression pattern used to match route parameters.
+	* Matches both single parameters and parameter groups.
+	* Examples:
+	*   - `[[...slug]]` matches parameter group with key 'slug', repeat: true, optional: true
+	*   - `[...slug]` matches parameter group with key 'slug', repeat: true, optional: false
+	*   - `[[foo]]` matches parameter with key 'foo', repeat: false, optional: true
+	*   - `[bar]` matches parameter with key 'bar', repeat: false, optional: false
+	*/ const PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+	function parseParameter(param) {
+		const match = param.match(PARAMETER_PATTERN);
+		if (!match) return parseMatchedParameter(param);
+		return parseMatchedParameter(match[2]);
+	}
+	/**
+	* Parses a matched parameter from the PARAMETER_PATTERN regex to a data structure that can be used
+	* to generate the parametrized route.
+	* Examples:
+	*   - `[...slug]` -> `{ key: 'slug', repeat: true, optional: true }`
+	*   - `...slug` -> `{ key: 'slug', repeat: true, optional: false }`
+	*   - `[foo]` -> `{ key: 'foo', repeat: false, optional: true }`
+	*   - `bar` -> `{ key: 'bar', repeat: false, optional: false }`
+	* @param param - The matched parameter to parse.
+	* @returns The parsed parameter as a data structure.
+	*/ function parseMatchedParameter(param) {
+		const optional = param.startsWith("[") && param.endsWith("]");
+		if (optional) param = param.slice(1, -1);
+		const repeat = param.startsWith("...");
+		if (repeat) param = param.slice(3);
+		return {
+			key: param,
+			repeat,
+			optional
+		};
+	}
+	function getParametrizedRoute(route, includeSuffix, includePrefix) {
+		const groups = {};
+		let groupIndex = 1;
+		const segments = [];
+		for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+			const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m));
+			const paramMatches = segment.match(PARAMETER_PATTERN);
+			if (markerMatch && paramMatches && paramMatches[2]) {
+				const { key, optional, repeat } = parseMatchedParameter(paramMatches[2]);
+				groups[key] = {
+					pos: groupIndex++,
+					repeat,
+					optional
+				};
+				segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(markerMatch) + "([^/]+?)");
+			} else if (paramMatches && paramMatches[2]) {
+				const { key, repeat, optional } = parseMatchedParameter(paramMatches[2]);
+				groups[key] = {
+					pos: groupIndex++,
+					repeat,
+					optional
+				};
+				if (includePrefix && paramMatches[1]) segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(paramMatches[1]));
+				let s = repeat ? optional ? "(?:/(.+?))?" : "/(.+?)" : "/([^/]+?)";
+				if (includePrefix && paramMatches[1]) s = s.substring(1);
+				segments.push(s);
+			} else segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(segment));
+			if (includeSuffix && paramMatches && paramMatches[3]) segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+		}
+		return {
+			parameterizedRoute: segments.join(""),
+			groups
+		};
+	}
+	function getRouteRegex(normalizedRoute, param) {
+		let { includeSuffix = false, includePrefix = false, excludeOptionalTrailingSlash = false } = param === void 0 ? {} : param;
+		const { parameterizedRoute, groups } = getParametrizedRoute(normalizedRoute, includeSuffix, includePrefix);
+		let re = parameterizedRoute;
+		if (!excludeOptionalTrailingSlash) re += "(?:/)?";
+		return {
+			re: /* @__PURE__ */ new RegExp("^" + re + "$"),
+			groups
+		};
+	}
+	/**
+	* Builds a function to generate a minimal routeKey using only a-z and minimal
+	* number of characters.
+	*/ function buildGetSafeRouteKey() {
+		let i = 0;
+		return () => {
+			let routeKey = "";
+			let j = ++i;
+			while (j > 0) {
+				routeKey += String.fromCharCode(97 + (j - 1) % 26);
+				j = Math.floor((j - 1) / 26);
+			}
+			return routeKey;
+		};
+	}
+	function getSafeKeyFromSegment(param) {
+		let { interceptionMarker, getSafeRouteKey, segment, routeKeys, keyPrefix, backreferenceDuplicateKeys } = param;
+		const { key, optional, repeat } = parseMatchedParameter(segment);
+		let cleanedKey = key.replace(/\W/g, "");
+		if (keyPrefix) cleanedKey = "" + keyPrefix + cleanedKey;
+		let invalidKey = false;
+		if (cleanedKey.length === 0 || cleanedKey.length > 30) invalidKey = true;
+		if (!isNaN(parseInt(cleanedKey.slice(0, 1)))) invalidKey = true;
+		if (invalidKey) cleanedKey = getSafeRouteKey();
+		const duplicateKey = cleanedKey in routeKeys;
+		if (keyPrefix) routeKeys[cleanedKey] = "" + keyPrefix + key;
+		else routeKeys[cleanedKey] = key;
+		const interceptionPrefix = interceptionMarker ? (0, _escaperegexp.escapeStringRegexp)(interceptionMarker) : "";
+		let pattern;
+		if (duplicateKey && backreferenceDuplicateKeys) pattern = "\\k<" + cleanedKey + ">";
+		else if (repeat) pattern = "(?<" + cleanedKey + ">.+?)";
+		else pattern = "(?<" + cleanedKey + ">[^/]+?)";
+		return optional ? "(?:/" + interceptionPrefix + pattern + ")?" : "/" + interceptionPrefix + pattern;
+	}
+	function getNamedParametrizedRoute(route, prefixRouteKeys, includeSuffix, includePrefix, backreferenceDuplicateKeys) {
+		const getSafeRouteKey = buildGetSafeRouteKey();
+		const routeKeys = {};
+		const segments = [];
+		for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+			const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m) => segment.startsWith(m));
+			const paramMatches = segment.match(PARAMETER_PATTERN);
+			if (hasInterceptionMarker && paramMatches && paramMatches[2]) segments.push(getSafeKeyFromSegment({
+				getSafeRouteKey,
+				interceptionMarker: paramMatches[1],
+				segment: paramMatches[2],
+				routeKeys,
+				keyPrefix: prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : void 0,
+				backreferenceDuplicateKeys
+			}));
+			else if (paramMatches && paramMatches[2]) {
+				if (includePrefix && paramMatches[1]) segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(paramMatches[1]));
+				let s = getSafeKeyFromSegment({
+					getSafeRouteKey,
+					segment: paramMatches[2],
+					routeKeys,
+					keyPrefix: prefixRouteKeys ? _constants.NEXT_QUERY_PARAM_PREFIX : void 0,
+					backreferenceDuplicateKeys
+				});
+				if (includePrefix && paramMatches[1]) s = s.substring(1);
+				segments.push(s);
+			} else segments.push("/" + (0, _escaperegexp.escapeStringRegexp)(segment));
+			if (includeSuffix && paramMatches && paramMatches[3]) segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+		}
+		return {
+			namedParameterizedRoute: segments.join(""),
+			routeKeys
+		};
+	}
+	function getNamedRouteRegex(normalizedRoute, options) {
+		var _options_includeSuffix, _options_includePrefix, _options_backreferenceDuplicateKeys;
+		const result = getNamedParametrizedRoute(normalizedRoute, options.prefixRouteKeys, (_options_includeSuffix = options.includeSuffix) != null ? _options_includeSuffix : false, (_options_includePrefix = options.includePrefix) != null ? _options_includePrefix : false, (_options_backreferenceDuplicateKeys = options.backreferenceDuplicateKeys) != null ? _options_backreferenceDuplicateKeys : false);
+		let namedRegex = result.namedParameterizedRoute;
+		if (!options.excludeOptionalTrailingSlash) namedRegex += "(?:/)?";
+		return {
+			...getRouteRegex(normalizedRoute, options),
+			namedRegex: "^" + namedRegex + "$",
+			routeKeys: result.routeKeys
+		};
+	}
+	function getNamedMiddlewareRegex(normalizedRoute, options) {
+		const { parameterizedRoute } = getParametrizedRoute(normalizedRoute, false, false);
+		const { catchAll = true } = options;
+		if (parameterizedRoute === "/") return { namedRegex: "^/" + (catchAll ? ".*" : "") + "$" };
+		const { namedParameterizedRoute } = getNamedParametrizedRoute(normalizedRoute, false, false, false, false);
+		let catchAllGroupedRegex = catchAll ? "(?:(/.*)?)" : "";
+		return { namedRegex: "^" + namedParameterizedRoute + catchAllGroupedRegex + "$" };
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/interpolate-as.js
+var require_interpolate_as = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/interpolate-as.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "interpolateAs", {
+		enumerable: true,
+		get: function() {
+			return interpolateAs;
+		}
+	});
+	const _routematcher = require_route_matcher();
+	const _routeregex = require_route_regex();
+	function interpolateAs(route, asPathname, query) {
+		let interpolatedRoute = "";
+		const dynamicRegex = (0, _routeregex.getRouteRegex)(route);
+		const dynamicGroups = dynamicRegex.groups;
+		const dynamicMatches = (asPathname !== route ? (0, _routematcher.getRouteMatcher)(dynamicRegex)(asPathname) : "") || query;
+		interpolatedRoute = route;
+		const params = Object.keys(dynamicGroups);
+		if (!params.every((param) => {
+			let value = dynamicMatches[param] || "";
+			const { repeat, optional } = dynamicGroups[param];
+			let replaced = "[" + (repeat ? "..." : "") + param + "]";
+			if (optional) replaced = (!value ? "/" : "") + "[" + replaced + "]";
+			if (repeat && !Array.isArray(value)) value = [value];
+			return (optional || param in dynamicMatches) && (interpolatedRoute = interpolatedRoute.replace(replaced, repeat ? value.map((segment) => encodeURIComponent(segment)).join("/") : encodeURIComponent(value)) || "/");
+		})) interpolatedRoute = "";
+		return {
+			params,
+			result: interpolatedRoute
+		};
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/resolve-href.js
+var require_resolve_href = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/resolve-href.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "resolveHref", {
+		enumerable: true,
+		get: function() {
+			return resolveHref;
+		}
+	});
+	const _querystring = require_querystring();
+	const _formaturl$1 = require_format_url();
+	const _omit = require_omit();
+	const _utils$1 = require_utils$1();
+	const _normalizetrailingslash$3 = require_normalize_trailing_slash();
+	const _islocalurl$1 = require_is_local_url();
+	const _utils1 = require_utils();
+	const _interpolateas = require_interpolate_as();
+	function resolveHref(router, href, resolveAs) {
+		let base;
+		let urlAsString = typeof href === "string" ? href : (0, _formaturl$1.formatWithValidation)(href);
+		const urlProtoMatch = urlAsString.match(/^[a-zA-Z]{1,}:\/\//);
+		const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
+		if ((urlAsStringNoProto.split("?", 1)[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$1.normalizeRepeatedSlashes)(urlAsStringNoProto);
+			urlAsString = (urlProtoMatch ? urlProtoMatch[0] : "") + normalizedUrl;
+		}
+		if (!(0, _islocalurl$1.isLocalURL)(urlAsString)) return resolveAs ? [urlAsString] : urlAsString;
+		try {
+			base = new URL(urlAsString.startsWith("#") ? router.asPath : router.pathname, "http://n");
+		} catch (_) {
+			base = new URL("/", "http://n");
+		}
+		try {
+			const finalUrl = new URL(urlAsString, base);
+			finalUrl.pathname = (0, _normalizetrailingslash$3.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$1.formatWithValidation)({
+					pathname: result,
+					hash: finalUrl.hash,
+					query: (0, _omit.omit)(query, params)
+				});
+			}
+			const resolvedHref = finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
+			return resolveAs ? [resolvedHref, interpolatedAs || resolvedHref] : resolvedHref;
+		} catch (_) {
+			return resolveAs ? [urlAsString] : urlAsString;
+		}
+	}
+	if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+		Object.defineProperty(exports.default, "__esModule", { value: true });
+		Object.assign(exports.default, exports);
+		module.exports = exports.default;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js
+var require_add_path_prefix = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "addPathPrefix", {
+		enumerable: true,
+		get: function() {
+			return addPathPrefix;
+		}
+	});
+	const _parsepath = require_parse_path();
+	function addPathPrefix(path, prefix) {
+		if (!path.startsWith("/") || !prefix) return path;
+		const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+		return "" + prefix + pathname + query + hash;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router/utils/add-locale.js
+var require_add_locale$1 = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router/utils/add-locale.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "addLocale", {
+		enumerable: true,
+		get: function() {
+			return addLocale$1;
+		}
+	});
+	const _addpathprefix$1 = require_add_path_prefix();
+	const _pathhasprefix = require_path_has_prefix();
+	function addLocale$1(path, locale, defaultLocale, ignorePrefix) {
+		if (!locale || locale === defaultLocale) return path;
+		const lower = path.toLowerCase();
+		if (!ignorePrefix) {
+			if ((0, _pathhasprefix.pathHasPrefix)(lower, "/api")) return path;
+			if ((0, _pathhasprefix.pathHasPrefix)(lower, "/" + locale.toLowerCase())) return path;
+		}
+		return (0, _addpathprefix$1.addPathPrefix)(path, "/" + locale);
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/add-locale.js
+var require_add_locale = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/add-locale.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "addLocale", {
+		enumerable: true,
+		get: function() {
+			return addLocale;
+		}
+	});
+	const _normalizetrailingslash$2 = require_normalize_trailing_slash();
+	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$2.normalizePathTrailingSlash)(require_add_locale$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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/@swc/helpers/cjs/_interop_require_default.cjs
+var require__interop_require_default = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/@swc/helpers/cjs/_interop_require_default.cjs": ((exports) => {
+	function _interop_require_default(obj) {
+		return obj && obj.__esModule ? obj : { default: obj };
+	}
+	exports._ = _interop_require_default;
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/router-context.shared-runtime.js
+var require_router_context_shared_runtime = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/router-context.shared-runtime.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "RouterContext", {
+		enumerable: true,
+		get: function() {
+			return RouterContext;
+		}
+	});
+	const RouterContext = (/* @__PURE__ */ require__interop_require_default()._(require("react"))).default.createContext(null);
+	if (process.env.NODE_ENV !== "production") RouterContext.displayName = "RouterContext";
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/request-idle-callback.js
+var require_request_idle_callback = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/request-idle-callback.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export$1(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export$1(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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/use-intersection.js
+var require_use_intersection = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/use-intersection.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "useIntersection", {
+		enumerable: true,
+		get: function() {
+			return useIntersection;
+		}
+	});
+	const _react$2 = require("react");
+	const _requestidlecallback = require_request_idle_callback();
+	const hasIntersectionObserver = typeof IntersectionObserver === "function";
+	const observers = /* @__PURE__ */ new Map();
+	const idList = [];
+	function createObserver(options) {
+		const id = {
+			root: options.root || null,
+			margin: options.rootMargin || ""
+		};
+		const existing = idList.find((obj) => obj.root === id.root && obj.margin === id.margin);
+		let instance;
+		if (existing) {
+			instance = observers.get(existing);
+			if (instance) return instance;
+		}
+		const elements = /* @__PURE__ */ new Map();
+		const observer = new IntersectionObserver((entries) => {
+			entries.forEach((entry) => {
+				const callback = elements.get(entry.target);
+				const isVisible = entry.isIntersecting || entry.intersectionRatio > 0;
+				if (callback && isVisible) callback(isVisible);
+			});
+		}, options);
+		instance = {
+			id,
+			observer,
+			elements
+		};
+		idList.push(id);
+		observers.set(id, instance);
+		return instance;
+	}
+	function observe(element, callback, options) {
+		const { id, observer, elements } = createObserver(options);
+		elements.set(element, callback);
+		observer.observe(element);
+		return function unobserve() {
+			elements.delete(element);
+			observer.unobserve(element);
+			if (elements.size === 0) {
+				observer.disconnect();
+				observers.delete(id);
+				const index = idList.findIndex((obj) => obj.root === id.root && obj.margin === id.margin);
+				if (index > -1) idList.splice(index, 1);
+			}
+		};
+	}
+	function useIntersection(param) {
+		let { rootRef, rootMargin, disabled } = param;
+		const isDisabled = disabled || !hasIntersectionObserver;
+		const [visible, setVisible] = (0, _react$2.useState)(false);
+		const elementRef = (0, _react$2.useRef)(null);
+		const setElement = (0, _react$2.useCallback)((element) => {
+			elementRef.current = element;
+		}, []);
+		(0, _react$2.useEffect)(() => {
+			if (hasIntersectionObserver) {
+				if (isDisabled || visible) return;
+				const element = elementRef.current;
+				if (element && element.tagName) return observe(element, (isVisible) => isVisible && setVisible(isVisible), {
+					root: rootRef == null ? void 0 : rootRef.current,
+					rootMargin
+				});
+			} else if (!visible) {
+				const idleCallback = (0, _requestidlecallback.requestIdleCallback)(() => setVisible(true));
+				return () => (0, _requestidlecallback.cancelIdleCallback)(idleCallback);
+			}
+		}, [
+			isDisabled,
+			rootMargin,
+			rootRef,
+			visible,
+			elementRef.current
+		]);
+		const resetVisible = (0, _react$2.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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js
+var require_normalize_locale_path$1 = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "normalizeLocalePath", {
+		enumerable: true,
+		get: function() {
+			return normalizeLocalePath$1;
+		}
+	});
+	/**
+	* A cache of lowercased locales for each list of locales. This is stored as a
+	* WeakMap so if the locales are garbage collected, the cache entry will be
+	* removed as well.
+	*/ const cache = /* @__PURE__ */ new WeakMap();
+	function normalizeLocalePath$1(pathname, locales) {
+		if (!locales) return { pathname };
+		let lowercasedLocales = cache.get(locales);
+		if (!lowercasedLocales) {
+			lowercasedLocales = locales.map((locale) => locale.toLowerCase());
+			cache.set(locales, lowercasedLocales);
+		}
+		let detectedLocale;
+		const segments = pathname.split("/", 2);
+		if (!segments[1]) return { pathname };
+		const segment = segments[1].toLowerCase();
+		const index = lowercasedLocales.indexOf(segment);
+		if (index < 0) return { pathname };
+		detectedLocale = locales[index];
+		pathname = pathname.slice(detectedLocale.length + 1) || "/";
+		return {
+			pathname,
+			detectedLocale
+		};
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/normalize-locale-path.js
+var require_normalize_locale_path = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/normalize-locale-path.js": ((exports, module) => {
+	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 require_normalize_locale_path$1().normalizeLocalePath(pathname, locales);
+		return {
+			pathname,
+			detectedLocale: void 0
+		};
+	};
+	if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+		Object.defineProperty(exports.default, "__esModule", { value: true });
+		Object.assign(exports.default, exports);
+		module.exports = exports.default;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js
+var require_detect_domain_locale$1 = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "detectDomainLocale", {
+		enumerable: true,
+		get: function() {
+			return detectDomainLocale$1;
+		}
+	});
+	function detectDomainLocale$1(domainItems, hostname, detectedLocale) {
+		if (!domainItems) return;
+		if (detectedLocale) detectedLocale = detectedLocale.toLowerCase();
+		for (const item of domainItems) {
+			var _item_domain, _item_locales;
+			const domainHostname = (_item_domain = item.domain) == null ? void 0 : _item_domain.split(":", 1)[0].toLowerCase();
+			if (hostname === domainHostname || detectedLocale === item.defaultLocale.toLowerCase() || ((_item_locales = item.locales) == null ? void 0 : _item_locales.some((locale) => locale.toLowerCase() === detectedLocale))) return item;
+		}
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/detect-domain-locale.js
+var require_detect_domain_locale = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/detect-domain-locale.js": ((exports, module) => {
+	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 require_detect_domain_locale$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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/get-domain-locale.js
+var require_get_domain_locale = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/get-domain-locale.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "getDomainLocale", {
+		enumerable: true,
+		get: function() {
+			return getDomainLocale;
+		}
+	});
+	const _normalizetrailingslash$1 = require_normalize_trailing_slash();
+	const basePath$1 = process.env.__NEXT_ROUTER_BASEPATH || "";
+	function getDomainLocale(path, locale, locales, domainLocales) {
+		if (process.env.__NEXT_I18N_SUPPORT) {
+			const normalizeLocalePath$2 = require_normalize_locale_path().normalizeLocalePath;
+			const detectDomainLocale$2 = require_detect_domain_locale().detectDomainLocale;
+			const target = locale || normalizeLocalePath$2(path, locales).detectedLocale;
+			const domain = detectDomainLocale$2(domainLocales, void 0, target);
+			if (domain) {
+				const proto = "http" + (domain.http ? "" : "s") + "://";
+				const finalLocale = target === domain.defaultLocale ? "" : "/" + target;
+				return "" + proto + domain.domain + (0, _normalizetrailingslash$1.normalizePathTrailingSlash)("" + basePath$1 + 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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/add-base-path.js
+var require_add_base_path = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/add-base-path.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "addBasePath", {
+		enumerable: true,
+		get: function() {
+			return addBasePath;
+		}
+	});
+	const _addpathprefix = require_add_path_prefix();
+	const _normalizetrailingslash = require_normalize_trailing_slash();
+	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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/use-merged-ref.js
+var require_use_merged_ref = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/use-merged-ref.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "useMergedRef", {
+		enumerable: true,
+		get: function() {
+			return useMergedRef;
+		}
+	});
+	const _react$1 = require("react");
+	function useMergedRef(refA, refB) {
+		const cleanupA = (0, _react$1.useRef)(null);
+		const cleanupB = (0, _react$1.useRef)(null);
+		return (0, _react$1.useCallback)((current) => {
+			if (current === null) {
+				const cleanupFnA = cleanupA.current;
+				if (cleanupFnA) {
+					cleanupA.current = null;
+					cleanupFnA();
+				}
+				const cleanupFnB = cleanupB.current;
+				if (cleanupFnB) {
+					cleanupB.current = null;
+					cleanupFnB();
+				}
+			} else {
+				if (refA) cleanupA.current = applyRef(refA, current);
+				if (refB) cleanupB.current = applyRef(refB, current);
+			}
+		}, [refA, refB]);
+	}
+	function applyRef(refA, current) {
+		if (typeof refA === "function") {
+			const cleanup = refA(current);
+			if (typeof cleanup === "function") return cleanup;
+			else return () => refA(null);
+		} else {
+			refA.current = current;
+			return () => {
+				refA.current = null;
+			};
+		}
+	}
+	if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+		Object.defineProperty(exports.default, "__esModule", { value: true });
+		Object.assign(exports.default, exports);
+		module.exports = exports.default;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/shared/lib/utils/error-once.js
+var require_error_once = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/shared/lib/utils/error-once.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "errorOnce", {
+		enumerable: true,
+		get: function() {
+			return errorOnce;
+		}
+	});
+	let errorOnce = (_) => {};
+	if (process.env.NODE_ENV !== "production") {
+		const errors = /* @__PURE__ */ new Set();
+		errorOnce = (msg) => {
+			if (!errors.has(msg)) console.error(msg);
+			errors.add(msg);
+		};
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/dist/client/link.js
+var require_link$1 = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/dist/client/link.js": ((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export(exports, {
+		default: function() {
+			return _default;
+		},
+		useLinkStatus: function() {
+			return useLinkStatus;
+		}
+	});
+	const _interop_require_wildcard = require__interop_require_wildcard();
+	const _jsxruntime = require("react/jsx-runtime");
+	const _react = /* @__PURE__ */ _interop_require_wildcard._(require("react"));
+	const _resolvehref = require_resolve_href();
+	const _islocalurl = require_is_local_url();
+	const _formaturl = require_format_url();
+	const _utils = require_utils$1();
+	const _addlocale = require_add_locale();
+	const _routercontextsharedruntime = require_router_context_shared_runtime();
+	const _useintersection = require_use_intersection();
+	const _getdomainlocale = require_get_domain_locale();
+	const _addbasepath = require_add_base_path();
+	const _usemergedref = require_use_merged_ref();
+	const _erroronce = require_error_once();
+	const prefetched = /* @__PURE__ */ new Set();
+	function prefetch(router, href, as, options) {
+		if (typeof window === "undefined") return;
+		if (!(0, _islocalurl.isLocalURL)(href)) return;
+		if (!options.bypassPrefetchedCheck) {
+			const locale = typeof options.locale !== "undefined" ? options.locale : "locale" in router ? router.locale : void 0;
+			const prefetchedKey = href + "%" + as + "%" + locale;
+			if (prefetched.has(prefetchedKey)) return;
+			prefetched.add(prefetchedKey);
+		}
+		router.prefetch(href, as, options).catch((err) => {
+			if (process.env.NODE_ENV !== "production") throw err;
+		});
+	}
+	function isModifiedEvent(event) {
+		const target = event.currentTarget.getAttribute("target");
+		return target && target !== "_self" || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.nativeEvent && event.nativeEvent.which === 2;
+	}
+	function linkClicked(e, router, href, as, replace, shallow, scroll, locale, onNavigate) {
+		const { nodeName } = e.currentTarget;
+		if (nodeName.toUpperCase() === "A" && isModifiedEvent(e) || e.currentTarget.hasAttribute("download")) return;
+		if (!(0, _islocalurl.isLocalURL)(href)) {
+			if (replace) {
+				e.preventDefault();
+				location.replace(href);
+			}
+			return;
+		}
+		e.preventDefault();
+		const navigate = () => {
+			if (onNavigate) {
+				let isDefaultPrevented = false;
+				onNavigate({ preventDefault: () => {
+					isDefaultPrevented = true;
+				} });
+				if (isDefaultPrevented) return;
+			}
+			const routerScroll = scroll != null ? scroll : true;
+			if ("beforePopState" in router) router[replace ? "replace" : "push"](href, as, {
+				shallow,
+				locale,
+				scroll: routerScroll
+			});
+			else router[replace ? "replace" : "push"](as || href, { scroll: routerScroll });
+		};
+		navigate();
+	}
+	function formatStringOrUrl(urlObjOrString) {
+		if (typeof urlObjOrString === "string") return urlObjOrString;
+		return (0, _formaturl.formatUrl)(urlObjOrString);
+	}
+	/**
+	* 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$1 = /* @__PURE__ */ _react.default.forwardRef(function LinkComponent(props, forwardedRef) {
+		let children;
+		const { href: hrefProp, as: asProp, children: childrenProp, prefetch: prefetchProp = null, passHref, replace, shallow, scroll, locale, onClick, onNavigate, onMouseEnter: onMouseEnterProp, onTouchStart: onTouchStartProp, legacyBehavior = false,...restProps } = props;
+		children = childrenProp;
+		if (legacyBehavior && (typeof children === "string" || typeof children === "number")) children = /* @__PURE__ */ (0, _jsxruntime.jsx)("a", { children });
+		const router = _react.default.useContext(_routercontextsharedruntime.RouterContext);
+		const prefetchEnabled = prefetchProp !== false;
+		if (process.env.NODE_ENV !== "production") {
+			function createPropError(args) {
+				return Object.defineProperty(/* @__PURE__ */ new Error("Failed prop type: The prop `" + args.key + "` expects a " + args.expected + " in `<Link>`, but got `" + args.actual + "` instead." + (typeof window !== "undefined" ? "\nOpen your browser's console to view the Component stack trace." : "")), "__NEXT_ERROR_CODE", {
+					value: "E319",
+					enumerable: false,
+					configurable: true
+				});
+			}
+			Object.keys({ href: true }).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]
+					});
+				}
+			});
+			Object.keys({
+				as: true,
+				replace: true,
+				scroll: true,
+				shallow: true,
+				passHref: true,
+				prefetch: true,
+				locale: true,
+				onClick: true,
+				onMouseEnter: true,
+				onTouchStart: true,
+				legacyBehavior: true,
+				onNavigate: true
+			}).forEach((key) => {
+				const valType = typeof props[key];
+				if (key === "as") {
+					if (props[key] && valType !== "string" && valType !== "object") throw createPropError({
+						key,
+						expected: "`string` or `object`",
+						actual: valType
+					});
+				} else if (key === "locale") {
+					if (props[key] && valType !== "string") throw createPropError({
+						key,
+						expected: "`string`",
+						actual: valType
+					});
+				} else if (key === "onClick" || key === "onMouseEnter" || key === "onTouchStart" || key === "onNavigate") {
+					if (props[key] && valType !== "function") throw createPropError({
+						key,
+						expected: "`function`",
+						actual: valType
+					});
+				} else if (key === "replace" || key === "scroll" || key === "shallow" || key === "passHref" || key === "prefetch" || key === "legacyBehavior") {
+					if (props[key] != null && valType !== "boolean") throw createPropError({
+						key,
+						expected: "`boolean`",
+						actual: valType
+					});
+				}
+			});
+		}
+		const { href, as } = _react.default.useMemo(() => {
+			if (!router) {
+				const resolvedHref$1 = formatStringOrUrl(hrefProp);
+				return {
+					href: resolvedHref$1,
+					as: asProp ? formatStringOrUrl(asProp) : resolvedHref$1
+				};
+			}
+			const [resolvedHref, resolvedAs] = (0, _resolvehref.resolveHref)(router, hrefProp, true);
+			return {
+				href: resolvedHref,
+				as: asProp ? (0, _resolvehref.resolveHref)(router, asProp) : resolvedAs || resolvedHref
+			};
+		}, [
+			router,
+			hrefProp,
+			asProp
+		]);
+		const previousHref = _react.default.useRef(href);
+		const previousAs = _react.default.useRef(as);
+		let child;
+		if (legacyBehavior) if (process.env.NODE_ENV === "development") {
+			if (onClick) console.warn("\"onClick\" was passed to <Link> with `href` of `" + hrefProp + "` but \"legacyBehavior\" was set. The legacy behavior requires onClick be set on the child of next/link");
+			if (onMouseEnterProp) console.warn("\"onMouseEnter\" was passed to <Link> with `href` of `" + hrefProp + "` but \"legacyBehavior\" was set. The legacy behavior requires onMouseEnter be set on the child of next/link");
+			try {
+				child = _react.default.Children.only(children);
+			} catch (err) {
+				if (!children) throw Object.defineProperty(/* @__PURE__ */ new Error("No children were passed to <Link> with `href` of `" + hrefProp + "` but one child is required https://nextjs.org/docs/messages/link-no-children"), "__NEXT_ERROR_CODE", {
+					value: "E320",
+					enumerable: false,
+					configurable: true
+				});
+				throw Object.defineProperty(/* @__PURE__ */ new Error("Multiple children were passed to <Link> with `href` of `" + hrefProp + "` but only one child is supported https://nextjs.org/docs/messages/link-multiple-children" + (typeof window !== "undefined" ? " \nOpen your browser's console to view the Component stack trace." : "")), "__NEXT_ERROR_CODE", {
+					value: "E266",
+					enumerable: false,
+					configurable: true
+				});
+			}
+		} else child = _react.default.Children.only(children);
+		else if (process.env.NODE_ENV === "development") {
+			if ((children == null ? void 0 : children.type) === "a") throw Object.defineProperty(/* @__PURE__ */ new Error("Invalid <Link> with <a> child. Please remove <a> or use <Link legacyBehavior>.\nLearn more: https://nextjs.org/docs/messages/invalid-new-link-with-extra-anchor"), "__NEXT_ERROR_CODE", {
+				value: "E209",
+				enumerable: false,
+				configurable: true
+			});
+		}
+		const childRef = legacyBehavior ? child && typeof child === "object" && child.ref : forwardedRef;
+		const [setIntersectionRef, isVisible, resetVisible] = (0, _useintersection.useIntersection)({ rootMargin: "200px" });
+		const setIntersectionWithResetRef = _react.default.useCallback((el) => {
+			if (previousAs.current !== as || previousHref.current !== href) {
+				resetVisible();
+				previousAs.current = as;
+				previousHref.current = href;
+			}
+			setIntersectionRef(el);
+		}, [
+			as,
+			href,
+			resetVisible,
+			setIntersectionRef
+		]);
+		const setRef = (0, _usemergedref.useMergedRef)(setIntersectionWithResetRef, childRef);
+		_react.default.useEffect(() => {
+			if (process.env.NODE_ENV !== "production") return;
+			if (!router) return;
+			if (!isVisible || !prefetchEnabled) return;
+			prefetch(router, href, as, { locale });
+		}, [
+			as,
+			href,
+			isVisible,
+			locale,
+			prefetchEnabled,
+			router == null ? void 0 : router.locale,
+			router
+		]);
+		const childProps = {
+			ref: setRef,
+			onClick(e) {
+				if (process.env.NODE_ENV !== "production") {
+					if (!e) throw Object.defineProperty(/* @__PURE__ */ new Error("Component rendered inside next/link has to pass click event to \"onClick\" prop."), "__NEXT_ERROR_CODE", {
+						value: "E312",
+						enumerable: false,
+						configurable: true
+					});
+				}
+				if (!legacyBehavior && typeof onClick === "function") onClick(e);
+				if (legacyBehavior && child.props && typeof child.props.onClick === "function") child.props.onClick(e);
+				if (!router) return;
+				if (e.defaultPrevented) return;
+				linkClicked(e, router, href, as, replace, shallow, scroll, locale, onNavigate);
+			},
+			onMouseEnter(e) {
+				if (!legacyBehavior && typeof onMouseEnterProp === "function") onMouseEnterProp(e);
+				if (legacyBehavior && child.props && typeof child.props.onMouseEnter === "function") child.props.onMouseEnter(e);
+				if (!router) return;
+				prefetch(router, href, as, {
+					locale,
+					priority: true,
+					bypassPrefetchedCheck: true
+				});
+			},
+			onTouchStart: process.env.__NEXT_LINK_NO_TOUCH_START ? void 0 : function onTouchStart(e) {
+				if (!legacyBehavior && typeof onTouchStartProp === "function") onTouchStartProp(e);
+				if (legacyBehavior && child.props && typeof child.props.onTouchStart === "function") child.props.onTouchStart(e);
+				if (!router) return;
+				prefetch(router, href, as, {
+					locale,
+					priority: true,
+					bypassPrefetchedCheck: true
+				});
+			}
+		};
+		if ((0, _utils.isAbsoluteUrl)(as)) childProps.href = as;
+		else if (!legacyBehavior || passHref || child.type === "a" && !("href" in child.props)) {
+			const curLocale = typeof locale !== "undefined" ? locale : router == null ? void 0 : router.locale;
+			childProps.href = (router == null ? void 0 : router.isLocaleDomain) && (0, _getdomainlocale.getDomainLocale)(as, curLocale, router == null ? void 0 : router.locales, router == null ? void 0 : router.domainLocales) || (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(as, curLocale, router == null ? void 0 : router.defaultLocale));
+		}
+		if (legacyBehavior) {
+			if (process.env.NODE_ENV === "development") (0, _erroronce.errorOnce)("`legacyBehavior` is deprecated and will be removed in a future release. A codemod is available to upgrade your components:\n\nnpx @next/codemod@latest new-link .\n\nLearn more: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#remove-a-tags-from-link-components");
+			return /* @__PURE__ */ _react.default.cloneElement(child, childProps);
+		}
+		return /* @__PURE__ */ (0, _jsxruntime.jsx)("a", {
+			...restProps,
+			...childProps,
+			children
+		});
+	});
+	const LinkStatusContext = /* @__PURE__ */ (0, _react.createContext)({ pending: false });
+	const useLinkStatus = () => {
+		return (0, _react.useContext)(LinkStatusContext);
+	};
+	const _default = Link$1;
+	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;
+	}
+}) });
+
+//#endregion
+//#region ../../node_modules/next/link.js
+var require_link = /* @__PURE__ */ require_chunk.__commonJS({ "../../node_modules/next/link.js": ((exports, module) => {
+	module.exports = require_link$1();
+}) });
+
+//#endregion
+//#region src/customized-link/internal-link.tsx
+var import_link = /* @__PURE__ */ require_chunk.__toESM(require_link());
+const InternalLink = ({ to, target = "_self", className = "", children }) => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(import_link.default, {
+		href: to,
+		target,
+		className,
+		children
+	});
+};
+var internal_link_default = InternalLink;
+
+//#endregion
+Object.defineProperty(exports, 'internal_link_default', {
+  enumerable: true,
+  get: function () {
+    return internal_link_default;
+  }
+});
+//# sourceMappingURL=internal-link-BLXTBMRq.js.map