@lssm/lib.design-system 1.11.1 → 1.41.0

package/dist/node_modules/next/dist/lib/route-pattern-normalizer.js

@@ -0,0 +1,69 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/lib/route-pattern-normalizer.js
+var require_route_pattern_normalizer = /* @__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, {
+		PARAM_SEPARATOR: function() {
+			return PARAM_SEPARATOR;
+		},
+		hasAdjacentParameterIssues: function() {
+			return hasAdjacentParameterIssues;
+		},
+		normalizeAdjacentParameters: function() {
+			return normalizeAdjacentParameters;
+		},
+		normalizeTokensForRegexp: function() {
+			return normalizeTokensForRegexp;
+		},
+		stripNormalizedSeparators: function() {
+			return stripNormalizedSeparators;
+		},
+		stripParameterSeparators: function() {
+			return stripParameterSeparators;
+		}
+	});
+	const PARAM_SEPARATOR = "_NEXTSEP_";
+	function hasAdjacentParameterIssues(route) {
+		if (typeof route !== "string") return false;
+		if (/\/\(\.{1,3}\):[^/\s]+/.test(route)) return true;
+		if (/:[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*/.test(route)) return true;
+		return false;
+	}
+	function normalizeAdjacentParameters(route) {
+		let normalized = route;
+		normalized = normalized.replace(/(\([^)]*\)):([^/\s]+)/g, `$1${PARAM_SEPARATOR}:$2`);
+		normalized = normalized.replace(/:([^:/\s)]+)(?=:)/g, `:$1${PARAM_SEPARATOR}`);
+		return normalized;
+	}
+	function normalizeTokensForRegexp(tokens) {
+		return tokens.map((token) => {
+			if (typeof token === "object" && token !== null && "modifier" in token && (token.modifier === "*" || token.modifier === "+") && "prefix" in token && "suffix" in token && token.prefix === "" && token.suffix === "") return {
+				...token,
+				prefix: "/"
+			};
+			return token;
+		});
+	}
+	function stripNormalizedSeparators(pathname) {
+		return pathname.replace(new RegExp(`\\)${PARAM_SEPARATOR}`, "g"), ")");
+	}
+	function stripParameterSeparators(params) {
+		const cleaned = {};
+		for (const [key, value] of Object.entries(params)) if (typeof value === "string") cleaned[key] = value.replace(/* @__PURE__ */ new RegExp(`^${PARAM_SEPARATOR}`), "");
+		else if (Array.isArray(value)) cleaned[key] = value.map((item) => typeof item === "string" ? item.replace(/* @__PURE__ */ new RegExp(`^${PARAM_SEPARATOR}`), "") : item);
+		else cleaned[key] = value;
+		return cleaned;
+	}
+}));
+
+//#endregion
+export default require_route_pattern_normalizer();
+
+export { require_route_pattern_normalizer };

package/dist/node_modules/next/dist/shared/lib/escape-regexp.js

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/escape-regexp.js
+var require_escape_regexp = /* @__PURE__ */ __commonJSMin(((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
+export default require_escape_regexp();
+
+export { require_escape_regexp };

package/dist/node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js

@@ -0,0 +1,22 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/i18n/detect-domain-locale.js
+var require_detect_domain_locale = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "detectDomainLocale", {
+		enumerable: true,
+		get: function() {
+			return detectDomainLocale;
+		}
+	});
+	function detectDomainLocale(domainItems, hostname, detectedLocale) {
+		if (!domainItems) return;
+		if (detectedLocale) detectedLocale = detectedLocale.toLowerCase();
+		for (const item of domainItems) if (hostname === item.domain?.split(":", 1)[0].toLowerCase() || detectedLocale === item.defaultLocale.toLowerCase() || item.locales?.some((locale) => locale.toLowerCase() === detectedLocale)) return item;
+	}
+}));
+
+//#endregion
+export default require_detect_domain_locale();
+
+export { require_detect_domain_locale };

package/dist/node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js

