ajo-ui 0.1.0

package/dist/toggle-group.js

@@ -0,0 +1,111 @@
+import { flag, strings } from "./utils.js";
+import { Toggle } from "./toggle.js";
+import { listen, roving, selection, statefulRootAttrs } from "ajo-cloves";
+import { context } from "ajo/context";
+import { Fragment, jsx } from "ajo/jsx-runtime";
+//#region packages/ajo-ui/src/toggle-group.tsx
+/** Composition context exposing ToggleGroup state and styling markers to descendant items. */
+var ToggleGroupContext = context(null);
+var selected = (type, value) => type === "multiple" ? strings(value) : value == null || value === "" ? [] : [String(value)];
+var isButton = (value) => value instanceof HTMLButtonElement && value.dataset.slot === "toggle-group-item";
+var focusableItems = (root) => Array.from(root.querySelectorAll("button[data-slot=\"toggle-group-item\"]")).filter((button) => !button.disabled);
+var ToggleGroupRoot = function* ({ defaultValue, type: initialType }) {
+	let disabled = false;
+	let loop = true;
+	let onValueChange;
+	let orientation = "horizontal";
+	let type = initialType;
+	const sel = selection(this, {
+		multiple: () => type === "multiple",
+		fallback: selected(initialType, defaultValue),
+		onChange: (next, event) => {
+			if (type === "multiple") onValueChange?.(next, event);
+			else onValueChange?.(next[0] ?? "", event);
+		}
+	});
+	const pressed = (value) => sel.has(value);
+	const change = (value, _nextPressed, event) => {
+		if (disabled) return;
+		sel.toggle(value, event);
+	};
+	const nav = roving(this, {
+		items: () => focusableItems(this),
+		orientation: () => orientation,
+		loop: () => loop,
+		onMove: (target) => target.focus()
+	});
+	listen(this, "keydown", (event) => {
+		if (!isButton(event.target)) return;
+		if (this.closest("[role=\"toolbar\"], [popover], dialog")?.matches("[role=\"toolbar\"]")) return;
+		nav.handle(event);
+	});
+	for (const args of this) {
+		type = args.type;
+		orientation = args.orientation;
+		disabled = Boolean(args.disabled);
+		loop = args.loop !== false;
+		onValueChange = args.onValueChange;
+		sel.sync(args.value != null ? selected(type, args.value) : void 0);
+		ToggleGroupContext({
+			disabled,
+			orientation,
+			pressed,
+			size: args.size,
+			spacing: args.spacing,
+			toggle: change,
+			type,
+			variant: args.variant
+		});
+		yield /* @__PURE__ */ jsx(Fragment, { children: args.children });
+	}
+};
+/** Unstyled toggle group with selection state and roving keyboard focus. */
+var ToggleGroup = ({ children, defaultValue, disabled, loop = true, onValueChange, orientation = "horizontal", role = "group", size, spacing = 2, type = "single", value, variant, ...attrs }) => {
+	const disabledFlag = Boolean(disabled);
+	return /* @__PURE__ */ jsx(ToggleGroupRoot, {
+		...statefulRootAttrs(attrs),
+		defaultValue,
+		disabled: disabledFlag,
+		loop,
+		onValueChange,
+		orientation,
+		size,
+		spacing,
+		type,
+		value,
+		variant,
+		"attr:aria-disabled": flag(disabledFlag),
+		"attr:aria-orientation": orientation,
+		"attr:data-disabled": flag(disabledFlag),
+		"attr:data-orientation": orientation,
+		"attr:data-size": size,
+		"attr:data-slot": "toggle-group",
+		"attr:data-spacing": spacing,
+		"attr:data-variant": variant,
+		"attr:role": role,
+		children
+	});
+};
+/** Unstyled toggle group item wired to the nearest group. */
+var ToggleGroupItem = ({ disabled, size, value, variant, ...attrs }) => {
+	const group = ToggleGroupContext();
+	const itemValue = String(value);
+	const itemSize = size ?? group?.size;
+	const itemVariant = variant ?? group?.variant;
+	const disabledFlag = Boolean(disabled ?? group?.disabled);
+	const pressed = group?.pressed(itemValue) ?? false;
+	return /* @__PURE__ */ jsx(Toggle, {
+		...attrs,
+		"data-orientation": group?.orientation ?? "horizontal",
+		"data-size": itemSize,
+		"data-slot": "toggle-group-item",
+		"data-spacing": group?.spacing ?? 2,
+		"data-variant": itemVariant,
+		disabled: disabledFlag,
+		pressed,
+		value: itemValue,
+		onPressedChange: (next, event) => group?.toggle(itemValue, next, event)
+	});
+};
+//#endregion
+export { ToggleGroup, ToggleGroupContext, ToggleGroupItem };

