@plastic-js/tsumiki 0.1.0

package/dist/index.js

@@ -0,0 +1,2715 @@
+import { Accordion, Avatar, Carousel, Checkbox, Clipboard, Collapsible, ColorPicker, Combobox, DateInput, DatePicker, Dialog, Drawer, Field, Fieldset, FileUpload, FocusTrap, HoverCard, Listbox, Menu, NumberInput, Pagination, Popover, Portal, Presence, Progress, RadioGroup, RatingGroup, Select, SignaturePad, Slider, Splitter, Steps, Switch, Tabs, TagsInput, Toast, Toggle, ToggleGroup, Tooltip, Tour, TreeView, createToaster, useComboboxContext } from "@plastic-js/ark";
+import { css, keyframes } from "@emotion/css";
+import { Loop, createComputed, createContext, createEffect, createSignal, splitProps, useContext } from "@plastic-js/plastic";
+import { collection } from "@zag-js/combobox";
+//#region src/components/Accordion.jsx
+var Accordion_default = Accordion;
+//#endregion
+//#region src/components/Avatar.jsx
+var Avatar_default = Avatar;
+//#endregion
+//#region node_modules/alien-signals/esm/system.mjs
+function createReactiveSystem({ update, notify, unwatched }) {
+	return {
+		link,
+		unlink,
+		propagate,
+		checkDirty,
+		shallowPropagate
+	};
+	function link(dep, sub, version) {
+		const prevDep = sub.depsTail;
+		if (prevDep !== void 0 && prevDep.dep === dep) return;
+		const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+		if (nextDep !== void 0 && nextDep.dep === dep) {
+			nextDep.version = version;
+			sub.depsTail = nextDep;
+			return;
+		}
+		const prevSub = dep.subsTail;
+		if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
+		const newLink = sub.depsTail = dep.subsTail = {
+			version,
+			dep,
+			sub,
+			prevDep,
+			nextDep,
+			prevSub,
+			nextSub: void 0
+		};
+		if (nextDep !== void 0) nextDep.prevDep = newLink;
+		if (prevDep !== void 0) prevDep.nextDep = newLink;
+		else sub.deps = newLink;
+		if (prevSub !== void 0) prevSub.nextSub = newLink;
+		else dep.subs = newLink;
+	}
+	function unlink(link, sub = link.sub) {
+		const { dep, prevDep, nextDep, nextSub, prevSub } = link;
+		if (nextDep !== void 0) nextDep.prevDep = prevDep;
+		else sub.depsTail = prevDep;
+		if (prevDep !== void 0) prevDep.nextDep = nextDep;
+		else sub.deps = nextDep;
+		if (nextSub !== void 0) nextSub.prevSub = prevSub;
+		else dep.subsTail = prevSub;
+		if (prevSub !== void 0) prevSub.nextSub = nextSub;
+		else if ((dep.subs = nextSub) === void 0) unwatched(dep);
+		return nextDep;
+	}
+	function propagate(link, innerWrite) {
+		let next = link.nextSub;
+		let stack;
+		top: do {
+			const sub = link.sub;
+			let flags = sub.flags;
+			if (!(flags & 60)) {
+				sub.flags = flags | 32;
+				if (innerWrite) sub.flags |= 8;
+			} else if (!(flags & 12)) flags = 0;
+			else if (!(flags & 4)) sub.flags = flags & -9 | 32;
+			else if (!(flags & 48) && isValidLink(link, sub)) {
+				sub.flags = flags | 40;
+				flags &= 1;
+			} else flags = 0;
+			if (flags & 2) notify(sub);
+			if (flags & 1) {
+				const subSubs = sub.subs;
+				if (subSubs !== void 0) {
+					const nextSub = (link = subSubs).nextSub;
+					if (nextSub !== void 0) {
+						stack = {
+							value: next,
+							prev: stack
+						};
+						next = nextSub;
+					}
+					continue;
+				}
+			}
+			if ((link = next) !== void 0) {
+				next = link.nextSub;
+				continue;
+			}
+			while (stack !== void 0) {
+				link = stack.value;
+				stack = stack.prev;
+				if (link !== void 0) {
+					next = link.nextSub;
+					continue top;
+				}
+			}
+			break;
+		} while (true);
+	}
+	function checkDirty(link, sub) {
+		let stack;
+		let checkDepth = 0;
+		let dirty = false;
+		top: do {
+			const dep = link.dep;
+			const flags = dep.flags;
+			if (sub.flags & 16) dirty = true;
+			else if ((flags & 17) === 17) {
+				const subs = dep.subs;
+				if (update(dep)) {
+					if (subs.nextSub !== void 0) shallowPropagate(subs);
+					dirty = true;
+				}
+			} else if ((flags & 33) === 33) {
+				stack = {
+					value: link,
+					prev: stack
+				};
+				link = dep.deps;
+				sub = dep;
+				++checkDepth;
+				continue;
+			}
+			if (!dirty) {
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue;
+				}
+			}
+			while (checkDepth--) {
+				link = stack.value;
+				stack = stack.prev;
+				if (dirty) {
+					const subs = sub.subs;
+					if (update(sub)) {
+						if (subs.nextSub !== void 0) shallowPropagate(subs);
+						sub = link.sub;
+						continue;
+					}
+					dirty = false;
+				} else sub.flags &= -33;
+				sub = link.sub;
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue top;
+				}
+			}
+			return dirty && !!sub.flags;
+		} while (true);
+	}
+	function shallowPropagate(link) {
+		do {
+			const sub = link.sub;
+			const flags = sub.flags;
+			if ((flags & 48) === 32) {
+				sub.flags = flags | 16;
+				if ((flags & 6) === 2) notify(sub);
+			}
+		} while ((link = link.nextSub) !== void 0);
+	}
+	function isValidLink(checkLink, sub) {
+		let link = sub.depsTail;
+		while (link !== void 0) {
+			if (link === checkLink) return true;
+			link = link.prevDep;
+		}
+		return false;
+	}
+}
+//#endregion
+//#region node_modules/alien-signals/esm/index.mjs
+var HasChildEffect = 64;
+var cycle = 0;
+var runDepth = 0;
+var batchDepth = 0;
+var notifyIndex = 0;
+var queuedLength = 0;
+var activeSub;
+var queued = [];
+var { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
+	update(node) {
+		if ("getter" in node) return updateComputed(node);
+		if ("currentValue" in node) return updateSignal(node);
+		node.flags = 1;
+		return true;
+	},
+	notify(effect) {
+		let insertIndex = queuedLength;
+		let firstInsertedIndex = insertIndex;
+		do {
+			queued[insertIndex++] = effect;
+			effect.flags &= -3;
+			effect = effect.subs?.sub;
+			if (effect === void 0 || !(effect.flags & 2)) break;
+		} while (true);
+		queuedLength = insertIndex;
+		while (firstInsertedIndex < --insertIndex) {
+			const left = queued[firstInsertedIndex];
+			queued[firstInsertedIndex++] = queued[insertIndex];
+			queued[insertIndex] = left;
+		}
+	},
+	unwatched(node) {
+		if ("getter" in node) {
+			if (node.depsTail !== void 0) {
+				node.flags = 17;
+				disposeAllDepsInReverse(node);
+			}
+		} else if ("currentValue" in node) {} else if ("fn" in node) effectOper.call(node);
+		else effectScopeOper.call(node);
+	}
+});
+function getActiveSub() {
+	return activeSub;
+}
+function setActiveSub(sub) {
+	const prevSub = activeSub;
+	activeSub = sub;
+	return prevSub;
+}
+function startBatch() {
+	++batchDepth;
+}
+function endBatch() {
+	if (!--batchDepth) flush();
+}
+function isSignal$1(fn) {
+	return fn.name === "bound " + signalOper.name;
+}
+function isComputed$1(fn) {
+	return fn.name === "bound " + computedOper.name;
+}
+function signal(initialValue) {
+	return signalOper.bind({
+		currentValue: initialValue,
+		pendingValue: initialValue,
+		subs: void 0,
+		subsTail: void 0,
+		flags: 1
+	});
+}
+function effect$1(fn) {
+	const e = {
+		fn,
+		cleanup: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: 6
+	};
+	const prevSub = setActiveSub(e);
+	if (prevSub !== void 0) {
+		link(e, prevSub, 0);
+		prevSub.flags |= HasChildEffect;
+	}
+	try {
+		++runDepth;
+		e.cleanup = e.fn();
+	} finally {
+		--runDepth;
+		activeSub = prevSub;
+		e.flags &= -5;
+	}
+	return effectOper.bind(e);
+}
+function updateComputed(c) {
+	if (c.flags & HasChildEffect) {
+		let link = c.depsTail;
+		while (link !== void 0) {
+			const prev = link.prevDep;
+			const dep = link.dep;
+			if (!("getter" in dep) && !("currentValue" in dep)) unlink(link, c);
+			link = prev;
+		}
+	}
+	c.depsTail = void 0;
+	c.flags = 5;
+	const prevSub = setActiveSub(c);
+	try {
+		++cycle;
+		const oldValue = c.value;
+		return oldValue !== (c.value = c.getter(oldValue));
+	} finally {
+		activeSub = prevSub;
+		c.flags &= -5;
+		purgeDeps(c);
+	}
+}
+function updateSignal(s) {
+	s.flags = 1;
+	return s.currentValue !== (s.currentValue = s.pendingValue);
+}
+function run(e) {
+	const flags = e.flags;
+	if (flags & 16 || flags & 32 && checkDirty(e.deps, e)) {
+		if (flags & HasChildEffect) {
+			let link = e.depsTail;
+			while (link !== void 0) {
+				const prev = link.prevDep;
+				const dep = link.dep;
+				if (!("getter" in dep) && !("currentValue" in dep)) unlink(link, e);
+				link = prev;
+			}
+		}
+		if (e.cleanup) {
+			runCleanup(e);
+			if (!e.flags) return;
+		}
+		e.depsTail = void 0;
+		e.flags = 6;
+		const prevSub = setActiveSub(e);
+		try {
+			++cycle;
+			++runDepth;
+			e.cleanup = e.fn();
+		} finally {
+			--runDepth;
+			activeSub = prevSub;
+			e.flags &= -5;
+			purgeDeps(e);
+		}
+	} else if (e.deps !== void 0) e.flags = 2 | flags & HasChildEffect;
+}
+function flush() {
+	try {
+		while (notifyIndex < queuedLength) {
+			const effect = queued[notifyIndex];
+			queued[notifyIndex++] = void 0;
+			run(effect);
+		}
+	} finally {
+		while (notifyIndex < queuedLength) {
+			const effect = queued[notifyIndex];
+			queued[notifyIndex++] = void 0;
+			effect.flags |= 10;
+		}
+		notifyIndex = 0;
+		queuedLength = 0;
+	}
+}
+function computedOper() {
+	const flags = this.flags;
+	if (flags & 16 || flags & 32 && (checkDirty(this.deps, this) || (this.flags = flags & -33, false))) {
+		if (updateComputed(this)) {
+			const subs = this.subs;
+			if (subs !== void 0) shallowPropagate(subs);
+		}
+	} else if (!flags) {
+		this.flags = 5;
+		const prevSub = setActiveSub(this);
+		try {
+			this.value = this.getter();
+		} finally {
+			activeSub = prevSub;
+			this.flags &= -5;
+		}
+	}
+	const sub = activeSub;
+	if (sub !== void 0) link(this, sub, cycle);
+	return this.value;
+}
+function signalOper(...value) {
+	if (value.length) {
+		if (this.pendingValue !== (this.pendingValue = value[0])) {
+			this.flags = 17;
+			const subs = this.subs;
+			if (subs !== void 0) {
+				propagate(subs, !!runDepth);
+				if (!batchDepth) flush();
+			}
+		}
+	} else {
+		if (this.flags & 16) {
+			if (updateSignal(this)) {
+				const subs = this.subs;
+				if (subs !== void 0) shallowPropagate(subs);
+			}
+		}
+		const sub = activeSub;
+		if (sub !== void 0) link(this, sub, cycle);
+		return this.currentValue;
+	}
+}
+function runCleanup(e) {
+	const cleanup = e.cleanup;
+	e.cleanup = void 0;
+	const prevSub = activeSub;
+	activeSub = void 0;
+	try {
+		cleanup();
+	} finally {
+		activeSub = prevSub;
+	}
+}
+function effectOper() {
+	effectScopeOper.call(this);
+	if (this.cleanup) runCleanup(this);
+}
+function effectScopeOper() {
+	this.flags = 0;
+	disposeAllDepsInReverse(this);
+	const sub = this.subs;
+	if (sub !== void 0) unlink(sub);
+}
+function disposeAllDepsInReverse(sub) {
+	let link = sub.depsTail;
+	while (link !== void 0) {
+		const prev = link.prevDep;
+		unlink(link, sub);
+		link = prev;
+	}
+}
+function purgeDeps(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink(dep, sub);
+}
+//#endregion
+//#region node_modules/@plastic-js/plastic/src/utils.js
+var isObject = (value) => {
+	return value !== null && typeof value === "object";
+};
+var isPlainObject = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+var flattenChildren = (children) => children.flat(Infinity);
+var isEventProp = (key) => /^on[A-Za-z]/.test(key);
+var normalizeTextNodeValue = (value) => {
+	if (value == null) return "";
+	return String(value);
+};
+var toClassTokens = (value) => {
+	if (typeof value !== "string") return /* @__PURE__ */ new Set();
+	return new Set(value.split(/\s+/).filter(Boolean));
+};
+var toClassMap = (value) => {
+	if (!value) return /* @__PURE__ */ new Map();
+	const tokens = toClassTokens(value);
+	const map = /* @__PURE__ */ new Map();
+	tokens.forEach((token) => {
+		map.set(token, true);
+	});
+	return map;
+};
+//#endregion
+//#region node_modules/@plastic-js/plastic/src/reactivity.js
+/**
+* reactivity.js — Reactive system for the Plastic framework.
+*
+* Built on top of the `alien-signals` library, which provides fine-grained
+* signal primitives (`signal`, `computed`, `effect`) suited for primitive values.
+* This module extends that foundation with deep object reactivity.
+*
+* ## Core concepts
+*
+* ### Signals (`createSignal`)
+* A thin public wrapper around `alien-signals`'s `signal()`. Calling
+* `createSignal(x)` on an already-signal value is a no-op — the original
+* signal is returned unchanged.
+*
+* ### Reactive trees (`tree` / `createTree`)
+* `tree(obj)` wraps a plain object (or array) in an ES Proxy that makes every
+* property access and mutation reactive. It is conceptually equivalent to
+* Vue 3's `reactive()`.
+*
+* Key implementation details:
+* - **Per-property signals**: Each accessed property is lazily backed by an
+*   `alien-signals` signal stored in a `signals` map (keyed by property name
+*   or symbol). Reads subscribe the current effect; writes trigger updates.
+* - **Proxy cache**: A `WeakMap` (proxyCache) ensures that wrapping the same
+*   raw object multiple times always returns the same proxy, preventing
+*   duplicate subscriptions.
+* - **`RAW` / `IS_TREE` sentinels**: Two well-known symbols allow consumers to
+*   unwrap to the original object (`toRaw`) and to test whether a value is
+*   already a reactive tree (`isTree`), avoiding double-wrapping.
+* - **Iterate tracking**: A dedicated `ITERATE_KEY` signal is used to track
+*   structural changes (property addition/deletion, array length changes).
+*   Operations like `for…in`, `Object.keys`, and spread trigger this signal so
+*   effects that iterate over an object re-run when its shape changes.
+* - **Non-trackable keys**: Built-in symbols (`Symbol.iterator`, etc.) and a
+*   small set of Vue-compatibility keys are excluded from tracking to avoid
+*   spurious subscriptions.
+* - **Array instrumentations**: Mutating array methods (`push`, `pop`, `shift`,
+*   `unshift`, `splice`) temporarily pause dependency tracking while executing
+*   to prevent the read of `length` inside those methods from creating
+*   unintended subscriptions. Search methods (`includes`, `indexOf`,
+*   `lastIndexOf`) explicitly track all indices and also fall back to comparing
+*   raw (unwrapped) values, supporting reactive proxies as search arguments.
+* - **Nested reactivity**: When `get` returns an object value it is recursively
+*   wrapped with `tree()`, providing deep reactivity on demand.
+* - **Raw value storage**: `set` always unwraps values through `toRaw` before
+*   writing to the underlying target, keeping raw objects free of proxy
+*   references and preventing double-wrapping in the signal store.
+*
+* ### Tracking pause/resume
+* `pauseTracking` / `resumeTracking` manipulate `alien-signals`'s active
+* subscriber stack via `getActiveSub` / `setActiveSub`, temporarily
+* suspending dependency collection for mutation-only code paths.
+*
+* ## Public API
+* Re-exports from `alien-signals`: `computed`, `effect`, `isSignal`, `isComputed`
+* Added by this module: `tree`, `createSignal`, `createTree`, `isTree`, `toRaw`
+*/
+var effect = (fn) => effect$1(() => {
+	const result = fn();
+	return typeof result === "function" ? result : void 0;
+});
+var IS_TREE = Symbol("isTree");
+new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter((symbol) => typeof symbol === "symbol"));
+var isSignal = (value) => {
+	if (typeof value === "function" && isSignal$1(value)) return true;
+	return false;
+};
+var isComputed = (value) => {
+	if (typeof value === "function" && isComputed$1(value)) return true;
+	return false;
+};
+var runUntracked = (fn) => {
+	if (getActiveSub() === void 0) return fn();
+	const prevSub = setActiveSub(void 0);
+	try {
+		return fn();
+	} finally {
+		setActiveSub(prevSub);
+	}
+};
+var createSignal$1 = (value) => {
+	if (isSignal(value)) return value;
+	if (isComputed(value)) console.warn("[reactivity] createSignal: wrapping a computed in a signal is redundant, use the computed directly.");
+	return signal(value);
+};
+var isTree = (value) => isObject(value) && value[IS_TREE] === true;
+var batch = (fn) => {
+	startBatch();
+	try {
+		return fn();
+	} finally {
+		endBatch();
+	}
+};
+//#endregion
+//#region node_modules/@plastic-js/plastic/src/computation-context.js
+var currentComputation = null;
+var getCurrentComputation = () => currentComputation;
+var setCurrentComputation = (value) => {
+	currentComputation = value;
+};
+//#endregion
+//#region node_modules/@plastic-js/plastic/src/control-flow.js
+var createControlFlow = ({ createOwner, runOwnerMounts, runWithOwner, disposeOwner, createBindingEffect, renderInOwner, getCurrentOwner, registerCleanup, appendChild, flushPendingDescriptors }) => {
+	const NO_BRANCH = Symbol("no-branch");
+	const mountDynamic = (anchor, selectBranch) => {
+		let prevNodes = [];
+		let prevOwner = null;
+		let prevBranch = NO_BRANCH;
+		const hostOwner = getCurrentOwner();
+		const update = () => {
+			const branch = selectBranch();
+			if (branch === prevBranch) return;
+			prevBranch = branch;
+			if (prevOwner) {
+				disposeOwner(prevOwner);
+				prevOwner = null;
+			}
+			prevNodes.forEach((n) => n.remove());
+			prevNodes = [];
+			const owner = createOwner(hostOwner);
+			const prevComp = getCurrentComputation();
+			setCurrentComputation(null);
+			const node = renderInOwner(owner, runUntracked(() => runWithOwner(owner, () => typeof branch === "function" ? branch() : null)) ?? null);
+			setCurrentComputation(prevComp);
+			if (node instanceof DocumentFragment && flushPendingDescriptors) runWithOwner(owner, () => flushPendingDescriptors(node));
+			if (node instanceof DocumentFragment) prevNodes = [...node.childNodes];
+			else prevNodes = [node];
+			anchor.after(node);
+			prevOwner = owner;
+			if (anchor.isConnected) runOwnerMounts(owner);
+		};
+		const stop = createBindingEffect(update);
+		return () => {
+			if (typeof stop === "function") stop();
+			if (prevOwner) {
+				disposeOwner(prevOwner);
+				prevOwner = null;
+			}
+			prevNodes.forEach((n) => n.remove());
+			prevNodes = [];
+		};
+	};
+	const True = ({ children }) => children;
+	const False = ({ children }) => children;
+	const Case = ({ children }) => children;
+	const Default = ({ children }) => children;
+	const Either = ({ condition, trueBranch, falseBranch }) => {
+		const anchor = document.createComment("if");
+		const fragment = document.createDocumentFragment();
+		fragment.appendChild(anchor);
+		const activeTrue = trueBranch;
+		const activeFalse = falseBranch;
+		mountDynamic(anchor, () => {
+			return (typeof condition === "function" ? condition() : condition) ? activeTrue : activeFalse;
+		});
+		return fragment;
+	};
+	const Match = ({ value, cases = [], defaultBranch }) => {
+		const anchor = document.createComment("match");
+		const fragment = document.createDocumentFragment();
+		fragment.appendChild(anchor);
+		const resolve = (source) => {
+			return typeof source === "function" ? source() : source;
+		};
+		mountDynamic(anchor, () => {
+			const resolvedCases = typeof cases === "function" ? cases() : cases;
+			const activeCases = Array.isArray(resolvedCases) ? resolvedCases : [];
+			const valueToMatch = resolve(value);
+			for (const slot of activeCases) {
+				if (!slot || typeof slot !== "object") continue;
+				let matched = false;
+				if (Object.prototype.hasOwnProperty.call(slot, "when")) matched = Object.is(valueToMatch, resolve(slot.when));
+				if (!matched) continue;
+				return typeof slot.branch === "function" ? slot.branch : null;
+			}
+			return typeof defaultBranch === "function" ? defaultBranch : null;
+		});
+		return fragment;
+	};
+	const Loop = ({ each, children }) => {
+		const anchor = document.createComment("for");
+		const fragment = document.createDocumentFragment();
+		fragment.appendChild(anchor);
+		const hostOwner = getCurrentOwner();
+		let rows = [];
+		const resolveList = () => {
+			const list = typeof each === "function" ? each() : each;
+			return Array.isArray(list) ? list : [];
+		};
+		const renderRow = (item, indexValue) => {
+			const owner = createOwner(hostOwner);
+			const indexSignal = createSignal$1(indexValue);
+			const prevComp = getCurrentComputation();
+			setCurrentComputation(null);
+			const result = runUntracked(() => runWithOwner(owner, () => {
+				if (typeof children !== "function") return null;
+				return children(item, indexSignal);
+			}));
+			const node = runUntracked(() => renderInOwner(owner, result));
+			setCurrentComputation(prevComp);
+			return {
+				owner,
+				indexSignal,
+				nodes: node instanceof DocumentFragment ? [...node.childNodes] : [node]
+			};
+		};
+		const mountRows = (nextRows) => {
+			const nodeFragment = document.createDocumentFragment();
+			nextRows.forEach((row) => {
+				row.nodes.forEach((node) => {
+					nodeFragment.appendChild(node);
+				});
+			});
+			anchor.before(nodeFragment);
+		};
+		const reconcileRows = (nextItems) => {
+			const prevRows = rows;
+			const nextRows = new Array(nextItems.length);
+			const createdRows = [];
+			const reusedPrevIndices = /* @__PURE__ */ new Set();
+			const prevRowsByIdentity = /* @__PURE__ */ new Map();
+			prevRows.forEach((row, prevIndex) => {
+				const bucket = prevRowsByIdentity.get(row.identity);
+				if (bucket) bucket.push(prevIndex);
+				else prevRowsByIdentity.set(row.identity, [prevIndex]);
+			});
+			nextItems.forEach((item, nextIndex) => {
+				const bucket = prevRowsByIdentity.get(item);
+				if (!bucket || bucket.length === 0) return;
+				const prevIndex = bucket.shift();
+				nextRows[nextIndex] = prevRows[prevIndex];
+				reusedPrevIndices.add(prevIndex);
+			});
+			for (let nextIndex = 0; nextIndex < nextRows.length; nextIndex++) {
+				const row = nextRows[nextIndex];
+				if (row) {
+					row.indexSignal(nextIndex);
+					continue;
+				}
+				const created = renderRow(nextItems[nextIndex], nextIndex);
+				created.identity = nextItems[nextIndex];
+				nextRows[nextIndex] = created;
+				createdRows.push(created);
+			}
+			prevRows.forEach((row, prevIndex) => {
+				if (reusedPrevIndices.has(prevIndex)) return;
+				disposeOwner(row.owner);
+				row.nodes.forEach((node) => node.remove());
+			});
+			rows = nextRows;
+			mountRows(rows);
+			if (anchor.isConnected) createdRows.forEach((row) => {
+				runOwnerMounts(row.owner);
+			});
+		};
+		const stop = createBindingEffect(() => {
+			reconcileRows(resolveList());
+		});
+		registerCleanup(() => {
+			if (typeof stop === "function") stop();
+			rows.forEach((row) => {
+				disposeOwner(row.owner);
+				row.nodes.forEach((node) => node.remove());
+			});
+			rows = [];
+		});
+		return fragment;
+	};
+	const Portal = ({ container, children }) => {
+		const target = (typeof container === "function" ? container() : container) ?? document.body;
+		const owner = createOwner(getCurrentOwner());
+		const prevComp = getCurrentComputation();
+		setCurrentComputation(null);
+		const node = renderInOwner(owner, runWithOwner(owner, () => typeof children === "function" ? children() : children) ?? null);
+		setCurrentComputation(prevComp);
+		const childCountBefore = target.childNodes.length;
+		if (node instanceof DocumentFragment && appendChild) appendChild(target, node);
+		else target.appendChild(node);
+		if (flushPendingDescriptors) flushPendingDescriptors(target);
+		const portalNodes = [...target.childNodes].slice(childCountBefore);
+		if (target.isConnected) runOwnerMounts(owner);
+		registerCleanup(() => {
+			disposeOwner(owner);
+			portalNodes.forEach((n) => n.remove());
+		});
+		return document.createComment("portal");
+	};
+	return {
+		mountDynamic,
+		Either,
+		True,
+		False,
+		Match,
+		Case,
+		Default,
+		Loop,
+		Portal
+	};
+};
+//#endregion
+//#region node_modules/@plastic-js/plastic/src/merge-props.js
+var CLASS_KEYS = ["class", "className"];
+var STYLE_KEYS = ["style"];
+var MAX_MERGE_VALUE_RESOLVE_STEPS = 16;
+var normalizeClassValue = (value) => {
+	if (value == null || value === false || value === "") return;
+	if (typeof value !== "string") return;
+	return value;
+};
+var isClassKey = (key) => key === "class" || key === "className";
+var resolveThunkValue = (value) => {
+	let resolved = value;
+	let steps = 0;
+	while (typeof resolved === "function" && steps < MAX_MERGE_VALUE_RESOLVE_STEPS) {
+		resolved = resolved();
+		steps += 1;
+	}
+	return resolved;
+};
+var mergeClassValues = (values) => {
+	if (values.some((value) => value != null && typeof value !== "string" && value !== false)) return values[values.length - 1];
+	const parts = values.map(normalizeClassValue).filter(Boolean);
+	return parts.length ? parts.join(" ") : void 0;
+};
+var mergeStyleValues = (values) => {
+	let result;
+	for (const value of values) {
+		if (value == null) continue;
+		if (isPlainObject(result) && isPlainObject(value)) result = {
+			...result,
+			...value
+		};
+		else if (typeof result === "string" && typeof value === "string") result = `${result}; ${value}`;
+		else result = value;
+	}
+	return result;
+};
+var resolveSource = (source) => typeof source === "function" ? source() : source;
+var collectPresentKeys = (source, keys) => {
+	const matches = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of Reflect.ownKeys(source)) {
+		if (typeof key !== "string" || !keys.includes(key) || seen.has(key)) continue;
+		seen.add(key);
+		matches.push(key);
+	}
+	for (const key of keys) {
+		if (seen.has(key) || !(key in source)) continue;
+		matches.push(key);
+	}
+	return matches;
+};
+var collectValues = (sources, keys) => {
+	const values = [];
+	for (const source of sources) {
+		const resolved = resolveSource(source);
+		if (resolved == null) continue;
+		for (const key of collectPresentKeys(resolved, keys)) values.push(resolved[key]);
+	}
+	return values;
+};
+var getKeyFamily = (key) => {
+	if (isClassKey(key)) return CLASS_KEYS;
+	if (key === "style") return STYLE_KEYS;
+	return [key];
+};
+var resolveKey = (sources, key) => {
+	const values = collectValues(sources, getKeyFamily(key));
+	if (values.length === 0) return;
+	if (key === "class" || key === "className") {
+		if (values.some((value) => typeof value === "function")) return () => mergeClassValues(values.map(resolveThunkValue));
+		return mergeClassValues(values);
+	}
+	if (key === "style") {
+		if (values.some((value) => typeof value === "function")) return () => mergeStyleValues(values.map(resolveThunkValue));
+		return mergeStyleValues(values);
+	}
+	return values[values.length - 1];
+};
+var hasKey = (sources, key) => {
+	const keys = getKeyFamily(key);
+	for (const source of sources) {
+		const resolved = resolveSource(source);
+		if (resolved == null) continue;
+		if (keys.some((candidate) => candidate in resolved)) return true;
+	}
+	return false;
+};
+var getCanonicalClassKey = (sources) => {
+	let canonicalKey;
+	for (const source of sources) {
+		const resolved = resolveSource(source);
+		if (resolved == null) continue;
+		for (const key of collectPresentKeys(resolved, CLASS_KEYS)) canonicalKey = key;
+	}
+	return canonicalKey;
+};
+var collectKeys = (sources) => {
+	const seen = /* @__PURE__ */ new Set();
+	const keys = [];
+	let hasClassAlias = false;
+	for (const source of sources) {
+		const resolved = resolveSource(source);
+		if (resolved == null) continue;
+		for (const key of Reflect.ownKeys(resolved)) {
+			if (isClassKey(key)) {
+				hasClassAlias = true;
+				continue;
+			}
+			if (!seen.has(key)) {
+				seen.add(key);
+				keys.push(key);
+			}
+		}
+	}
+	if (hasClassAlias) keys.push(getCanonicalClassKey(sources) ?? "class");
+	return keys;
+};
+var readOnlyTrap = () => {
+	throw new Error("mergeProps result is read-only");
+};
+var IS_MERGED_PROPS = Symbol("mergeProps");
+var HAS_STATIC_KEYS = Symbol("mergeProps.staticKeys");
+var mergeProps = (...sources) => {
+	if (sources.length === 1 && sources[0] != null && typeof sources[0] === "object" && isPlainObject(sources[0])) return sources[0];
+	let hasStaticKeys = true;
+	for (const source of sources) if (typeof source === "function") {
+		hasStaticKeys = false;
+		break;
+	}
+	return new Proxy({}, {
+		get: (_, key) => {
+			if (key === IS_MERGED_PROPS) return true;
+			if (key === HAS_STATIC_KEYS) return hasStaticKeys;
+			return resolveKey(sources, key);
+		},
+		has: (_, key) => hasKey(sources, key),
+		ownKeys: () => collectKeys(sources),
+		getOwnPropertyDescriptor: (_, key) => {
+			if (!hasKey(sources, key)) return;
+			return {
+				enumerable: true,
+				configurable: true,
+				get: () => resolveKey(sources, key)
+			};
+		},
+		set: readOnlyTrap,
+		deleteProperty: readOnlyTrap
+	});
+};
+var isMergedProps = (value) => value != null && typeof value === "object" && value[IS_MERGED_PROPS] === true;
+var hasMergedPropsStaticKeys = (value) => value != null && typeof value === "object" && value[HAS_STATIC_KEYS] === true;
+//#endregion
+//#region node_modules/@plastic-js/plastic/src/jsx-runtime.js
+var Fragment = Symbol("Fragment");
+var OWNER = Symbol("owner");
+var COMPONENT_DESCRIPTOR = Symbol("component-descriptor");
+var PENDING_DESCRIPTORS = Symbol("pending-descriptors");
+var currentOwner = null;
+var getCurrentOwner = () => currentOwner;
+var createOwner = (parent = null) => {
+	const owner = {
+		parent,
+		children: void 0,
+		cleanups: void 0,
+		effects: void 0,
+		contexts: void 0,
+		refs: void 0,
+		mounts: void 0,
+		mounted: false
+	};
+	if (parent) (parent.children ??= /* @__PURE__ */ new Set()).add(owner);
+	return owner;
+};
+var runOwnerMounts = (owner) => {
+	runUntracked(() => {
+		owner.children?.forEach((child) => runOwnerMounts(child));
+		owner.refs?.forEach((fn) => {
+			fn();
+		});
+		owner.mounts?.forEach((fn) => {
+			fn();
+		});
+		owner.mounted = true;
+	});
+};
+var runWithOwner = (owner, fn) => {
+	const prev = currentOwner;
+	currentOwner = owner;
+	try {
+		return fn();
+	} finally {
+		currentOwner = prev;
+	}
+};
+var renderInOwner = (owner, result) => runWithOwner(owner, () => node2Element(result));
+var mountOwnedSubtree = (node, { force = false } = {}) => {
+	if (!(node instanceof Node)) return;
+	const stack = [node];
+	while (stack.length) {
+		const current = stack.pop();
+		const owner = current[OWNER];
+		if (owner && !owner.mounted && (force || current.isConnected)) runOwnerMounts(owner);
+		for (const child of current.childNodes) stack.push(child);
+	}
+};
+var disposeOwner = (owner) => {
+	if (owner.parent) owner.parent.children?.delete(owner);
+	if (owner.children) {
+		owner.children.forEach((child) => disposeOwner(child));
+		owner.children.clear();
+	}
+	if (owner.effects) {
+		for (let i = owner.effects.length - 1; i >= 0; i -= 1) {
+			const stop = owner.effects[i];
+			if (typeof stop === "function") stop();
+		}
+		owner.effects.length = 0;
+	}
+	if (owner.cleanups) {
+		for (let i = owner.cleanups.length - 1; i >= 0; i -= 1) {
+			const cleanup = owner.cleanups[i];
+			if (typeof cleanup === "function") cleanup();
+		}
+		owner.cleanups.length = 0;
+	}
+	if (owner.refs) owner.refs.length = 0;
+	if (owner.mounts) owner.mounts.length = 0;
+};
+var flushCleanups = (list) => {
+	runUntracked(() => {
+		[...list].reverse().forEach((l) => {
+			l();
+		});
+		list.length = 0;
+	});
+};
+var createBindingEffect = (runner) => {
+	const owner = currentOwner;
+	const local = [];
+	const stop = effect(() => {
+		flushCleanups(local);
+		const prevComp = getCurrentComputation();
+		setCurrentComputation({ cleanups: local });
+		const prevOwner = currentOwner;
+		currentOwner = owner;
+		try {
+			runner();
+		} finally {
+			setCurrentComputation(prevComp);
+			currentOwner = prevOwner;
+		}
+	});
+	if (!owner) return stop;
+	(owner.effects ??= []).push(stop);
+	(owner.cleanups ??= []).push(() => {
+		flushCleanups(local);
+	});
+	return stop;
+};
+var registerCleanup = (fn) => {
+	const currentComputation = getCurrentComputation();
+	if (!currentOwner && !currentComputation) throw new Error("registerCleanup must be called within a component or effect scope");
+	if (currentComputation) currentComputation.cleanups.push(fn);
+	else (currentOwner.cleanups ??= []).push(fn);
+};
+var createComponentDescriptor = (tag, props, children) => ({
+	[COMPONENT_DESCRIPTOR]: true,
+	tag,
+	props,
+	children,
+	instance: null
+});
+var isComponentDescriptor = (value) => value != null && typeof value === "object" && value[COMPONENT_DESCRIPTOR] === true;
+var isReactivePrimitive = (value) => value != null && (isSignal(value) || isComputed(value));
+var isReactive = (value) => isReactivePrimitive(value) || typeof value === "function";
+var createPlaceholder = () => document.createComment("null");
+var isSupportedEvent = (element, eventName) => `on${eventName}` in element;
+var isBooleanDomProp = (element, key) => key in element && typeof element[key] === "boolean";
+var JSX_PROP_MAP = {
+	autoComplete: "autocomplete",
+	autoFocus: "autofocus",
+	autoPlay: "autoplay",
+	encType: "enctype",
+	hrefLang: "hreflang"
+};
+var MAX_REACTIVE_RESOLVE_STEPS = 16;
+var resolveReactiveValue = (value) => {
+	let resolved = value;
+	let steps = 0;
+	while (steps < MAX_REACTIVE_RESOLVE_STEPS) {
+		if (resolved == null) break;
+		if (isSignal(resolved) || isComputed(resolved)) {
+			resolved = resolved();
+			steps++;
+			continue;
+		}
+		if (typeof resolved === "function") {
+			resolved = resolved();
+			steps++;
+			continue;
+		}
+		break;
+	}
+	return resolved;
+};
+var createReactiveTextNode = (reactiveValue) => {
+	const textNode = document.createTextNode("");
+	let prev = textNode.data;
+	createBindingEffect(() => {
+		const next = normalizeTextNodeValue(resolveReactiveValue(reactiveValue));
+		if (prev === next) return;
+		textNode.data = next;
+		prev = next;
+	});
+	return textNode;
+};
+var materializeComponentDescriptor = (descriptor) => {
+	if (descriptor.instance instanceof Node) if (descriptor.instance instanceof DocumentFragment && descriptor.instance.childNodes.length === 0) {
+		if (descriptor._owner) {
+			disposeOwner(descriptor._owner);
+			descriptor._owner = null;
+		}
+		descriptor.instance = null;
+	} else return descriptor.instance;
+	const owner = createOwner(currentOwner);
+	let componentProps = descriptor.props ?? {};
+	if (descriptor.children && descriptor.children.length > 0) {
+		const kids = descriptor.children.length === 1 ? descriptor.children[0] : descriptor.children;
+		componentProps = mergeProps(componentProps, { children: kids });
+	}
+	const prevOwner = currentOwner;
+	const prevSub = getActiveSub();
+	currentOwner = owner;
+	setActiveSub(void 0);
+	let normalized;
+	try {
+		normalized = node2Element(descriptor.tag(componentProps));
+	} finally {
+		currentOwner = prevOwner;
+		setActiveSub(prevSub);
+	}
+	if (normalized instanceof DocumentFragment) {
+		if (normalized.firstChild) normalized.firstChild[OWNER] = owner;
+	} else if (normalized instanceof Node) normalized[OWNER] = owner;
+	descriptor._owner = owner;
+	descriptor.instance = normalized;
+	return normalized;
+};
+var createReactiveChildNode = (reactiveValue) => {
+	const start = document.createComment("dynamic-start");
+	const end = document.createComment("dynamic-end");
+	const fragment = document.createDocumentFragment();
+	fragment.append(start, end);
+	let mountedNodes = [];
+	createBindingEffect(() => {
+		const nextNode = node2Element(resolveReactiveValue(reactiveValue));
+		if (nextNode instanceof DocumentFragment && nextNode[PENDING_DESCRIPTORS]) flushPendingDescriptors(nextNode);
+		const parent = end.parentNode;
+		if (!parent) return;
+		mountedNodes.forEach((node) => {
+			if (node.parentNode) node.parentNode.removeChild(node);
+		});
+		mountedNodes = [];
+		if (nextNode instanceof DocumentFragment) mountedNodes = [...nextNode.childNodes];
+		else mountedNodes = [nextNode];
+		parent.insertBefore(nextNode, end);
+		if (start.isConnected) mountedNodes.forEach((node) => mountOwnedSubtree(node));
+	});
+	if (currentOwner || getCurrentComputation()) registerCleanup(() => {
+		mountedNodes.forEach((node) => {
+			if (node.parentNode) node.parentNode.removeChild(node);
+		});
+		mountedNodes = [];
+		if (start.parentNode) start.parentNode.removeChild(start);
+		if (end.parentNode) end.parentNode.removeChild(end);
+	});
+	return fragment;
+};
+var applyClassNameMap = (element, classNameMap) => {
+	if (!(classNameMap instanceof Map)) {
+		const temp = /* @__PURE__ */ new Map();
+		Object.entries(classNameMap).forEach(([className, enabled]) => {
+			temp.set(className, enabled);
+		});
+		classNameMap = temp;
+	}
+	classNameMap.forEach((enabled, className) => {
+		if (enabled && !element.classList.contains(className)) element.classList.add(className);
+		if (!enabled && element.classList.contains(className)) element.classList.remove(className);
+	});
+};
+var applyClassProp = (element, value) => {
+	const expectedClass = toClassMap(value);
+	const shouldRemove = [...new Set(element.classList)].filter((className) => !expectedClass.has(className));
+	applyClassNameMap(element, new Map([...expectedClass, ...shouldRemove.map((className) => [className, false])]));
+};
+var applyStyleObject = (element, styles, prevStyles = {}) => {
+	const nextStyles = styles ?? {};
+	Object.keys(prevStyles).forEach((property) => {
+		if (nextStyles[property] != null && nextStyles[property] !== false) return;
+		clearStyleKey(element, property);
+		delete prevStyles[property];
+	});
+	Object.entries(nextStyles).forEach(([property, value]) => {
+		if (value == null || value === false) return;
+		const nextValue = String(value);
+		if (prevStyles[property] === nextValue) return;
+		if (property.startsWith("--")) element.style.setProperty(property, nextValue);
+		else element.style[property] = nextValue;
+		prevStyles[property] = nextValue;
+	});
+	return prevStyles;
+};
+var clearStyleKey = (element, key) => {
+	if (key.startsWith("--")) element.style.removeProperty(key);
+	else element.style[key] = "";
+};
+var applyStyleProp = (element, value, prevValue) => {
+	if (value == null || value === false) {
+		element.style.cssText = "";
+		return;
+	}
+	if (typeof value === "string") {
+		element.style.cssText = value;
+		return value;
+	}
+	if (typeof value === "object") return applyStyleObject(element, value, typeof prevValue === "string" ? void 0 : prevValue);
+	return prevValue;
+};
+var clearDomProp = (element, key) => {
+	if (key in element) try {
+		element[key] = "";
+	} catch {}
+	element.removeAttribute(key);
+};
+var setDomProp = (element, key, value) => {
+	if (isBooleanDomProp(element, key)) {
+		const next = Boolean(value);
+		const prev = element[key];
+		const hasAttribute = element.hasAttribute(key);
+		if (prev === next && (next && hasAttribute || !next && !hasAttribute)) return;
+		element[key] = next;
+		if (next) {
+			element.setAttribute(key, "");
+			return;
+		}
+		element.removeAttribute(key);
+		return;
+	}
+	if (value == null || value === false) {
+		if (!(value === false && typeof key === "string" && key.startsWith("aria-"))) {
+			if ((key in element ? element[key] : "") === "" && !element.hasAttribute(key)) return;
+			clearDomProp(element, key);
+			return;
+		}
+	}
+	if (key in element) {
+		if (element[key] === value) return;
+		try {
+			element[key] = value;
+			return;
+		} catch {}
+	}
+	const next = String(value);
+	if (element.getAttribute(key) === next) return;
+	element.setAttribute(key, next);
+};
+var applyRefProp = (element, ref) => {
+	if (typeof ref !== "function") return;
+	const assignRef = (value) => ref(value);
+	const owner = currentOwner;
+	if (owner && !owner.mounted) (owner.refs ??= []).push(() => assignRef(element));
+	else assignRef(element);
+	if (owner || getCurrentComputation()) registerCleanup(() => {
+		assignRef(null);
+	});
+};
+var bindReactiveProp = (element, props, key, propsIsTracked) => {
+	const rawValue = props[key];
+	const descriptor = propsIsTracked ? null : Object.getOwnPropertyDescriptor(props, key);
+	const hasGetter = descriptor != null && typeof descriptor.get === "function";
+	if (!propsIsTracked && !hasGetter && !isReactive(rawValue)) {
+		let prevStyleValue;
+		if (key === "className" || key === "class") applyClassProp(element, rawValue);
+		else if (key === "style") prevStyleValue = applyStyleProp(element, rawValue, void 0);
+		else setDomProp(element, JSX_PROP_MAP[key] ?? key, rawValue);
+		return () => {
+			if (key === "className" || key === "class") {
+				element.removeAttribute("class");
+				return;
+			}
+			if (key === "style") {
+				if (prevStyleValue && typeof prevStyleValue === "object") Object.keys(prevStyleValue).forEach((prop) => clearStyleKey(element, prop));
+				else if (typeof prevStyleValue === "string") element.style.cssText = "";
+				return;
+			}
+			clearDomProp(element, JSX_PROP_MAP[key] ?? key);
+		};
+	}
+	let prevStyleValue;
+	const stop = createBindingEffect(() => {
+		const value = resolveReactiveValue(props[key]);
+		if (key === "className" || key === "class") {
+			applyClassProp(element, value);
+			return;
+		}
+		if (key === "style") {
+			prevStyleValue = applyStyleProp(element, value, prevStyleValue);
+			return;
+		}
+		setDomProp(element, JSX_PROP_MAP[key] ?? key, value);
+	});
+	return () => {
+		stop?.();
+		if (key === "className" || key === "class") {
+			element.removeAttribute("class");
+			return;
+		}
+		if (key === "style") {
+			if (prevStyleValue && typeof prevStyleValue === "object") Object.keys(prevStyleValue).forEach((prop) => clearStyleKey(element, prop));
+			else if (typeof prevStyleValue === "string") element.style.cssText = "";
+			return;
+		}
+		clearDomProp(element, JSX_PROP_MAP[key] ?? key);
+	};
+};
+var bindReactiveEvent = (element, props, key) => {
+	const eventName = key.slice(2).toLowerCase();
+	if (!isSupportedEvent(element, eventName)) return () => {};
+	const listener = (...args) => {
+		const handler = props[key];
+		if (typeof handler === "function") handler(...args);
+	};
+	element.addEventListener(eventName, listener);
+	if (currentOwner || getCurrentComputation()) registerCleanup(() => {
+		element.removeEventListener(eventName, listener);
+	});
+	return () => {
+		element.removeEventListener(eventName, listener);
+	};
+};
+var applyProps = (element, props = {}) => {
+	const propsIsTracked = isMergedProps(props) || isTree(props);
+	const bindings = /* @__PURE__ */ new Map();
+	const createBindingForKey = (key) => {
+		if (key === "classList") throw new Error("classList prop is not supported. Use className instead.");
+		const prevComp = getCurrentComputation();
+		const prevSub = getActiveSub();
+		setCurrentComputation(null);
+		setActiveSub(void 0);
+		try {
+			if (key === "ref") {
+				const ref = props[key];
+				applyRefProp(element, ref);
+				return () => {
+					if (typeof ref === "function") ref(null);
+				};
+			}
+			if (isEventProp(key)) return bindReactiveEvent(element, props, key);
+			return bindReactiveProp(element, props, key, propsIsTracked);
+		} finally {
+			setCurrentComputation(prevComp);
+			setActiveSub(prevSub);
+		}
+	};
+	const setup = () => {
+		const nextKeys = /* @__PURE__ */ new Set();
+		for (const key of Reflect.ownKeys(props)) {
+			if (typeof key === "symbol" || key === "children" || key === "key") continue;
+			nextKeys.add(key);
+		}
+		for (const [key, dispose] of bindings) {
+			if (nextKeys.has(key)) continue;
+			if (typeof dispose === "function") dispose();
+			bindings.delete(key);
+		}
+		for (const key of nextKeys) {
+			if (bindings.has(key)) continue;
+			bindings.set(key, createBindingForKey(key));
+		}
+	};
+	if (currentOwner || getCurrentComputation()) registerCleanup(() => {
+		for (const dispose of bindings.values()) if (typeof dispose === "function") dispose();
+		bindings.clear();
+	});
+	if (isMergedProps(props) && !hasMergedPropsStaticKeys(props) || isTree(props)) createBindingEffect(setup);
+	else setup();
+	return element;
+};
+var node2Element = (node) => {
+	switch (typeof node) {
+		case "string":
+		case "number": return document.createTextNode(String(node));
+		case "function":
+			if (isReactivePrimitive(node)) return createReactiveTextNode(node);
+			return createReactiveChildNode(node);
+		case "undefined": return createPlaceholder();
+		case "object":
+			if (node === null) return createPlaceholder();
+			if (typeof node.nodeType === "number") {
+				flushPendingDescriptors(node);
+				return node;
+			}
+			if (node[COMPONENT_DESCRIPTOR] === true) return materializeComponentDescriptor(node);
+			if (Array.isArray(node)) {
+				const fragment = document.createDocumentFragment();
+				appendChildren(fragment, node);
+				return fragment;
+			}
+			return createPlaceholder();
+		default: return createPlaceholder();
+	}
+};
+var flushPendingDescriptors = (root) => {
+	if (!(root instanceof Element) && !(root instanceof DocumentFragment)) return;
+	const stack = [root];
+	while (stack.length) {
+		const node = stack.pop();
+		const pending = node[PENDING_DESCRIPTORS];
+		if (pending) {
+			node[PENDING_DESCRIPTORS] = void 0;
+			pending.forEach(({ placeholder, descriptor }) => {
+				if (!placeholder.parentNode) return;
+				const materialized = node2Element(descriptor);
+				if (materialized instanceof DocumentFragment && materialized[PENDING_DESCRIPTORS]) flushPendingDescriptors(materialized);
+				placeholder.parentNode.replaceChild(materialized, placeholder);
+			});
+		}
+		for (const child of node.childNodes) if (child instanceof Element) stack.push(child);
+	}
+};
+var appendChild = (parent, child) => {
+	if (child == null) return parent;
+	if ((isComponentDescriptor(child) || typeof child === "function") && currentOwner != null && (parent instanceof Element || parent instanceof DocumentFragment)) {
+		const placeholder = document.createComment("pending");
+		parent.appendChild(placeholder);
+		(parent[PENDING_DESCRIPTORS] ?? (parent[PENDING_DESCRIPTORS] = [])).push({
+			placeholder,
+			descriptor: child
+		});
+		return parent;
+	}
+	if (child instanceof Element && currentOwner != null && (parent instanceof Element || parent instanceof DocumentFragment)) {
+		const stack = [child];
+		while (stack.length) {
+			const node = stack.pop();
+			const pending = node[PENDING_DESCRIPTORS];
+			if (pending) {
+				node[PENDING_DESCRIPTORS] = void 0;
+				(parent[PENDING_DESCRIPTORS] ?? (parent[PENDING_DESCRIPTORS] = [])).push(...pending);
+			}
+			for (const grandchild of node.childNodes) if (grandchild instanceof Element) stack.push(grandchild);
+		}
+		parent.appendChild(child);
+		return parent;
+	}
+	const childNode = node2Element(child);
+	if (childNode instanceof DocumentFragment && childNode[PENDING_DESCRIPTORS] && (parent instanceof Element || parent instanceof DocumentFragment)) {
+		(parent[PENDING_DESCRIPTORS] ?? (parent[PENDING_DESCRIPTORS] = [])).push(...childNode[PENDING_DESCRIPTORS]);
+		childNode[PENDING_DESCRIPTORS] = void 0;
+	}
+	parent.appendChild(childNode);
+	return parent;
+};
+var appendChildren = (parent, children) => {
+	flattenChildren(children).forEach((child) => {
+		appendChild(parent, child);
+	});
+	return parent;
+};
+var { mountDynamic, Either, True, False, Match, Case, Default, Loop: Loop$1, Portal: Portal$1 } = createControlFlow({
+	createOwner,
+	runOwnerMounts,
+	runWithOwner,
+	disposeOwner,
+	createBindingEffect,
+	renderInOwner,
+	getCurrentOwner,
+	registerCleanup,
+	batch,
+	appendChild,
+	flushPendingDescriptors
+});
+var SVG_TAGS = new Set([
+	"svg",
+	"animate",
+	"animateMotion",
+	"animateTransform",
+	"circle",
+	"clipPath",
+	"defs",
+	"desc",
+	"ellipse",
+	"feBlend",
+	"feColorMatrix",
+	"feComponentTransfer",
+	"feComposite",
+	"feConvolveMatrix",
+	"feDiffuseLighting",
+	"feDisplacementMap",
+	"feDistantLight",
+	"feDropShadow",
+	"feFlood",
+	"feFuncA",
+	"feFuncB",
+	"feFuncG",
+	"feFuncR",
+	"feGaussianBlur",
+	"feImage",
+	"feMerge",
+	"feMergeNode",
+	"feMorphology",
+	"feOffset",
+	"fePointLight",
+	"feSpecularLighting",
+	"feSpotLight",
+	"feTile",
+	"feTurbulence",
+	"filter",
+	"foreignObject",
+	"g",
+	"image",
+	"line",
+	"linearGradient",
+	"marker",
+	"mask",
+	"metadata",
+	"mpath",
+	"path",
+	"pattern",
+	"polygon",
+	"polyline",
+	"radialGradient",
+	"rect",
+	"set",
+	"stop",
+	"switch",
+	"symbol",
+	"text",
+	"textPath",
+	"tspan",
+	"use",
+	"view"
+]);
+var h = (tag, props, ...children) => {
+	const nextProps = props || {};
+	if (tag === Fragment) {
+		const propChildren = nextProps.children ?? [];
+		const mergedChildren = [...Array.isArray(propChildren) ? propChildren : [propChildren], ...children];
+		const fragment = document.createDocumentFragment();
+		appendChildren(fragment, mergedChildren);
+		return fragment;
+	}
+	if (typeof tag === "function") return createComponentDescriptor(tag, nextProps, children);
+	if (typeof tag !== "string") throw new Error("Only static string tags and Fragment are supported.");
+	const element = SVG_TAGS.has(tag) ? document.createElementNS("http://www.w3.org/2000/svg", tag) : document.createElement(tag);
+	applyProps(element, nextProps);
+	const propChildren = nextProps.children ?? [];
+	appendChildren(element, [...Array.isArray(propChildren) ? propChildren : [propChildren], ...children]);
+	return element;
+};
+var jsx = (tag, props, key) => {
+	if (key === void 0) return h(tag, props);
+	return h(tag, mergeProps(props, { key }));
+};
+var applyStaticProp = (element, key, value) => {
+	if (key === "className" || key === "class") {
+		applyClassProp(element, value);
+		return;
+	}
+	if (key === "style") {
+		applyStyleProp(element, value, void 0);
+		return;
+	}
+	setDomProp(element, JSX_PROP_MAP[key] ?? key, value);
+};
+var template = (html, isSVG = false) => {
+	const t = document.createElement("template");
+	if (isSVG) {
+		t.innerHTML = `<svg>${html}</svg>`;
+		const svgRoot = t.content.firstChild;
+		return svgRoot.firstChild ?? svgRoot;
+	}
+	t.innerHTML = html;
+	return t.content.firstChild;
+};
+var resolveChildToNodes = (value, out) => {
+	let v = value;
+	let steps = 0;
+	while (typeof v === "function" && !isReactivePrimitive(v) && steps < MAX_REACTIVE_RESOLVE_STEPS) {
+		v = v();
+		steps += 1;
+	}
+	if (v == null || v === true || v === false) return;
+	if (v instanceof Node) {
+		out.push(v);
+		return;
+	}
+	if (Array.isArray(v)) {
+		for (const item of v) resolveChildToNodes(item, out);
+		return;
+	}
+	if (isComponentDescriptor(v)) {
+		out.push(materializeComponentDescriptor(v));
+		return;
+	}
+	if (isReactivePrimitive(v)) {
+		out.push(createReactiveTextNode(v));
+		return;
+	}
+	out.push(document.createTextNode(String(v)));
+};
+var insert = (parent, accessor, marker = null) => {
+	if (typeof accessor !== "function") {
+		const nodes = [];
+		resolveChildToNodes(accessor, nodes);
+		for (const n of nodes) parent.insertBefore(n, marker);
+		return;
+	}
+	let current = [];
+	createBindingEffect(() => {
+		const next = accessor();
+		if (current.length === 1 && current[0].nodeType === 3 && (typeof next === "string" || typeof next === "number")) {
+			const str = String(next);
+			if (current[0].data !== str) current[0].data = str;
+			return;
+		}
+		const nodes = [];
+		resolveChildToNodes(next, nodes);
+		for (const n of current) if (n.parentNode === parent) parent.removeChild(n);
+		for (const n of nodes) parent.insertBefore(n, marker);
+		if (parent.isConnected) for (const n of nodes) mountOwnedSubtree(n);
+		current = nodes;
+	});
+};
+var setProp = (element, key, accessor) => {
+	if (key === "ref") {
+		applyRefProp(element, typeof accessor === "function" && accessor.length === 0 ? accessor() : accessor);
+		return;
+	}
+	if (isEventProp(key)) {
+		const eventName = key.slice(2).toLowerCase();
+		if (!isSupportedEvent(element, eventName)) return;
+		const listener = (...args) => {
+			const handler = accessor;
+			if (typeof handler === "function") {
+				const unwrapped = handler(...args);
+				if (typeof unwrapped === "function") unwrapped(...args);
+			}
+		};
+		element.addEventListener(eventName, listener);
+		if (currentOwner || getCurrentComputation()) registerCleanup(() => {
+			element.removeEventListener(eventName, listener);
+		});
+		return;
+	}
+	if (typeof accessor !== "function" || isReactivePrimitive(accessor)) {
+		if (!isReactive(accessor)) {
+			applyStaticProp(element, key, accessor);
+			return;
+		}
+	}
+	let prevStyle;
+	createBindingEffect(() => {
+		const v = resolveReactiveValue(accessor);
+		if (key === "className" || key === "class") {
+			applyClassProp(element, v);
+			return;
+		}
+		if (key === "style") {
+			prevStyle = applyStyleProp(element, v, prevStyle);
+			return;
+		}
+		setDomProp(element, JSX_PROP_MAP[key] ?? key, v);
+	});
+};
+//#endregion
+//#region src/components/CardNumberInput.jsx
+var _tmpl$8 = template("<div></div>");
+var wrapperClass$3 = css({
+	display: "flex",
+	alignItems: "center",
+	width: "100%",
+	boxSizing: "border-box",
+	height: "44px",
+	background: "var(--bg, rgba(0,0,0,0.2))",
+	border: "1px solid var(--border)",
+	borderRadius: "10px",
+	padding: "0 14px",
+	"&:focus-within": { borderColor: "var(--accent)" }
+});
+var errorClass$1 = css({ borderColor: "var(--danger) !important" });
+var inputClass$2 = css({
+	flex: 1,
+	minWidth: 0,
+	height: "100%",
+	background: "transparent",
+	border: "none",
+	color: "var(--ink)",
+	fontSize: "15px",
+	fontFamily: "inherit",
+	outline: "none",
+	letterSpacing: "1.5px",
+	"&::placeholder": {
+		color: "var(--muted)",
+		letterSpacing: "normal"
+	}
+});
+var read$1 = (value) => {
+	return typeof value === "function" ? value() : value;
+};
+var groupDigits = (digits) => {
+	if (!digits) return "";
+	return digits.replace(/(\d{4})(?=\d)/g, "$1-");
+};
+var CardNumberInput = (props) => {
+	const [local, rest] = splitProps(props, [
+		"value",
+		"onValueChange",
+		"invalid",
+		"placeholder"
+	]);
+	return (() => {
+		const _el0 = _tmpl$8.cloneNode(true);
+		insert(_el0, () => jsx("input", mergeProps({
+			className: inputClass$2,
+			inputMode: "numeric",
+			onInput: (e) => local.onValueChange?.(e.target.value.replace(/\D/g, "")),
+			get placeholder() {
+				return local.placeholder ?? "0000-0000-0000-0000";
+			},
+			value: () => groupDigits(read$1(local.value))
+		}, rest)));
+		setProp(_el0, "className", () => `${wrapperClass$3} ${read$1(local.invalid) ? errorClass$1 : ""}`);
+		return _el0;
+	})();
+};
+//#endregion
+//#region src/components/Carousel.jsx
+var Carousel_default = Carousel;
+//#endregion
+//#region src/components/Checkbox.jsx
+var Checkbox_default = Checkbox;
+//#endregion
+//#region src/components/Clipboard.jsx
+var Clipboard_default = Clipboard;
+//#endregion
+//#region src/components/Collapsible.jsx
+var Collapsible_default = Collapsible;
+//#endregion
+//#region src/components/ColorPicker.jsx
+var ColorPicker_default = ColorPicker;
+//#endregion
+//#region src/components/Combobox.jsx
+var OriginalRoot$1 = Combobox.Root;
+var Root$2 = (props = {}) => jsx(OriginalRoot$1, mergeProps(props));
+var Input$1 = (props = {}) => {
+	const combobox = useComboboxContext();
+	return jsx(Combobox.Input, mergeProps(props, { onInput: (event) => combobox().getInputProps().onChange?.(event) }));
+};
+var Combobox_default = Object.assign(Root$2, {
+	...Combobox,
+	OriginalRoot: OriginalRoot$1,
+	Root: Root$2,
+	Input: Input$1
+});
+//#endregion
+//#region src/components/Portal.jsx
+var Portal_default = Portal;
+//#endregion
+//#region src/components/Icon.jsx
+var _tmpl$7 = template("<span></span>");
+var iconClass$1 = css({
+	display: "inline-flex",
+	alignItems: "center",
+	justifyContent: "center",
+	color: "currentColor",
+	"& svg": {
+		width: "100%",
+		height: "100%",
+		display: "block",
+		strokeWidth: "var(--icon-sw)"
+	}
+});
+var Icon = ({ svg, size = 22, strokeWidth = 1.25, className }) => {
+	const style = {
+		width: `${size}px`,
+		height: `${size}px`,
+		"--icon-sw": strokeWidth
+	};
+	const setEl = (el) => {
+		if (el && el.innerHTML !== svg) el.innerHTML = svg;
+	};
+	return (() => {
+		const _el0 = _tmpl$7.cloneNode(true);
+		setProp(_el0, "className", () => className ? `${iconClass$1} ${className}` : iconClass$1);
+		setProp(_el0, "ref", () => setEl);
+		setProp(_el0, "style", () => style);
+		return _el0;
+	})();
+};
+//#endregion
+//#region src/components/Dialog.jsx
+var _tmpl4 = template("<button type=\"button\"></button>");
+var _tmpl3$1 = template("<div><!><!></div>");
+var _tmpl2$4 = template("<div></div>");
+var _tmpl$6 = template("<div><div><!><!></div><!></div>");
+var backdropClass = css({
+	position: "fixed",
+	inset: 0,
+	background: "rgba(0, 0, 0, 0.6)",
+	backdropFilter: "blur(4px)",
+	zIndex: 9998,
+	"&[hidden]": { display: "none" }
+});
+var positionerClass = css({
+	position: "fixed",
+	inset: 0,
+	display: "flex",
+	alignItems: "flex-end",
+	justifyContent: "center",
+	zIndex: 9999,
+	"@media (min-width: 640px)": {
+		alignItems: "center",
+		padding: "24px"
+	}
+});
+var contentClass$1 = css({
+	background: "var(--surface)",
+	border: "1px solid var(--border)",
+	borderRadius: "20px 20px 0 0",
+	width: "100%",
+	maxWidth: "480px",
+	maxHeight: "92vh",
+	display: "flex",
+	flexDirection: "column",
+	color: "var(--ink)",
+	boxShadow: "0 -8px 32px rgba(0,0,0,0.4)",
+	"&[hidden]": { display: "none" },
+	"@media (min-width: 640px)": { borderRadius: "20px" }
+});
+var headClass = css({
+	display: "flex",
+	alignItems: "center",
+	justifyContent: "space-between",
+	padding: "18px 20px",
+	borderBottom: "1px solid var(--border)"
+});
+var titleWrapClass = css({
+	display: "flex",
+	alignItems: "center",
+	gap: "10px",
+	minWidth: 0
+});
+var titleIconClass = css({
+	flexShrink: 0,
+	color: "var(--accent)"
+});
+var titleClass = css({
+	fontSize: "18px",
+	fontWeight: 700,
+	margin: 0
+});
+var closeBtnClass = css({
+	width: "32px",
+	height: "32px",
+	borderRadius: "50%",
+	background: "transparent",
+	border: "none",
+	color: "var(--muted)",
+	fontSize: "22px",
+	lineHeight: 1,
+	cursor: "pointer",
+	display: "flex",
+	alignItems: "center",
+	justifyContent: "center",
+	"&:hover": {
+		background: "rgba(255,255,255,0.06)",
+		color: "var(--ink)"
+	},
+	"&[hidden]": { display: "none" }
+});
+var bodyClass = css({
+	padding: "20px",
+	overflowY: "auto"
+});
+var footClass = css({
+	display: "flex",
+	gap: "10px",
+	padding: "14px 20px 20px",
+	borderTop: "1px solid var(--border)"
+});
+var btnClass = css({
+	flex: 1,
+	height: "46px",
+	borderRadius: "10px",
+	border: "1px solid var(--border)",
+	background: "transparent",
+	color: "var(--ink)",
+	fontSize: "15px",
+	fontWeight: 600,
+	fontFamily: "inherit",
+	cursor: "pointer",
+	"&:hover": { borderColor: "rgba(255,255,255,0.2)" }
+});
+var btnPrimaryClass = css({
+	background: "var(--accent)",
+	borderColor: "var(--accent)",
+	color: "#fff",
+	"&:hover": { filter: "brightness(1.08)" },
+	"&:disabled": {
+		opacity: .5,
+		cursor: "not-allowed"
+	}
+});
+var OriginalRoot = Dialog.Root;
+var Root$1 = (props = {}) => {
+	const [local, rest] = splitProps(props, [
+		"onOpen",
+		"onClose",
+		"onOpenChange",
+		"closeOnInteractOutside"
+	]);
+	return OriginalRoot({
+		...rest,
+		closeOnInteractOutside: local.closeOnInteractOutside ?? false,
+		onOpenChange: (open) => {
+			local.onOpenChange?.(open);
+			if (open) local.onOpen?.();
+			else local.onClose?.();
+		}
+	});
+};
+var Preset = (props) => {
+	const [local, rootProps] = splitProps(props, [
+		"title",
+		"icon",
+		"cancelText",
+		"confirmText",
+		"onConfirm",
+		"loading",
+		"children"
+	]);
+	return jsx(Root$1, mergeProps(rootProps, { children: jsx(Portal_default, mergeProps({ children: [jsx(Dialog.Backdrop, mergeProps({ className: backdropClass })), jsx(Dialog.Positioner, mergeProps({
+		className: positionerClass,
+		children: jsx(Dialog.Content, mergeProps({
+			className: contentClass$1,
+			children: [
+				() => {
+					const _el0 = _tmpl$6.cloneNode(true);
+					const _el1 = _el0.firstChild;
+					const _el2 = _el1.firstChild;
+					const _el3 = _el1.firstChild.nextSibling;
+					const _el4 = _el0.firstChild.nextSibling;
+					insert(_el1, () => local.icon && jsx(Icon, mergeProps({
+						className: titleIconClass,
+						size: 20,
+						get svg() {
+							return local.icon;
+						}
+					})), _el2);
+					insert(_el1, () => jsx(Dialog.Title, mergeProps({
+						className: titleClass,
+						children: () => local.title
+					})), _el3);
+					setProp(_el1, "className", () => titleWrapClass);
+					insert(_el0, () => jsx(Dialog.CloseTrigger, mergeProps({
+						"aria-label": "Close",
+						className: closeBtnClass,
+						hidden: true,
+						children: "×"
+					})), _el4);
+					setProp(_el0, "className", () => headClass);
+					return _el0;
+				},
+				() => {
+					const _el0 = _tmpl2$4.cloneNode(true);
+					insert(_el0, () => local.children);
+					setProp(_el0, "className", () => bodyClass);
+					return _el0;
+				},
+				() => ((local.cancelText ?? "Cancel") || (local.confirmText ?? "Confirm")) && (() => {
+					const _el0 = _tmpl3$1.cloneNode(true);
+					const _el1 = _el0.firstChild;
+					const _el2 = _el0.firstChild.nextSibling;
+					insert(_el0, () => jsx(Dialog.CloseTrigger, mergeProps({
+						className: btnClass,
+						type: "button",
+						children: () => local.cancelText ?? "Cancel"
+					})), _el1);
+					insert(_el0, () => (local.confirmText ?? "Confirm") && (() => {
+						const _el0 = _tmpl4.cloneNode(true);
+						insert(_el0, () => local.loading?.() ? "Loading…" : local.confirmText ?? "Confirm");
+						setProp(_el0, "className", () => `${btnClass} ${btnPrimaryClass}`);
+						setProp(_el0, "disabled", () => local.loading?.());
+						setProp(_el0, "onClick", () => local.onConfirm);
+						return _el0;
+					}), _el2);
+					setProp(_el0, "className", () => footClass);
+					return _el0;
+				})
+			]
+		}))
+	}))] })) }));
+};
+var Dialog_default = Object.assign(Root$1, {
+	...Dialog,
+	OriginalRoot: Root$1,
+	Root: Preset
+});
+//#endregion
+//#region src/components/ConfirmDialog.jsx
+var _tmpl$5 = template("<p></p>");
+var messageClass = css({
+	fontSize: "15px",
+	lineHeight: 1.5,
+	color: "var(--ink)",
+	textAlign: "center",
+	padding: "8px 0"
+});
+var ConfirmDialog = ({ open, onOpenChange, onConfirm, loading, title, message, confirmText, cancelText }) => {
+	const handleConfirm = () => {
+		onConfirm?.();
+	};
+	return jsx(Dialog_default.Root, mergeProps({
+		cancelText: cancelText ?? "Cancel",
+		confirmText: confirmText ?? "Delete",
+		loading,
+		onConfirm: handleConfirm,
+		onOpenChange,
+		open,
+		title: title ?? "Confirm",
+		children: () => {
+			const _el0 = _tmpl$5.cloneNode(true);
+			insert(_el0, () => message);
+			setProp(_el0, "className", () => messageClass);
+			return _el0;
+		}
+	}));
+};
+//#endregion
+//#region src/components/DateInput.jsx
+var DateInput_default = DateInput;
+//#endregion
+//#region src/components/DatePicker.jsx
+var DatePicker_default = DatePicker;
+//#endregion
+//#region src/components/Drawer.jsx
+var Drawer_default = Drawer;
+//#endregion
+//#region src/components/Field.jsx
+var Field_default = Field;
+//#endregion
+//#region src/components/Fieldset.jsx
+var Fieldset_default = Fieldset;
+//#endregion
+//#region src/components/FileUpload.jsx
+var FileUpload_default = FileUpload;
+//#endregion
+//#region src/components/FilteredSelect.jsx
+var _tmpl3 = template("<span></span>");
+var _tmpl2$3 = template("<svg fill=\"none\" stroke=\"currentColor\" strokeLinecap=\"round\" strokeLinejoin=\"round\" strokeWidth=\"2.5\" viewBox=\"0 0 24 24\"><polyline points=\"20 6 9 17 4 12\"></polyline></svg>");
+var _tmpl$4 = template("<svg fill=\"none\" stroke=\"currentColor\" strokeLinecap=\"round\" strokeLinejoin=\"round\" strokeWidth=\"2\" viewBox=\"0 0 24 24\"><polyline points=\"6 9 12 15 18 9\"></polyline></svg>");
+var access = (value) => {
+	return typeof value === "function" ? value() : value;
+};
+var FilterContext = createContext(null);
+var defaultItemToValue = (item) => String(item?.value ?? item?.id ?? item);
+var defaultItemToString = (item) => String(item?.label ?? item?.name ?? item);
+var defaultFilter = (item, query, itemToString) => itemToString(item).toLowerCase().includes(query);
+var Root = (props = {}) => {
+	const [local, rest] = splitProps(props, [
+		"items",
+		"itemToValue",
+		"itemToString",
+		"filter",
+		"inputValue",
+		"onInputValueChange",
+		"children"
+	]);
+	const itemToValue = local.itemToValue ?? defaultItemToValue;
+	const itemToString = local.itemToString ?? defaultItemToString;
+	const filter = local.filter ?? defaultFilter;
+	const query = createSignal(access(local.inputValue) ?? "");
+	const filteredItems = createComputed(() => {
+		const q = query().trim().toLowerCase();
+		const list = access(local.items) ?? [];
+		return q ? list.filter((item) => filter(item, q, itemToString)) : list;
+	});
+	const collection$1 = createComputed(() => collection({
+		items: filteredItems(),
+		itemToValue,
+		itemToString
+	}));
+	return jsx(FilterContext.Provider, mergeProps({
+		value: filteredItems,
+		children: () => jsx(Combobox.Root, mergeProps(rest, {
+			collection: collection$1,
+			inputValue: query,
+			onInputValueChange: (value) => {
+				query(value);
+				local.onInputValueChange?.(value);
+			},
+			children: [jsx(HighlightSingleMatch, mergeProps({
+				itemToValue,
+				items: filteredItems
+			})), () => local.children]
+		}))
+	}));
+};
+var HighlightSingleMatch = (props = {}) => {
+	const combobox = useComboboxContext();
+	createEffect(() => {
+		const api = combobox();
+		const list = props.items();
+		if (!api.open || list.length !== 1) return;
+		const value = props.itemToValue(list[0]);
+		if (api.highlightedValue !== value) api.setHighlightValue(value);
+	});
+	return null;
+};
+var Input = (props = {}) => {
+	const combobox = useComboboxContext();
+	return jsx(Combobox.Input, mergeProps(props, { onInput: (event) => combobox().getInputProps().onChange?.(event) }));
+};
+var Items = (props = {}) => {
+	return jsx(Loop, mergeProps({
+		each: useContext(FilterContext) ?? [],
+		children: (item) => props.children?.(item)
+	}));
+};
+function ChevronIcon() {
+	return _tmpl$4.cloneNode(true);
+}
+function CheckIcon() {
+	return _tmpl2$3.cloneNode(true);
+}
+var FilteredSelect = (props = {}) => {
+	const [local, rest] = splitProps(props, [
+		"items",
+		"itemToString",
+		"itemToValue",
+		"placeholder",
+		"label",
+		"openOnClick",
+		"disabled",
+		"classNames",
+		"emptyText"
+	]);
+	const cn = local.classNames ?? {};
+	return jsx(Root, mergeProps({
+		get itemToString() {
+			return local.itemToString;
+		},
+		get itemToValue() {
+			return local.itemToValue;
+		},
+		get items() {
+			return local.items;
+		},
+		get openOnClick() {
+			return local.openOnClick ?? true;
+		}
+	}, rest, { children: [
+		() => local.label && jsx(Combobox.Label, mergeProps({
+			get className() {
+				return cn.label;
+			},
+			children: () => local.label
+		})),
+		jsx(Combobox.Control, mergeProps({
+			get className() {
+				return cn.control;
+			},
+			children: [jsx(Input, mergeProps({
+				get className() {
+					return cn.input;
+				},
+				get disabled() {
+					return local.disabled;
+				},
+				get placeholder() {
+					return local.placeholder ?? "Type to search...";
+				}
+			})), jsx(Combobox.Trigger, mergeProps({
+				get className() {
+					return cn.trigger;
+				},
+				type: "button",
+				children: jsx(ChevronIcon, {})
+			}))]
+		})),
+		jsx(Combobox.Content, mergeProps({
+			get className() {
+				return cn.content;
+			},
+			children: [jsx(Combobox.Empty, mergeProps({
+				get className() {
+					return cn.empty;
+				},
+				children: () => local.emptyText ?? "No results found"
+			})), jsx(Items, mergeProps({ children: (item) => jsx(Combobox.Item, mergeProps({
+				get className() {
+					return cn.item;
+				},
+				item,
+				get key() {
+					return local.itemToValue?.(item) ?? item;
+				},
+				children: [jsx(Combobox.ItemText, mergeProps({
+					get className() {
+						return cn.itemText;
+					},
+					children: () => local.itemToString?.(item) ?? String(item)
+				})), () => {
+					const _el0 = _tmpl3.cloneNode(true);
+					insert(_el0, () => jsx(CheckIcon, {}));
+					setProp(_el0, "className", () => cn.check);
+					return _el0;
+				}]
+			})) }))]
+		}))
+	] }));
+};
+//#endregion
+//#region src/components/FocusTrap.jsx
+var FocusTrap_default = FocusTrap;
+//#endregion
+//#region src/components/HoverCard.jsx
+var HoverCard_default = HoverCard;
+//#endregion
+//#region src/components/Listbox.jsx
+var Listbox_default = Listbox;
+//#endregion
+//#region src/components/Menu.jsx
+var Menu_default = Menu;
+//#endregion
+//#region src/components/MoneyInput.jsx
+var _tmpl2$2 = template("<span></span>");
+var _tmpl$3 = template("<div><span></span><!><!></div>");
+var wrapperClass$2 = css({
+	display: "flex",
+	alignItems: "center",
+	width: "100%",
+	boxSizing: "border-box",
+	height: "44px",
+	background: "var(--bg, rgba(0,0,0,0.2))",
+	border: "1px solid var(--border)",
+	borderRadius: "10px",
+	padding: "0 14px",
+	"&:focus-within": { borderColor: "var(--accent)" }
+});
+var errorClass = css({ borderColor: "var(--danger) !important" });
+var affixTextClass = css({
+	color: "var(--muted)",
+	fontSize: "14px",
+	whiteSpace: "nowrap",
+	userSelect: "none",
+	marginRight: "2px"
+});
+var affixSuffixClass = css({
+	color: "var(--ink)",
+	fontSize: "14px",
+	fontWeight: 600,
+	whiteSpace: "nowrap",
+	userSelect: "none",
+	paddingLeft: "10px",
+	marginLeft: "4px",
+	borderLeft: "1px solid var(--border)"
+});
+var affixSuffixDisabledClass = css({ opacity: .5 });
+var inputClass$1 = css({
+	flex: 1,
+	minWidth: 0,
+	height: "100%",
+	background: "transparent",
+	border: "none",
+	color: "var(--ink)",
+	fontSize: "15px",
+	fontFamily: "inherit",
+	outline: "none",
+	"&::placeholder": { color: "var(--muted)" },
+	"&:disabled": {
+		opacity: .5,
+		cursor: "not-allowed",
+		WebkitTextFillColor: "var(--ink)"
+	}
+});
+var read = (value) => {
+	return typeof value === "function" ? value() : value;
+};
+var groupThousands = (digits) => {
+	if (!digits) return "";
+	return Number(digits).toLocaleString("en-US");
+};
+/**
+* Currency amount input. Keeps an integer digits-only string as its value and
+* renders it grouped by thousands with a currency prefix.
+*
+* @param value         digits-only string, or an accessor returning one
+* @param onValueChange called with the next digits-only string on input
+* @param invalid       boolean or accessor; toggles the error border
+* @param currency      prefix symbol, defaults to ₱
+* @param affix         optional suffix text (e.g. K, M), defaults to empty
+*/
+var MoneyInput = (props) => {
+	const [local, rest] = splitProps(props, [
+		"value",
+		"onValueChange",
+		"invalid",
+		"currency",
+		"affix",
+		"placeholder",
+		"disabled"
+	]);
+	return () => {
+		const _el0 = _tmpl$3.cloneNode(true);
+		const _el1 = _el0.firstChild;
+		const _el2 = _el0.firstChild.nextSibling;
+		const _el3 = _el0.firstChild.nextSibling.nextSibling;
+		insert(_el1, () => local.currency ?? "₱");
+		setProp(_el1, "className", () => affixTextClass);
+		insert(_el0, () => jsx("input", mergeProps({
+			className: inputClass$1,
+			get disabled() {
+				return local.disabled;
+			},
+			inputMode: "numeric",
+			onInput: (e) => local.onValueChange?.(e.target.value.replace(/\D/g, "")),
+			get placeholder() {
+				return local.placeholder;
+			},
+			value: () => groupThousands(read(local.value))
+		}, rest)), _el2);
+		insert(_el0, () => read(local.affix) && (() => {
+			const _el0 = _tmpl2$2.cloneNode(true);
+			insert(_el0, () => read(local.affix));
+			setProp(_el0, "className", () => `${affixSuffixClass} ${read(local.disabled) ? affixSuffixDisabledClass : ""}`);
+			return _el0;
+		}), _el3);
+		setProp(_el0, "className", () => `${wrapperClass$2} ${read(local.invalid) ? errorClass : ""}`);
+		return _el0;
+	};
+};
+//#endregion
+//#region src/components/MyFilteredSelect.jsx
+var classNames = {
+	control: css({
+		position: "relative",
+		display: "flex",
+		alignItems: "center",
+		width: "100%",
+		height: "46px",
+		background: "var(--surface)",
+		border: "1px solid var(--border)",
+		borderRadius: "10px",
+		transition: "border-color 150ms ease",
+		"&:focus-within": { borderColor: "var(--accent)" }
+	}),
+	input: css({
+		flex: 1,
+		minWidth: 0,
+		height: "100%",
+		background: "transparent",
+		border: "none",
+		outline: "none",
+		padding: "0 0 0 14px",
+		color: "var(--ink)",
+		fontSize: "15px",
+		fontFamily: "inherit",
+		"&::placeholder": { color: "var(--muted)" }
+	}),
+	trigger: css({
+		flexShrink: 0,
+		width: "36px",
+		height: "100%",
+		display: "flex",
+		alignItems: "center",
+		justifyContent: "center",
+		background: "transparent",
+		border: "none",
+		color: "var(--muted)",
+		cursor: "pointer",
+		padding: 0,
+		transition: "transform 180ms ease, color 180ms ease",
+		"&[data-state=\"open\"]": {
+			transform: "rotate(180deg)",
+			color: "var(--accent)"
+		},
+		"& svg": {
+			width: "18px",
+			height: "18px"
+		}
+	}),
+	content: css({
+		background: "var(--surface)",
+		border: "1px solid var(--border)",
+		borderRadius: "12px",
+		padding: "6px",
+		boxShadow: "0 8px 32px rgba(0,0,0,0.5)",
+		maxHeight: "280px",
+		overflowY: "auto",
+		minWidth: "220px",
+		zIndex: 9999,
+		marginTop: "4px",
+		"&[hidden]": { display: "none" },
+		"&::-webkit-scrollbar": { width: "4px" },
+		"&::-webkit-scrollbar-track": { background: "transparent" },
+		"&::-webkit-scrollbar-thumb": {
+			background: "var(--border)",
+			borderRadius: "4px"
+		}
+	}),
+	item: css({
+		display: "flex",
+		alignItems: "center",
+		gap: "10px",
+		padding: "10px 12px",
+		borderRadius: "8px",
+		cursor: "pointer",
+		color: "var(--ink)",
+		fontSize: "14px",
+		transition: "background 120ms ease",
+		"&[data-highlighted]": { background: "var(--surface-2)" },
+		"&[data-selected]": {
+			color: "var(--accent)",
+			background: "rgba(47, 123, 255, 0.1)"
+		}
+	}),
+	itemText: css({
+		flex: 1,
+		minWidth: 0
+	}),
+	check: css({
+		flexShrink: 0,
+		width: "18px",
+		height: "18px",
+		color: "var(--accent)",
+		opacity: 0,
+		transition: "opacity 120ms ease",
+		"[data-selected] &": { opacity: 1 }
+	}),
+	empty: css({
+		padding: "24px 12px",
+		textAlign: "center",
+		color: "var(--muted)",
+		fontSize: "14px"
+	}),
+	label: css({
+		display: "block",
+		fontSize: "13px",
+		fontWeight: 600,
+		color: "var(--muted)",
+		marginBottom: "6px"
+	})
+};
+var MyFilteredSelect = (props = {}) => jsx(FilteredSelect, mergeProps({ classNames }, props));
+//#endregion
+//#region src/components/NumberInput.jsx
+var NumberInput_default = NumberInput;
+//#endregion
+//#region src/components/Pagination.jsx
+var Pagination_default = Pagination;
+//#endregion
+//#region src/components/Popover.jsx
+var Popover_default = Popover;
+//#endregion
+//#region src/components/Presence.jsx
+var Presence_default = Presence;
+//#endregion
+//#region src/components/Progress.jsx
+var Progress_default = Progress;
+//#endregion
+//#region src/components/RadioGroup.jsx
+var RadioGroup_default = RadioGroup;
+//#endregion
+//#region src/components/RatingGroup.jsx
+var RatingGroup_default = RatingGroup;
+//#endregion
+//#region src/components/SearchInput.jsx
+var _tmpl2$1 = template("<svg fill=\"none\" stroke=\"currentColor\" strokeLinecap=\"round\" strokeLinejoin=\"round\" strokeWidth=\"2\" viewBox=\"0 0 24 24\"><circle cx=\"11\" cy=\"11\" r=\"7\"></circle><path d=\"M21 21l-4.35-4.35\"></path></svg>");
+var _tmpl$2 = template("<div><span aria-hidden=\"true\"></span><!></div>");
+var wrapperClass$1 = css({
+	flex: 1,
+	minWidth: 0,
+	position: "relative"
+});
+var inputClass = css({
+	width: "100%",
+	height: "44px",
+	background: "var(--surface)",
+	border: "1px solid var(--border)",
+	borderRadius: "10px",
+	padding: "0 14px 0 44px",
+	color: "var(--ink)",
+	fontSize: "15px",
+	fontFamily: "inherit",
+	outline: "none",
+	"&::placeholder": { color: "var(--muted)" },
+	"&:focus": { borderColor: "var(--accent)" }
+});
+var iconClass = css({
+	position: "absolute",
+	left: "13px",
+	top: "50%",
+	transform: "translateY(-50%)",
+	color: "var(--muted)",
+	pointerEvents: "none",
+	"& svg": {
+		width: "18px",
+		height: "18px"
+	}
+});
+var SearchInput = (props) => {
+	const [local, rest] = splitProps(props, ["placeholder", "onInput"]);
+	return () => {
+		const _el0 = _tmpl$2.cloneNode(true);
+		const _el1 = _el0.firstChild;
+		const _el2 = _el0.firstChild.nextSibling;
+		insert(_el1, () => jsx(SearchIcon, {}));
+		setProp(_el1, "className", () => iconClass);
+		insert(_el0, () => jsx("input", mergeProps({
+			className: inputClass,
+			get onInput() {
+				return local.onInput;
+			},
+			get placeholder() {
+				return local.placeholder ?? "Search...";
+			},
+			type: "search"
+		}, rest)), _el2);
+		setProp(_el0, "className", () => wrapperClass$1);
+		return _el0;
+	};
+};
+function SearchIcon() {
+	return _tmpl2$1.cloneNode(true);
+}
+//#endregion
+//#region src/components/Select.jsx
+var Select_default = Select;
+//#endregion
+//#region src/components/SignaturePad.jsx
+var SignaturePad_default = SignaturePad;
+//#endregion
+//#region src/components/Skeleton.jsx
+var _tmpl$1 = template("<span></span>");
+var baseClass = css({
+	display: "block",
+	background: "linear-gradient(90deg, var(--border) 0%, var(--surface) 50%, var(--border) 100%)",
+	backgroundSize: "200% 100%",
+	animation: `${keyframes({
+		"0%": { backgroundPosition: "-200% 0" },
+		"100%": { backgroundPosition: "200% 0" }
+	})} 1.4s ease-in-out infinite`,
+	borderRadius: "6px"
+});
+var Skeleton = ({ width = "100%", height = "14px", radius, className, style }) => (() => {
+	const _el0 = _tmpl$1.cloneNode(true);
+	setProp(_el0, "className", () => className ? `${baseClass} ${className}` : baseClass);
+	setProp(_el0, "style", () => ({
+		width,
+		height,
+		borderRadius: radius,
+		...style
+	}));
+	return _el0;
+})();
+//#endregion
+//#region src/components/Slider.jsx
+var Slider_default = Slider;
+//#endregion
+//#region src/components/Splitter.jsx
+var Splitter_default = Splitter;
+//#endregion
+//#region src/components/Steps.jsx
+var Steps_default = Steps;
+//#endregion
+//#region src/components/SwipeReveal.jsx
+var _tmpl2 = template("<button type=\"button\"></button>");
+var _tmpl = template("<div><div data-dragging=\"false\"><div></div><div></div></div></div>");
+var ACTIONS_WIDTH = 160;
+var wrapperClass = css`
+	position: relative;
+	overflow: hidden;
+	border-radius: 12px;
+	user-select: none;
+`;
+var trackClass = css`
+	display: flex;
+	align-items: stretch;
+	will-change: transform;
+	transition: transform 220ms ease;
+	touch-action: pan-y;
+	&[data-dragging="true"] { transition: none; }
+`;
+var actionsClass = css`
+	flex: 0 0 ${ACTIONS_WIDTH}px;
+	display: flex;
+`;
+var actionBtnClass = css`
+	flex: 1;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	border: none;
+	color: #fff;
+	font-size: 14px;
+	font-weight: 600;
+	cursor: pointer;
+	font-family: inherit;
+`;
+var contentClass = css`
+	flex: 0 0 100%;
+`;
+var SwipeReveal = ({ actions, children, onSwipeStart, onOpenChange, activeId, thisId }) => {
+	const isOpen = createSignal(false);
+	let trackEl = null;
+	let startX = 0;
+	let startY = 0;
+	let baseOffset = 0;
+	let currentOffset = 0;
+	let dragging = false;
+	let axisLocked = false;
+	let horizontal = false;
+	let moved = false;
+	const setTrackRef = (el) => {
+		trackEl = el;
+	};
+	const applyTransform = (px) => {
+		if (trackEl) trackEl.style.transform = `translateX(${px}px)`;
+	};
+	const snap = (toOpen) => {
+		currentOffset = toOpen ? -160 : 0;
+		if (trackEl) {
+			trackEl.dataset.dragging = "false";
+			applyTransform(currentOffset);
+		}
+		onOpenChange?.(toOpen);
+		isOpen(toOpen);
+	};
+	createEffect(() => {
+		const currentActive = typeof activeId === "function" ? activeId() : activeId;
+		if (currentActive !== void 0 && currentActive !== thisId && isOpen()) {
+			isOpen(false);
+			currentOffset = 0;
+			if (trackEl) {
+				trackEl.dataset.dragging = "false";
+				applyTransform(0);
+			}
+		}
+	});
+	const onPointerDown = (e) => {
+		if (e.pointerType === "mouse" && e.button !== 0) return;
+		startX = e.clientX;
+		startY = e.clientY;
+		baseOffset = isOpen() ? -160 : 0;
+		dragging = true;
+		axisLocked = false;
+		horizontal = false;
+		moved = false;
+		e.currentTarget.setPointerCapture?.(e.pointerId);
+	};
+	const onPointerMove = (e) => {
+		if (!dragging) return;
+		const dx = e.clientX - startX;
+		const dy = e.clientY - startY;
+		if (!axisLocked) {
+			if (Math.abs(dx) < 6 && Math.abs(dy) < 6) return;
+			horizontal = Math.abs(dx) > Math.abs(dy);
+			axisLocked = true;
+			if (horizontal && trackEl) trackEl.dataset.dragging = "true";
+		}
+		if (!horizontal) return;
+		moved = true;
+		let next = baseOffset + dx;
+		if (next > 0) next = 0;
+		if (next < -160) next = -160 - (next + ACTIONS_WIDTH) * .2;
+		currentOffset = next;
+		applyTransform(next);
+	};
+	const onPointerUp = (e) => {
+		if (!dragging) return;
+		dragging = false;
+		e.currentTarget.releasePointerCapture?.(e.pointerId);
+		if (!horizontal) return;
+		snap(currentOffset < -80);
+	};
+	const handleContentClick = (e) => {
+		if (moved) {
+			e.stopPropagation();
+			return;
+		}
+		if (isOpen()) {
+			e.stopPropagation();
+			snap(false);
+			return;
+		}
+	};
+	const handleActionClick = (action) => (e) => {
+		e.stopPropagation();
+		snap(false);
+		action.onClick?.(e);
+	};
+	return () => {
+		const _el0 = _tmpl.cloneNode(true);
+		const _el1 = _el0.firstChild;
+		const _el2 = _el1.firstChild;
+		const _el3 = _el1.firstChild.nextSibling;
+		insert(_el2, () => children);
+		setProp(_el2, "className", () => contentClass);
+		setProp(_el2, "onClick", () => handleContentClick);
+		insert(_el3, () => actions.map((action) => () => {
+			const _el0 = _tmpl2.cloneNode(true);
+			insert(_el0, () => action.label);
+			setProp(_el0, "className", () => actionBtnClass);
+			setProp(_el0, "onClick", () => handleActionClick(action));
+			setProp(_el0, "style", () => ({ background: action.color }));
+			setProp(_el0, "tabIndex", () => isOpen() ? 0 : -1);
+			return _el0;
+		}));
+		setProp(_el3, "className", () => actionsClass);
+		setProp(_el1, "className", () => trackClass);
+		setProp(_el1, "onPointerCancel", () => onPointerUp);
+		setProp(_el1, "onPointerDown", () => onPointerDown);
+		setProp(_el1, "onPointerMove", () => onPointerMove);
+		setProp(_el1, "onPointerUp", () => onPointerUp);
+		setProp(_el1, "ref", () => setTrackRef);
+		setProp(_el0, "className", () => wrapperClass);
+		return _el0;
+	};
+};
+//#endregion
+//#region src/components/Switch.jsx
+var Switch_default = Switch;
+//#endregion
+//#region src/components/Tabs.jsx
+var Tabs_default = Tabs;
+//#endregion
+//#region src/components/TagsInput.jsx
+var TagsInput_default = TagsInput;
+//#endregion
+//#region src/components/Toast.jsx
+var Toast_default = Object.assign(Toast, { createToaster });
+//#endregion
+//#region src/components/Toggle.jsx
+var Toggle_default = Toggle;
+//#endregion
+//#region src/components/ToggleGroup.jsx
+var ToggleGroup_default = ToggleGroup;
+//#endregion
+//#region src/components/Tooltip.jsx
+var Tooltip_default = Tooltip;
+//#endregion
+//#region src/components/Tour.jsx
+var Tour_default = Tour;
+//#endregion
+//#region src/components/TreeView.jsx
+var TreeView_default = TreeView;
+//#endregion
+export { Accordion_default as Accordion, Avatar_default as Avatar, CardNumberInput, Carousel_default as Carousel, Checkbox_default as Checkbox, Clipboard_default as Clipboard, Collapsible_default as Collapsible, ColorPicker_default as ColorPicker, Combobox_default as Combobox, ConfirmDialog, DateInput_default as DateInput, DatePicker_default as DatePicker, Dialog_default as Dialog, Drawer_default as Drawer, Field_default as Field, Fieldset_default as Fieldset, FileUpload_default as FileUpload, FilteredSelect, FocusTrap_default as FocusTrap, HoverCard_default as HoverCard, Icon, Listbox_default as Listbox, Menu_default as Menu, MoneyInput, MyFilteredSelect, NumberInput_default as NumberInput, Pagination_default as Pagination, Popover_default as Popover, Portal_default as Portal, Presence_default as Presence, Progress_default as Progress, RadioGroup_default as RadioGroup, RatingGroup_default as RatingGroup, SearchInput, Select_default as Select, SignaturePad_default as SignaturePad, Skeleton, Slider_default as Slider, Splitter_default as Splitter, Steps_default as Steps, SwipeReveal, Switch_default as Switch, Tabs_default as Tabs, TagsInput_default as TagsInput, Toast_default as Toast, Toggle_default as Toggle, ToggleGroup_default as ToggleGroup, Tooltip_default as Tooltip, Tour_default as Tour, TreeView_default as TreeView };
+
+//# sourceMappingURL=index.js.map