@@ -0,0 +1,42 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/i18n/normalize-locale-path.js
+var require_normalize_locale_path = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "normalizeLocalePath", {
+		enumerable: true,
+		get: function() {
+			return normalizeLocalePath;
+		}
+	});
+	/**
+	* A cache of lowercased locales for each list of locales. This is stored as a
+	* WeakMap so if the locales are garbage collected, the cache entry will be
+	* removed as well.
+	*/ const cache = /* @__PURE__ */ new WeakMap();
+	function normalizeLocalePath(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
+export default require_normalize_locale_path();
+
+export { require_normalize_locale_path };

package/dist/node_modules/next/dist/shared/lib/invariant-error.js

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/invariant-error.js
+var require_invariant_error = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "InvariantError", {
+		enumerable: true,
+		get: function() {
+			return InvariantError;
+		}
+	});
+	var InvariantError = class extends Error {
+		constructor(message, options) {
+			super(`Invariant: ${message.endsWith(".") ? message : message + "."} This is a bug in Next.js.`, options);
+			this.name = "InvariantError";
+		}
+	};
+}));
+
+//#endregion
+export default require_invariant_error();
+
+export { require_invariant_error };

package/dist/node_modules/next/dist/shared/lib/page-path/ensure-leading-slash.js

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/page-path/ensure-leading-slash.js
+/**
+* For a given page path, this function ensures that there is a leading slash.
+* If there is not a leading slash, one is added, otherwise it is noop.
+*/ var require_ensure_leading_slash = /* @__PURE__ */ __commonJSMin(((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
+export default require_ensure_leading_slash();
+
+export { require_ensure_leading_slash };

package/dist/node_modules/next/dist/shared/lib/router/utils/add-locale.js

@@ -0,0 +1,30 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_path_has_prefix } from "./path-has-prefix.js";
+import { require_add_path_prefix } from "./add-path-prefix.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/add-locale.js
+var require_add_locale = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "addLocale", {
+		enumerable: true,
+		get: function() {
+			return addLocale;
+		}
+	});
+	const _addpathprefix = require_add_path_prefix();
+	const _pathhasprefix = require_path_has_prefix();
+	function addLocale(path, locale, defaultLocale, ignorePrefix) {
+		if (!locale || locale === defaultLocale) return path;
+		const lower = path.toLowerCase();
+		if (!ignorePrefix) {
+			if ((0, _pathhasprefix.pathHasPrefix)(lower, "/api")) return path;
+			if ((0, _pathhasprefix.pathHasPrefix)(lower, `/${locale.toLowerCase()}`)) return path;
+		}
+		return (0, _addpathprefix.addPathPrefix)(path, `/${locale}`);
+	}
+}));
+
+//#endregion
+export default require_add_locale();
+
+export { require_add_locale };

package/dist/node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js