package/dist/toggle.js

@@ -0,0 +1,52 @@
+import { callHandler, controlled, dom, statefulRootAttrs } from "ajo-cloves";
+import { Fragment, jsx } from "ajo/jsx-runtime";
+//#region packages/ajo-ui/src/toggle.tsx
+var pressedAttribute = (pressed) => pressed ? "true" : "false";
+var stateAttribute = (pressed) => pressed ? "on" : "off";
+var ToggleRoot = function* ({ defaultPressed, pressed }) {
+	let disabled = false;
+	let onClick;
+	let onPressedChange;
+	const state = controlled(this, {
+		fallback: Boolean(pressed ?? defaultPressed),
+		onChange: (next, event) => onPressedChange?.(next, event)
+	});
+	for (const args of this) {
+		disabled = Boolean(args.disabled);
+		onClick = args.onClick;
+		onPressedChange = args.onPressedChange;
+		state.sync(args.pressed != null ? Boolean(args.pressed) : void 0);
+		if (dom(this)) {
+			this.dataset.state = stateAttribute(state.value);
+			this.setAttribute("aria-pressed", pressedAttribute(state.value));
+			this.onclick = (event) => {
+				callHandler(onClick, event);
+				if (event.defaultPrevented || disabled) return;
+				state.set(!state.value, event);
+			};
+		}
+		yield /* @__PURE__ */ jsx(Fragment, { children: args.children });
+	}
+};
+ToggleRoot.is = "button";
+/** Unstyled two-state button using aria-pressed. */
+var Toggle = ({ children, defaultPressed, disabled, onPressedChange, pressed, type = "button", "set:onclick": onClick, ...attrs }) => {
+	const state = stateAttribute(Boolean(pressed ?? defaultPressed));
+	const disabledFlag = Boolean(disabled);
+	return /* @__PURE__ */ jsx(ToggleRoot, {
+		...statefulRootAttrs(attrs),
+		defaultPressed,
+		disabled: disabledFlag,
+		onClick,
+		onPressedChange,
+		pressed,
+		"attr:aria-pressed": pressedAttribute(state === "on"),
+		"attr:data-state": state,
+		"attr:data-slot": attrs["data-slot"] ?? "toggle",
+		"attr:disabled": disabledFlag || void 0,
+		"attr:type": type,
+		children
+	});
+};
+//#endregion
+export { Toggle };

package/dist/toolbar.js

