@lssm/lib.ui-kit 1.11.0 → 1.41.0

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

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