@typlog/ui 0.14.0 → 0.16.0

package/addons.js

@@ -1,492 +1,1840 @@
-import { defineComponent, computed, openBlock, createBlock, unref, normalizeClass, withCtx, createCommentVNode, renderSlot, createElementBlock, createElementVNode, toDisplayString, Fragment, renderList, createVNode, ref, onMounted, withDirectives, withKeys, mergeProps, withModifiers, vShow, createTextVNode, normalizeStyle, useTemplateRef, onBeforeUnmount } from "vue";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, onMounted, onScopeDispose, openBlock, ref, renderList, renderSlot, shallowRef, toDisplayString, triggerRef, unref, useTemplateRef, watch, withCtx } from "vue";
+import { Primitive } from "reka-ui";
 import { Icon } from "@iconify/vue";
-import { Primitive, injectDialogRootContext } from "reka-ui";
-import { buildPropsClass, TextField, Button, Tooltip, Pagination } from "./components";
-const BRAND_ICONS = {
-  google: "logos:google-icon",
-  facebook: "simple-icons:facebook",
-  x: "simple-icons:x",
-  github: "simple-icons:github",
-  apple: "simple-icons:apple",
-  slack: "logos:slack-icon",
-  figma: "logos:figma"
+import { Button, TextField, buildPropsClass } from "@typlog/ui";
+//#region src/addons/button/SocialButton.vue?vue&type=script&setup=true&lang.ts
+var BRAND_ICONS = {
+	google: "logos:google-icon",
+	facebook: "simple-icons:facebook",
+	x: "simple-icons:x",
+	github: "simple-icons:github",
+	apple: "simple-icons:apple",
+	slack: "logos:slack-icon",
+	figma: "logos:figma"
 };
-const _sfc_main$3 = /* @__PURE__ */ defineComponent({
-  __name: "SocialButton",
-  props: {
-    brand: {},
-    variant: { default: "classic" },
-    radius: {},
-    size: { default: "2" },
-    disabled: { type: Boolean },
-    asChild: { type: Boolean },
-    as: { default: "button" }
-  },
-  setup(__props) {
-    const props = __props;
-    const resetClass = buildPropsClass(props, ["size", "brand", "variant"]);
-    const brandIcon = computed(() => {
-      return BRAND_ICONS[props.brand];
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createBlock(unref(Primitive), {
-        class: normalizeClass(["ui-Button ui-SocialButton", unref(resetClass)]),
-        "as-child": props.asChild,
-        as: props.as,
-        "data-radius": props.radius,
-        "data-disabled": props.disabled ? true : void 0
-      }, {
-        default: withCtx(() => [
-          brandIcon.value ? (openBlock(), createBlock(unref(Icon), {
-            key: 0,
-            icon: brandIcon.value
-          }, null, 8, ["icon"])) : createCommentVNode("", true),
-          renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-      }, 8, ["class", "as-child", "as", "data-radius", "data-disabled"]);
-    };
-  }
+//#endregion
+//#region src/addons/button/SocialButton.vue
+var SocialButton_default = /* @__PURE__ */ defineComponent({
+	__name: "SocialButton",
+	props: {
+		brand: {},
+		variant: { default: "classic" },
+		radius: {},
+		size: { default: "2" },
+		disabled: { type: Boolean },
+		asChild: { type: Boolean },
+		as: { default: "button" }
+	},
+	setup(__props) {
+		const props = __props;
+		const resetClass = buildPropsClass(props, [
+			"size",
+			"brand",
+			"variant"
+		]);
+		const brandIcon = computed(() => {
+			return BRAND_ICONS[props.brand];
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(Primitive), {
+				class: normalizeClass(["ui-Button ui-SocialButton", unref(resetClass)]),
+				"as-child": props.asChild,
+				as: props.as,
+				"data-radius": props.radius,
+				"data-disabled": props.disabled ? true : void 0
+			}, {
+				default: withCtx(() => [brandIcon.value ? (openBlock(), createBlock(unref(Icon), {
+					key: 0,
+					icon: brandIcon.value
+				}, null, 8, ["icon"])) : createCommentVNode("", true), renderSlot(_ctx.$slots, "default")]),
+				_: 3
+			}, 8, [
+				"class",
+				"as-child",
+				"as",
+				"data-radius",
+				"data-disabled"
+			]);
+		};
+	}
 });
-const _hoisted_1$1 = {
-  type: "button",
-  class: "ui-IconifySample"
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+virtual-core@3.17.8/node_modules/@tanstack/virtual-core/dist/esm/lazy-measurements.js
+function createLazyMeasurementsView(count, flat, getItemKey) {
+	const cache = new Array(count);
+	return new Proxy(cache, { get(target, prop, receiver) {
+		if (typeof prop === "string") {
+			const c = prop.charCodeAt(0);
+			if (c >= 48 && c <= 57) {
+				const i = +prop;
+				if (Number.isInteger(i) && i >= 0 && i < count) {
+					let v = target[i];
+					if (!v) {
+						const s = flat[i * 2];
+						v = target[i] = {
+							index: i,
+							key: getItemKey(i),
+							start: s,
+							size: flat[i * 2 + 1],
+							end: s + flat[i * 2 + 1],
+							lane: 0
+						};
+					}
+					return v;
+				}
+			}
+			if (prop === "length") return count;
+		}
+		return Reflect.get(target, prop, receiver);
+	} });
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+virtual-core@3.17.8/node_modules/@tanstack/virtual-core/dist/esm/utils.js
+function memo(getDeps, fn, opts) {
+	let deps = opts.initialDeps ?? [];
+	let result;
+	let isInitial = true;
+	function memoizedFunction() {
+		var _a;
+		const debugEnabled = process.env.NODE_ENV !== "production" && !!opts.key && !!((_a = opts.debug) == null ? void 0 : _a.call(opts));
+		let depTime = 0;
+		if (debugEnabled) depTime = Date.now();
+		const newDeps = getDeps();
+		if (!(newDeps.length !== deps.length || newDeps.some((dep, index) => deps[index] !== dep))) return result;
+		deps = newDeps;
+		let resultTime = 0;
+		if (debugEnabled) resultTime = Date.now();
+		result = fn(...newDeps);
+		if (debugEnabled) {
+			const depEndTime = Math.round((Date.now() - depTime) * 100) / 100;
+			const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100;
+			const resultFpsPercentage = resultEndTime / 16;
+			const pad = (str, num) => {
+				str = String(str);
+				while (str.length < num) str = " " + str;
+				return str;
+			};
+			console.info(`%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`, `
+            font-size: .6rem;
+            font-weight: bold;
+            color: hsl(${Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120))}deg 100% 31%);`, opts == null ? void 0 : opts.key);
+		}
+		if ((opts == null ? void 0 : opts.onChange) && !(isInitial && opts.skipInitialOnChange)) opts.onChange(result);
+		isInitial = false;
+		return result;
+	}
+	memoizedFunction.updateDeps = (newDeps) => {
+		deps = newDeps;
+	};
+	return memoizedFunction;
+}
+function notUndefined(value, msg) {
+	if (value === void 0) throw new Error(`Unexpected undefined${msg ? `: ${msg}` : ""}`);
+	else return value;
+}
+var approxEqual = (a, b) => Math.abs(a - b) < 1.01;
+var debounce = (targetWindow, fn, ms) => {
+	let timeoutId;
+	return Object.assign(function(...args) {
+		targetWindow.clearTimeout(timeoutId);
+		timeoutId = targetWindow.setTimeout(() => fn.apply(this, args), ms);
+	}, { cancel: () => {
+		targetWindow.clearTimeout(timeoutId);
+	} });
 };
-const _hoisted_2$1 = { class: "ui-IconifySampleInfo" };
-const _hoisted_3$1 = { class: "ui-IconifySampleIcons" };
-const _sfc_main$2 = /* @__PURE__ */ defineComponent({
-  __name: "IconifySample",
-  props: {
-    prefix: {},
-    category: {},
-    name: {},
-    samples: {},
-    total: {},
-    license: {}
-  },
-  setup(__props) {
-    const props = __props;
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("button", _hoisted_1$1, [
-        createElementVNode("div", _hoisted_2$1, [
-          createElementVNode("strong", null, toDisplayString(props.name), 1),
-          createElementVNode("span", null, toDisplayString(props.license.title), 1),
-          createElementVNode("span", null, toDisplayString(props.total) + " icons", 1)
-        ]),
-        createElementVNode("div", _hoisted_3$1, [
-          (openBlock(true), createElementBlock(Fragment, null, renderList(props.samples, (icon) => {
-            return openBlock(), createElementBlock("span", { key: icon }, [
-              createVNode(unref(Icon), {
-                icon: props.prefix + ":" + icon
-              }, null, 8, ["icon"])
-            ]);
-          }), 128))
-        ])
-      ]);
-    };
-  }
-});
-const _hoisted_1 = { class: "ui-IconifyCollection" };
-const _hoisted_2 = { class: "ui-IconifyCollectionGroups" };
-const _hoisted_3 = { class: "ui-IconifyCollectionGroupsHead" };
-const _hoisted_4 = { class: "ui-IconifyCollectionForm" };
-const _hoisted_5 = { class: "mb-2" };
-const _hoisted_6 = { class: "font-medium" };
-const _hoisted_7 = { class: "text-sm ml-1" };
-const _hoisted_8 = { class: "ui-IconifyCollectionSampleGrid" };
-const _hoisted_9 = {
-  key: 0,
-  class: "ui-IconifyCollectionIcons"
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+virtual-core@3.17.8/node_modules/@tanstack/virtual-core/dist/esm/index.js
+var _isIOSResult;
+var isIOSWebKit = () => {
+	if (_isIOSResult !== void 0) return _isIOSResult;
+	if (typeof navigator === "undefined") return _isIOSResult = false;
+	if (/iP(hone|od|ad)/.test(navigator.userAgent)) return _isIOSResult = true;
+	const mtp = navigator.maxTouchPoints;
+	return _isIOSResult = navigator.platform === "MacIntel" && mtp !== void 0 && mtp > 0;
+};
+var getRect = (element) => {
+	const { offsetWidth, offsetHeight } = element;
+	return {
+		width: offsetWidth,
+		height: offsetHeight
+	};
+};
+var defaultKeyExtractor = (index) => index;
+var defaultRangeExtractor = (range) => {
+	const start = Math.max(range.startIndex - range.overscan, 0);
+	const len = Math.min(range.endIndex + range.overscan, range.count - 1) - start + 1;
+	const arr = new Array(len);
+	for (let i = 0; i < len; i++) arr[i] = start + i;
+	return arr;
 };
-const _hoisted_10 = { class: "ui-IconifyCollectionForm" };
-const _hoisted_11 = {
-  key: 0,
-  class: "ui-IconifyCollectionSuffixes"
+var observeElementRect = (instance, cb) => {
+	const element = instance.scrollElement;
+	if (!element) return;
+	const targetWindow = instance.targetWindow;
+	if (!targetWindow) return;
+	const handler = (rect) => {
+		const { width, height } = rect;
+		cb({
+			width: Math.round(width),
+			height: Math.round(height)
+		});
+	};
+	handler(getRect(element));
+	if (!targetWindow.ResizeObserver) return () => {};
+	const observer = new targetWindow.ResizeObserver((entries) => {
+		const run = () => {
+			const entry = entries[0];
+			if (entry == null ? void 0 : entry.borderBoxSize) {
+				const box = entry.borderBoxSize[0];
+				if (box) {
+					handler({
+						width: box.inlineSize,
+						height: box.blockSize
+					});
+					return;
+				}
+			}
+			handler(getRect(element));
+		};
+		instance.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
+	});
+	observer.observe(element, { box: "border-box" });
+	return () => {
+		observer.unobserve(element);
+	};
 };
-const _hoisted_12 = ["onClick"];
-const fetchCollections = async () => {
-  const apiLink = "https://api.iconify.design/collections";
-  const resp = await fetch(apiLink);
-  const data = await resp.json();
-  const cache = {};
-  Object.keys(data).forEach((prefix) => {
-    const item = data[prefix];
-    if (item.hidden) {
-      return;
-    }
-    if (!cache[item.category]) {
-      cache[item.category] = [];
-    }
-    cache[item.category].push({ ...item, prefix });
-  });
-  const collections = [];
-  Object.keys(cache).forEach((category) => {
-    collections.push({
-      category,
-      items: cache[category]
-    });
-  });
-  return collections;
+var addEventListenerOptions = { passive: true };
+var supportsScrollend = typeof window == "undefined" ? true : "onscrollend" in window;
+var observeOffset = (instance, cb, readOffset) => {
+	const element = instance.scrollElement;
+	if (!element) return;
+	const targetWindow = instance.targetWindow;
+	if (!targetWindow) return;
+	const registerScrollendEvent = instance.options.useScrollendEvent && supportsScrollend;
+	let offset = 0;
+	const fallback = registerScrollendEvent ? null : debounce(targetWindow, () => cb(offset, false), instance.options.isScrollingResetDelay);
+	const createHandler = (isScrolling) => () => {
+		offset = readOffset(element);
+		fallback?.();
+		cb(offset, isScrolling);
+	};
+	const handler = createHandler(true);
+	const endHandler = createHandler(false);
+	element.addEventListener("scroll", handler, addEventListenerOptions);
+	if (registerScrollendEvent) element.addEventListener("scrollend", endHandler, addEventListenerOptions);
+	return () => {
+		element.removeEventListener("scroll", handler);
+		if (registerScrollendEvent) element.removeEventListener("scrollend", endHandler);
+		fallback?.cancel();
+	};
 };
-const searchIcons = async (query) => {
-  const apiLink = `https://api.iconify.design/search?query=${encodeURIComponent(query)}&limit=999`;
-  const resp = await fetch(apiLink);
-  const data = await resp.json();
-  return data.icons;
+var observeElementOffset = (instance, cb) => observeOffset(instance, cb, (el) => {
+	const { horizontal, isRtl } = instance.options;
+	return horizontal ? el.scrollLeft * (isRtl && -1 || 1) : el.scrollTop;
+});
+var measureElement = (element, entry, instance) => {
+	if (instance.options.useCachedMeasurements) {
+		const index = instance.indexFromElement(element);
+		const key = instance.options.getItemKey(index);
+		return instance.itemSizeCache.get(key) ?? instance.options.estimateSize(index);
+	}
+	if (entry == null ? void 0 : entry.borderBoxSize) {
+		const box = entry.borderBoxSize[0];
+		if (box) return Math.round(box[instance.options.horizontal ? "inlineSize" : "blockSize"]);
+	}
+	if (!entry) {
+		const index = instance.indexFromElement(element);
+		const key = instance.options.getItemKey(index);
+		const cachedSize = instance.itemSizeCache.get(key);
+		if (cachedSize !== void 0) return cachedSize;
+	}
+	return element[instance.options.horizontal ? "offsetWidth" : "offsetHeight"];
+};
+var scrollWithAdjustments = (offset, { adjustments = 0, behavior }, instance) => {
+	var _a, _b;
+	(_b = (_a = instance.scrollElement) == null ? void 0 : _a.scrollTo) == null || _b.call(_a, {
+		[instance.options.horizontal ? "left" : "top"]: offset + adjustments,
+		behavior
+	});
 };
-const fetchCollectionIcons = async (prefix) => {
-  const apiLink = `https://api.iconify.design/collection?prefix=${encodeURIComponent(prefix)}&chars=true&aliases=true`;
-  const resp = await fetch(apiLink);
-  const data = await resp.json();
-  return data;
+var elementScroll = scrollWithAdjustments;
+var Virtualizer = class {
+	constructor(opts) {
+		this.unsubs = [];
+		this.scrollElement = null;
+		this.targetWindow = null;
+		this.isScrolling = false;
+		this.scrollState = null;
+		this.measurementsCache = [];
+		this._flatMeasurements = null;
+		this.itemSizeCache = /* @__PURE__ */ new Map();
+		this.itemSizeCacheVersion = 0;
+		this.laneAssignments = /* @__PURE__ */ new Map();
+		this.pendingMin = null;
+		this.prevLanes = void 0;
+		this.lanesChangedFlag = false;
+		this.lanesSettling = false;
+		this.pendingScrollAnchor = null;
+		this.scrollRect = null;
+		this.scrollOffset = null;
+		this.scrollDirection = null;
+		this.scrollAdjustments = 0;
+		this._iosDeferredAdjustment = 0;
+		this._iosTouching = false;
+		this._iosJustTouchEnded = false;
+		this._iosTouchEndTimerId = null;
+		this._intendedScrollOffset = null;
+		this.elementsCache = /* @__PURE__ */ new Map();
+		this.now = () => {
+			var _a, _b, _c;
+			return ((_c = (_b = (_a = this.targetWindow) == null ? void 0 : _a.performance) == null ? void 0 : _b.now) == null ? void 0 : _c.call(_b)) ?? Date.now();
+		};
+		this.observer = /* @__PURE__ */ (() => {
+			let _ro = null;
+			const get = () => {
+				if (_ro) return _ro;
+				if (!this.targetWindow || !this.targetWindow.ResizeObserver) return null;
+				return _ro = new this.targetWindow.ResizeObserver((entries) => {
+					entries.forEach((entry) => {
+						const run = () => {
+							const node = entry.target;
+							const index = this.indexFromElement(node);
+							if (!node.isConnected) {
+								this.observer.unobserve(node);
+								for (const [cacheKey, cachedNode] of this.elementsCache) if (cachedNode === node) {
+									this.elementsCache.delete(cacheKey);
+									break;
+								}
+								return;
+							}
+							if (!this.isIndexInRange(index)) return;
+							if (this.shouldMeasureDuringScroll(index)) this.resizeItem(index, this.options.measureElement(node, entry, this));
+						};
+						this.options.useAnimationFrameWithResizeObserver ? requestAnimationFrame(run) : run();
+					});
+				});
+			};
+			return {
+				disconnect: () => {
+					var _a;
+					(_a = get()) == null || _a.disconnect();
+					_ro = null;
+				},
+				observe: (target) => {
+					var _a;
+					return (_a = get()) == null ? void 0 : _a.observe(target, { box: "border-box" });
+				},
+				unobserve: (target) => {
+					var _a;
+					return (_a = get()) == null ? void 0 : _a.unobserve(target);
+				}
+			};
+		})();
+		this.range = null;
+		this.setOptions = (opts2) => {
+			var _a, _b;
+			const merged = {
+				debug: false,
+				initialOffset: 0,
+				overscan: 1,
+				paddingStart: 0,
+				paddingEnd: 0,
+				scrollPaddingStart: 0,
+				scrollPaddingEnd: 0,
+				horizontal: false,
+				getItemKey: defaultKeyExtractor,
+				rangeExtractor: defaultRangeExtractor,
+				onChange: () => {},
+				measureElement,
+				initialRect: {
+					width: 0,
+					height: 0
+				},
+				scrollMargin: 0,
+				gap: 0,
+				indexAttribute: "data-index",
+				initialMeasurementsCache: [],
+				lanes: 1,
+				anchorTo: "start",
+				followOnAppend: false,
+				scrollEndThreshold: 1,
+				isScrollingResetDelay: 150,
+				enabled: true,
+				isRtl: false,
+				useScrollendEvent: false,
+				useAnimationFrameWithResizeObserver: false,
+				laneAssignmentMode: "estimate",
+				useCachedMeasurements: false
+			};
+			for (const key in opts2) {
+				const v = opts2[key];
+				if (v !== void 0) merged[key] = v;
+			}
+			const prevOptions = this.options;
+			let anchor = null;
+			let followOnAppend = null;
+			let edgeKeysChanged = false;
+			if (prevOptions !== void 0 && prevOptions.enabled && merged.enabled && merged.anchorTo === "end" && this.scrollElement !== null) {
+				const prevCount = prevOptions.count;
+				const nextCount = merged.count;
+				const measurements = this.getMeasurements();
+				const prevFirstKey = prevCount > 0 ? ((_a = measurements[0]) == null ? void 0 : _a.key) ?? prevOptions.getItemKey(0) : null;
+				const prevLastKey = prevCount > 0 ? ((_b = measurements[prevCount - 1]) == null ? void 0 : _b.key) ?? prevOptions.getItemKey(prevCount - 1) : null;
+				if (nextCount !== prevCount || prevCount > 0 && nextCount > 0 && (merged.getItemKey(0) !== prevFirstKey || merged.getItemKey(nextCount - 1) !== prevLastKey)) {
+					edgeKeysChanged = true;
+					const item = prevCount > 0 ? this.getVirtualItemForOffset(this.getScrollOffset()) ?? measurements[0] : null;
+					if (item) anchor = [item.key, this.getScrollOffset() - item.start];
+					const behavior = merged.followOnAppend === true ? "auto" : merged.followOnAppend || null;
+					if (behavior && nextCount > prevCount && this.isAtEnd(prevOptions.scrollEndThreshold) && (prevCount === 0 || merged.getItemKey(nextCount - 1) !== prevLastKey)) followOnAppend = behavior;
+				}
+			}
+			this.options = merged;
+			if (edgeKeysChanged) {
+				this.pendingMin = 0;
+				this.itemSizeCacheVersion++;
+			}
+			let anchorResolved = false;
+			let anchorDelta = 0;
+			if (anchor && this.scrollOffset !== null) {
+				const [anchorKey, anchorOffset] = anchor;
+				const newMeasurements = this.getMeasurements();
+				const { count, getItemKey } = this.options;
+				let idx = 0;
+				while (idx < count && getItemKey(idx) !== anchorKey) idx++;
+				if (idx < count) {
+					const anchorItem = newMeasurements[idx];
+					if (anchorItem) {
+						const newOffset = Math.max(0, anchorItem.start + anchorOffset);
+						if (newOffset !== this.scrollOffset) {
+							anchorDelta = newOffset - this.scrollOffset;
+							this.scrollOffset = newOffset;
+							anchorResolved = true;
+						}
+					}
+				}
+			}
+			if (anchorResolved || followOnAppend) this.pendingScrollAnchor = [
+				anchorResolved ? anchor[0] : null,
+				anchorResolved ? anchor[1] : 0,
+				followOnAppend,
+				anchorDelta
+			];
+		};
+		this.notify = (sync) => {
+			var _a, _b;
+			(_b = (_a = this.options).onChange) == null || _b.call(_a, this, sync);
+		};
+		this.maybeNotify = memo(() => {
+			this.calculateRange();
+			return [
+				this.isScrolling,
+				this.range ? this.range.startIndex : null,
+				this.range ? this.range.endIndex : null
+			];
+		}, (isScrolling) => {
+			this.notify(isScrolling);
+		}, {
+			key: process.env.NODE_ENV !== "production" && "maybeNotify",
+			debug: () => this.options.debug,
+			initialDeps: [
+				this.isScrolling,
+				this.range ? this.range.startIndex : null,
+				this.range ? this.range.endIndex : null
+			]
+		});
+		this.cleanup = () => {
+			this.unsubs.filter(Boolean).forEach((d) => d());
+			this.unsubs = [];
+			this.observer.disconnect();
+			if (this.rafId != null && this.targetWindow) {
+				this.targetWindow.cancelAnimationFrame(this.rafId);
+				this.rafId = null;
+			}
+			this.scrollState = null;
+			this.isScrolling = false;
+			this.scrollDirection = null;
+			this._iosDeferredAdjustment = 0;
+			this._iosTouching = false;
+			this._iosJustTouchEnded = false;
+			this.scrollElement = null;
+			this.targetWindow = null;
+		};
+		this._didMount = () => {
+			return () => {
+				this.cleanup();
+			};
+		};
+		this._willUpdate = () => {
+			var _a;
+			const scrollElement = this.options.enabled ? this.options.getScrollElement() : null;
+			if (this.scrollElement !== scrollElement) {
+				this.cleanup();
+				if (!scrollElement) {
+					this.maybeNotify();
+					return;
+				}
+				this.scrollElement = scrollElement;
+				if (this.scrollElement && "ownerDocument" in this.scrollElement) this.targetWindow = this.scrollElement.ownerDocument.defaultView;
+				else this.targetWindow = ((_a = this.scrollElement) == null ? void 0 : _a.window) ?? null;
+				this.elementsCache.forEach((cached) => {
+					this.observer.observe(cached);
+				});
+				this.unsubs.push(this.options.observeElementRect(this, (rect) => {
+					this.scrollRect = rect;
+					this.maybeNotify();
+				}));
+				this.unsubs.push(this.options.observeElementOffset(this, (offset, isScrolling) => {
+					if (isScrolling && this._intendedScrollOffset === null && offset === this.scrollOffset) return;
+					if (this._intendedScrollOffset !== null && Math.abs(offset - this._intendedScrollOffset) < 1.5) offset = this._intendedScrollOffset;
+					this._intendedScrollOffset = null;
+					this.scrollAdjustments = 0;
+					const prevOffset = this.getScrollOffset();
+					this.scrollDirection = isScrolling ? prevOffset === offset ? this.scrollDirection : prevOffset < offset ? "forward" : "backward" : null;
+					this.scrollOffset = offset;
+					this.isScrolling = isScrolling;
+					this._flushIosDeferredIfReady();
+					if (this.scrollState) this.scheduleScrollReconcile();
+					this.maybeNotify();
+				}));
+				if ("addEventListener" in this.scrollElement) {
+					const scrollEl = this.scrollElement;
+					const onTouchStart = () => {
+						this._iosTouching = true;
+						this._iosJustTouchEnded = false;
+						if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+							this.targetWindow.clearTimeout(this._iosTouchEndTimerId);
+							this._iosTouchEndTimerId = null;
+						}
+					};
+					const onTouchEnd = () => {
+						this._iosTouching = false;
+						if (!isIOSWebKit() || this.targetWindow == null) return;
+						this._iosJustTouchEnded = true;
+						this._iosTouchEndTimerId = this.targetWindow.setTimeout(() => {
+							this._iosJustTouchEnded = false;
+							this._iosTouchEndTimerId = null;
+							this._flushIosDeferredIfReady();
+						}, 150);
+					};
+					scrollEl.addEventListener("touchstart", onTouchStart, addEventListenerOptions);
+					scrollEl.addEventListener("touchend", onTouchEnd, addEventListenerOptions);
+					this.unsubs.push(() => {
+						scrollEl.removeEventListener("touchstart", onTouchStart);
+						scrollEl.removeEventListener("touchend", onTouchEnd);
+						if (this._iosTouchEndTimerId !== null && this.targetWindow != null) {
+							this.targetWindow.clearTimeout(this._iosTouchEndTimerId);
+							this._iosTouchEndTimerId = null;
+						}
+					});
+				}
+				this._scrollToOffset(this.getScrollOffset(), {
+					adjustments: void 0,
+					behavior: void 0
+				});
+			}
+			const anchor = this.pendingScrollAnchor;
+			this.pendingScrollAnchor = null;
+			if (anchor && this.scrollElement && this.options.enabled) {
+				const [key, _offset, followOnAppend, anchorDelta] = anchor;
+				if (key !== null && !followOnAppend) {
+					if (isIOSWebKit() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded)) {
+						if (anchorDelta !== 0) this._iosDeferredAdjustment += anchorDelta;
+					} else this._scrollToOffset(this.getScrollOffset(), {
+						adjustments: void 0,
+						behavior: void 0
+					});
+				}
+				if (followOnAppend) this.scrollToEnd({ behavior: followOnAppend });
+			}
+		};
+		this._flushIosDeferredIfReady = () => {
+			if (this._iosDeferredAdjustment === 0) return;
+			if (this.isScrolling) return;
+			if (this._iosTouching) return;
+			if (this._iosJustTouchEnded) return;
+			const cur = this.getScrollOffset();
+			const max = this.getMaxScrollOffset();
+			if (cur < 0 || cur > max) return;
+			if (this._iosDeferredAdjustment < 0 && cur >= max - 1) {
+				this._iosDeferredAdjustment = 0;
+				return;
+			}
+			const delta = this._iosDeferredAdjustment;
+			this._iosDeferredAdjustment = 0;
+			this._scrollToOffset(cur, {
+				adjustments: this.scrollAdjustments += delta,
+				behavior: void 0
+			});
+		};
+		this.rafId = null;
+		this.getSize = () => {
+			if (!this.options.enabled) {
+				this.scrollRect = null;
+				return 0;
+			}
+			this.scrollRect = this.scrollRect ?? this.options.initialRect;
+			return this.scrollRect[this.options.horizontal ? "width" : "height"];
+		};
+		this.getScrollOffset = () => {
+			if (!this.options.enabled) {
+				this.scrollOffset = null;
+				return 0;
+			}
+			this.scrollOffset = this.scrollOffset ?? (typeof this.options.initialOffset === "function" ? this.options.initialOffset() : this.options.initialOffset);
+			return this.scrollOffset;
+		};
+		this.getMeasurementOptions = memo(() => [
+			this.options.count,
+			this.options.paddingStart,
+			this.options.scrollMargin,
+			this.options.getItemKey,
+			this.options.enabled,
+			this.options.lanes,
+			this.options.laneAssignmentMode,
+			this.options.gap
+		], (count, paddingStart, scrollMargin, getItemKey, enabled, lanes, laneAssignmentMode, gap) => {
+			if (this.prevLanes !== void 0 && this.prevLanes !== lanes) this.lanesChangedFlag = true;
+			this.prevLanes = lanes;
+			this.pendingMin = null;
+			return {
+				count,
+				paddingStart,
+				scrollMargin,
+				getItemKey,
+				enabled,
+				lanes,
+				laneAssignmentMode,
+				gap
+			};
+		}, { key: false });
+		this.isIndexInRange = (index) => index >= 0 && index < this.options.count;
+		this.getMeasurements = memo(() => [this.getMeasurementOptions(), this.itemSizeCacheVersion], ({ count, paddingStart, scrollMargin, getItemKey, enabled, lanes, laneAssignmentMode, gap }, _itemSizeCacheVersion) => {
+			const itemSizeCache = this.itemSizeCache;
+			if (!enabled) {
+				this.measurementsCache = [];
+				this.itemSizeCache.clear();
+				this.laneAssignments.clear();
+				return [];
+			}
+			if (this.laneAssignments.size > count) {
+				for (const index of this.laneAssignments.keys()) if (index >= count) this.laneAssignments.delete(index);
+			}
+			if (this.lanesChangedFlag) {
+				this.lanesChangedFlag = false;
+				this.lanesSettling = true;
+				this.measurementsCache = [];
+				this.itemSizeCache.clear();
+				this.laneAssignments.clear();
+				this.pendingMin = null;
+			}
+			if (this.measurementsCache.length === 0 && !this.lanesSettling) {
+				this.measurementsCache = this.options.initialMeasurementsCache;
+				this.measurementsCache.forEach((item) => {
+					this.itemSizeCache.set(item.key, item.size);
+				});
+			}
+			const min = this.lanesSettling ? 0 : this.pendingMin ?? 0;
+			this.pendingMin = null;
+			if (this.lanesSettling && this.measurementsCache.length === count) this.lanesSettling = false;
+			if (lanes === 1) {
+				const need = count * 2;
+				let flat = this._flatMeasurements;
+				if (!flat || flat.length < need) {
+					const next = new Float64Array(need);
+					if (flat && min > 0) next.set(flat.subarray(0, min * 2));
+					flat = next;
+					this._flatMeasurements = flat;
+				}
+				let runningStart;
+				if (min === 0) runningStart = paddingStart + scrollMargin;
+				else {
+					const prevIdx = min - 1;
+					runningStart = flat[prevIdx * 2] + flat[prevIdx * 2 + 1] + gap;
+				}
+				for (let i = min; i < count; i++) {
+					const key = getItemKey(i);
+					const measuredSize = itemSizeCache.get(key);
+					const size = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i);
+					flat[i * 2] = runningStart;
+					flat[i * 2 + 1] = size;
+					runningStart += size + gap;
+				}
+				const view = createLazyMeasurementsView(count, flat, getItemKey);
+				this.measurementsCache = view;
+				return view;
+			}
+			const measurements = this.measurementsCache.slice(0, min);
+			const laneLastIndex = new Array(lanes).fill(void 0);
+			const laneEnds = new Float64Array(lanes);
+			let filledLanes = 0;
+			for (let m = 0; m < min; m++) {
+				const item = measurements[m];
+				if (item) {
+					if (laneLastIndex[item.lane] === void 0) filledLanes++;
+					laneLastIndex[item.lane] = m;
+					laneEnds[item.lane] = item.end;
+				}
+			}
+			for (let i = min; i < count; i++) {
+				const key = getItemKey(i);
+				const cachedLane = this.laneAssignments.get(i);
+				let lane;
+				let start;
+				const shouldCacheLane = laneAssignmentMode === "estimate" || itemSizeCache.has(key);
+				if (cachedLane !== void 0 && this.options.lanes > 1) {
+					lane = cachedLane;
+					const prevIndex = laneLastIndex[lane];
+					const prevInLane = prevIndex !== void 0 ? measurements[prevIndex] : void 0;
+					start = prevInLane ? prevInLane.end + gap : paddingStart + scrollMargin;
+				} else if (filledLanes === lanes) {
+					let bestLane = 0;
+					let bestEnd = laneEnds[0];
+					let bestIdx = laneLastIndex[0];
+					for (let l = 1; l < lanes; l++) {
+						const e = laneEnds[l];
+						if (e < bestEnd || e === bestEnd && laneLastIndex[l] < bestIdx) {
+							bestLane = l;
+							bestEnd = e;
+							bestIdx = laneLastIndex[l];
+						}
+					}
+					lane = bestLane;
+					start = bestEnd + gap;
+					if (shouldCacheLane) this.laneAssignments.set(i, lane);
+				} else {
+					lane = i % this.options.lanes;
+					start = paddingStart + scrollMargin;
+					if (shouldCacheLane) this.laneAssignments.set(i, lane);
+				}
+				const measuredSize = itemSizeCache.get(key);
+				const size = typeof measuredSize === "number" ? measuredSize : this.options.estimateSize(i);
+				const end = start + size;
+				measurements[i] = {
+					index: i,
+					start,
+					size,
+					end,
+					key,
+					lane
+				};
+				if (laneLastIndex[lane] === void 0) filledLanes++;
+				laneLastIndex[lane] = i;
+				laneEnds[lane] = end;
+			}
+			this.measurementsCache = measurements;
+			return measurements;
+		}, {
+			key: process.env.NODE_ENV !== "production" && "getMeasurements",
+			debug: () => this.options.debug
+		});
+		this.calculateRange = memo(() => [
+			this.getMeasurements(),
+			this.getSize(),
+			this.getScrollOffset(),
+			this.options.lanes
+		], (measurements, outerSize, scrollOffset, lanes) => {
+			if (measurements.length === 0 || outerSize === 0) {
+				this.range = null;
+				return null;
+			}
+			this.range = calculateRangeImpl(measurements, outerSize, scrollOffset, lanes, lanes === 1 && this._flatMeasurements != null ? this._flatMeasurements : null);
+			return this.range;
+		}, {
+			key: process.env.NODE_ENV !== "production" && "calculateRange",
+			debug: () => this.options.debug
+		});
+		this.getVirtualIndexes = memo(() => {
+			let startIndex = null;
+			let endIndex = null;
+			const range = this.calculateRange();
+			if (range) {
+				startIndex = range.startIndex;
+				endIndex = range.endIndex;
+			}
+			this.maybeNotify.updateDeps([
+				this.isScrolling,
+				startIndex,
+				endIndex
+			]);
+			return [
+				this.options.rangeExtractor,
+				this.options.overscan,
+				this.options.count,
+				startIndex,
+				endIndex
+			];
+		}, (rangeExtractor, overscan, count, startIndex, endIndex) => {
+			return startIndex === null || endIndex === null ? [] : rangeExtractor({
+				startIndex,
+				endIndex,
+				overscan,
+				count
+			});
+		}, {
+			key: process.env.NODE_ENV !== "production" && "getVirtualIndexes",
+			debug: () => this.options.debug
+		});
+		this.indexFromElement = (node) => {
+			const attributeName = this.options.indexAttribute;
+			const indexStr = node.getAttribute(attributeName);
+			if (!indexStr) {
+				console.warn(`Missing attribute name '${attributeName}={index}' on measured element.`);
+				return -1;
+			}
+			return parseInt(indexStr, 10);
+		};
+		this.shouldMeasureDuringScroll = (index) => {
+			var _a;
+			if (!this.scrollState || this.scrollState.behavior !== "smooth") return true;
+			const scrollIndex = this.scrollState.index ?? ((_a = this.getVirtualItemForOffset(this.scrollState.lastTargetOffset)) == null ? void 0 : _a.index);
+			if (scrollIndex !== void 0 && this.range) {
+				const bufferSize = Math.max(this.options.overscan, Math.ceil((this.range.endIndex - this.range.startIndex) / 2));
+				const minIndex = Math.max(0, scrollIndex - bufferSize);
+				const maxIndex = Math.min(this.options.count - 1, scrollIndex + bufferSize);
+				return index >= minIndex && index <= maxIndex;
+			}
+			return true;
+		};
+		this.measureElement = (node) => {
+			if (!node) {
+				this.elementsCache.forEach((cached, key2) => {
+					if (!cached.isConnected) {
+						this.observer.unobserve(cached);
+						this.elementsCache.delete(key2);
+					}
+				});
+				return;
+			}
+			const index = this.indexFromElement(node);
+			if (!this.isIndexInRange(index)) return;
+			const key = this.options.getItemKey(index);
+			const prevNode = this.elementsCache.get(key);
+			if (prevNode !== node) {
+				if (prevNode) this.observer.unobserve(prevNode);
+				this.observer.observe(node);
+				this.elementsCache.set(key, node);
+			}
+			if ((!this.isScrolling || this.scrollState) && this.shouldMeasureDuringScroll(index)) this.resizeItem(index, this.options.measureElement(node, void 0, this));
+		};
+		this.resizeItem = (index, size) => {
+			var _a, _b;
+			if (!this.isIndexInRange(index)) return;
+			let cachedSize;
+			let itemStart;
+			let key;
+			const flat = this._flatMeasurements;
+			if (this.options.lanes === 1 && flat !== null) {
+				key = this.options.getItemKey(index);
+				itemStart = flat[index * 2];
+				cachedSize = flat[index * 2 + 1];
+			} else {
+				const item = this.measurementsCache[index];
+				if (!item) return;
+				key = item.key;
+				itemStart = item.start;
+				cachedSize = item.size;
+			}
+			const itemSize = this.itemSizeCache.get(key) ?? cachedSize;
+			const delta = size - itemSize;
+			if (delta !== 0) {
+				const wasAtEnd = this.options.anchorTo === "end" && ((_a = this.scrollState) == null ? void 0 : _a.behavior) !== "smooth" && this.getVirtualDistanceFromEnd() <= this.options.scrollEndThreshold;
+				const prevTotalSize = wasAtEnd ? this.getTotalSize() : 0;
+				const scrollOffsetWithAdj = this.getScrollOffset() + this.scrollAdjustments;
+				const defaultShouldAdjust = !this.itemSizeCache.has(key) ? itemStart < scrollOffsetWithAdj : itemStart + itemSize <= scrollOffsetWithAdj && this.scrollDirection !== "backward";
+				const shouldAdjustScroll = ((_b = this.scrollState) == null ? void 0 : _b.behavior) !== "smooth" && (this.shouldAdjustScrollPositionOnItemSizeChange !== void 0 ? this.shouldAdjustScrollPositionOnItemSizeChange(this.measurementsCache[index] ?? {
+					index,
+					key,
+					start: itemStart,
+					size: cachedSize,
+					end: itemStart + cachedSize,
+					lane: 0
+				}, delta, this) : defaultShouldAdjust);
+				if (this.pendingMin === null || index < this.pendingMin) this.pendingMin = index;
+				this.itemSizeCache.set(key, size);
+				this.itemSizeCacheVersion++;
+				let adjustedSync = false;
+				if (wasAtEnd) adjustedSync = this.applyScrollAdjustment(this.getTotalSize() - prevTotalSize);
+				else if (shouldAdjustScroll) adjustedSync = this.applyScrollAdjustment(delta);
+				this.notify(adjustedSync);
+			}
+		};
+		this.getVirtualItems = memo(() => [this.getVirtualIndexes(), this.getMeasurements()], (indexes, measurements) => {
+			const virtualItems = [];
+			for (let k = 0, len = indexes.length; k < len; k++) {
+				const measurement = measurements[indexes[k]];
+				virtualItems.push(measurement);
+			}
+			return virtualItems;
+		}, {
+			key: process.env.NODE_ENV !== "production" && "getVirtualItems",
+			debug: () => this.options.debug
+		});
+		this.getVirtualItemForOffset = (offset) => {
+			const measurements = this.getMeasurements();
+			if (measurements.length === 0) return;
+			const flat = this._flatMeasurements;
+			const useFlat = this.options.lanes === 1 && flat != null;
+			return notUndefined(measurements[findNearestBinarySearch(0, measurements.length - 1, useFlat ? (i) => flat[i * 2] : (i) => notUndefined(measurements[i]).start, offset)]);
+		};
+		this.getMaxScrollOffset = () => {
+			if (!this.scrollElement) return 0;
+			if ("scrollHeight" in this.scrollElement) return this.options.horizontal ? this.scrollElement.scrollWidth - this.scrollElement.clientWidth : this.scrollElement.scrollHeight - this.scrollElement.clientHeight;
+			else {
+				const doc = this.scrollElement.document.documentElement;
+				return this.options.horizontal ? doc.scrollWidth - this.scrollElement.innerWidth : doc.scrollHeight - this.scrollElement.innerHeight;
+			}
+		};
+		this.getVirtualDistanceFromEnd = () => {
+			return Math.max(this.getTotalSize() - this.getSize() - this.getScrollOffset(), 0);
+		};
+		this.getDistanceFromEnd = () => {
+			return Math.max(this.getMaxScrollOffset() - this.getScrollOffset(), 0);
+		};
+		this.isAtEnd = (threshold = this.options.scrollEndThreshold) => {
+			return this.getDistanceFromEnd() <= threshold;
+		};
+		this.getOffsetForAlignment = (toOffset, align, itemSize = 0) => {
+			if (!this.scrollElement) return 0;
+			const size = this.getSize();
+			const scrollOffset = this.getScrollOffset();
+			if (align === "auto") align = toOffset >= scrollOffset + size ? "end" : "start";
+			if (align === "center") toOffset += (itemSize - size) / 2;
+			else if (align === "end") toOffset -= size;
+			const maxOffset = this.getMaxScrollOffset();
+			return Math.max(Math.min(maxOffset, toOffset), 0);
+		};
+		this.getOffsetForIndex = (index, align = "auto") => {
+			index = Math.max(0, Math.min(index, this.options.count - 1));
+			const size = this.getSize();
+			const scrollOffset = this.getScrollOffset();
+			const item = this.measurementsCache[index];
+			if (!item) return;
+			if (align === "auto") {
+				if (item.end >= scrollOffset + size - this.options.scrollPaddingEnd) align = "end";
+				else if (item.start <= scrollOffset + this.options.scrollPaddingStart) align = "start";
+				else return [scrollOffset, align];
+			}
+			if (align === "end" && index === this.options.count - 1) return [this.getMaxScrollOffset(), align];
+			const toOffset = align === "end" ? item.end + this.options.scrollPaddingEnd : item.start - this.options.scrollPaddingStart;
+			return [this.getOffsetForAlignment(toOffset, align, item.size), align];
+		};
+		this.scrollToOffset = (toOffset, { align = "start", behavior = "auto" } = {}) => {
+			this._iosDeferredAdjustment = 0;
+			const offset = this.getOffsetForAlignment(toOffset, align);
+			const now = this.now();
+			this.scrollState = {
+				index: null,
+				align,
+				behavior,
+				startedAt: now,
+				lastTargetOffset: offset,
+				stableFrames: 0
+			};
+			this._scrollToOffset(offset, {
+				adjustments: void 0,
+				behavior
+			});
+			this.scheduleScrollReconcile();
+		};
+		this.scrollToIndex = (index, { align: initialAlign = "auto", behavior = "auto" } = {}) => {
+			this._iosDeferredAdjustment = 0;
+			index = Math.max(0, Math.min(index, this.options.count - 1));
+			const offsetInfo = this.getOffsetForIndex(index, initialAlign);
+			if (!offsetInfo) return;
+			const [offset, align] = offsetInfo;
+			const now = this.now();
+			this.scrollState = {
+				index,
+				align,
+				behavior,
+				startedAt: now,
+				lastTargetOffset: offset,
+				stableFrames: 0
+			};
+			this._scrollToOffset(offset, {
+				adjustments: void 0,
+				behavior
+			});
+			this.scheduleScrollReconcile();
+		};
+		this.scrollBy = (delta, { behavior = "auto" } = {}) => {
+			const offset = this.getScrollOffset() + delta;
+			const now = this.now();
+			this.scrollState = {
+				index: null,
+				align: "start",
+				behavior,
+				startedAt: now,
+				lastTargetOffset: offset,
+				stableFrames: 0
+			};
+			this._scrollToOffset(offset, {
+				adjustments: void 0,
+				behavior
+			});
+			this.scheduleScrollReconcile();
+		};
+		this.scrollToEnd = ({ behavior = "auto" } = {}) => {
+			if (this.options.count > 0) {
+				this.scrollToIndex(this.options.count - 1, {
+					align: "end",
+					behavior
+				});
+				return;
+			}
+			this.scrollToOffset(Math.max(this.getTotalSize() - this.getSize(), 0), { behavior });
+		};
+		this.getTotalSize = () => {
+			var _a;
+			const measurements = this.getMeasurements();
+			let end;
+			if (measurements.length === 0) end = this.options.paddingStart;
+			else if (this.options.lanes === 1) {
+				const lastIdx = measurements.length - 1;
+				const flat = this._flatMeasurements;
+				if (flat != null) end = flat[lastIdx * 2] + flat[lastIdx * 2 + 1];
+				else end = ((_a = measurements[lastIdx]) == null ? void 0 : _a.end) ?? 0;
+			} else {
+				const endByLane = Array(this.options.lanes).fill(null);
+				let endIndex = measurements.length - 1;
+				while (endIndex >= 0 && endByLane.some((val) => val === null)) {
+					const item = measurements[endIndex];
+					if (endByLane[item.lane] === null) endByLane[item.lane] = item.end;
+					endIndex--;
+				}
+				end = Math.max(...endByLane.filter((val) => val !== null));
+			}
+			return Math.max(end - this.options.scrollMargin + this.options.paddingEnd, 0);
+		};
+		this.takeSnapshot = () => {
+			const snapshot = [];
+			if (this.itemSizeCache.size === 0) return snapshot;
+			const m = this.getMeasurements();
+			for (const item of m) if (item && this.itemSizeCache.has(item.key)) snapshot.push({
+				index: item.index,
+				key: item.key,
+				start: item.start,
+				size: item.size,
+				end: item.end,
+				lane: item.lane
+			});
+			return snapshot;
+		};
+		this._scrollToOffset = (offset, { adjustments, behavior }) => {
+			this._intendedScrollOffset = offset + (adjustments ?? 0);
+			this.options.scrollToFn(offset, {
+				behavior,
+				adjustments
+			}, this);
+		};
+		this.measure = () => {
+			this.pendingMin = null;
+			this.itemSizeCache.clear();
+			this.laneAssignments.clear();
+			this.itemSizeCacheVersion++;
+			this.notify(false);
+		};
+		this.setOptions(opts);
+	}
+	applyScrollAdjustment(delta, behavior) {
+		if (delta === 0) return false;
+		if (process.env.NODE_ENV !== "production" && this.options.debug) console.info("correction", delta);
+		if (isIOSWebKit() && (this.isScrolling || this._iosTouching || this._iosJustTouchEnded)) {
+			this._iosDeferredAdjustment += delta;
+			return false;
+		} else {
+			this._scrollToOffset(this.getScrollOffset(), {
+				adjustments: this.scrollAdjustments += delta,
+				behavior
+			});
+			if (this.scrollOffset !== null) {
+				this.scrollOffset += this.scrollAdjustments;
+				if (this.scrollOffset < 0) this.scrollOffset = 0;
+				this.scrollAdjustments = 0;
+			}
+			return true;
+		}
+	}
+	scheduleScrollReconcile() {
+		if (!this.targetWindow) {
+			this.scrollState = null;
+			return;
+		}
+		if (this.rafId != null) return;
+		this.rafId = this.targetWindow.requestAnimationFrame(() => {
+			this.rafId = null;
+			this.reconcileScroll();
+		});
+	}
+	reconcileScroll() {
+		if (!this.scrollState) return;
+		if (!this.scrollElement) return;
+		if (this.now() - this.scrollState.startedAt > 5e3) {
+			this.scrollState = null;
+			return;
+		}
+		const offsetInfo = this.scrollState.index != null ? this.getOffsetForIndex(this.scrollState.index, this.scrollState.align) : void 0;
+		const targetOffset = offsetInfo ? offsetInfo[0] : this.scrollState.lastTargetOffset;
+		const STABLE_FRAMES = 1;
+		const targetChanged = targetOffset !== this.scrollState.lastTargetOffset;
+		if (!targetChanged && approxEqual(targetOffset, this.getScrollOffset())) {
+			this.scrollState.stableFrames++;
+			if (this.scrollState.stableFrames >= STABLE_FRAMES) {
+				if (this.getScrollOffset() !== targetOffset) this._scrollToOffset(targetOffset, {
+					adjustments: void 0,
+					behavior: "auto"
+				});
+				this.scrollState = null;
+				return;
+			}
+		} else {
+			this.scrollState.stableFrames = 0;
+			if (targetChanged) {
+				const viewport = this.getSize() || 600;
+				const distance = Math.abs(targetOffset - this.getScrollOffset());
+				const keepSmooth = this.scrollState.behavior === "smooth" && distance > viewport;
+				this.scrollState.lastTargetOffset = targetOffset;
+				if (!keepSmooth) this.scrollState.behavior = "auto";
+				this._scrollToOffset(targetOffset, {
+					adjustments: void 0,
+					behavior: keepSmooth ? "smooth" : "auto"
+				});
+			}
+		}
+		this.scheduleScrollReconcile();
+	}
 };
-const filterIcons = (names, query, suffix) => {
-  return names.filter((key) => {
-    let match = true;
-    if (query && key.indexOf(query) === -1) {
-      match = false;
-    }
-    if (suffix && key.indexOf(`-${suffix}`) === -1) {
-      match = false;
-    }
-    return match;
-  });
+var findNearestBinarySearch = (low, high, getCurrentValue, value) => {
+	while (low <= high) {
+		const middle = (low + high) / 2 | 0;
+		const currentValue = getCurrentValue(middle);
+		if (currentValue < value) low = middle + 1;
+		else if (currentValue > value) high = middle - 1;
+		else return middle;
+	}
+	if (low > 0) return low - 1;
+	else return 0;
 };
-const _sfc_main$1 = /* @__PURE__ */ defineComponent({
-  __name: "IconifyCollection",
-  props: {
-    prefix: {},
-    search: {},
-    perpage: { default: 200 },
-    iconSize: { default: 20 }
-  },
-  emits: ["select"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emits = __emit;
-    const dialogContext = injectDialogRootContext(null);
-    const shouldDisplay = ref("all");
-    const groupCollections = ref([]);
-    const collectionFilter = ref("");
-    const page = ref(1);
-    const searchQuery = ref("");
-    const searchResultIcons = ref([]);
-    const collectionData = ref();
-    const collectionQuery = ref("");
-    const collectionSuffix = ref("");
-    const reset = () => {
-      page.value = 1;
-      searchQuery.value = "";
-      searchResultIcons.value = [];
-      collectionData.value = void 0;
-      collectionQuery.value = "";
-      collectionSuffix.value = "";
-      shouldDisplay.value = "all";
-    };
-    const onSelectIcon = (icon) => {
-      emits("select", icon);
-      if (dialogContext) {
-        dialogContext.onOpenChange(false);
-      }
-    };
-    const onSearch = async () => {
-      if (searchQuery.value) {
-        shouldDisplay.value = "search";
-        searchResultIcons.value = await searchIcons(searchQuery.value);
-      } else {
-        shouldDisplay.value = "all";
-      }
-    };
-    const onSelectPrefix = async (prefix) => {
-      collectionData.value = void 0;
-      collectionQuery.value = "";
-      collectionSuffix.value = "";
-      shouldDisplay.value = "collection";
-      collectionData.value = await fetchCollectionIcons(prefix);
-    };
-    const collectionCount = computed(() => {
-      let count = 0;
-      groupCollections.value.forEach((item) => {
-        count += item.items.length;
-      });
-      return count;
-    });
-    const visibleCollections = computed(() => {
-      if (!collectionFilter.value) {
-        return groupCollections.value;
-      }
-      return groupCollections.value.map((collection) => {
-        const items = collection.items.filter((item) => {
-          const key = [item.category, item.name, item.prefix].join(" ");
-          return key.toLowerCase().indexOf(collectionFilter.value) !== -1;
-        });
-        return { ...collection, items };
-      }).filter((collection) => collection.items.length !== 0);
-    });
-    const collectionIcons = computed(() => {
-      let rv = [];
-      if (!collectionData.value) {
-        return rv;
-      }
-      if (collectionData.value.uncategorized) {
-        rv = filterIcons(collectionData.value.uncategorized, collectionQuery.value, collectionSuffix.value);
-      } else if (collectionData.value.categories) {
-        Object.keys(collectionData.value.categories).forEach((category) => {
-          const icons = collectionData.value.categories[category];
-          filterIcons(icons, collectionQuery.value, collectionSuffix.value).forEach((k) => {
-            rv.push(k);
-          });
-        });
-      }
-      if (collectionQuery.value && !rv.length && collectionData.value.hidden) {
-        rv = filterIcons(collectionData.value.hidden, collectionQuery.value, collectionSuffix.value);
-      }
-      return rv.map((name) => `${collectionData.value?.prefix}:${name}`);
-    });
-    const allIcons = computed(() => {
-      if (shouldDisplay.value === "search") {
-        return searchResultIcons.value;
-      } else if (shouldDisplay.value === "collection") {
-        return collectionIcons.value;
-      } else {
-        return [];
-      }
-    });
-    const visibleIcons = computed(() => {
-      const start = (page.value - 1) * props.perpage;
-      const end = page.value * props.perpage;
-      return allIcons.value.slice(start, end);
-    });
-    const iconSize = computed(() => {
-      const size = props.iconSize.toString();
-      if (/^\d+/.test(size)) {
-        return size + "px";
-      } else {
-        return size;
-      }
-    });
-    onMounted(async () => {
-      if (props.prefix) {
-        onSelectPrefix(props.prefix);
-      } else if (props.search) {
-        searchQuery.value = props.search;
-        onSearch();
-      }
-      groupCollections.value = await fetchCollections();
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", _hoisted_1, [
-        withDirectives(createElementVNode("div", _hoisted_2, [
-          createElementVNode("section", _hoisted_3, [
-            createElementVNode("h1", null, toDisplayString(collectionCount.value) + " icon sets", 1),
-            createElementVNode("div", _hoisted_4, [
-              createVNode(unref(TextField), {
-                modelValue: collectionFilter.value,
-                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => collectionFilter.value = $event),
-                placeholder: "Filter icon sets..."
-              }, null, 8, ["modelValue"]),
-              createVNode(unref(TextField), {
-                modelValue: searchQuery.value,
-                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => searchQuery.value = $event),
-                placeholder: "Search icons...",
-                onKeydown: withKeys(onSearch, ["enter"])
-              }, null, 8, ["modelValue"])
-            ])
-          ]),
-          (openBlock(true), createElementBlock(Fragment, null, renderList(visibleCollections.value, (collection) => {
-            return openBlock(), createElementBlock("section", {
-              key: collection.category,
-              class: "ui-IconifyCollectionSample"
-            }, [
-              createElementVNode("h1", _hoisted_5, [
-                createElementVNode("span", _hoisted_6, toDisplayString(collection.category), 1),
-                createElementVNode("span", _hoisted_7, "(" + toDisplayString(collection.items.length) + " icon sets)", 1)
-              ]),
-              createElementVNode("div", _hoisted_8, [
-                (openBlock(true), createElementBlock(Fragment, null, renderList(collection.items, (item) => {
-                  return openBlock(), createBlock(_sfc_main$2, mergeProps({
-                    key: item.prefix
-                  }, { ref_for: true }, item, {
-                    onClick: withModifiers(($event) => onSelectPrefix(item.prefix), ["prevent"])
-                  }), null, 16, ["onClick"]);
-                }), 128))
-              ])
-            ]);
-          }), 128))
-        ], 512), [
-          [vShow, shouldDisplay.value === "all"]
-        ]),
-        shouldDisplay.value !== "all" ? (openBlock(), createElementBlock("div", _hoisted_9, [
-          createElementVNode("div", _hoisted_10, [
-            createVNode(unref(Button), {
-              type: "button",
-              variant: "surface",
-              color: "gray",
-              onClick: withModifiers(reset, ["prevent"])
-            }, {
-              default: withCtx(() => [..._cache[5] || (_cache[5] = [
-                createTextVNode(" Back ", -1)
-              ])]),
-              _: 1
-            }),
-            shouldDisplay.value === "search" ? (openBlock(), createBlock(unref(TextField), {
-              key: 0,
-              modelValue: searchQuery.value,
-              "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => searchQuery.value = $event),
-              placeholder: "Search icons...",
-              onKeydown: withKeys(onSearch, ["enter"])
-            }, null, 8, ["modelValue"])) : createCommentVNode("", true),
-            shouldDisplay.value === "collection" ? (openBlock(), createBlock(unref(TextField), {
-              key: 1,
-              modelValue: collectionQuery.value,
-              "onUpdate:modelValue": _cache[3] || (_cache[3] = ($event) => collectionQuery.value = $event),
-              placeholder: "Search icons..."
-            }, null, 8, ["modelValue"])) : createCommentVNode("", true)
-          ]),
-          shouldDisplay.value === "collection" && collectionData.value?.suffixes ? (openBlock(), createElementBlock("div", _hoisted_11, [
-            (openBlock(true), createElementBlock(Fragment, null, renderList(collectionData.value.suffixes, (k, v) => {
-              return openBlock(), createBlock(unref(Button), {
-                key: v,
-                variant: collectionSuffix.value === v ? "solid" : "outline",
-                color: "gray",
-                "high-contrast": "",
-                radius: "full",
-                onClick: withModifiers(($event) => collectionSuffix.value = v, ["prevent"])
-              }, {
-                default: withCtx(() => [
-                  createTextVNode(toDisplayString(k), 1)
-                ]),
-                _: 2
-              }, 1032, ["variant", "onClick"]);
-            }), 128))
-          ])) : createCommentVNode("", true),
-          createElementVNode("div", {
-            class: "ui-IconifyCollectionIconGrid",
-            style: normalizeStyle({ fontSize: iconSize.value })
-          }, [
-            (openBlock(true), createElementBlock(Fragment, null, renderList(visibleIcons.value, (icon) => {
-              return openBlock(), createBlock(unref(Tooltip), {
-                key: icon,
-                as: "div",
-                content: icon
-              }, {
-                default: withCtx(() => [
-                  createElementVNode("button", {
-                    type: "button",
-                    onClick: withModifiers(($event) => onSelectIcon(icon), ["prevent"])
-                  }, [
-                    createVNode(unref(Icon), { icon }, null, 8, ["icon"])
-                  ], 8, _hoisted_12)
-                ]),
-                _: 2
-              }, 1032, ["content"]);
-            }), 128))
-          ], 4),
-          createVNode(unref(Pagination), {
-            page: page.value,
-            "onUpdate:page": _cache[4] || (_cache[4] = ($event) => page.value = $event),
-            total: allIcons.value.length,
-            "items-per-page": __props.perpage
-          }, null, 8, ["page", "total", "items-per-page"])
-        ])) : createCommentVNode("", true)
-      ]);
-    };
-  }
+function findNearestBinarySearchFlat(flat, high, value) {
+	let low = 0;
+	while (low <= high) {
+		const middle = (low + high) / 2 | 0;
+		const currentValue = flat[middle * 2];
+		if (currentValue < value) low = middle + 1;
+		else if (currentValue > value) high = middle - 1;
+		else return middle;
+	}
+	return low > 0 ? low - 1 : 0;
+}
+function calculateRangeImpl(measurements, outerSize, scrollOffset, lanes, flat) {
+	const lastIndex = measurements.length - 1;
+	if (measurements.length <= lanes) return {
+		startIndex: 0,
+		endIndex: lastIndex
+	};
+	if (lanes === 1 && flat !== null) {
+		const startIndex2 = findNearestBinarySearchFlat(flat, lastIndex, scrollOffset);
+		let endIndex2 = startIndex2;
+		const limit = scrollOffset + outerSize;
+		while (endIndex2 < lastIndex && flat[endIndex2 * 2] + flat[endIndex2 * 2 + 1] < limit) endIndex2++;
+		return {
+			startIndex: startIndex2,
+			endIndex: endIndex2
+		};
+	}
+	const getStart = (index) => measurements[index].start;
+	let startIndex = findNearestBinarySearch(0, lastIndex, getStart, scrollOffset);
+	let endIndex = startIndex;
+	if (lanes === 1) while (endIndex < lastIndex && measurements[endIndex].end < scrollOffset + outerSize) endIndex++;
+	else if (lanes > 1) {
+		const endPerLane = Array(lanes).fill(0);
+		while (endIndex < lastIndex && endPerLane.some((pos) => pos < scrollOffset + outerSize)) {
+			const item = measurements[endIndex];
+			endPerLane[item.lane] = item.end;
+			endIndex++;
+		}
+		const startPerLane = Array(lanes).fill(scrollOffset + outerSize);
+		while (startIndex >= 0 && startPerLane.some((pos) => pos >= scrollOffset)) {
+			const item = measurements[startIndex];
+			startPerLane[item.lane] = item.start;
+			startIndex--;
+		}
+		startIndex = Math.max(0, startIndex - startIndex % lanes);
+		endIndex = Math.min(lastIndex, endIndex + (lanes - 1 - endIndex % lanes));
+	}
+	return {
+		startIndex,
+		endIndex
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+vue-virtual@3.13.36_vue@3.5.42_typescript@5.9.3_/node_modules/@tanstack/vue-virtual/dist/esm/index.js
+function useVirtualizerBase(options) {
+	const virtualizer = new Virtualizer(unref(options));
+	const state = shallowRef(virtualizer);
+	const cleanup = virtualizer._didMount();
+	watch(() => unref(options).getScrollElement(), (el) => {
+		if (el) virtualizer._willUpdate();
+	}, { immediate: true });
+	watch(() => unref(options), (options2) => {
+		virtualizer.setOptions({
+			...options2,
+			onChange: (instance, sync) => {
+				var _a;
+				triggerRef(state);
+				(_a = options2.onChange) == null || _a.call(options2, instance, sync);
+			}
+		});
+		virtualizer._willUpdate();
+		triggerRef(state);
+	}, { immediate: true });
+	onScopeDispose(cleanup);
+	return state;
+}
+function useVirtualizer(options) {
+	return useVirtualizerBase(computed(() => ({
+		observeElementRect,
+		observeElementOffset,
+		scrollToFn: elementScroll,
+		...unref(options)
+	})));
+}
+//#endregion
+//#region src/addons/iconset/api.ts
+var apiRoot = "https://api.iconify.design";
+var collectionsCache = /* @__PURE__ */ new Map();
+var collectionDataCache = /* @__PURE__ */ new Map();
+async function getJson(url, signal) {
+	const response = await fetch(url, { signal });
+	if (!response.ok) throw new Error(`Iconify request failed (${response.status})`);
+	return response.json();
+}
+/** Fetches the Iconify catalog, grouped by its category. */
+function fetchCollections() {
+	const cached = collectionsCache.get("all");
+	if (cached) return cached;
+	const request = getJson(`${apiRoot}/collections`).then((data) => {
+		const groups = /* @__PURE__ */ new Map();
+		for (const [prefix, item] of Object.entries(data)) {
+			if (item.hidden) continue;
+			const category = item.category || "Other";
+			const group = groups.get(category) || [];
+			group.push({
+				...item,
+				prefix,
+				category
+			});
+			groups.set(category, group);
+		}
+		const orderedGroups = [...groups.entries()].map(([category, items]) => ({
+			category,
+			items
+		}));
+		return [...orderedGroups.filter((group) => !/archiv|unmaintained/i.test(group.category)), ...orderedGroups.filter((group) => /archiv|unmaintained/i.test(group.category))];
+	});
+	collectionsCache.set("all", request);
+	request.catch(() => collectionsCache.delete("all"));
+	return request;
+}
+/** Fetches one icon set's names and metadata. Requests are cached by prefix. */
+function fetchCollection(prefix) {
+	const cached = collectionDataCache.get(prefix);
+	if (cached) return cached;
+	const request = getJson(`${apiRoot}/collection?prefix=${encodeURIComponent(prefix)}&chars=true&aliases=true`);
+	collectionDataCache.set(prefix, request);
+	request.catch(() => collectionDataCache.delete(prefix));
+	return request;
+}
+/** Searches the global Iconify index. The signal lets callers cancel stale requests. */
+function searchIcons(query, signal) {
+	return getJson(`${apiRoot}/search?query=${encodeURIComponent(query)}&limit=999`, signal).then((data) => ({ icons: data.icons || [] }));
+}
+/** Returns icon names from a collection in stable API order. */
+function getCollectionIconNames(data, query = "") {
+	const names = [];
+	if (data.uncategorized) names.push(...data.uncategorized);
+	if (data.categories) for (const category of Object.keys(data.categories)) names.push(...data.categories[category]);
+	const normalizedQuery = query.toLowerCase();
+	const filtered = names.filter((name) => !normalizedQuery || name.toLowerCase().includes(normalizedQuery));
+	if (filtered.length === 0 && normalizedQuery && data.hidden) filtered.push(...data.hidden.filter((name) => name.toLowerCase().includes(normalizedQuery)));
+	return [...new Set(filtered)];
+}
+//#endregion
+//#region src/addons/iconset/IconGrid.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$1 = ["aria-pressed"];
+var _hoisted_2 = ["aria-pressed", "onClick"];
+var _hoisted_3 = [
+	"aria-label",
+	"aria-pressed",
+	"title",
+	"onClick"
+];
+//#endregion
+//#region src/addons/iconset/IconGrid.vue
+var IconGrid_default = /* @__PURE__ */ defineComponent({
+	__name: "IconGrid",
+	props: {
+		collections: { default: () => [] },
+		modelValue: {},
+		query: { default: "" },
+		activeCollection: { default: "" },
+		iconSize: { default: 20 },
+		cellSize: { default: 40 },
+		height: { default: 420 },
+		ui: {},
+		overscan: { default: 4 }
+	},
+	emits: [
+		"update:modelValue",
+		"update:query",
+		"update:activeCollection",
+		"select"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const viewport = ref();
+		const viewportWidth = ref(0);
+		const icons = ref([]);
+		const labels = ref({});
+		const selectedIcon = ref(props.modelValue || "");
+		const query = ref(props.query);
+		const activeCollection = ref(props.activeCollection);
+		const loading = ref(false);
+		const error = ref();
+		const requestId = ref(0);
+		let searchController;
+		const toCssSize = (size) => {
+			const value = String(size);
+			return /^\d+(\.\d+)?$/.test(value) ? `${value}px` : value;
+		};
+		const iconSize = computed(() => toCssSize(props.iconSize));
+		const viewportHeight = computed(() => toCssSize(props.height));
+		const columns = computed(() => Math.max(1, Math.floor(viewportWidth.value / props.cellSize) || 1));
+		const rowCount = computed(() => Math.ceil(icons.value.length / columns.value));
+		const activePrefix = computed(() => {
+			if (props.collections.length <= 1) return props.collections[0] || "";
+			return props.collections.includes(activeCollection.value) ? activeCollection.value : "";
+		});
+		const hasCollectionTabs = computed(() => props.collections.length > 1);
+		const virtualizer = useVirtualizer({
+			get count() {
+				return rowCount.value;
+			},
+			getScrollElement() {
+				return viewport.value || null;
+			},
+			estimateSize() {
+				return props.cellSize;
+			},
+			getItemKey(index) {
+				return `${activePrefix.value}:${query.value}:${index}`;
+			},
+			get overscan() {
+				return props.overscan;
+			}
+		});
+		const virtualRows = computed(() => virtualizer.value.getVirtualItems());
+		const selectCollection = (prefix) => {
+			activeCollection.value = prefix;
+			emits("update:activeCollection", prefix);
+		};
+		const selectIcon = (icon) => {
+			selectedIcon.value = icon;
+			emits("update:modelValue", icon);
+			emits("select", icon);
+		};
+		const updateQuery = (value) => {
+			query.value = value;
+			emits("update:query", value);
+		};
+		const resetScroll = async () => {
+			await nextTick();
+			virtualizer.value.scrollToOffset(0);
+			virtualizer.value.measure();
+		};
+		const loadIcons = async () => {
+			const id = ++requestId.value;
+			searchController?.abort();
+			searchController = void 0;
+			error.value = void 0;
+			icons.value = [];
+			const normalizedQuery = query.value.trim();
+			if (props.collections.length === 0 && !normalizedQuery) {
+				loading.value = false;
+				await resetScroll();
+				return;
+			}
+			loading.value = true;
+			try {
+				if (props.collections.length === 0) {
+					searchController = new AbortController();
+					const result = await searchIcons(normalizedQuery, searchController.signal);
+					if (id !== requestId.value) return;
+					icons.value = result.icons;
+				} else {
+					const prefixes = activePrefix.value ? [activePrefix.value] : props.collections;
+					const data = await Promise.all(prefixes.map((prefix) => fetchCollection(prefix)));
+					if (id !== requestId.value) return;
+					const nextIcons = [];
+					data.forEach((collection, index) => {
+						const prefix = prefixes[index];
+						getCollectionIconNames(collection, normalizedQuery).forEach((name) => nextIcons.push(`${prefix}:${name}`));
+					});
+					icons.value = [...new Set(nextIcons)];
+				}
+			} catch (cause) {
+				if (id !== requestId.value || cause instanceof DOMException && cause.name === "AbortError") return;
+				error.value = cause instanceof Error ? cause : /* @__PURE__ */ new Error("Unable to load icons");
+			} finally {
+				if (id === requestId.value) {
+					loading.value = false;
+					resetScroll();
+				}
+			}
+		};
+		const loadLabels = async () => {
+			if (props.collections.length === 0) {
+				labels.value = {};
+				return;
+			}
+			try {
+				const groups = await fetchCollections();
+				const next = {};
+				groups.forEach((group) => group.items.forEach((item) => {
+					next[item.prefix] = item.name;
+				}));
+				labels.value = next;
+			} catch {
+				labels.value = {};
+			}
+		};
+		const resizeObserver = typeof ResizeObserver !== "undefined" ? new ResizeObserver((entries) => {
+			viewportWidth.value = entries[0]?.contentRect.width || 0;
+		}) : void 0;
+		watch(viewport, (element, previous) => {
+			if (previous) resizeObserver?.unobserve(previous);
+			if (element) {
+				resizeObserver?.observe(element);
+				const style = getComputedStyle(element);
+				viewportWidth.value = element.clientWidth - Number.parseFloat(style.paddingLeft) - Number.parseFloat(style.paddingRight);
+			}
+		});
+		watch(() => props.modelValue, (value) => {
+			selectedIcon.value = value || "";
+		});
+		watch(() => props.query, (value) => {
+			query.value = value;
+		});
+		watch(() => props.activeCollection, (value) => {
+			activeCollection.value = value;
+		});
+		watch(() => [
+			props.collections,
+			query.value,
+			activeCollection.value
+		], loadIcons, {
+			deep: true,
+			immediate: true
+		});
+		watch(() => props.collections, loadLabels, {
+			deep: true,
+			immediate: true
+		});
+		watch(() => props.cellSize, () => virtualizer.value.measure());
+		onBeforeUnmount(() => {
+			searchController?.abort();
+			resizeObserver?.disconnect();
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(["ui-IconGrid", props.ui?.base]) }, [
+				createElementVNode("div", { class: normalizeClass(["ui-IconGridHeader", props.ui?.header]) }, [renderSlot(_ctx.$slots, "header-leading"), renderSlot(_ctx.$slots, "header-search", {}, () => [createVNode(unref(TextField), {
+					"model-value": query.value,
+					type: "search",
+					placeholder: "Search icons...",
+					"aria-label": "Search icons",
+					class: normalizeClass(["ui-IconGridSearch", props.ui?.search]),
+					"onUpdate:modelValue": updateQuery
+				}, null, 8, ["model-value", "class"])])], 2),
+				hasCollectionTabs.value ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(["ui-IconGridTabs", props.ui?.tabs]),
+					role: "group",
+					"aria-label": "Icon collections"
+				}, [createElementVNode("button", {
+					type: "button",
+					class: normalizeClass([props.ui?.tab, { "is-active": !activePrefix.value }]),
+					"aria-pressed": !activePrefix.value,
+					onClick: _cache[0] || (_cache[0] = ($event) => selectCollection(""))
+				}, " All ", 10, _hoisted_1$1), (openBlock(true), createElementBlock(Fragment, null, renderList(props.collections, (prefix) => {
+					return openBlock(), createElementBlock("button", {
+						key: prefix,
+						type: "button",
+						class: normalizeClass([props.ui?.tab, { "is-active": activePrefix.value === prefix }]),
+						"aria-pressed": activePrefix.value === prefix,
+						onClick: ($event) => selectCollection(prefix)
+					}, toDisplayString(labels.value[prefix] || prefix), 11, _hoisted_2);
+				}), 128))], 2)) : createCommentVNode("", true),
+				createElementVNode("div", {
+					ref_key: "viewport",
+					ref: viewport,
+					class: normalizeClass(["ui-IconGridViewport", props.ui?.viewport]),
+					style: normalizeStyle({ height: viewportHeight.value }),
+					tabindex: "0"
+				}, [loading.value ? (openBlock(), createElementBlock("p", {
+					key: 0,
+					class: normalizeClass(["ui-IconGridMessage", props.ui?.message]),
+					role: "status"
+				}, " Loading icons... ", 2)) : error.value ? (openBlock(), createElementBlock("p", {
+					key: 1,
+					class: normalizeClass(["ui-IconGridMessage", props.ui?.message]),
+					role: "alert"
+				}, toDisplayString(error.value.message), 3)) : icons.value.length === 0 ? (openBlock(), createElementBlock("p", {
+					key: 2,
+					class: normalizeClass(["ui-IconGridMessage", props.ui?.message])
+				}, " No icons found. ", 2)) : (openBlock(), createElementBlock("div", {
+					key: 3,
+					class: normalizeClass(["ui-IconGridContent", props.ui?.content]),
+					style: normalizeStyle({ height: `${unref(virtualizer).getTotalSize()}px` })
+				}, [(openBlock(true), createElementBlock(Fragment, null, renderList(virtualRows.value, (row) => {
+					return openBlock(), createElementBlock("div", {
+						key: String(row.key),
+						class: "ui-IconGridRow",
+						style: normalizeStyle({
+							transform: `translateY(${row.start}px)`,
+							height: `${props.cellSize}px`
+						})
+					}, [(openBlock(true), createElementBlock(Fragment, null, renderList(icons.value.slice(row.index * columns.value, (row.index + 1) * columns.value), (icon) => {
+						return openBlock(), createElementBlock("button", {
+							key: icon,
+							type: "button",
+							class: normalizeClass(["ui-IconGridCell", props.ui?.cell]),
+							"aria-label": icon,
+							"aria-pressed": selectedIcon.value === icon,
+							title: icon,
+							style: normalizeStyle({ flexBasis: `${100 / columns.value}%` }),
+							onClick: ($event) => selectIcon(icon)
+						}, [createVNode(unref(Icon), {
+							icon,
+							style: normalizeStyle({ fontSize: iconSize.value }),
+							"aria-hidden": "true"
+						}, null, 8, ["icon", "style"])], 14, _hoisted_3);
+					}), 128))], 4);
+				}), 128))], 6))], 6)
+			], 2);
+		};
+	}
 });
-const turnstileSrc = "https://challenges.cloudflare.com/turnstile/v0/api.js";
-const turnstileLoadFunction = "cfTurnstileOnLoad";
-let turnstileState = typeof window !== "undefined" ? window.turnstile !== void 0 ? "ready" : "unloaded" : "unloaded";
-let turnstileLoad;
-let widgetId;
-let resetTimeout;
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "Turnstile",
-  props: {
-    sitekey: {},
-    modelValue: {},
-    resetInterval: { default: 295 * 1e3 },
-    size: { default: "normal" },
-    theme: { default: "auto" },
-    action: { default: "" },
-    appearance: { default: "always" },
-    renderOnMount: { type: Boolean, default: true }
-  },
-  emits: ["update:modelValue"],
-  setup(__props, { emit: __emit }) {
-    const props = __props;
-    const emit = __emit;
-    const element = useTemplateRef("element");
-    const resetTurnstile = () => {
-      if (window.turnstile) {
-        emit("update:modelValue", "");
-        window.turnstile.reset();
-      }
-    };
-    const removeTurnstile = () => {
-      if (widgetId) {
-        window.turnstile.remove(widgetId);
-        widgetId = void 0;
-      }
-    };
-    const callbackTurnstile = (token) => {
-      emit("update:modelValue", token);
-      resetTimeout = setTimeout(() => {
-        resetTurnstile();
-      }, props.resetInterval);
-    };
-    const renderTurnstile = () => {
-      widgetId = window.turnstile.render(element.value, {
-        sitekey: props.sitekey,
-        theme: props.theme,
-        size: props.size,
-        callback: callbackTurnstile,
-        action: props.action,
-        appearance: props.appearance
-      });
-    };
-    onMounted(async () => {
-      const turnstileLoadPromise = new Promise((resolve, reject) => {
-        turnstileLoad = { resolve, reject };
-        if (turnstileState === "ready") resolve(void 0);
-      });
-      window[turnstileLoadFunction] = () => {
-        turnstileLoad.resolve();
-        turnstileState = "ready";
-      };
-      const ensureTurnstile = () => {
-        if (turnstileState === "unloaded") {
-          turnstileState = "loading";
-          const url = `${turnstileSrc}?onload=${turnstileLoadFunction}&render=explicit`;
-          const script = document.createElement("script");
-          script.src = url;
-          script.async = true;
-          script.addEventListener("error", () => {
-            turnstileLoad.reject("Failed to load Turnstile.");
-          });
-          document.head.appendChild(script);
-        }
-        return turnstileLoadPromise;
-      };
-      await ensureTurnstile();
-      if (props.renderOnMount) {
-        renderTurnstile();
-      }
-    });
-    onBeforeUnmount(() => {
-      removeTurnstile();
-      clearTimeout(resetTimeout);
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        ref_key: "element",
-        ref: element,
-        class: normalizeClass(["ui-Turnstile", `r-size-${__props.size}`])
-      }, null, 2);
-    };
-  }
+//#endregion
+//#region src/addons/iconset/IconCollection.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["onClick"];
+//#endregion
+//#region src/addons/iconset/IconCollection.vue
+var IconCollection_default = /* @__PURE__ */ defineComponent({
+	__name: "IconCollection",
+	props: {
+		modelValue: {},
+		collection: { default: "" },
+		query: { default: "" },
+		filter: { default: "" },
+		iconSize: { default: 20 },
+		cellSize: { default: 40 },
+		height: { default: 420 },
+		overscan: { default: 4 },
+		ui: {}
+	},
+	emits: [
+		"update:modelValue",
+		"update:collection",
+		"update:query",
+		"update:filter",
+		"select"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emits = __emit;
+		const groups = ref([]);
+		const selectedIcon = ref(props.modelValue || "");
+		const collection = ref(props.collection);
+		const query = ref(props.query);
+		const filter = ref(props.filter);
+		const loading = ref(true);
+		const error = ref();
+		const toCssSize = (size) => {
+			const value = String(size);
+			return /^\d+(\.\d+)?$/.test(value) ? `${value}px` : value;
+		};
+		const viewportHeight = computed(() => toCssSize(props.height));
+		const visibleGroups = computed(() => {
+			const normalizedFilter = filter.value.trim().toLowerCase();
+			if (!normalizedFilter) return groups.value;
+			return groups.value.map((group) => ({
+				...group,
+				items: group.items.filter((item) => [
+					group.category,
+					item.name,
+					item.prefix
+				].join(" ").toLowerCase().includes(normalizedFilter))
+			})).filter((group) => group.items.length > 0);
+		});
+		const collectionCount = computed(() => groups.value.reduce((count, group) => count + group.items.length, 0));
+		const updateFilter = (value) => {
+			filter.value = value;
+			emits("update:filter", value);
+		};
+		const selectCollection = (item) => {
+			collection.value = item.prefix;
+			query.value = "";
+			emits("update:collection", item.prefix);
+			emits("update:query", "");
+		};
+		const showCollections = () => {
+			collection.value = "";
+			query.value = "";
+			emits("update:collection", "");
+			emits("update:query", "");
+		};
+		const updateQuery = (value) => {
+			query.value = value;
+			emits("update:query", value);
+		};
+		const selectIcon = (icon) => {
+			selectedIcon.value = icon;
+			emits("update:modelValue", icon);
+			emits("select", icon);
+		};
+		watch(() => props.modelValue, (value) => {
+			selectedIcon.value = value || "";
+		});
+		watch(() => props.collection, (value) => {
+			collection.value = value;
+		});
+		watch(() => props.query, (value) => {
+			query.value = value;
+		});
+		watch(() => props.filter, (value) => {
+			filter.value = value;
+		});
+		onMounted(async () => {
+			try {
+				groups.value = await fetchCollections();
+			} catch (cause) {
+				error.value = cause instanceof Error ? cause : /* @__PURE__ */ new Error("Unable to load icon collections");
+			} finally {
+				loading.value = false;
+			}
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass(["ui-IconCollection", props.ui?.base]) }, [collection.value ? (openBlock(), createBlock(IconGrid_default, {
+				key: 0,
+				"model-value": selectedIcon.value,
+				query: query.value,
+				collections: [collection.value],
+				"icon-size": props.iconSize,
+				"cell-size": props.cellSize,
+				height: props.height,
+				overscan: props.overscan,
+				ui: props.ui?.grid,
+				"onUpdate:query": updateQuery,
+				onSelect: selectIcon
+			}, {
+				"header-leading": withCtx(() => [createVNode(unref(Button), {
+					type: "button",
+					variant: "ghost",
+					color: "gray",
+					class: normalizeClass(["ui-IconCollectionBack", props.ui?.back]),
+					"aria-label": "Back to icon sets",
+					onClick: showCollections
+				}, {
+					default: withCtx(() => [createVNode(unref(Icon), {
+						icon: "lucide:chevron-left",
+						"aria-hidden": "true"
+					}), _cache[0] || (_cache[0] = createTextVNode(" Back ", -1))]),
+					_: 1
+				}, 8, ["class"])]),
+				_: 1
+			}, 8, [
+				"model-value",
+				"query",
+				"collections",
+				"icon-size",
+				"cell-size",
+				"height",
+				"overscan",
+				"ui"
+			])) : (openBlock(), createElementBlock("div", {
+				key: 1,
+				class: normalizeClass(["ui-IconCollectionBrowser", props.ui?.browser]),
+				style: normalizeStyle({ height: viewportHeight.value }),
+				tabindex: "0"
+			}, [createElementVNode("div", { class: normalizeClass(["ui-IconCollectionToolbar", props.ui?.toolbar]) }, [createElementVNode("h2", { class: normalizeClass(["ui-IconCollectionTitle", props.ui?.title]) }, toDisplayString(collectionCount.value) + " icon sets", 3), createVNode(unref(TextField), {
+				"model-value": filter.value,
+				type: "search",
+				placeholder: "Filter icon sets...",
+				"aria-label": "Filter icon sets",
+				class: normalizeClass(["ui-IconCollectionFilter", props.ui?.filter]),
+				"onUpdate:modelValue": updateFilter
+			}, null, 8, ["model-value", "class"])], 2), loading.value ? (openBlock(), createElementBlock("p", {
+				key: 0,
+				class: normalizeClass(["ui-IconCollectionMessage", props.ui?.message]),
+				role: "status"
+			}, " Loading icon sets... ", 2)) : error.value ? (openBlock(), createElementBlock("p", {
+				key: 1,
+				class: normalizeClass(["ui-IconCollectionMessage", props.ui?.message]),
+				role: "alert"
+			}, toDisplayString(error.value.message), 3)) : visibleGroups.value.length === 0 ? (openBlock(), createElementBlock("p", {
+				key: 2,
+				class: normalizeClass(["ui-IconCollectionMessage", props.ui?.message])
+			}, " No icon sets found. ", 2)) : (openBlock(), createElementBlock("div", {
+				key: 3,
+				class: normalizeClass(["ui-IconCollectionGroups", props.ui?.groups])
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(visibleGroups.value, (group) => {
+				return openBlock(), createElementBlock("section", {
+					key: group.category,
+					class: normalizeClass(["ui-IconCollectionGroup", props.ui?.group])
+				}, [createElementVNode("h3", { class: normalizeClass(["ui-IconCollectionGroupTitle", props.ui?.groupTitle]) }, [createElementVNode("span", null, toDisplayString(group.category), 1), createElementVNode("span", null, "(" + toDisplayString(group.items.length) + " icon sets)", 1)], 2), createElementVNode("div", { class: normalizeClass(["ui-IconCollectionCards", props.ui?.cards]) }, [(openBlock(true), createElementBlock(Fragment, null, renderList(group.items, (item) => {
+					return openBlock(), createElementBlock("button", {
+						key: item.prefix,
+						type: "button",
+						class: normalizeClass(["ui-IconCollectionCard", props.ui?.card]),
+						onClick: ($event) => selectCollection(item)
+					}, [createElementVNode("span", { class: normalizeClass(["ui-IconCollectionInfo", props.ui?.info]) }, [
+						createElementVNode("strong", null, toDisplayString(item.name), 1),
+						createElementVNode("span", null, toDisplayString(item.license?.title || "Unknown license"), 1),
+						createElementVNode("span", null, toDisplayString(item.total) + " icons", 1)
+					], 2), createElementVNode("span", {
+						class: normalizeClass(["ui-IconCollectionSamples", props.ui?.samples]),
+						"aria-hidden": "true"
+					}, [(openBlock(true), createElementBlock(Fragment, null, renderList(item.samples?.slice(0, 6), (sample) => {
+						return openBlock(), createBlock(unref(Icon), {
+							key: sample,
+							icon: `${item.prefix}:${sample}`
+						}, null, 8, ["icon"]);
+					}), 128))], 2)], 10, _hoisted_1);
+				}), 128))], 2)], 2);
+			}), 128))], 2))], 6))], 2);
+		};
+	}
 });
-export {
-  _sfc_main$1 as IconifyCollection,
-  _sfc_main$3 as SocialButton,
-  _sfc_main as Turnstile
+//#endregion
+//#region src/addons/turnstile/Turnstile.vue?vue&type=script&setup=true&lang.ts
+var turnstileSrc = "https://challenges.cloudflare.com/turnstile/v0/api.js";
+var turnstileLoadFunction = "cfTurnstileOnLoad";
+var turnstileLoadPromise;
+var loadTurnstile = () => {
+	if (typeof window === "undefined") return Promise.reject(/* @__PURE__ */ new Error("Turnstile is only available in a browser."));
+	if (window.turnstile) return Promise.resolve();
+	if (turnstileLoadPromise) return turnstileLoadPromise;
+	turnstileLoadPromise = new Promise((resolve, reject) => {
+		const onLoad = () => {
+			if (window.turnstile) resolve();
+			else reject(/* @__PURE__ */ new Error("Turnstile loaded without exposing its API."));
+		};
+		window[turnstileLoadFunction] = onLoad;
+		const script = document.createElement("script");
+		script.src = `${turnstileSrc}?onload=${turnstileLoadFunction}&render=explicit`;
+		script.async = true;
+		script.addEventListener("error", () => {
+			reject(/* @__PURE__ */ new Error("Failed to load Turnstile."));
+		}, { once: true });
+		document.head.appendChild(script);
+	}).catch((error) => {
+		turnstileLoadPromise = void 0;
+		if (window.cfTurnstileOnLoad) delete window.cfTurnstileOnLoad;
+		throw error;
+	});
+	return turnstileLoadPromise;
 };
+//#endregion
+//#region src/addons/turnstile/Turnstile.vue
+var Turnstile_default = /* @__PURE__ */ defineComponent({
+	__name: "Turnstile",
+	props: {
+		sitekey: {},
+		modelValue: {},
+		resetInterval: { default: 295e3 },
+		size: { default: "normal" },
+		theme: { default: "auto" },
+		action: { default: "" },
+		appearance: { default: "always" },
+		renderOnMount: {
+			type: Boolean,
+			default: true
+		}
+	},
+	emits: ["update:modelValue"],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const element = useTemplateRef("element");
+		const mounted = ref(false);
+		let widgetId;
+		let resetTimeout;
+		const clearResetTimeout = () => {
+			if (resetTimeout !== void 0) {
+				clearTimeout(resetTimeout);
+				resetTimeout = void 0;
+			}
+		};
+		const resetTurnstile = () => {
+			if (widgetId !== void 0 && window.turnstile) {
+				clearResetTimeout();
+				emit("update:modelValue", "");
+				window.turnstile.reset(widgetId);
+			}
+		};
+		const removeTurnstile = () => {
+			clearResetTimeout();
+			if (widgetId !== void 0) {
+				if (window.turnstile) window.turnstile.remove(widgetId);
+				widgetId = void 0;
+			}
+		};
+		const callbackTurnstile = (token) => {
+			emit("update:modelValue", token);
+			clearResetTimeout();
+			resetTimeout = setTimeout(() => {
+				resetTurnstile();
+			}, props.resetInterval);
+		};
+		const renderTurnstile = async () => {
+			if (!mounted.value || widgetId !== void 0 || !element.value) return;
+			if (!window.turnstile) try {
+				await loadTurnstile();
+			} catch {
+				return;
+			}
+			if (!mounted.value || widgetId !== void 0 || !element.value || !window.turnstile) return;
+			widgetId = window.turnstile.render(element.value, {
+				sitekey: props.sitekey,
+				theme: props.theme,
+				size: props.size,
+				callback: callbackTurnstile,
+				action: props.action,
+				appearance: props.appearance
+			});
+		};
+		__expose({
+			render: renderTurnstile,
+			reset: resetTurnstile,
+			remove: removeTurnstile
+		});
+		onMounted(() => {
+			mounted.value = true;
+			if (props.renderOnMount) renderTurnstile();
+		});
+		onBeforeUnmount(() => {
+			mounted.value = false;
+			removeTurnstile();
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "element",
+				ref: element,
+				class: normalizeClass(["ui-Turnstile", `r-size-${__props.size}`])
+			}, null, 2);
+		};
+	}
+});
+//#endregion
+export { IconCollection_default as IconCollection, IconGrid_default as IconGrid, SocialButton_default as SocialButton, Turnstile_default as Turnstile };