@lssm/lib.ui-kit 1.11.0 → 1.41.0

package/dist/node_modules/next/dist/client/resolve-href.js

@@ -0,0 +1,86 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+import { require_querystring } from "../shared/lib/router/utils/querystring.js";
+import { require_format_url } from "../shared/lib/router/utils/format-url.js";
+import { require_omit } from "../shared/lib/router/utils/omit.js";
+import { require_utils } from "../shared/lib/utils.js";
+import { require_normalize_trailing_slash } from "./normalize-trailing-slash.js";
+import { require_is_local_url } from "../shared/lib/router/utils/is-local-url.js";
+import { require_utils as require_utils$1 } from "../shared/lib/router/utils/index.js";
+import { require_route_matcher } from "../shared/lib/router/utils/route-matcher.js";
+import { require_route_regex } from "../shared/lib/router/utils/route-regex.js";
+import { require_interpolate_as } from "../shared/lib/router/utils/interpolate-as.js";
+
+//#region ../../../node_modules/next/dist/client/resolve-href.js
+var require_resolve_href = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "resolveHref", {
+		enumerable: true,
+		get: function() {
+			return resolveHref;
+		}
+	});
+	const _querystring = require_querystring();
+	const _formaturl = require_format_url();
+	const _omit = require_omit();
+	const _utils = require_utils();
+	const _normalizetrailingslash = require_normalize_trailing_slash();
+	const _islocalurl = require_is_local_url();
+	const _utils1 = require_utils$1();
+	const _interpolateas = require_interpolate_as();
+	const _routeregex = require_route_regex();
+	const _routematcher = require_route_matcher();
+	function resolveHref(router, href, resolveAs) {
+		let base;
+		let urlAsString = typeof href === "string" ? href : (0, _formaturl.formatWithValidation)(href);
+		const urlProtoMatch = urlAsString.match(/^[a-z][a-z0-9+.-]*:\/\//i);
+		const urlAsStringNoProto = urlProtoMatch ? urlAsString.slice(urlProtoMatch[0].length) : urlAsString;
+		if ((urlAsStringNoProto.split("?", 1)[0] || "").match(/(\/\/|\\)/)) {
+			console.error(`Invalid href '${urlAsString}' passed to next/router in page: '${router.pathname}'. Repeated forward-slashes (//) or backslashes \\ are not valid in the href.`);
+			const normalizedUrl = (0, _utils.normalizeRepeatedSlashes)(urlAsStringNoProto);
+			urlAsString = (urlProtoMatch ? urlProtoMatch[0] : "") + normalizedUrl;
+		}
+		if (!(0, _islocalurl.isLocalURL)(urlAsString)) return resolveAs ? [urlAsString] : urlAsString;
+		try {
+			let baseBase = urlAsString.startsWith("#") ? router.asPath : router.pathname;
+			if (urlAsString.startsWith("?")) {
+				baseBase = router.asPath;
+				if ((0, _utils1.isDynamicRoute)(router.pathname)) {
+					baseBase = router.pathname;
+					const routeRegex = (0, _routeregex.getRouteRegex)(router.pathname);
+					if (!(0, _routematcher.getRouteMatcher)(routeRegex)(router.asPath)) baseBase = router.asPath;
+				}
+			}
+			base = new URL(baseBase, "http://n");
+		} catch (_) {
+			base = new URL("/", "http://n");
+		}
+		try {
+			const finalUrl = new URL(urlAsString, base);
+			finalUrl.pathname = (0, _normalizetrailingslash.normalizePathTrailingSlash)(finalUrl.pathname);
+			let interpolatedAs = "";
+			if ((0, _utils1.isDynamicRoute)(finalUrl.pathname) && finalUrl.searchParams && resolveAs) {
+				const query = (0, _querystring.searchParamsToUrlQuery)(finalUrl.searchParams);
+				const { result, params } = (0, _interpolateas.interpolateAs)(finalUrl.pathname, finalUrl.pathname, query);
+				if (result) interpolatedAs = (0, _formaturl.formatWithValidation)({
+					pathname: result,
+					hash: finalUrl.hash,
+					query: (0, _omit.omit)(query, params)
+				});
+			}
+			const resolvedHref = finalUrl.origin === base.origin ? finalUrl.href.slice(finalUrl.origin.length) : finalUrl.href;
+			return resolveAs ? [resolvedHref, interpolatedAs || resolvedHref] : resolvedHref;
+		} catch (_) {
+			return resolveAs ? [urlAsString] : urlAsString;
+		}
+	}
+	if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+		Object.defineProperty(exports.default, "__esModule", { value: true });
+		Object.assign(exports.default, exports);
+		module.exports = exports.default;
+	}
+}));
+
+//#endregion
+export default require_resolve_href();
+
+export { require_resolve_href };

