@lssm/lib.ui-kit 1.11.0 → 1.41.0

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

@@ -0,0 +1,56 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/querystring.js
+var require_querystring = /* @__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, {
+		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, ...searchParamsList) {
+		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
+export default require_querystring();
+
+export { require_querystring };

package/dist/node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js

@@ -0,0 +1,26 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/remove-trailing-slash.js
+/**
+* Removes the trailing slash for a given route or page path. Preserves the
+* root page. Examples:
+*   - `/foo/bar/` -> `/foo/bar`
+*   - `/foo/bar` -> `/foo/bar`
+*   - `/` -> `/`
+*/ var require_remove_trailing_slash = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "removeTrailingSlash", {
+		enumerable: true,
+		get: function() {
+			return removeTrailingSlash;
+		}
+	});
+	function removeTrailingSlash(route) {
+		return route.replace(/\/$/, "") || "/";
+	}
+}));
+
+//#endregion
+export default require_remove_trailing_slash();
+
+export { require_remove_trailing_slash };

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

@@ -0,0 +1,94 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_path_to_regexp } from "../../../../compiled/path-to-regexp/index.js";
+import { require_route_pattern_normalizer } from "../../../../lib/route-pattern-normalizer.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/route-match-utils.js
+/**
+* Client-safe utilities for route matching that don't import server-side
+* utilities to avoid bundling issues with Turbopack
+*/ var require_route_match_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, {
+		safeCompile: function() {
+			return safeCompile;
+		},
+		safePathToRegexp: function() {
+			return safePathToRegexp;
+		},
+		safeRegexpToFunction: function() {
+			return safeRegexpToFunction;
+		},
+		safeRouteMatcher: function() {
+			return safeRouteMatcher;
+		}
+	});
+	const _pathtoregexp = require_path_to_regexp();
+	const _routepatternnormalizer = require_route_pattern_normalizer();
+	function safePathToRegexp(route, keys, options) {
+		if (typeof route !== "string") return (0, _pathtoregexp.pathToRegexp)(route, keys, options);
+		const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
+		const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
+		try {
+			return (0, _pathtoregexp.pathToRegexp)(routeToUse, keys, options);
+		} catch (error) {
+			if (!needsNormalization) try {
+				const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
+				return (0, _pathtoregexp.pathToRegexp)(normalizedRoute, keys, options);
+			} catch (retryError) {
+				throw error;
+			}
+			throw error;
+		}
+	}
+	function safeCompile(route, options) {
+		const needsNormalization = (0, _routepatternnormalizer.hasAdjacentParameterIssues)(route);
+		const routeToUse = needsNormalization ? (0, _routepatternnormalizer.normalizeAdjacentParameters)(route) : route;
+		try {
+			const compiler = (0, _pathtoregexp.compile)(routeToUse, options);
+			if (needsNormalization) return (params) => {
+				return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
+			};
+			return compiler;
+		} catch (error) {
+			if (!needsNormalization) try {
+				const normalizedRoute = (0, _routepatternnormalizer.normalizeAdjacentParameters)(route);
+				const compiler = (0, _pathtoregexp.compile)(normalizedRoute, options);
+				return (params) => {
+					return (0, _routepatternnormalizer.stripNormalizedSeparators)(compiler(params));
+				};
+			} catch (retryError) {
+				throw error;
+			}
+			throw error;
+		}
+	}
+	function safeRegexpToFunction(regexp, keys) {
+		const originalMatcher = (0, _pathtoregexp.regexpToFunction)(regexp, keys || []);
+		return (pathname) => {
+			const result = originalMatcher(pathname);
+			if (!result) return false;
+			return {
+				...result,
+				params: (0, _routepatternnormalizer.stripParameterSeparators)(result.params)
+			};
+		};
+	}
+	function safeRouteMatcher(matcherFn) {
+		return (pathname) => {
+			const result = matcherFn(pathname);
+			if (!result) return false;
+			return (0, _routepatternnormalizer.stripParameterSeparators)(result);
+		};
+	}
+}));
+
+//#endregion
+export default require_route_match_utils();
+
+export { require_route_match_utils };

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

@@ -0,0 +1,46 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "../../utils.js";
+import { require_route_match_utils } from "./route-match-utils.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/route-matcher.js
+var require_route_matcher = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "getRouteMatcher", {
+		enumerable: true,
+		get: function() {
+			return getRouteMatcher;
+		}
+	});
+	const _utils = require_utils();
+	const _routematchutils = require_route_match_utils();
+	function getRouteMatcher({ re, groups }) {
+		const rawMatcher = (pathname) => {
+			const routeMatch = re.exec(pathname);
+			if (!routeMatch) return false;
+			const decode = (param) => {
+				try {
+					return decodeURIComponent(param);
+				} catch {
+					throw Object.defineProperty(new _utils.DecodeError("failed to decode param"), "__NEXT_ERROR_CODE", {
+						value: "E528",
+						enumerable: false,
+						configurable: true
+					});
+				}
+			};
+			const params = {};
+			for (const [key, group] of Object.entries(groups)) {
+				const match = routeMatch[group.pos];
+				if (match !== void 0) if (group.repeat) params[key] = match.split("/").map((entry) => decode(entry));
+				else params[key] = decode(match);
+			}
+			return params;
+		};
+		return (0, _routematchutils.safeRouteMatcher)(rawMatcher);
+	}
+}));
+
+//#endregion
+export default require_route_matcher();
+
+export { require_route_matcher };

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 };