@lssm/lib.design-system 1.11.1 → 1.41.0

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

@@ -0,0 +1,92 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_app_paths } from "./app-paths.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/interception-routes.js
+var require_interception_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, {
+		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;
+		let marker;
+		let 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
+export default require_interception_routes();
+
+export { require_interception_routes };

package/dist/node_modules/next/dist/shared/lib/router/utils/interpolate-as.js

@@ -0,0 +1,41 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_route_matcher } from "./route-matcher.js";
+import { require_route_regex } from "./route-regex.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/interpolate-as.js
+var require_interpolate_as = /* @__PURE__ */ __commonJSMin(((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
+export default require_interpolate_as();
+
+export { require_interpolate_as };

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

@@ -0,0 +1,26 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_interception_routes } from "./interception-routes.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/is-dynamic.js
+var require_is_dynamic = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "isDynamicRoute", {
+		enumerable: true,
+		get: function() {
+			return isDynamicRoute;
+		}
+	});
+	const _interceptionroutes = require_interception_routes();
+	const TEST_ROUTE = /\/[^/]*\[[^/]+\][^/]*(?=\/|$)/;
+	const TEST_STRICT_ROUTE = /\/\[[^/]+\](?=\/|$)/;
+	function isDynamicRoute(route, strict = true) {
+		if ((0, _interceptionroutes.isInterceptionRouteAppPath)(route)) route = (0, _interceptionroutes.extractInterceptionRouteInformation)(route).interceptedRoute;
+		if (strict) return TEST_STRICT_ROUTE.test(route);
+		return TEST_ROUTE.test(route);
+	}
+}));
+
+//#endregion
+export default require_is_dynamic();
+
+export { require_is_dynamic };

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

@@ -0,0 +1,31 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_utils } from "../../utils.js";
+import { require_has_base_path } from "../../../../client/has-base-path.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/is-local-url.js
+var require_is_local_url = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "isLocalURL", {
+		enumerable: true,
+		get: function() {
+			return isLocalURL;
+		}
+	});
+	const _utils = require_utils();
+	const _hasbasepath = require_has_base_path();
+	function isLocalURL(url) {
+		if (!(0, _utils.isAbsoluteUrl)(url)) return true;
+		try {
+			const locationOrigin = (0, _utils.getLocationOrigin)();
+			const resolved = new URL(url, locationOrigin);
+			return resolved.origin === locationOrigin && (0, _hasbasepath.hasBasePath)(resolved.pathname);
+		} catch (_) {
+			return false;
+		}
+	}
+}));
+
+//#endregion
+export default require_is_local_url();
+
+export { require_is_local_url };

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

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

package/dist/node_modules/next/dist/shared/lib/router/utils/parse-loader-tree.js

@@ -0,0 +1,33 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_segment } from "../../segment.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/parse-loader-tree.js
+var require_parse_loader_tree = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "parseLoaderTree", {
+		enumerable: true,
+		get: function() {
+			return parseLoaderTree;
+		}
+	});
+	const _segment = require_segment();
+	function parseLoaderTree(tree) {
+		const [segment, parallelRoutes, modules] = tree;
+		const { layout, template } = modules;
+		let { page } = modules;
+		page = segment === _segment.DEFAULT_SEGMENT_KEY ? modules.defaultPage : page;
+		const conventionPath = layout?.[1] || template?.[1] || page?.[1];
+		return {
+			page,
+			segment,
+			modules,
+			conventionPath,
+			parallelRoutes
+		};
+	}
+}));
+
+//#endregion
+export default require_parse_loader_tree();
+
+export { require_parse_loader_tree };

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

@@ -0,0 +1,36 @@
+import { __commonJSMin } from "../../../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/shared/lib/router/utils/parse-path.js
+/**
+* Given a path this function will find the pathname, query and hash and return
+* them. This is useful to parse full paths on the client side.
+* @param path A path to parse e.g. /foo/bar?id=1#hash
+*/ var require_parse_path = /* @__PURE__ */ __commonJSMin(((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
+export default require_parse_path();
+
+export { require_parse_path };

package/dist/node_modules/next/dist/shared/lib/router/utils/path-has-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/path-has-prefix.js
+var require_path_has_prefix = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "pathHasPrefix", {
+		enumerable: true,
+		get: function() {
+			return pathHasPrefix;
+		}
+	});
+	const _parsepath = require_parse_path();
+	function pathHasPrefix(path, prefix) {
+		if (typeof path !== "string") return false;
+		const { pathname } = (0, _parsepath.parsePath)(path);
+		return pathname === prefix || pathname.startsWith(prefix + "/");
+	}
+}));
+
+//#endregion
+export default require_path_has_prefix();
+
+export { require_path_has_prefix };

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