package/dist/node_modules/next/dist/client/use-intersection.js

@@ -0,0 +1,104 @@
+import { __commonJSMin, __require } from "../../../../_virtual/rolldown_runtime.js";
+import { require_request_idle_callback } from "./request-idle-callback.js";
+
+//#region ../../../node_modules/next/dist/client/use-intersection.js
+var require_use_intersection = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "useIntersection", {
+		enumerable: true,
+		get: function() {
+			return useIntersection;
+		}
+	});
+	const _react = __require("react");
+	const _requestidlecallback = require_request_idle_callback();
+	const hasIntersectionObserver = typeof IntersectionObserver === "function";
+	const observers = /* @__PURE__ */ new Map();
+	const idList = [];
+	function createObserver(options) {
+		const id = {
+			root: options.root || null,
+			margin: options.rootMargin || ""
+		};
+		const existing = idList.find((obj) => obj.root === id.root && obj.margin === id.margin);
+		let instance;
+		if (existing) {
+			instance = observers.get(existing);
+			if (instance) return instance;
+		}
+		const elements = /* @__PURE__ */ new Map();
+		instance = {
+			id,
+			observer: new IntersectionObserver((entries) => {
+				entries.forEach((entry) => {
+					const callback = elements.get(entry.target);
+					const isVisible = entry.isIntersecting || entry.intersectionRatio > 0;
+					if (callback && isVisible) callback(isVisible);
+				});
+			}, options),
+			elements
+		};
+		idList.push(id);
+		observers.set(id, instance);
+		return instance;
+	}
+	function observe(element, callback, options) {
+		const { id, observer, elements } = createObserver(options);
+		elements.set(element, callback);
+		observer.observe(element);
+		return function unobserve() {
+			elements.delete(element);
+			observer.unobserve(element);
+			if (elements.size === 0) {
+				observer.disconnect();
+				observers.delete(id);
+				const index = idList.findIndex((obj) => obj.root === id.root && obj.margin === id.margin);
+				if (index > -1) idList.splice(index, 1);
+			}
+		};
+	}
+	function useIntersection({ rootRef, rootMargin, disabled }) {
+		const isDisabled = disabled || !hasIntersectionObserver;
+		const [visible, setVisible] = (0, _react.useState)(false);
+		const elementRef = (0, _react.useRef)(null);
+		const setElement = (0, _react.useCallback)((element) => {
+			elementRef.current = element;
+		}, []);
+		(0, _react.useEffect)(() => {
+			if (hasIntersectionObserver) {
+				if (isDisabled || visible) return;
+				const element = elementRef.current;
+				if (element && element.tagName) return observe(element, (isVisible) => isVisible && setVisible(isVisible), {
+					root: rootRef?.current,
+					rootMargin
+				});
+			} else if (!visible) {
+				const idleCallback = (0, _requestidlecallback.requestIdleCallback)(() => setVisible(true));
+				return () => (0, _requestidlecallback.cancelIdleCallback)(idleCallback);
+			}
+		}, [
+			isDisabled,
+			rootMargin,
+			rootRef,
+			visible,
+			elementRef.current
+		]);
+		return [
+			setElement,
+			visible,
+			(0, _react.useCallback)(() => {
+				setVisible(false);
+			}, [])
+		];
+	}
+	if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+		Object.defineProperty(exports.default, "__esModule", { value: true });
+		Object.assign(exports.default, exports);
+		module.exports = exports.default;
+	}
+}));
+
+//#endregion
+export default require_use_intersection();
+
+export { require_use_intersection };

