@lssm/lib.design-system 1.11.1 → 1.41.0

package/dist/node_modules/next/dist/shared/lib/router/utils/route-regex.js

@@ -0,0 +1,203 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_remove_trailing_slash } from "./remove-trailing-slash.js";
+import { require_interception_routes } from "./interception-routes.js";
+import { require_constants } from "../../../../lib/constants.js";
+import { require_escape_regexp } from "../../escape-regexp.js";
+import { require_get_dynamic_param } from "./get-dynamic-param.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/route-regex.js
+var require_route_regex = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export(exports, {
+		getNamedMiddlewareRegex: function() {
+			return getNamedMiddlewareRegex;
+		},
+		getNamedRouteRegex: function() {
+			return getNamedRouteRegex;
+		},
+		getRouteRegex: function() {
+			return getRouteRegex;
+		}
+	});
+	const _constants = require_constants();
+	const _interceptionroutes = require_interception_routes();
+	const _escaperegexp = require_escape_regexp();
+	const _removetrailingslash = require_remove_trailing_slash();
+	const _getdynamicparam = require_get_dynamic_param();
+	function getParametrizedRoute(route, includeSuffix, includePrefix) {
+		const groups = {};
+		let groupIndex = 1;
+		const segments = [];
+		for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+			const markerMatch = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((m) => segment.startsWith(m));
+			const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN);
+			if (markerMatch && paramMatches && paramMatches[2]) {
+				const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
+				groups[key] = {
+					pos: groupIndex++,
+					repeat,
+					optional
+				};
+				segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(markerMatch)}([^/]+?)`);
+			} else if (paramMatches && paramMatches[2]) {
+				const { key, repeat, optional } = (0, _getdynamicparam.parseMatchedParameter)(paramMatches[2]);
+				groups[key] = {
+					pos: groupIndex++,
+					repeat,
+					optional
+				};
+				if (includePrefix && paramMatches[1]) segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(paramMatches[1])}`);
+				let s = repeat ? optional ? "(?:/(.+?))?" : "/(.+?)" : "/([^/]+?)";
+				if (includePrefix && paramMatches[1]) s = s.substring(1);
+				segments.push(s);
+			} else segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(segment)}`);
+			if (includeSuffix && paramMatches && paramMatches[3]) segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+		}
+		return {
+			parameterizedRoute: segments.join(""),
+			groups
+		};
+	}
+	function getRouteRegex(normalizedRoute, { includeSuffix = false, includePrefix = false, excludeOptionalTrailingSlash = false } = {}) {
+		const { parameterizedRoute, groups } = getParametrizedRoute(normalizedRoute, includeSuffix, includePrefix);
+		let re = parameterizedRoute;
+		if (!excludeOptionalTrailingSlash) re += "(?:/)?";
+		return {
+			re: /* @__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({ interceptionMarker, getSafeRouteKey, segment, routeKeys, keyPrefix, backreferenceDuplicateKeys }) {
+		const { key, optional, repeat } = (0, _getdynamicparam.parseMatchedParameter)(segment);
+		let cleanedKey = key.replace(/\W/g, "");
+		if (keyPrefix) cleanedKey = `${keyPrefix}${cleanedKey}`;
+		let invalidKey = false;
+		if (cleanedKey.length === 0 || cleanedKey.length > 30) invalidKey = true;
+		if (!isNaN(parseInt(cleanedKey.slice(0, 1)))) invalidKey = true;
+		if (invalidKey) cleanedKey = getSafeRouteKey();
+		const duplicateKey = cleanedKey in routeKeys;
+		if (keyPrefix) routeKeys[cleanedKey] = `${keyPrefix}${key}`;
+		else routeKeys[cleanedKey] = key;
+		const interceptionPrefix = interceptionMarker ? (0, _escaperegexp.escapeStringRegexp)(interceptionMarker) : "";
+		let pattern;
+		if (duplicateKey && backreferenceDuplicateKeys) pattern = `\\k<${cleanedKey}>`;
+		else if (repeat) pattern = `(?<${cleanedKey}>.+?)`;
+		else pattern = `(?<${cleanedKey}>[^/]+?)`;
+		return {
+			key,
+			pattern: optional ? `(?:/${interceptionPrefix}${pattern})?` : `/${interceptionPrefix}${pattern}`,
+			cleanedKey,
+			optional,
+			repeat
+		};
+	}
+	function getNamedParametrizedRoute(route, prefixRouteKeys, includeSuffix, includePrefix, backreferenceDuplicateKeys, reference = {
+		names: {},
+		intercepted: {}
+	}) {
+		const getSafeRouteKey = buildGetSafeRouteKey();
+		const routeKeys = {};
+		const segments = [];
+		const inverseParts = [];
+		reference = structuredClone(reference);
+		for (const segment of (0, _removetrailingslash.removeTrailingSlash)(route).slice(1).split("/")) {
+			const hasInterceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.some((m) => segment.startsWith(m));
+			const paramMatches = segment.match(_getdynamicparam.PARAMETER_PATTERN);
+			const interceptionMarker = hasInterceptionMarker ? paramMatches?.[1] : void 0;
+			let keyPrefix;
+			if (interceptionMarker && paramMatches?.[2]) {
+				keyPrefix = prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : void 0;
+				reference.intercepted[paramMatches[2]] = interceptionMarker;
+			} else if (paramMatches?.[2] && reference.intercepted[paramMatches[2]]) keyPrefix = prefixRouteKeys ? _constants.NEXT_INTERCEPTION_MARKER_PREFIX : void 0;
+			else keyPrefix = prefixRouteKeys ? _constants.NEXT_QUERY_PARAM_PREFIX : void 0;
+			if (interceptionMarker && paramMatches && paramMatches[2]) {
+				const { key, pattern, cleanedKey, repeat, optional } = getSafeKeyFromSegment({
+					getSafeRouteKey,
+					interceptionMarker,
+					segment: paramMatches[2],
+					routeKeys,
+					keyPrefix,
+					backreferenceDuplicateKeys
+				});
+				segments.push(pattern);
+				inverseParts.push(`/${paramMatches[1]}:${reference.names[key] ?? cleanedKey}${repeat ? optional ? "*" : "+" : ""}`);
+				reference.names[key] ??= cleanedKey;
+			} else if (paramMatches && paramMatches[2]) {
+				if (includePrefix && paramMatches[1]) {
+					segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(paramMatches[1])}`);
+					inverseParts.push(`/${paramMatches[1]}`);
+				}
+				const { key, pattern, cleanedKey, repeat, optional } = getSafeKeyFromSegment({
+					getSafeRouteKey,
+					segment: paramMatches[2],
+					routeKeys,
+					keyPrefix,
+					backreferenceDuplicateKeys
+				});
+				let s = pattern;
+				if (includePrefix && paramMatches[1]) s = s.substring(1);
+				segments.push(s);
+				inverseParts.push(`/:${reference.names[key] ?? cleanedKey}${repeat ? optional ? "*" : "+" : ""}`);
+				reference.names[key] ??= cleanedKey;
+			} else {
+				segments.push(`/${(0, _escaperegexp.escapeStringRegexp)(segment)}`);
+				inverseParts.push(`/${segment}`);
+			}
+			if (includeSuffix && paramMatches && paramMatches[3]) {
+				segments.push((0, _escaperegexp.escapeStringRegexp)(paramMatches[3]));
+				inverseParts.push(paramMatches[3]);
+			}
+		}
+		return {
+			namedParameterizedRoute: segments.join(""),
+			routeKeys,
+			pathToRegexpPattern: inverseParts.join(""),
+			reference
+		};
+	}
+	function getNamedRouteRegex(normalizedRoute, options) {
+		const result = getNamedParametrizedRoute(normalizedRoute, options.prefixRouteKeys, options.includeSuffix ?? false, options.includePrefix ?? false, options.backreferenceDuplicateKeys ?? false, options.reference);
+		let namedRegex = result.namedParameterizedRoute;
+		if (!options.excludeOptionalTrailingSlash) namedRegex += "(?:/)?";
+		return {
+			...getRouteRegex(normalizedRoute, options),
+			namedRegex: `^${namedRegex}$`,
+			routeKeys: result.routeKeys,
+			pathToRegexpPattern: result.pathToRegexpPattern,
+			reference: result.reference
+		};
+	}
+	function getNamedMiddlewareRegex(normalizedRoute, options) {
+		const { parameterizedRoute } = getParametrizedRoute(normalizedRoute, false, false);
+		const { catchAll = true } = options;
+		if (parameterizedRoute === "/") return { namedRegex: `^/${catchAll ? ".*" : ""}$` };
+		const { namedParameterizedRoute } = getNamedParametrizedRoute(normalizedRoute, false, false, false, false, void 0);
+		return { namedRegex: `^${namedParameterizedRoute}${catchAll ? "(?:(/.*)?)" : ""}$` };
+	}
+}));
+
+//#endregion
+export default require_route_regex();
+
+export { require_route_regex };

