@lssm/lib.design-system 1.11.1 → 1.41.0

package/dist/node_modules/next/dist/client/link.js

@@ -0,0 +1,311 @@
+'use client';
+
+import { __commonJSMin, __require } from "../../../../_virtual/rolldown_runtime.js";
+import { require__interop_require_wildcard } from "../../../@swc/helpers/cjs/_interop_require_wildcard.js";
+import { require_format_url } from "../shared/lib/router/utils/format-url.js";
+import { require_utils } from "../shared/lib/utils.js";
+import { require_is_local_url } from "../shared/lib/router/utils/is-local-url.js";
+import { require_resolve_href } from "./resolve-href.js";
+import { require_add_locale } from "./add-locale.js";
+import { require_router_context_shared_runtime } from "../shared/lib/router-context.shared-runtime.js";
+import { require_use_intersection } from "./use-intersection.js";
+import { require_get_domain_locale } from "./get-domain-locale.js";
+import { require_add_base_path } from "./add-base-path.js";
+import { require_use_merged_ref } from "./use-merged-ref.js";
+import { require_error_once } from "../shared/lib/utils/error-once.js";
+
+//#region ../../../node_modules/next/dist/client/link.js
+var require_link = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	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, {
+		default: function() {
+			return _default;
+		},
+		useLinkStatus: function() {
+			return useLinkStatus;
+		}
+	});
+	const _interop_require_wildcard = require__interop_require_wildcard();
+	const _jsxruntime = __require("react/jsx-runtime");
+	const _react = /* @__PURE__ */ _interop_require_wildcard._(__require("react"));
+	const _resolvehref = require_resolve_href();
+	const _islocalurl = require_is_local_url();
+	const _formaturl = require_format_url();
+	const _utils = require_utils();
+	const _addlocale = require_add_locale();
+	const _routercontextsharedruntime = require_router_context_shared_runtime();
+	const _useintersection = require_use_intersection();
+	const _getdomainlocale = require_get_domain_locale();
+	const _addbasepath = require_add_base_path();
+	const _usemergedref = require_use_merged_ref();
+	const _erroronce = require_error_once();
+	const prefetched = /* @__PURE__ */ new Set();
+	function prefetch(router, href, as, options) {
+		if (typeof window === "undefined") return;
+		if (!(0, _islocalurl.isLocalURL)(href)) return;
+		if (!options.bypassPrefetchedCheck) {
+			const locale = typeof options.locale !== "undefined" ? options.locale : "locale" in router ? router.locale : void 0;
+			const prefetchedKey = href + "%" + as + "%" + locale;
+			if (prefetched.has(prefetchedKey)) return;
+			prefetched.add(prefetchedKey);
+		}
+		router.prefetch(href, as, options).catch((err) => {
+			throw err;
+		});
+	}
+	function isModifiedEvent(event) {
+		const target = event.currentTarget.getAttribute("target");
+		return target && target !== "_self" || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || event.nativeEvent && event.nativeEvent.which === 2;
+	}
+	function linkClicked(e, router, href, as, replace, shallow, scroll, locale, onNavigate) {
+		const { nodeName } = e.currentTarget;
+		if (nodeName.toUpperCase() === "A" && isModifiedEvent(e) || e.currentTarget.hasAttribute("download")) return;
+		if (!(0, _islocalurl.isLocalURL)(href)) {
+			if (replace) {
+				e.preventDefault();
+				location.replace(href);
+			}
+			return;
+		}
+		e.preventDefault();
+		const navigate = () => {
+			if (onNavigate) {
+				let isDefaultPrevented = false;
+				onNavigate({ preventDefault: () => {
+					isDefaultPrevented = true;
+				} });
+				if (isDefaultPrevented) return;
+			}
+			const routerScroll = scroll ?? true;
+			if ("beforePopState" in router) router[replace ? "replace" : "push"](href, as, {
+				shallow,
+				locale,
+				scroll: routerScroll
+			});
+			else router[replace ? "replace" : "push"](as || href, { scroll: routerScroll });
+		};
+		navigate();
+	}
+	function formatStringOrUrl(urlObjOrString) {
+		if (typeof urlObjOrString === "string") return urlObjOrString;
+		return (0, _formaturl.formatUrl)(urlObjOrString);
+	}
+	/**
+	* A React component that extends the HTML `<a>` element to provide [prefetching](https://nextjs.org/docs/app/building-your-application/routing/linking-and-navigating#2-prefetching)
+	* and client-side navigation between routes.
+	*
+	* It is the primary way to navigate between routes in Next.js.
+	*
+	* Read more: [Next.js docs: `<Link>`](https://nextjs.org/docs/app/api-reference/components/link)
+	*/ const Link = /* @__PURE__ */ _react.default.forwardRef(function LinkComponent(props, forwardedRef) {
+		let children;
+		const { href: hrefProp, as: asProp, children: childrenProp, prefetch: prefetchProp = null, passHref, replace, shallow, scroll, locale, onClick, onNavigate, onMouseEnter: onMouseEnterProp, onTouchStart: onTouchStartProp, legacyBehavior = false, ...restProps } = props;
+		children = childrenProp;
+		if (legacyBehavior && (typeof children === "string" || typeof children === "number")) children = /* @__PURE__ */ (0, _jsxruntime.jsx)("a", { children });
+		const router = _react.default.useContext(_routercontextsharedruntime.RouterContext);
+		const prefetchEnabled = prefetchProp !== false;
+		{
+			function createPropError(args) {
+				return Object.defineProperty(/* @__PURE__ */ new Error(`Failed prop type: The prop \`${args.key}\` expects a ${args.expected} in \`<Link>\`, but got \`${args.actual}\` instead.` + (typeof window !== "undefined" ? "\nOpen your browser's console to view the Component stack trace." : "")), "__NEXT_ERROR_CODE", {
+					value: "E319",
+					enumerable: false,
+					configurable: true
+				});
+			}
+			Object.keys({ href: true }).forEach((key) => {
+				if (key === "href") {
+					if (props[key] == null || typeof props[key] !== "string" && typeof props[key] !== "object") throw createPropError({
+						key,
+						expected: "`string` or `object`",
+						actual: props[key] === null ? "null" : typeof props[key]
+					});
+				}
+			});
+			Object.keys({
+				as: true,
+				replace: true,
+				scroll: true,
+				shallow: true,
+				passHref: true,
+				prefetch: true,
+				locale: true,
+				onClick: true,
+				onMouseEnter: true,
+				onTouchStart: true,
+				legacyBehavior: true,
+				onNavigate: true
+			}).forEach((key) => {
+				const valType = typeof props[key];
+				if (key === "as") {
+					if (props[key] && valType !== "string" && valType !== "object") throw createPropError({
+						key,
+						expected: "`string` or `object`",
+						actual: valType
+					});
+				} else if (key === "locale") {
+					if (props[key] && valType !== "string") throw createPropError({
+						key,
+						expected: "`string`",
+						actual: valType
+					});
+				} else if (key === "onClick" || key === "onMouseEnter" || key === "onTouchStart" || key === "onNavigate") {
+					if (props[key] && valType !== "function") throw createPropError({
+						key,
+						expected: "`function`",
+						actual: valType
+					});
+				} else if (key === "replace" || key === "scroll" || key === "shallow" || key === "passHref" || key === "legacyBehavior") {
+					if (props[key] != null && valType !== "boolean") throw createPropError({
+						key,
+						expected: "`boolean`",
+						actual: valType
+					});
+				} else if (key === "prefetch") {
+					if (props[key] != null && valType !== "boolean" && props[key] !== "auto") throw createPropError({
+						key,
+						expected: "`boolean | \"auto\"`",
+						actual: valType
+					});
+				}
+			});
+		}
+		const { href, as } = _react.default.useMemo(() => {
+			if (!router) {
+				const resolvedHref$1 = formatStringOrUrl(hrefProp);
+				return {
+					href: resolvedHref$1,
+					as: asProp ? formatStringOrUrl(asProp) : resolvedHref$1
+				};
+			}
+			const [resolvedHref, resolvedAs] = (0, _resolvehref.resolveHref)(router, hrefProp, true);
+			return {
+				href: resolvedHref,
+				as: asProp ? (0, _resolvehref.resolveHref)(router, asProp) : resolvedAs || resolvedHref
+			};
+		}, [
+			router,
+			hrefProp,
+			asProp
+		]);
+		const previousHref = _react.default.useRef(href);
+		const previousAs = _react.default.useRef(as);
+		let child;
+		if (legacyBehavior) {
+			if (onClick) console.warn(`"onClick" was passed to <Link> with \`href\` of \`${hrefProp}\` but "legacyBehavior" was set. The legacy behavior requires onClick be set on the child of next/link`);
+			if (onMouseEnterProp) console.warn(`"onMouseEnter" was passed to <Link> with \`href\` of \`${hrefProp}\` but "legacyBehavior" was set. The legacy behavior requires onMouseEnter be set on the child of next/link`);
+			try {
+				child = _react.default.Children.only(children);
+			} catch (err) {
+				if (!children) throw Object.defineProperty(/* @__PURE__ */ new Error(`No children were passed to <Link> with \`href\` of \`${hrefProp}\` but one child is required https://nextjs.org/docs/messages/link-no-children`), "__NEXT_ERROR_CODE", {
+					value: "E320",
+					enumerable: false,
+					configurable: true
+				});
+				throw Object.defineProperty(/* @__PURE__ */ new Error(`Multiple children were passed to <Link> with \`href\` of \`${hrefProp}\` but only one child is supported https://nextjs.org/docs/messages/link-multiple-children` + (typeof window !== "undefined" ? " \nOpen your browser's console to view the Component stack trace." : "")), "__NEXT_ERROR_CODE", {
+					value: "E266",
+					enumerable: false,
+					configurable: true
+				});
+			}
+		} else if (children?.type === "a") throw Object.defineProperty(/* @__PURE__ */ new Error("Invalid <Link> with <a> child. Please remove <a> or use <Link legacyBehavior>.\nLearn more: https://nextjs.org/docs/messages/invalid-new-link-with-extra-anchor"), "__NEXT_ERROR_CODE", {
+			value: "E209",
+			enumerable: false,
+			configurable: true
+		});
+		const childRef = legacyBehavior ? child && typeof child === "object" && child.ref : forwardedRef;
+		const [setIntersectionRef, isVisible, resetVisible] = (0, _useintersection.useIntersection)({ rootMargin: "200px" });
+		const setIntersectionWithResetRef = _react.default.useCallback((el) => {
+			if (previousAs.current !== as || previousHref.current !== href) {
+				resetVisible();
+				previousAs.current = as;
+				previousHref.current = href;
+			}
+			setIntersectionRef(el);
+		}, [
+			as,
+			href,
+			resetVisible,
+			setIntersectionRef
+		]);
+		const setRef = (0, _usemergedref.useMergedRef)(setIntersectionWithResetRef, childRef);
+		_react.default.useEffect(() => {}, [
+			as,
+			href,
+			isVisible,
+			locale,
+			prefetchEnabled,
+			router?.locale,
+			router
+		]);
+		const childProps = {
+			ref: setRef,
+			onClick(e) {
+				if (!e) throw Object.defineProperty(/* @__PURE__ */ new Error(`Component rendered inside next/link has to pass click event to "onClick" prop.`), "__NEXT_ERROR_CODE", {
+					value: "E312",
+					enumerable: false,
+					configurable: true
+				});
+				if (!legacyBehavior && typeof onClick === "function") onClick(e);
+				if (legacyBehavior && child.props && typeof child.props.onClick === "function") child.props.onClick(e);
+				if (!router) return;
+				if (e.defaultPrevented) return;
+				linkClicked(e, router, href, as, replace, shallow, scroll, locale, onNavigate);
+			},
+			onMouseEnter(e) {
+				if (!legacyBehavior && typeof onMouseEnterProp === "function") onMouseEnterProp(e);
+				if (legacyBehavior && child.props && typeof child.props.onMouseEnter === "function") child.props.onMouseEnter(e);
+				if (!router) return;
+				prefetch(router, href, as, {
+					locale,
+					priority: true,
+					bypassPrefetchedCheck: true
+				});
+			},
+			onTouchStart: process.env.__NEXT_LINK_NO_TOUCH_START ? void 0 : function onTouchStart(e) {
+				if (!legacyBehavior && typeof onTouchStartProp === "function") onTouchStartProp(e);
+				if (legacyBehavior && child.props && typeof child.props.onTouchStart === "function") child.props.onTouchStart(e);
+				if (!router) return;
+				prefetch(router, href, as, {
+					locale,
+					priority: true,
+					bypassPrefetchedCheck: true
+				});
+			}
+		};
+		if ((0, _utils.isAbsoluteUrl)(as)) childProps.href = as;
+		else if (!legacyBehavior || passHref || child.type === "a" && !("href" in child.props)) {
+			const curLocale = typeof locale !== "undefined" ? locale : router?.locale;
+			childProps.href = router?.isLocaleDomain && (0, _getdomainlocale.getDomainLocale)(as, curLocale, router?.locales, router?.domainLocales) || (0, _addbasepath.addBasePath)((0, _addlocale.addLocale)(as, curLocale, router?.defaultLocale));
+		}
+		if (legacyBehavior) {
+			(0, _erroronce.errorOnce)("`legacyBehavior` is deprecated and will be removed in a future release. A codemod is available to upgrade your components:\n\nnpx @next/codemod@latest new-link .\n\nLearn more: https://nextjs.org/docs/app/building-your-application/upgrading/codemods#remove-a-tags-from-link-components");
+			return /* @__PURE__ */ _react.default.cloneElement(child, childProps);
+		}
+		return /* @__PURE__ */ (0, _jsxruntime.jsx)("a", {
+			...restProps,
+			...childProps,
+			children
+		});
+	});
+	const LinkStatusContext = /* @__PURE__ */ (0, _react.createContext)({ pending: false });
+	const useLinkStatus = () => {
+		return (0, _react.useContext)(LinkStatusContext);
+	};
+	const _default = Link;
+	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_link();
+
+export { require_link };