package/dist/node_modules/next/dist/client/use-merged-ref.js

@@ -0,0 +1,56 @@
+import { __commonJSMin, __require } from "../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/client/use-merged-ref.js
+var require_use_merged_ref = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "useMergedRef", {
+		enumerable: true,
+		get: function() {
+			return useMergedRef;
+		}
+	});
+	const _react = __require("react");
+	function useMergedRef(refA, refB) {
+		const cleanupA = (0, _react.useRef)(null);
+		const cleanupB = (0, _react.useRef)(null);
+		return (0, _react.useCallback)((current) => {
+			if (current === null) {
+				const cleanupFnA = cleanupA.current;
+				if (cleanupFnA) {
+					cleanupA.current = null;
+					cleanupFnA();
+				}
+				const cleanupFnB = cleanupB.current;
+				if (cleanupFnB) {
+					cleanupB.current = null;
+					cleanupFnB();
+				}
+			} else {
+				if (refA) cleanupA.current = applyRef(refA, current);
+				if (refB) cleanupB.current = applyRef(refB, current);
+			}
+		}, [refA, refB]);
+	}
+	function applyRef(refA, current) {
+		if (typeof refA === "function") {
+			const cleanup = refA(current);
+			if (typeof cleanup === "function") return cleanup;
+			else return () => refA(null);
+		} else {
+			refA.current = current;
+			return () => {
+				refA.current = null;
+			};
+		}
+	}
+	if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") {
+		Object.defineProperty(exports.default, "__esModule", { value: true });
+		Object.assign(exports.default, exports);
+		module.exports = exports.default;
+	}
+}));
+
+//#endregion
+export default require_use_merged_ref();
+
+export { require_use_merged_ref };

package/dist/node_modules/next/dist/compiled/path-to-regexp/index.js