package/dist/node_modules/next/dist/shared/lib/router/utils/sorted-routes.js

@@ -0,0 +1,167 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/sorted-routes.js
+var require_sorted_routes = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export(exports, {
+		getSortedRouteObjects: function() {
+			return getSortedRouteObjects;
+		},
+		getSortedRoutes: function() {
+			return getSortedRoutes;
+		}
+	});
+	var UrlNode = class UrlNode {
+		insert(urlPath) {
+			this._insert(urlPath.split("/").filter(Boolean), [], false);
+		}
+		smoosh() {
+			return this._smoosh();
+		}
+		_smoosh(prefix = "/") {
+			const childrenPaths = [...this.children.keys()].sort();
+			if (this.slugName !== null) childrenPaths.splice(childrenPaths.indexOf("[]"), 1);
+			if (this.restSlugName !== null) childrenPaths.splice(childrenPaths.indexOf("[...]"), 1);
+			if (this.optionalRestSlugName !== null) childrenPaths.splice(childrenPaths.indexOf("[[...]]"), 1);
+			const routes = childrenPaths.map((c) => this.children.get(c)._smoosh(`${prefix}${c}/`)).reduce((prev, curr) => [...prev, ...curr], []);
+			if (this.slugName !== null) routes.push(...this.children.get("[]")._smoosh(`${prefix}[${this.slugName}]/`));
+			if (!this.placeholder) {
+				const r = prefix === "/" ? "/" : prefix.slice(0, -1);
+				if (this.optionalRestSlugName != null) throw Object.defineProperty(/* @__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
+export default require_sorted_routes();
+
+export { require_sorted_routes };

package/dist/node_modules/next/dist/shared/lib/router-context.shared-runtime.js

@@ -0,0 +1,20 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/rolldown_runtime.js";
+import { require__interop_require_default } from "../../../../@swc/helpers/cjs/_interop_require_default.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router-context.shared-runtime.js
+var require_router_context_shared_runtime = /* @__PURE__ */ __commonJSMin(((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);
+	RouterContext.displayName = "RouterContext";
+}));
+
+//#endregion
+export default require_router_context_shared_runtime();
+
+export { require_router_context_shared_runtime };

package/dist/node_modules/next/dist/shared/lib/segment.js

@@ -0,0 +1,80 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/segment.js
+var require_segment = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export(exports, {
+		DEFAULT_SEGMENT_KEY: function() {
+			return DEFAULT_SEGMENT_KEY;
+		},
+		PAGE_SEGMENT_KEY: function() {
+			return PAGE_SEGMENT_KEY;
+		},
+		addSearchParamsIfPageSegment: function() {
+			return addSearchParamsIfPageSegment;
+		},
+		computeSelectedLayoutSegment: function() {
+			return computeSelectedLayoutSegment;
+		},
+		getSegmentValue: function() {
+			return getSegmentValue;
+		},
+		getSelectedLayoutSegmentPath: function() {
+			return getSelectedLayoutSegmentPath;
+		},
+		isGroupSegment: function() {
+			return isGroupSegment;
+		},
+		isParallelRouteSegment: function() {
+			return isParallelRouteSegment;
+		}
+	});
+	function getSegmentValue(segment) {
+		return Array.isArray(segment) ? segment[1] : segment;
+	}
+	function isGroupSegment(segment) {
+		return segment[0] === "(" && segment.endsWith(")");
+	}
+	function isParallelRouteSegment(segment) {
+		return segment.startsWith("@") && segment !== "@children";
+	}
+	function addSearchParamsIfPageSegment(segment, searchParams) {
+		if (segment.includes(PAGE_SEGMENT_KEY)) {
+			const stringifiedQuery = JSON.stringify(searchParams);
+			return stringifiedQuery !== "{}" ? PAGE_SEGMENT_KEY + "?" + stringifiedQuery : PAGE_SEGMENT_KEY;
+		}
+		return segment;
+	}
+	function computeSelectedLayoutSegment(segments, parallelRouteKey) {
+		if (!segments || segments.length === 0) return null;
+		const rawSegment = parallelRouteKey === "children" ? segments[0] : segments[segments.length - 1];
+		return rawSegment === DEFAULT_SEGMENT_KEY ? null : rawSegment;
+	}
+	function getSelectedLayoutSegmentPath(tree, parallelRouteKey, first = true, segmentPath = []) {
+		let node;
+		if (first) node = tree[1][parallelRouteKey];
+		else {
+			const parallelRoutes = tree[1];
+			node = parallelRoutes.children ?? Object.values(parallelRoutes)[0];
+		}
+		if (!node) return segmentPath;
+		const segment = node[0];
+		let segmentValue = getSegmentValue(segment);
+		if (!segmentValue || segmentValue.startsWith(PAGE_SEGMENT_KEY)) return segmentPath;
+		segmentPath.push(segmentValue);
+		return getSelectedLayoutSegmentPath(node, parallelRouteKey, false, segmentPath);
+	}
+	const PAGE_SEGMENT_KEY = "__PAGE__";
+	const DEFAULT_SEGMENT_KEY = "__DEFAULT__";
+}));
+
+//#endregion
+export default require_segment();
+
+export { require_segment };