package/dist/node_modules/next/dist/client/normalize-locale-path.js

@@ -0,0 +1,30 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+import { require_normalize_locale_path as require_normalize_locale_path$1 } from "../shared/lib/i18n/normalize-locale-path.js";
+
+//#region ../../../node_modules/next/dist/client/normalize-locale-path.js
+var require_normalize_locale_path = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "normalizeLocalePath", {
+		enumerable: true,
+		get: function() {
+			return normalizeLocalePath;
+		}
+	});
+	const normalizeLocalePath = (pathname, locales) => {
+		if (process.env.__NEXT_I18N_SUPPORT) return require_normalize_locale_path$1().normalizeLocalePath(pathname, locales);
+		return {
+			pathname,
+			detectedLocale: void 0
+		};
+	};
+	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_normalize_locale_path();
+
+export { require_normalize_locale_path };

package/dist/node_modules/next/dist/client/normalize-trailing-slash.js

@@ -0,0 +1,34 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+import { require_remove_trailing_slash } from "../shared/lib/router/utils/remove-trailing-slash.js";
+import { require_parse_path } from "../shared/lib/router/utils/parse-path.js";
+
+//#region ../../../node_modules/next/dist/client/normalize-trailing-slash.js
+var require_normalize_trailing_slash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	Object.defineProperty(exports, "normalizePathTrailingSlash", {
+		enumerable: true,
+		get: function() {
+			return normalizePathTrailingSlash;
+		}
+	});
+	const _removetrailingslash = require_remove_trailing_slash();
+	const _parsepath = require_parse_path();
+	const normalizePathTrailingSlash = (path) => {
+		if (!path.startsWith("/") || process.env.__NEXT_MANUAL_TRAILING_SLASH) return path;
+		const { pathname, query, hash } = (0, _parsepath.parsePath)(path);
+		if (process.env.__NEXT_TRAILING_SLASH) if (/\.[^/]+\/?$/.test(pathname)) return `${(0, _removetrailingslash.removeTrailingSlash)(pathname)}${query}${hash}`;
+		else if (pathname.endsWith("/")) return `${pathname}${query}${hash}`;
+		else return `${pathname}/${query}${hash}`;
+		return `${(0, _removetrailingslash.removeTrailingSlash)(pathname)}${query}${hash}`;
+	};
+	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_normalize_trailing_slash();
+
+export { require_normalize_trailing_slash };

package/dist/node_modules/next/dist/client/request-idle-callback.js

@@ -0,0 +1,44 @@
+import { __commonJSMin } from "../../../../_virtual/rolldown_runtime.js";
+
+//#region ../../../node_modules/next/dist/client/request-idle-callback.js
+var require_request_idle_callback = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	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, {
+		cancelIdleCallback: function() {
+			return cancelIdleCallback;
+		},
+		requestIdleCallback: function() {
+			return requestIdleCallback;
+		}
+	});
+	const requestIdleCallback = typeof self !== "undefined" && self.requestIdleCallback && self.requestIdleCallback.bind(window) || function(cb) {
+		let start = Date.now();
+		return self.setTimeout(function() {
+			cb({
+				didTimeout: false,
+				timeRemaining: function() {
+					return Math.max(0, 50 - (Date.now() - start));
+				}
+			});
+		}, 1);
+	};
+	const cancelIdleCallback = typeof self !== "undefined" && self.cancelIdleCallback && self.cancelIdleCallback.bind(window) || function(id) {
+		return clearTimeout(id);
+	};
+	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_request_idle_callback();
+
+export { require_request_idle_callback };

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