@@ -0,0 +1,372 @@
+import { __commonJSMin } from "../../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/compiled/path-to-regexp/index.js
+var require_path_to_regexp = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(() => {
+		"use strict";
+		if (typeof __nccwpck_require__ !== "undefined") __nccwpck_require__.ab = __dirname + "/";
+		var e = {};
+		(() => {
+			var n = e;
+			Object.defineProperty(n, "__esModule", { value: true });
+			n.pathToRegexp = n.tokensToRegexp = n.regexpToFunction = n.match = n.tokensToFunction = n.compile = n.parse = void 0;
+			function lexer(e$1) {
+				var n$1 = [];
+				var r = 0;
+				while (r < e$1.length) {
+					var t = e$1[r];
+					if (t === "*" || t === "+" || t === "?") {
+						n$1.push({
+							type: "MODIFIER",
+							index: r,
+							value: e$1[r++]
+						});
+						continue;
+					}
+					if (t === "\\") {
+						n$1.push({
+							type: "ESCAPED_CHAR",
+							index: r++,
+							value: e$1[r++]
+						});
+						continue;
+					}
+					if (t === "{") {
+						n$1.push({
+							type: "OPEN",
+							index: r,
+							value: e$1[r++]
+						});
+						continue;
+					}
+					if (t === "}") {
+						n$1.push({
+							type: "CLOSE",
+							index: r,
+							value: e$1[r++]
+						});
+						continue;
+					}
+					if (t === ":") {
+						var a = "";
+						var i = r + 1;
+						while (i < e$1.length) {
+							var o = e$1.charCodeAt(i);
+							if (o >= 48 && o <= 57 || o >= 65 && o <= 90 || o >= 97 && o <= 122 || o === 95) {
+								a += e$1[i++];
+								continue;
+							}
+							break;
+						}
+						if (!a) throw new TypeError("Missing parameter name at ".concat(r));
+						n$1.push({
+							type: "NAME",
+							index: r,
+							value: a
+						});
+						r = i;
+						continue;
+					}
+					if (t === "(") {
+						var c = 1;
+						var f = "";
+						var i = r + 1;
+						if (e$1[i] === "?") throw new TypeError("Pattern cannot start with \"?\" at ".concat(i));
+						while (i < e$1.length) {
+							if (e$1[i] === "\\") {
+								f += e$1[i++] + e$1[i++];
+								continue;
+							}
+							if (e$1[i] === ")") {
+								c--;
+								if (c === 0) {
+									i++;
+									break;
+								}
+							} else if (e$1[i] === "(") {
+								c++;
+								if (e$1[i + 1] !== "?") throw new TypeError("Capturing groups are not allowed at ".concat(i));
+							}
+							f += e$1[i++];
+						}
+						if (c) throw new TypeError("Unbalanced pattern at ".concat(r));
+						if (!f) throw new TypeError("Missing pattern at ".concat(r));
+						n$1.push({
+							type: "PATTERN",
+							index: r,
+							value: f
+						});
+						r = i;
+						continue;
+					}
+					n$1.push({
+						type: "CHAR",
+						index: r,
+						value: e$1[r++]
+					});
+				}
+				n$1.push({
+					type: "END",
+					index: r,
+					value: ""
+				});
+				return n$1;
+			}
+			function parse(e$1, n$1) {
+				if (n$1 === void 0) n$1 = {};
+				var r = lexer(e$1);
+				var t = n$1.prefixes, a = t === void 0 ? "./" : t, i = n$1.delimiter, o = i === void 0 ? "/#?" : i;
+				var c = [];
+				var f = 0;
+				var u = 0;
+				var p = "";
+				var tryConsume = function(e$2) {
+					if (u < r.length && r[u].type === e$2) return r[u++].value;
+				};
+				var mustConsume = function(e$2) {
+					var n$2 = tryConsume(e$2);
+					if (n$2 !== void 0) return n$2;
+					var t$1 = r[u], a$1 = t$1.type, i$1 = t$1.index;
+					throw new TypeError("Unexpected ".concat(a$1, " at ").concat(i$1, ", expected ").concat(e$2));
+				};
+				var consumeText = function() {
+					var e$2 = "";
+					var n$2;
+					while (n$2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) e$2 += n$2;
+					return e$2;
+				};
+				var isSafe = function(e$2) {
+					for (var n$2 = 0, r$1 = o; n$2 < r$1.length; n$2++) {
+						var t$1 = r$1[n$2];
+						if (e$2.indexOf(t$1) > -1) return true;
+					}
+					return false;
+				};
+				var safePattern = function(e$2) {
+					var n$2 = c[c.length - 1];
+					var r$1 = e$2 || (n$2 && typeof n$2 === "string" ? n$2 : "");
+					if (n$2 && !r$1) throw new TypeError("Must have text between two parameters, missing text after \"".concat(n$2.name, "\""));
+					if (!r$1 || isSafe(r$1)) return "[^".concat(escapeString(o), "]+?");
+					return "(?:(?!".concat(escapeString(r$1), ")[^").concat(escapeString(o), "])+?");
+				};
+				while (u < r.length) {
+					var v = tryConsume("CHAR");
+					var s = tryConsume("NAME");
+					var d = tryConsume("PATTERN");
+					if (s || d) {
+						var g = v || "";
+						if (a.indexOf(g) === -1) {
+							p += g;
+							g = "";
+						}
+						if (p) {
+							c.push(p);
+							p = "";
+						}
+						c.push({
+							name: s || f++,
+							prefix: g,
+							suffix: "",
+							pattern: d || safePattern(g),
+							modifier: tryConsume("MODIFIER") || ""
+						});
+						continue;
+					}
+					var x = v || tryConsume("ESCAPED_CHAR");
+					if (x) {
+						p += x;
+						continue;
+					}
+					if (p) {
+						c.push(p);
+						p = "";
+					}
+					if (tryConsume("OPEN")) {
+						var g = consumeText();
+						var l = tryConsume("NAME") || "";
+						var m = tryConsume("PATTERN") || "";
+						var T = consumeText();
+						mustConsume("CLOSE");
+						c.push({
+							name: l || (m ? f++ : ""),
+							pattern: l && !m ? safePattern(g) : m,
+							prefix: g,
+							suffix: T,
+							modifier: tryConsume("MODIFIER") || ""
+						});
+						continue;
+					}
+					mustConsume("END");
+				}
+				return c;
+			}
+			n.parse = parse;
+			function compile(e$1, n$1) {
+				return tokensToFunction(parse(e$1, n$1), n$1);
+			}
+			n.compile = compile;
+			function tokensToFunction(e$1, n$1) {
+				if (n$1 === void 0) n$1 = {};
+				var r = flags(n$1);
+				var t = n$1.encode, a = t === void 0 ? function(e$2) {
+					return e$2;
+				} : t, i = n$1.validate, o = i === void 0 ? true : i;
+				var c = e$1.map((function(e$2) {
+					if (typeof e$2 === "object") return new RegExp("^(?:".concat(e$2.pattern, ")$"), r);
+				}));
+				return function(n$2) {
+					var r$1 = "";
+					for (var t$1 = 0; t$1 < e$1.length; t$1++) {
+						var i$1 = e$1[t$1];
+						if (typeof i$1 === "string") {
+							r$1 += i$1;
+							continue;
+						}
+						var f = n$2 ? n$2[i$1.name] : void 0;
+						var u = i$1.modifier === "?" || i$1.modifier === "*";
+						var p = i$1.modifier === "*" || i$1.modifier === "+";
+						if (Array.isArray(f)) {
+							if (!p) throw new TypeError("Expected \"".concat(i$1.name, "\" to not repeat, but got an array"));
+							if (f.length === 0) {
+								if (u) continue;
+								throw new TypeError("Expected \"".concat(i$1.name, "\" to not be empty"));
+							}
+							for (var v = 0; v < f.length; v++) {
+								var s = a(f[v], i$1);
+								if (o && !c[t$1].test(s)) throw new TypeError("Expected all \"".concat(i$1.name, "\" to match \"").concat(i$1.pattern, "\", but got \"").concat(s, "\""));
+								r$1 += i$1.prefix + s + i$1.suffix;
+							}
+							continue;
+						}
+						if (typeof f === "string" || typeof f === "number") {
+							var s = a(String(f), i$1);
+							if (o && !c[t$1].test(s)) throw new TypeError("Expected \"".concat(i$1.name, "\" to match \"").concat(i$1.pattern, "\", but got \"").concat(s, "\""));
+							r$1 += i$1.prefix + s + i$1.suffix;
+							continue;
+						}
+						if (u) continue;
+						var d = p ? "an array" : "a string";
+						throw new TypeError("Expected \"".concat(i$1.name, "\" to be ").concat(d));
+					}
+					return r$1;
+				};
+			}
+			n.tokensToFunction = tokensToFunction;
+			function match(e$1, n$1) {
+				var r = [];
+				return regexpToFunction(pathToRegexp(e$1, r, n$1), r, n$1);
+			}
+			n.match = match;
+			function regexpToFunction(e$1, n$1, r) {
+				if (r === void 0) r = {};
+				var t = r.decode, a = t === void 0 ? function(e$2) {
+					return e$2;
+				} : t;
+				return function(r$1) {
+					var t$1 = e$1.exec(r$1);
+					if (!t$1) return false;
+					var i = t$1[0], o = t$1.index;
+					var c = Object.create(null);
+					var _loop_1 = function(e$2) {
+						if (t$1[e$2] === void 0) return "continue";
+						var r$2 = n$1[e$2 - 1];
+						if (r$2.modifier === "*" || r$2.modifier === "+") c[r$2.name] = t$1[e$2].split(r$2.prefix + r$2.suffix).map((function(e$3) {
+							return a(e$3, r$2);
+						}));
+						else c[r$2.name] = a(t$1[e$2], r$2);
+					};
+					for (var f = 1; f < t$1.length; f++) _loop_1(f);
+					return {
+						path: i,
+						index: o,
+						params: c
+					};
+				};
+			}
+			n.regexpToFunction = regexpToFunction;
+			function escapeString(e$1) {
+				return e$1.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+			}
+			function flags(e$1) {
+				return e$1 && e$1.sensitive ? "" : "i";
+			}
+			function regexpToRegexp(e$1, n$1) {
+				if (!n$1) return e$1;
+				var r = /\((?:\?<(.*?)>)?(?!\?)/g;
+				var t = 0;
+				var a = r.exec(e$1.source);
+				while (a) {
+					n$1.push({
+						name: a[1] || t++,
+						prefix: "",
+						suffix: "",
+						modifier: "",
+						pattern: ""
+					});
+					a = r.exec(e$1.source);
+				}
+				return e$1;
+			}
+			function arrayToRegexp(e$1, n$1, r) {
+				var t = e$1.map((function(e$2) {
+					return pathToRegexp(e$2, n$1, r).source;
+				}));
+				return new RegExp("(?:".concat(t.join("|"), ")"), flags(r));
+			}
+			function stringToRegexp(e$1, n$1, r) {
+				return tokensToRegexp(parse(e$1, r), n$1, r);
+			}
+			function tokensToRegexp(e$1, n$1, r) {
+				if (r === void 0) r = {};
+				var t = r.strict, a = t === void 0 ? false : t, i = r.start, o = i === void 0 ? true : i, c = r.end, f = c === void 0 ? true : c, u = r.encode, p = u === void 0 ? function(e$2) {
+					return e$2;
+				} : u, v = r.delimiter, s = v === void 0 ? "/#?" : v, d = r.endsWith, g = d === void 0 ? "" : d;
+				var x = "[".concat(escapeString(g), "]|$");
+				var h = "[".concat(escapeString(s), "]");
+				var l = o ? "^" : "";
+				for (var m = 0, T = e$1; m < T.length; m++) {
+					var E = T[m];
+					if (typeof E === "string") l += escapeString(p(E));
+					else {
+						var w = escapeString(p(E.prefix));
+						var y = escapeString(p(E.suffix));
+						if (E.pattern) {
+							if (n$1) n$1.push(E);
+							if (w || y) if (E.modifier === "+" || E.modifier === "*") {
+								var R = E.modifier === "*" ? "?" : "";
+								l += "(?:".concat(w, "((?:").concat(E.pattern, ")(?:").concat(y).concat(w, "(?:").concat(E.pattern, "))*)").concat(y, ")").concat(R);
+							} else l += "(?:".concat(w, "(").concat(E.pattern, ")").concat(y, ")").concat(E.modifier);
+							else {
+								if (E.modifier === "+" || E.modifier === "*") throw new TypeError("Can not repeat \"".concat(E.name, "\" without a prefix and suffix"));
+								l += "(".concat(E.pattern, ")").concat(E.modifier);
+							}
+						} else l += "(?:".concat(w).concat(y, ")").concat(E.modifier);
+					}
+				}
+				if (f) {
+					if (!a) l += "".concat(h, "?");
+					l += !r.endsWith ? "$" : "(?=".concat(x, ")");
+				} else {
+					var A = e$1[e$1.length - 1];
+					var _ = typeof A === "string" ? h.indexOf(A[A.length - 1]) > -1 : A === void 0;
+					if (!a) l += "(?:".concat(h, "(?=").concat(x, "))?");
+					if (!_) l += "(?=".concat(h, "|").concat(x, ")");
+				}
+				return new RegExp(l, flags(r));
+			}
+			n.tokensToRegexp = tokensToRegexp;
+			function pathToRegexp(e$1, n$1, r) {
+				if (e$1 instanceof RegExp) return regexpToRegexp(e$1, n$1);
+				if (Array.isArray(e$1)) return arrayToRegexp(e$1, n$1, r);
+				return stringToRegexp(e$1, n$1, r);
+			}
+			n.pathToRegexp = pathToRegexp;
+		})();
+		module.exports = e;
+	})();
+}));
+
+//#endregion
+export default require_path_to_regexp();
+
+export { require_path_to_regexp };