@@ -0,0 +1,127 @@
+import { DirectionContext } from "./direction.js";
+import { dom, listen, roving, statefulRootAttrs } from "ajo-cloves";
+import { context } from "ajo/context";
+import { Fragment, jsx } from "ajo/jsx-runtime";
+//#region packages/ajo-ui/src/toolbar.tsx
+var ToolbarContext = context(null);
+var CONTROL_SELECTOR = "button, [href], input, select, textarea, summary, [tabindex]";
+var controls = (root) => {
+	const layer = root.closest("[popover], dialog");
+	return Array.from(root.querySelectorAll(CONTROL_SELECTOR)).filter((control) => !control.disabled && (control.checkVisibility?.() ?? control.offsetParent !== null) && control.closest("[popover], dialog") === layer);
+};
+var NON_TEXT_INPUTS = new Set([
+	"button",
+	"checkbox",
+	"color",
+	"file",
+	"hidden",
+	"image",
+	"radio",
+	"range",
+	"reset",
+	"submit"
+]);
+var textEntry = (element) => element instanceof HTMLTextAreaElement || element.isContentEditable || element instanceof HTMLInputElement && !NON_TEXT_INPUTS.has(element.type);
+var caretEscapes = (target, event) => {
+	if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return false;
+	if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement)) return false;
+	const caret = target.selectionStart;
+	if (caret == null || caret !== target.selectionEnd) return false;
+	const rtl = getComputedStyle(target).direction === "rtl";
+	return event.key === "ArrowLeft" !== rtl ? caret === 0 : caret === target.value.length;
+};
+var ToolbarRoot = function* () {
+	let active = null;
+	let dir = "ltr";
+	let loop = true;
+	let orientation = "horizontal";
+	let queued = false;
+	const apply = () => {
+		if (!dom(this)) return;
+		const row = controls(this);
+		if (!active || !row.includes(active)) active = row[0] ?? null;
+		for (const control of row) {
+			const value = control === active ? "0" : "-1";
+			if (control.getAttribute("tabindex") !== value) control.setAttribute("tabindex", value);
+		}
+	};
+	const sync = () => {
+		if (queued) return;
+		queued = true;
+		queueMicrotask(() => {
+			queued = false;
+			apply();
+		});
+	};
+	const nav = roving(this, {
+		items: () => controls(this),
+		orientation: () => orientation,
+		dir: () => dir,
+		loop: () => loop,
+		onMove: (target) => target.focus()
+	});
+	listen(this, "focusin", (event) => {
+		const target = event.target;
+		if (!target || !controls(this).includes(target)) return;
+		active = target;
+		apply();
+	});
+	listen(this, "keydown", (event) => {
+		const target = event.target;
+		if (!target || event.defaultPrevented || event.isComposing || event.keyCode === 229) return;
+		if (!controls(this).includes(target)) return;
+		if (textEntry(target) && !caretEscapes(target, event)) return;
+		nav.handle(event);
+	});
+	if (dom(this)) {
+		const observer = new MutationObserver(sync);
+		observer.observe(this, {
+			attributeFilter: [
+				"disabled",
+				"hidden",
+				"tabindex"
+			],
+			attributes: true,
+			childList: true,
+			subtree: true
+		});
+		this.signal.addEventListener("abort", () => observer.disconnect());
+	}
+	for (const args of this) {
+		dir = args.dir;
+		loop = args.loop;
+		orientation = args.orientation;
+		ToolbarContext({ orientation });
+		sync();
+		yield /* @__PURE__ */ jsx(Fragment, { children: args.children });
+	}
+};
+/** Unstyled toolbar: arbitrary controls behind a single tab stop with dir-aware arrow-key roving (APG toolbar pattern). Button, ToggleGroup, Select, and Input compose inside; nested ToggleGroup items join the toolbar roving. */
+var Toolbar = ({ children, "data-slot": slot = "toolbar", dir, loop = true, orientation = "horizontal", role = "toolbar", ...attrs }) => {
+	const resolvedDir = dir ?? DirectionContext();
+	return /* @__PURE__ */ jsx(ToolbarRoot, {
+		...statefulRootAttrs(attrs),
+		dir: resolvedDir,
+		loop,
+		orientation,
+		"attr:aria-orientation": orientation,
+		"attr:data-orientation": orientation,
+		"attr:data-slot": slot,
+		"attr:dir": resolvedDir,
+		"attr:role": role,
+		children
+	});
+};
+/** Unstyled separator between toolbar groups, oriented across the toolbar axis. */
+var ToolbarSeparator = ({ role = "separator", ...attrs }) => {
+	const orientation = (ToolbarContext()?.orientation ?? "horizontal") === "horizontal" ? "vertical" : "horizontal";
+	return /* @__PURE__ */ jsx("div", {
+		...attrs,
+		"aria-orientation": orientation,
+		"data-orientation": orientation,
+		"data-slot": "toolbar-separator",
+		role
+	});
+};
+//#endregion
+export { Toolbar, ToolbarSeparator };

package/dist/tooltip.js