@@ -0,0 +1,24 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_parse_path } from "./parse-path.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/add-path-prefix.js
+var require_add_path_prefix = /* @__PURE__ */ __commonJSMin(((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
+export default require_add_path_prefix();
+
+export { require_add_path_prefix };

package/dist/node_modules/next/dist/shared/lib/router/utils/app-paths.js

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_ensure_leading_slash } from "../../page-path/ensure-leading-slash.js";
+import { require_segment } from "../../segment.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/app-paths.js
+var require_app_paths = /* @__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, {
+		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
+export default require_app_paths();
+
+export { require_app_paths };

package/dist/node_modules/next/dist/shared/lib/router/utils/format-url.js

@@ -0,0 +1,78 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require__interop_require_wildcard } from "../../../../../../@swc/helpers/cjs/_interop_require_wildcard.js";
+import { require_querystring } from "./querystring.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/format-url.js
+var require_format_url = /* @__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, {
+		formatUrl: function() {
+			return formatUrl;
+		},
+		formatWithValidation: function() {
+			return formatWithValidation;
+		},
+		urlObjectKeys: function() {
+			return urlObjectKeys;
+		}
+	});
+	const _querystring = /* @__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.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 (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
+export default require_format_url();
+
+export { require_format_url };

package/dist/node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js

@@ -0,0 +1,151 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_invariant_error } from "../../invariant-error.js";
+import { require_parse_loader_tree } from "./parse-loader-tree.js";
+import { require_get_segment_param } from "./get-segment-param.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/get-dynamic-param.js
+var require_get_dynamic_param = /* @__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, {
+		PARAMETER_PATTERN: function() {
+			return PARAMETER_PATTERN;
+		},
+		getDynamicParam: function() {
+			return getDynamicParam;
+		},
+		interpolateParallelRouteParams: function() {
+			return interpolateParallelRouteParams;
+		},
+		parseMatchedParameter: function() {
+			return parseMatchedParameter;
+		},
+		parseParameter: function() {
+			return parseParameter;
+		}
+	});
+	const _invarianterror = require_invariant_error();
+	const _parseloadertree = require_parse_loader_tree();
+	const _getsegmentparam = require_get_segment_param();
+	/**
+	* Gets the value of a param from the params object. This correctly handles the
+	* case where the param is a fallback route param and encodes the resulting
+	* value.
+	*
+	* @param interpolatedParams - The params object.
+	* @param segmentKey - The key of the segment.
+	* @param fallbackRouteParams - The fallback route params.
+	* @returns The value of the param.
+	*/ function getParamValue(interpolatedParams, segmentKey, fallbackRouteParams) {
+		let value = interpolatedParams[segmentKey];
+		if (fallbackRouteParams?.has(segmentKey)) {
+			const [searchValue] = fallbackRouteParams.get(segmentKey);
+			value = searchValue;
+		} else if (Array.isArray(value)) value = value.map((i) => encodeURIComponent(i));
+		else if (typeof value === "string") value = encodeURIComponent(value);
+		return value;
+	}
+	function interpolateParallelRouteParams(loaderTree, params, pagePath, fallbackRouteParams) {
+		const interpolated = structuredClone(params);
+		const stack = [{
+			tree: loaderTree,
+			depth: 0
+		}];
+		const pathSegments = pagePath.split("/").slice(1);
+		while (stack.length > 0) {
+			const { tree, depth } = stack.pop();
+			const { segment, parallelRoutes } = (0, _parseloadertree.parseLoaderTree)(tree);
+			const segmentParam = (0, _getsegmentparam.getSegmentParam)(segment);
+			if (segmentParam && !interpolated.hasOwnProperty(segmentParam.param) && !fallbackRouteParams?.has(segmentParam.param)) switch (segmentParam.type) {
+				case "catchall":
+				case "optional-catchall":
+				case "catchall-intercepted-(..)(..)":
+				case "catchall-intercepted-(.)":
+				case "catchall-intercepted-(..)":
+				case "catchall-intercepted-(...)":
+					const processedSegments = pathSegments.slice(depth).flatMap((pathSegment) => {
+						const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+						return param ? interpolated[param.param] : pathSegment;
+					}).filter((s) => s !== void 0);
+					if (processedSegments.length > 0) interpolated[segmentParam.param] = processedSegments;
+					break;
+				case "dynamic":
+				case "dynamic-intercepted-(..)(..)":
+				case "dynamic-intercepted-(.)":
+				case "dynamic-intercepted-(..)":
+				case "dynamic-intercepted-(...)":
+					if (depth < pathSegments.length) {
+						const pathSegment = pathSegments[depth];
+						const param = (0, _getsegmentparam.getSegmentParam)(pathSegment);
+						interpolated[segmentParam.param] = param ? interpolated[param.param] : pathSegment;
+					}
+					break;
+				default: segmentParam.type;
+			}
+			let nextDepth = depth;
+			if (!(segment.startsWith("(") && segment.endsWith(")")) && segment !== "") nextDepth++;
+			for (const route of Object.values(parallelRoutes)) stack.push({
+				tree: route,
+				depth: nextDepth
+			});
+		}
+		return interpolated;
+	}
+	function getDynamicParam(interpolatedParams, segmentKey, dynamicParamType, fallbackRouteParams) {
+		let value = getParamValue(interpolatedParams, segmentKey, fallbackRouteParams);
+		if (!value || value.length === 0) {
+			if (dynamicParamType === "oc") return {
+				param: segmentKey,
+				value: null,
+				type: dynamicParamType,
+				treeSegment: [
+					segmentKey,
+					"",
+					dynamicParamType
+				]
+			};
+			throw Object.defineProperty(new _invarianterror.InvariantError(`Missing value for segment key: "${segmentKey}" with dynamic param type: ${dynamicParamType}`), "__NEXT_ERROR_CODE", {
+				value: "E864",
+				enumerable: false,
+				configurable: true
+			});
+		}
+		return {
+			param: segmentKey,
+			value,
+			treeSegment: [
+				segmentKey,
+				Array.isArray(value) ? value.join("/") : value,
+				dynamicParamType
+			],
+			type: dynamicParamType
+		};
+	}
+	const PARAMETER_PATTERN = /^([^[]*)\[((?:\[[^\]]*\])|[^\]]+)\](.*)$/;
+	function parseParameter(param) {
+		const match = param.match(PARAMETER_PATTERN);
+		if (!match) return parseMatchedParameter(param);
+		return parseMatchedParameter(match[2]);
+	}
+	function parseMatchedParameter(param) {
+		const optional = param.startsWith("[") && param.endsWith("]");
+		if (optional) param = param.slice(1, -1);
+		const repeat = param.startsWith("...");
+		if (repeat) param = param.slice(3);
+		return {
+			key: param,
+			repeat,
+			optional
+		};
+	}
+}));
+
+//#endregion
+export default require_get_dynamic_param();
+
+export { require_get_dynamic_param };