package/dist/node_modules/next/dist/shared/lib/utils/error-once.js

@@ -0,0 +1,25 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/utils/error-once.js
+var require_error_once = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "errorOnce", {
+		enumerable: true,
+		get: function() {
+			return errorOnce;
+		}
+	});
+	let errorOnce = (_) => {};
+	{
+		const errors = /* @__PURE__ */ new Set();
+		errorOnce = (msg) => {
+			if (!errors.has(msg)) console.error(msg);
+			errors.add(msg);
+		};
+	}
+}));
+
+//#endregion
+export default require_error_once();
+
+export { require_error_once };

package/dist/node_modules/next/dist/shared/lib/utils.js

@@ -0,0 +1,172 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _export(target, all) {
+		for (var name in all) Object.defineProperty(target, name, {
+			enumerable: true,
+			get: all[name]
+		});
+	}
+	_export(exports, {
+		DecodeError: function() {
+			return DecodeError;
+		},
+		MiddlewareNotFoundError: function() {
+			return MiddlewareNotFoundError;
+		},
+		MissingStaticPage: function() {
+			return MissingStaticPage;
+		},
+		NormalizeError: function() {
+			return NormalizeError;
+		},
+		PageNotFoundError: function() {
+			return PageNotFoundError;
+		},
+		SP: function() {
+			return SP;
+		},
+		ST: function() {
+			return ST;
+		},
+		WEB_VITALS: function() {
+			return WEB_VITALS;
+		},
+		execOnce: function() {
+			return execOnce;
+		},
+		getDisplayName: function() {
+			return getDisplayName;
+		},
+		getLocationOrigin: function() {
+			return getLocationOrigin;
+		},
+		getURL: function() {
+			return getURL;
+		},
+		isAbsoluteUrl: function() {
+			return isAbsoluteUrl;
+		},
+		isResSent: function() {
+			return isResSent;
+		},
+		loadGetInitialProps: function() {
+			return loadGetInitialProps;
+		},
+		normalizeRepeatedSlashes: function() {
+			return normalizeRepeatedSlashes;
+		},
+		stringifyError: function() {
+			return stringifyError;
+		}
+	});
+	const WEB_VITALS = [
+		"CLS",
+		"FCP",
+		"FID",
+		"INP",
+		"LCP",
+		"TTFB"
+	];
+	function execOnce(fn) {
+		let used = false;
+		let result;
+		return (...args) => {
+			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 (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 (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
+export default require_utils();
+
+export { require_utils };

package/dist/node_modules/next/link.js

@@ -0,0 +1,12 @@
+import { __commonJSMin } from "../../_virtual/rolldown_runtime.js";
+import { require_link as require_link$1 } from "./dist/client/link.js";
+
+//#region ../../../node_modules/next/link.js
+var require_link = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_link$1();
+}));
+
+//#endregion
+export default require_link();
+
+export { require_link };