@@ -0,0 +1,196 @@
+import { popupStyle, triggerAttrs } from "./utils.js";
+import { n as popup, t as contentAttrs } from "./chunks/popup-C8Bb3l_g.js";
+import { t as PopupSurface } from "./chunks/popup-surface-BDCgtVU0.js";
+import { callHandler, statefulRootAttrs } from "ajo-cloves";
+import { context } from "ajo/context";
+import { Fragment, jsx, jsxs } from "ajo/jsx-runtime";
+//#region packages/ajo-ui/src/tooltip.tsx
+var ProviderContext = context(null);
+var TooltipContext = context(null);
+var TooltipProviderRoot = function* () {
+	let lastClosedAt = 0;
+	let skipDelayDuration = 300;
+	for (const args of this) {
+		skipDelayDuration = Math.max(0, Number(args.skipDelayDuration ?? 300));
+		ProviderContext({
+			delayDuration: Math.max(0, Number(args.delayDuration ?? 0)),
+			disableHoverableContent: Boolean(args.disableHoverableContent),
+			markClosed: () => lastClosedAt = Date.now(),
+			shouldSkipDelay: () => skipDelayDuration > 0 && Date.now() - lastClosedAt < skipDelayDuration
+		});
+		yield /* @__PURE__ */ jsx(Fragment, { children: args.children });
+	}
+};
+/** Unstyled shared defaults provider for descendant tooltips. */
+var TooltipProvider = ({ children, class: classes, "data-slot": slot = "tooltip-provider", delayDuration, disableHoverableContent, skipDelayDuration, style, ...attrs }) => /* @__PURE__ */ jsx(TooltipProviderRoot, {
+	...statefulRootAttrs(attrs),
+	delayDuration,
+	disableHoverableContent,
+	skipDelayDuration,
+	"attr:class": classes,
+	"attr:data-slot": slot,
+	"attr:style": style,
+	children
+});
+var TooltipRoot = function* ({ defaultOpen, open }) {
+	let delayDuration = 0;
+	let disabled = false;
+	let disableHoverableContent = false;
+	let onOpenChange;
+	let provider = null;
+	let tip;
+	tip = popup(this, {
+		prefix: "tooltip",
+		profile: "tooltip",
+		initialOpen: Boolean(open ?? defaultOpen),
+		disabled: () => disabled,
+		hover: {
+			openDelay: () => delayDuration <= 0 || provider?.shouldSkipDelay() ? 0 : delayDuration,
+			closeDelay: () => disableHoverableContent ? 0 : 80
+		},
+		onOpenChange: (next, event) => onOpenChange?.(next, event),
+		onSync: (next) => {
+			if (!next) provider?.markClosed();
+		},
+		referenceHidden: "hide",
+		dismiss: {
+			prevent: true,
+			onDismiss: (event, view) => {
+				view.cancelHover();
+				view.setOpen(false, event);
+			}
+		}
+	});
+	const registerContentHover = (hovering, event) => {
+		if (hovering) {
+			if (!disableHoverableContent) tip.hold("content", event);
+		} else tip.release("content", event);
+	};
+	const registerTriggerHover = (hovering, event) => {
+		if (hovering) tip.hold("trigger", event);
+		else tip.release("trigger", event);
+	};
+	const registerFocus = (next, event) => {
+		if (next) tip.hold("focus", event);
+		else tip.release("focus", event);
+	};
+	for (const args of this) {
+		provider = ProviderContext();
+		delayDuration = Math.max(0, Number(args.delayDuration ?? provider?.delayDuration ?? 0));
+		disabled = Boolean(args.disabled);
+		disableHoverableContent = Boolean(args.disableHoverableContent ?? provider?.disableHoverableContent);
+		onOpenChange = args.onOpenChange;
+		const opened = tip.sync(args.open == null ? null : Boolean(args.open), {
+			placement: args.placement,
+			gap: args.gap
+		});
+		TooltipContext({
+			...tip,
+			disabled,
+			open: opened,
+			registerContentHover,
+			registerFocus,
+			registerTriggerHover
+		});
+		yield /* @__PURE__ */ jsx(Fragment, { children: args.children });
+	}
+};
+/** Unstyled root provider for one tooltip. */
+var Tooltip = ({ children, class: classes, "data-slot": slot = "tooltip", defaultOpen, delayDuration, disabled, disableHoverableContent, gap, onOpenChange, open, placement, ...attrs }) => /* @__PURE__ */ jsx(TooltipRoot, {
+	...statefulRootAttrs(attrs),
+	defaultOpen,
+	delayDuration,
+	disabled,
+	disableHoverableContent,
+	gap,
+	onOpenChange,
+	open,
+	placement,
+	"attr:class": classes,
+	"attr:data-slot": slot,
+	children
+});
+/** Unstyled element that owns the tooltip description. */
+var TooltipTrigger = ({ as = "button", children, class: classes, "data-slot": slot = "tooltip-trigger", disabled, id, ref, type = "button", "aria-describedby": describedBy, "set:onblur": onBlur, "set:onfocus": onFocus, "set:onkeydown": onKeydown, "set:onmouseleave": onMouseLeave, "set:onmouseenter": onMouseEnter, ...attrs }) => {
+	const tooltip = TooltipContext();
+	const disabledFlag = Boolean(disabled ?? tooltip?.disabled);
+	const descriptions = [...new Set(`${describedBy ?? ""} ${tooltip?.contentId ?? ""}`.trim().split(/\s+/).filter(Boolean))].join(" ") || void 0;
+	const common = {
+		...attrs,
+		...triggerAttrs({
+			describedby: descriptions,
+			id,
+			open: Boolean(tooltip?.open),
+			ref,
+			setTrigger: tooltip?.setTrigger,
+			triggerId: tooltip?.triggerId
+		}),
+		class: classes,
+		"data-slot": slot,
+		"set:onblur": (event) => {
+			callHandler(onBlur, event);
+			tooltip?.registerFocus(false, event);
+		},
+		"set:onfocus": (event) => {
+			callHandler(onFocus, event);
+			if (event.defaultPrevented || disabledFlag) return;
+			tooltip?.registerFocus(true, event);
+		},
+		"set:onkeydown": (event) => {
+			callHandler(onKeydown, event);
+		},
+		"set:onmouseleave": (event) => {
+			callHandler(onMouseLeave, event);
+			tooltip?.registerTriggerHover(false, event);
+		},
+		"set:onmouseenter": (event) => {
+			callHandler(onMouseEnter, event);
+			if (event.defaultPrevented || disabledFlag) return;
+			tooltip?.registerTriggerHover(true, event);
+		}
+	};
+	if (as === "span") return /* @__PURE__ */ jsx("span", {
+		...common,
+		"aria-disabled": disabledFlag ? "true" : void 0,
+		children
+	});
+	return /* @__PURE__ */ jsx("button", {
+		...common,
+		disabled: disabledFlag,
+		type,
+		children
+	});
+};
+/** Unstyled non-interactive text bubble shown for a TooltipTrigger. */
+var TooltipContent = ({ children, class: classes, "data-slot": slot = "tooltip-content", ref, style, "set:onmouseleave": onMouseLeave, "set:onmouseenter": onMouseEnter, ...attrs }) => {
+	const tooltip = TooltipContext();
+	return /* @__PURE__ */ jsxs("div", {
+		...attrs,
+		...contentAttrs({
+			id: tooltip?.contentId,
+			open: Boolean(tooltip?.open),
+			ref,
+			setContent: tooltip?.setContent,
+			style: tooltip?.contentStyle(style) ?? popupStyle(style),
+			tabindex: void 0
+		}),
+		class: classes,
+		"data-arrow": "true",
+		"data-slot": slot,
+		role: "tooltip",
+		"set:onmouseleave": (event) => {
+			callHandler(onMouseLeave, event);
+			tooltip?.registerContentHover(false, event);
+		},
+		"set:onmouseenter": (event) => {
+			callHandler(onMouseEnter, event);
+			tooltip?.registerContentHover(true, event);
+		},
+		children: [/* @__PURE__ */ jsx(PopupSurface, {
+			arrow: true,
+			popup: tooltip
+		}), children]
+	});
+};
+//#endregion
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/utils.js