package/dist/node_modules/next/dist/shared/lib/router/utils/get-segment-param.js

@@ -0,0 +1,77 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_interception_routes } from "./interception-routes.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/get-segment-param.js
+var require_get_segment_param = /* @__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, {
+		getParamProperties: function() {
+			return getParamProperties;
+		},
+		getSegmentParam: function() {
+			return getSegmentParam;
+		},
+		isCatchAll: function() {
+			return isCatchAll;
+		}
+	});
+	const _interceptionroutes = require_interception_routes();
+	function getSegmentParam(segment) {
+		const interceptionMarker = _interceptionroutes.INTERCEPTION_ROUTE_MARKERS.find((marker) => segment.startsWith(marker));
+		if (interceptionMarker) segment = segment.slice(interceptionMarker.length);
+		if (segment.startsWith("[[...") && segment.endsWith("]]")) return {
+			type: "optional-catchall",
+			param: segment.slice(5, -2)
+		};
+		if (segment.startsWith("[...") && segment.endsWith("]")) return {
+			type: interceptionMarker ? `catchall-intercepted-${interceptionMarker}` : "catchall",
+			param: segment.slice(4, -1)
+		};
+		if (segment.startsWith("[") && segment.endsWith("]")) return {
+			type: interceptionMarker ? `dynamic-intercepted-${interceptionMarker}` : "dynamic",
+			param: segment.slice(1, -1)
+		};
+		return null;
+	}
+	function isCatchAll(type) {
+		return type === "catchall" || type === "catchall-intercepted-(..)(..)" || type === "catchall-intercepted-(.)" || type === "catchall-intercepted-(..)" || type === "catchall-intercepted-(...)" || type === "optional-catchall";
+	}
+	function getParamProperties(paramType) {
+		let repeat = false;
+		let optional = false;
+		switch (paramType) {
+			case "catchall":
+			case "catchall-intercepted-(..)(..)":
+			case "catchall-intercepted-(.)":
+			case "catchall-intercepted-(..)":
+			case "catchall-intercepted-(...)":
+				repeat = true;
+				break;
+			case "optional-catchall":
+				repeat = true;
+				optional = true;
+				break;
+			case "dynamic":
+			case "dynamic-intercepted-(..)(..)":
+			case "dynamic-intercepted-(.)":
+			case "dynamic-intercepted-(..)":
+			case "dynamic-intercepted-(...)": break;
+			default:
+		}
+		return {
+			repeat,
+			optional
+		};
+	}
+}));
+
+//#endregion
+export default require_get_segment_param();
+
+export { require_get_segment_param };

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

@@ -0,0 +1,32 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_sorted_routes } from "./sorted-routes.js";
+import { require_is_dynamic } from "./is-dynamic.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/index.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, {
+		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
+export default require_utils();
+
+export { require_utils };