@@ -0,0 +1,104 @@
+import { callRef } from "ajo-cloves";
+import { jsx } from "ajo/jsx-runtime";
+//#region packages/ajo-ui/src/utils.ts
+/** Builds state, popup relations, ids and a composed trigger ref. */
+var triggerAttrs = (options) => {
+	const { controls, describedby, expanded, haspopup, id, open, ref, setTrigger, triggerId } = options;
+	const attrs = { "data-state": open ? "open" : "closed" };
+	if ("controls" in options) attrs["aria-controls"] = controls;
+	if ("describedby" in options) attrs["aria-describedby"] = describedby;
+	if ("expanded" in options) attrs["aria-expanded"] = expanded ? "true" : "false";
+	if ("haspopup" in options) attrs["aria-haspopup"] = haspopup;
+	if ("id" in options || "triggerId" in options) attrs.id = id ?? triggerId;
+	if ("ref" in options || "setTrigger" in options) attrs.ref = (element) => {
+		setTrigger?.(element);
+		callRef(ref, element);
+	};
+	return attrs;
+};
+/** Inline reset for a native popover plus caller-owned declarations. */
+var popupStyle = (...parts) => [
+	"inset:auto",
+	"margin:0",
+	...parts.filter((part) => typeof part === "string" && part.length > 0)
+].join(";");
+/** Wraps a re-exported family part with a fixed data-slot and optional defaults. */
+var withSlot = (Component, slot, defaults) => (attrs) => jsx(Component, {
+	...defaults,
+	...attrs,
+	"data-slot": slot
+});
+/** Marks a boolean state attr: 'true' when set, absent otherwise. */
+var flag = (value) => value ? "true" : void 0;
+/** Parses boolean-ish attr input (true, '', 'true'). */
+var bool = (value) => value === true || value === "" || value === "true";
+/** Maps a checked-state token to the native aria-checked vocabulary. */
+var ariaChecked = (state) => state === "indeterminate" ? "mixed" : state === "checked" ? "true" : "false";
+/** Mirrors a native input's live checked state onto it and one visual companion. */
+var syncCheckedState = (input, companion) => {
+	const state = input.type === "checkbox" && input.indeterminate ? "indeterminate" : input.checked ? "checked" : "unchecked";
+	input.dataset.state = state;
+	input.setAttribute("aria-checked", ariaChecked(state));
+	if (companion) companion.dataset.state = state;
+	return state;
+};
+/** Flattens JSX children into their concatenated plain-text content. */
+var text = (value) => {
+	if (value == null || value === false) return "";
+	if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") return String(value);
+	if (Array.isArray(value)) return value.map(text).join("");
+	return "";
+};
+/** Copies a multi-value array while coercing each present value to a string. */
+var strings = (value) => Array.isArray(value) ? value.map(String) : [];
+/** Token match: every whitespace-separated search token appears in the haystack, case-insensitive; an empty search matches. */
+var matchesTokens = (search, haystack) => {
+	const query = search.trim().toLowerCase();
+	if (!query) return true;
+	const target = haystack.trim().toLowerCase();
+	return query.split(/\s+/).every((part) => target.includes(part));
+};
+/** Formats the default English result count for filterable collections. */
+var defaultResultsLabel = (count) => `${count} result${count === 1 ? "" : "s"}`;
+var passAll = () => true;
+/** Resolves undefined to the built-in filter, null to unfiltered, and preserves a custom filter. */
+var resolveFilter = (filter, fallback) => filter === void 0 ? fallback : filter ?? passAll;
+/** Joins conditional class names, returning undefined when empty. */
+var clx = (...values) => values.filter(Boolean).join(" ") || void 0;
+/** Coerces to a finite number, falling back otherwise. */
+var toNumber = (value, fallback) => {
+	const next = Number(value);
+	return Number.isFinite(next) ? next : fallback;
+};
+/** Returns true when JSX children carry no visible content. */
+var emptyChildren = (children) => children == null || children === false || Array.isArray(children) && children.every((child) => child == null || child === false);
+var property = (key) => {
+	if (key === "cssFloat") return "float";
+	if (key.startsWith("--")) return key;
+	const css = key.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+	return css.startsWith("ms-") ? `-${css}` : css;
+};
+var collectStyles = (input, result) => {
+	if (!input || input === true || typeof input === "number") return;
+	if (typeof input === "string") {
+		const value = input.trim().replace(/;+$/, "");
+		if (value) result.push(value);
+		return;
+	}
+	if (Array.isArray(input)) {
+		for (const item of input) collectStyles(item, result);
+		return;
+	}
+	for (const [key, value] of Object.entries(input)) {
+		if (value == null || value === false) continue;
+		result.push(`${property(key)}:${value}`);
+	}
+};
+/** Build an inline style string from strings, objects, arrays, and falsey entries. */
+var stlx = (...input) => {
+	const result = [];
+	for (const item of input) collectStyles(item, result);
+	return result.join(";");
+};
+//#endregion
+export { ariaChecked, bool, clx, defaultResultsLabel, emptyChildren, flag, matchesTokens, popupStyle, resolveFilter, stlx, strings, syncCheckedState, text, toNumber, triggerAttrs, withSlot };

package/dist/virtual-list.js

@@ -0,0 +1,2 @@
+import { t as VirtualList } from "./chunks/virtual-list-B7hjGkjk.js";
+export { VirtualList, VirtualList as default };