react-grab 0.1.29 → 0.1.30

package/dist/state-BaTqKR5-.js

@@ -0,0 +1,1832 @@
+/**
+ * @license MIT
+ *
+ * Copyright (c) 2025 Aiden Bai
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { P as DEFAULT_ACTION_ID, j as getTagName, ot as TOOLBAR_DEFAULT_POSITION_RATIO } from "./freeze-updates-JRZCAR0q.js";
+
+//#region ../../node_modules/.pnpm/solid-js@1.9.10/node_modules/solid-js/dist/solid.js
+const sharedConfig = {
+	context: void 0,
+	registry: void 0,
+	effects: void 0,
+	done: false,
+	getContextId() {
+		return getContextId(this.context.count);
+	},
+	getNextContextId() {
+		return getContextId(this.context.count++);
+	}
+};
+function getContextId(count) {
+	const num = String(count), len = num.length - 1;
+	return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
+}
+function setHydrateContext(context) {
+	sharedConfig.context = context;
+}
+function nextHydrateContext() {
+	return {
+		...sharedConfig.context,
+		id: sharedConfig.getNextContextId(),
+		count: 0
+	};
+}
+const equalFn = (a, b) => a === b;
+const $PROXY = Symbol("solid-proxy");
+const SUPPORTS_PROXY = typeof Proxy === "function";
+const $TRACK = Symbol("solid-track");
+const signalOptions = { equals: equalFn };
+let ERROR = null;
+let runEffects = runQueue;
+const STALE = 1;
+const PENDING = 2;
+const UNOWNED = {
+	owned: null,
+	cleanups: null,
+	context: null,
+	owner: null
+};
+const NO_INIT = {};
+var Owner = null;
+let Transition = null;
+let Scheduler = null;
+let ExternalSourceConfig = null;
+let Listener = null;
+let Updates = null;
+let Effects = null;
+let ExecCount = 0;
+function createRoot(fn, detachedOwner) {
+	const listener = Listener, owner = Owner, unowned = fn.length === 0, current = detachedOwner === void 0 ? owner : detachedOwner, root = unowned ? UNOWNED : {
+		owned: null,
+		cleanups: null,
+		context: current ? current.context : null,
+		owner: current
+	}, updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
+	Owner = root;
+	Listener = null;
+	try {
+		return runUpdates(updateFn, true);
+	} finally {
+		Listener = listener;
+		Owner = owner;
+	}
+}
+function createSignal(value, options) {
+	options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+	const s = {
+		value,
+		observers: null,
+		observerSlots: null,
+		comparator: options.equals || void 0
+	};
+	const setter = (value) => {
+		if (typeof value === "function") if (Transition && Transition.running && Transition.sources.has(s)) value = value(s.tValue);
+		else value = value(s.value);
+		return writeSignal(s, value);
+	};
+	return [readSignal.bind(s), setter];
+}
+function createComputed(fn, value, options) {
+	const c = createComputation(fn, value, true, STALE);
+	if (Scheduler && Transition && Transition.running) Updates.push(c);
+	else updateComputation(c);
+}
+function createRenderEffect(fn, value, options) {
+	const c = createComputation(fn, value, false, STALE);
+	if (Scheduler && Transition && Transition.running) Updates.push(c);
+	else updateComputation(c);
+}
+function createEffect(fn, value, options) {
+	runEffects = runUserEffects;
+	const c = createComputation(fn, value, false, STALE), s = SuspenseContext && useContext(SuspenseContext);
+	if (s) c.suspense = s;
+	if (!options || !options.render) c.user = true;
+	Effects ? Effects.push(c) : updateComputation(c);
+}
+function createMemo(fn, value, options) {
+	options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+	const c = createComputation(fn, value, true, 0);
+	c.observers = null;
+	c.observerSlots = null;
+	c.comparator = options.equals || void 0;
+	if (Scheduler && Transition && Transition.running) {
+		c.tState = STALE;
+		Updates.push(c);
+	} else updateComputation(c);
+	return readSignal.bind(c);
+}
+function isPromise(v) {
+	return v && typeof v === "object" && "then" in v;
+}
+function createResource(pSource, pFetcher, pOptions) {
+	let source;
+	let fetcher;
+	let options;
+	if (typeof pFetcher === "function") {
+		source = pSource;
+		fetcher = pFetcher;
+		options = pOptions || {};
+	} else {
+		source = true;
+		fetcher = pSource;
+		options = pFetcher || {};
+	}
+	let pr = null, initP = NO_INIT, id = null, loadedUnderTransition = false, scheduled = false, resolved = "initialValue" in options, dynamic = typeof source === "function" && createMemo(source);
+	const contexts = /* @__PURE__ */ new Set(), [value, setValue] = (options.storage || createSignal)(options.initialValue), [error, setError] = createSignal(void 0), [track, trigger] = createSignal(void 0, { equals: false }), [state, setState] = createSignal(resolved ? "ready" : "unresolved");
+	if (sharedConfig.context) {
+		id = sharedConfig.getNextContextId();
+		if (options.ssrLoadFrom === "initial") initP = options.initialValue;
+		else if (sharedConfig.load && sharedConfig.has(id)) initP = sharedConfig.load(id);
+	}
+	function loadEnd(p, v, error, key) {
+		if (pr === p) {
+			pr = null;
+			key !== void 0 && (resolved = true);
+			if ((p === initP || v === initP) && options.onHydrated) queueMicrotask(() => options.onHydrated(key, { value: v }));
+			initP = NO_INIT;
+			if (Transition && p && loadedUnderTransition) {
+				Transition.promises.delete(p);
+				loadedUnderTransition = false;
+				runUpdates(() => {
+					Transition.running = true;
+					completeLoad(v, error);
+				}, false);
+			} else completeLoad(v, error);
+		}
+		return v;
+	}
+	function completeLoad(v, err) {
+		runUpdates(() => {
+			if (err === void 0) setValue(() => v);
+			setState(err !== void 0 ? "errored" : resolved ? "ready" : "unresolved");
+			setError(err);
+			for (const c of contexts.keys()) c.decrement();
+			contexts.clear();
+		}, false);
+	}
+	function read() {
+		const c = SuspenseContext && useContext(SuspenseContext), v = value(), err = error();
+		if (err !== void 0 && !pr) throw err;
+		if (Listener && !Listener.user && c) createComputed(() => {
+			track();
+			if (pr) {
+				if (c.resolved && Transition && loadedUnderTransition) Transition.promises.add(pr);
+				else if (!contexts.has(c)) {
+					c.increment();
+					contexts.add(c);
+				}
+			}
+		});
+		return v;
+	}
+	function load(refetching = true) {
+		if (refetching !== false && scheduled) return;
+		scheduled = false;
+		const lookup = dynamic ? dynamic() : source;
+		loadedUnderTransition = Transition && Transition.running;
+		if (lookup == null || lookup === false) {
+			loadEnd(pr, untrack(value));
+			return;
+		}
+		if (Transition && pr) Transition.promises.delete(pr);
+		let error;
+		const p = initP !== NO_INIT ? initP : untrack(() => {
+			try {
+				return fetcher(lookup, {
+					value: value(),
+					refetching
+				});
+			} catch (fetcherError) {
+				error = fetcherError;
+			}
+		});
+		if (error !== void 0) {
+			loadEnd(pr, void 0, castError(error), lookup);
+			return;
+		} else if (!isPromise(p)) {
+			loadEnd(pr, p, void 0, lookup);
+			return p;
+		}
+		pr = p;
+		if ("v" in p) {
+			if (p.s === 1) loadEnd(pr, p.v, void 0, lookup);
+			else loadEnd(pr, void 0, castError(p.v), lookup);
+			return p;
+		}
+		scheduled = true;
+		queueMicrotask(() => scheduled = false);
+		runUpdates(() => {
+			setState(resolved ? "refreshing" : "pending");
+			trigger();
+		}, false);
+		return p.then((v) => loadEnd(p, v, void 0, lookup), (e) => loadEnd(p, void 0, castError(e), lookup));
+	}
+	Object.defineProperties(read, {
+		state: { get: () => state() },
+		error: { get: () => error() },
+		loading: { get() {
+			const s = state();
+			return s === "pending" || s === "refreshing";
+		} },
+		latest: { get() {
+			if (!resolved) return read();
+			const err = error();
+			if (err && !pr) throw err;
+			return value();
+		} }
+	});
+	let owner = Owner;
+	if (dynamic) createComputed(() => (owner = Owner, load(false)));
+	else load(false);
+	return [read, {
+		refetch: (info) => runWithOwner(owner, () => load(info)),
+		mutate: setValue
+	}];
+}
+function batch(fn) {
+	return runUpdates(fn, false);
+}
+function untrack(fn) {
+	if (!ExternalSourceConfig && Listener === null) return fn();
+	const listener = Listener;
+	Listener = null;
+	try {
+		if (ExternalSourceConfig) return ExternalSourceConfig.untrack(fn);
+		return fn();
+	} finally {
+		Listener = listener;
+	}
+}
+function on(deps, fn, options) {
+	const isArray = Array.isArray(deps);
+	let prevInput;
+	let defer = options && options.defer;
+	return (prevValue) => {
+		let input;
+		if (isArray) {
+			input = Array(deps.length);
+			for (let i = 0; i < deps.length; i++) input[i] = deps[i]();
+		} else input = deps();
+		if (defer) {
+			defer = false;
+			return prevValue;
+		}
+		const result = untrack(() => fn(input, prevInput, prevValue));
+		prevInput = input;
+		return result;
+	};
+}
+function onMount(fn) {
+	createEffect(() => untrack(fn));
+}
+function onCleanup(fn) {
+	if (Owner === null);
+	else if (Owner.cleanups === null) Owner.cleanups = [fn];
+	else Owner.cleanups.push(fn);
+	return fn;
+}
+function getListener() {
+	return Listener;
+}
+function runWithOwner(o, fn) {
+	const prev = Owner;
+	const prevListener = Listener;
+	Owner = o;
+	Listener = null;
+	try {
+		return runUpdates(fn, true);
+	} catch (err) {
+		handleError(err);
+	} finally {
+		Owner = prev;
+		Listener = prevListener;
+	}
+}
+function startTransition(fn) {
+	if (Transition && Transition.running) {
+		fn();
+		return Transition.done;
+	}
+	const l = Listener;
+	const o = Owner;
+	return Promise.resolve().then(() => {
+		Listener = l;
+		Owner = o;
+		let t;
+		if (Scheduler || SuspenseContext) {
+			t = Transition || (Transition = {
+				sources: /* @__PURE__ */ new Set(),
+				effects: [],
+				promises: /* @__PURE__ */ new Set(),
+				disposed: /* @__PURE__ */ new Set(),
+				queue: /* @__PURE__ */ new Set(),
+				running: true
+			});
+			t.done || (t.done = new Promise((res) => t.resolve = res));
+			t.running = true;
+		}
+		runUpdates(fn, false);
+		Listener = Owner = null;
+		return t ? t.done : void 0;
+	});
+}
+const [transPending, setTransPending] = /* @__PURE__ */ createSignal(false);
+function useContext(context) {
+	let value;
+	return Owner && Owner.context && (value = Owner.context[context.id]) !== void 0 ? value : context.defaultValue;
+}
+let SuspenseContext;
+function readSignal() {
+	const runningTransition = Transition && Transition.running;
+	if (this.sources && (runningTransition ? this.tState : this.state)) if ((runningTransition ? this.tState : this.state) === STALE) updateComputation(this);
+	else {
+		const updates = Updates;
+		Updates = null;
+		runUpdates(() => lookUpstream(this), false);
+		Updates = updates;
+	}
+	if (Listener) {
+		const sSlot = this.observers ? this.observers.length : 0;
+		if (!Listener.sources) {
+			Listener.sources = [this];
+			Listener.sourceSlots = [sSlot];
+		} else {
+			Listener.sources.push(this);
+			Listener.sourceSlots.push(sSlot);
+		}
+		if (!this.observers) {
+			this.observers = [Listener];
+			this.observerSlots = [Listener.sources.length - 1];
+		} else {
+			this.observers.push(Listener);
+			this.observerSlots.push(Listener.sources.length - 1);
+		}
+	}
+	if (runningTransition && Transition.sources.has(this)) return this.tValue;
+	return this.value;
+}
+function writeSignal(node, value, isComp) {
+	let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
+	if (!node.comparator || !node.comparator(current, value)) {
+		if (Transition) {
+			const TransitionRunning = Transition.running;
+			if (TransitionRunning || !isComp && Transition.sources.has(node)) {
+				Transition.sources.add(node);
+				node.tValue = value;
+			}
+			if (!TransitionRunning) node.value = value;
+		} else node.value = value;
+		if (node.observers && node.observers.length) runUpdates(() => {
+			for (let i = 0; i < node.observers.length; i += 1) {
+				const o = node.observers[i];
+				const TransitionRunning = Transition && Transition.running;
+				if (TransitionRunning && Transition.disposed.has(o)) continue;
+				if (TransitionRunning ? !o.tState : !o.state) {
+					if (o.pure) Updates.push(o);
+					else Effects.push(o);
+					if (o.observers) markDownstream(o);
+				}
+				if (!TransitionRunning) o.state = STALE;
+				else o.tState = STALE;
+			}
+			if (Updates.length > 1e6) {
+				Updates = [];
+				throw new Error();
+			}
+		}, false);
+	}
+	return value;
+}
+function updateComputation(node) {
+	if (!node.fn) return;
+	cleanNode(node);
+	const time = ExecCount;
+	runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
+	if (Transition && !Transition.running && Transition.sources.has(node)) queueMicrotask(() => {
+		runUpdates(() => {
+			Transition && (Transition.running = true);
+			Listener = Owner = node;
+			runComputation(node, node.tValue, time);
+			Listener = Owner = null;
+		}, false);
+	});
+}
+function runComputation(node, value, time) {
+	let nextValue;
+	const owner = Owner, listener = Listener;
+	Listener = Owner = node;
+	try {
+		nextValue = node.fn(value);
+	} catch (err) {
+		if (node.pure) if (Transition && Transition.running) {
+			node.tState = STALE;
+			node.tOwned && node.tOwned.forEach(cleanNode);
+			node.tOwned = void 0;
+		} else {
+			node.state = STALE;
+			node.owned && node.owned.forEach(cleanNode);
+			node.owned = null;
+		}
+		node.updatedAt = time + 1;
+		return handleError(err);
+	} finally {
+		Listener = listener;
+		Owner = owner;
+	}
+	if (!node.updatedAt || node.updatedAt <= time) {
+		if (node.updatedAt != null && "observers" in node) writeSignal(node, nextValue, true);
+		else if (Transition && Transition.running && node.pure) {
+			Transition.sources.add(node);
+			node.tValue = nextValue;
+		} else node.value = nextValue;
+		node.updatedAt = time;
+	}
+}
+function createComputation(fn, init, pure, state = STALE, options) {
+	const c = {
+		fn,
+		state,
+		updatedAt: null,
+		owned: null,
+		sources: null,
+		sourceSlots: null,
+		cleanups: null,
+		value: init,
+		owner: Owner,
+		context: Owner ? Owner.context : null,
+		pure
+	};
+	if (Transition && Transition.running) {
+		c.state = 0;
+		c.tState = state;
+	}
+	if (Owner === null);
+	else if (Owner !== UNOWNED) if (Transition && Transition.running && Owner.pure) if (!Owner.tOwned) Owner.tOwned = [c];
+	else Owner.tOwned.push(c);
+	else if (!Owner.owned) Owner.owned = [c];
+	else Owner.owned.push(c);
+	if (ExternalSourceConfig && c.fn) {
+		const [track, trigger] = createSignal(void 0, { equals: false });
+		const ordinary = ExternalSourceConfig.factory(c.fn, trigger);
+		onCleanup(() => ordinary.dispose());
+		const triggerInTransition = () => startTransition(trigger).then(() => inTransition.dispose());
+		const inTransition = ExternalSourceConfig.factory(c.fn, triggerInTransition);
+		c.fn = (x) => {
+			track();
+			return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
+		};
+	}
+	return c;
+}
+function runTop(node) {
+	const runningTransition = Transition && Transition.running;
+	if ((runningTransition ? node.tState : node.state) === 0) return;
+	if ((runningTransition ? node.tState : node.state) === PENDING) return lookUpstream(node);
+	if (node.suspense && untrack(node.suspense.inFallback)) return node.suspense.effects.push(node);
+	const ancestors = [node];
+	while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
+		if (runningTransition && Transition.disposed.has(node)) return;
+		if (runningTransition ? node.tState : node.state) ancestors.push(node);
+	}
+	for (let i = ancestors.length - 1; i >= 0; i--) {
+		node = ancestors[i];
+		if (runningTransition) {
+			let top = node, prev = ancestors[i + 1];
+			while ((top = top.owner) && top !== prev) if (Transition.disposed.has(top)) return;
+		}
+		if ((runningTransition ? node.tState : node.state) === STALE) updateComputation(node);
+		else if ((runningTransition ? node.tState : node.state) === PENDING) {
+			const updates = Updates;
+			Updates = null;
+			runUpdates(() => lookUpstream(node, ancestors[0]), false);
+			Updates = updates;
+		}
+	}
+}
+function runUpdates(fn, init) {
+	if (Updates) return fn();
+	let wait = false;
+	if (!init) Updates = [];
+	if (Effects) wait = true;
+	else Effects = [];
+	ExecCount++;
+	try {
+		const res = fn();
+		completeUpdates(wait);
+		return res;
+	} catch (err) {
+		if (!wait) Effects = null;
+		Updates = null;
+		handleError(err);
+	}
+}
+function completeUpdates(wait) {
+	if (Updates) {
+		if (Scheduler && Transition && Transition.running) scheduleQueue(Updates);
+		else runQueue(Updates);
+		Updates = null;
+	}
+	if (wait) return;
+	let res;
+	if (Transition) {
+		if (!Transition.promises.size && !Transition.queue.size) {
+			const sources = Transition.sources;
+			const disposed = Transition.disposed;
+			Effects.push.apply(Effects, Transition.effects);
+			res = Transition.resolve;
+			for (const e of Effects) {
+				"tState" in e && (e.state = e.tState);
+				delete e.tState;
+			}
+			Transition = null;
+			runUpdates(() => {
+				for (const d of disposed) cleanNode(d);
+				for (const v of sources) {
+					v.value = v.tValue;
+					if (v.owned) for (let i = 0, len = v.owned.length; i < len; i++) cleanNode(v.owned[i]);
+					if (v.tOwned) v.owned = v.tOwned;
+					delete v.tValue;
+					delete v.tOwned;
+					v.tState = 0;
+				}
+				setTransPending(false);
+			}, false);
+		} else if (Transition.running) {
+			Transition.running = false;
+			Transition.effects.push.apply(Transition.effects, Effects);
+			Effects = null;
+			setTransPending(true);
+			return;
+		}
+	}
+	const e = Effects;
+	Effects = null;
+	if (e.length) runUpdates(() => runEffects(e), false);
+	if (res) res();
+}
+function runQueue(queue) {
+	for (let i = 0; i < queue.length; i++) runTop(queue[i]);
+}
+function scheduleQueue(queue) {
+	for (let i = 0; i < queue.length; i++) {
+		const item = queue[i];
+		const tasks = Transition.queue;
+		if (!tasks.has(item)) {
+			tasks.add(item);
+			Scheduler(() => {
+				tasks.delete(item);
+				runUpdates(() => {
+					Transition.running = true;
+					runTop(item);
+				}, false);
+				Transition && (Transition.running = false);
+			});
+		}
+	}
+}
+function runUserEffects(queue) {
+	let i, userLength = 0;
+	for (i = 0; i < queue.length; i++) {
+		const e = queue[i];
+		if (!e.user) runTop(e);
+		else queue[userLength++] = e;
+	}
+	if (sharedConfig.context) {
+		if (sharedConfig.count) {
+			sharedConfig.effects || (sharedConfig.effects = []);
+			sharedConfig.effects.push(...queue.slice(0, userLength));
+			return;
+		}
+		setHydrateContext();
+	}
+	if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
+		queue = [...sharedConfig.effects, ...queue];
+		userLength += sharedConfig.effects.length;
+		delete sharedConfig.effects;
+	}
+	for (i = 0; i < userLength; i++) runTop(queue[i]);
+}
+function lookUpstream(node, ignore) {
+	const runningTransition = Transition && Transition.running;
+	if (runningTransition) node.tState = 0;
+	else node.state = 0;
+	for (let i = 0; i < node.sources.length; i += 1) {
+		const source = node.sources[i];
+		if (source.sources) {
+			const state = runningTransition ? source.tState : source.state;
+			if (state === STALE) {
+				if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount)) runTop(source);
+			} else if (state === PENDING) lookUpstream(source, ignore);
+		}
+	}
+}
+function markDownstream(node) {
+	const runningTransition = Transition && Transition.running;
+	for (let i = 0; i < node.observers.length; i += 1) {
+		const o = node.observers[i];
+		if (runningTransition ? !o.tState : !o.state) {
+			if (runningTransition) o.tState = PENDING;
+			else o.state = PENDING;
+			if (o.pure) Updates.push(o);
+			else Effects.push(o);
+			o.observers && markDownstream(o);
+		}
+	}
+}
+function cleanNode(node) {
+	let i;
+	if (node.sources) while (node.sources.length) {
+		const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
+		if (obs && obs.length) {
+			const n = obs.pop(), s = source.observerSlots.pop();
+			if (index < obs.length) {
+				n.sourceSlots[s] = index;
+				obs[index] = n;
+				source.observerSlots[index] = s;
+			}
+		}
+	}
+	if (node.tOwned) {
+		for (i = node.tOwned.length - 1; i >= 0; i--) cleanNode(node.tOwned[i]);
+		delete node.tOwned;
+	}
+	if (Transition && Transition.running && node.pure) reset(node, true);
+	else if (node.owned) {
+		for (i = node.owned.length - 1; i >= 0; i--) cleanNode(node.owned[i]);
+		node.owned = null;
+	}
+	if (node.cleanups) {
+		for (i = node.cleanups.length - 1; i >= 0; i--) node.cleanups[i]();
+		node.cleanups = null;
+	}
+	if (Transition && Transition.running) node.tState = 0;
+	else node.state = 0;
+}
+function reset(node, top) {
+	if (!top) {
+		node.tState = 0;
+		Transition.disposed.add(node);
+	}
+	if (node.owned) for (let i = 0; i < node.owned.length; i++) reset(node.owned[i]);
+}
+function castError(err) {
+	if (err instanceof Error) return err;
+	return new Error(typeof err === "string" ? err : "Unknown error", { cause: err });
+}
+function runErrors(err, fns, owner) {
+	try {
+		for (const f of fns) f(err);
+	} catch (e) {
+		handleError(e, owner && owner.owner || null);
+	}
+}
+function handleError(err, owner = Owner) {
+	const fns = ERROR && owner && owner.context && owner.context[ERROR];
+	const error = castError(err);
+	if (!fns) throw error;
+	if (Effects) Effects.push({
+		fn() {
+			runErrors(error, fns, owner);
+		},
+		state: STALE
+	});
+	else runErrors(error, fns, owner);
+}
+const FALLBACK = Symbol("fallback");
+function dispose(d) {
+	for (let i = 0; i < d.length; i++) d[i]();
+}
+function mapArray(list, mapFn, options = {}) {
+	let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
+	onCleanup(() => dispose(disposers));
+	return () => {
+		let newItems = list() || [], newLen = newItems.length, i, j;
+		newItems[$TRACK];
+		return untrack(() => {
+			let newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
+			if (newLen === 0) {
+				if (len !== 0) {
+					dispose(disposers);
+					disposers = [];
+					items = [];
+					mapped = [];
+					len = 0;
+					indexes && (indexes = []);
+				}
+				if (options.fallback) {
+					items = [FALLBACK];
+					mapped[0] = createRoot((disposer) => {
+						disposers[0] = disposer;
+						return options.fallback();
+					});
+					len = 1;
+				}
+			} else if (len === 0) {
+				mapped = new Array(newLen);
+				for (j = 0; j < newLen; j++) {
+					items[j] = newItems[j];
+					mapped[j] = createRoot(mapper);
+				}
+				len = newLen;
+			} else {
+				temp = new Array(newLen);
+				tempdisposers = new Array(newLen);
+				indexes && (tempIndexes = new Array(newLen));
+				for (start = 0, end = Math.min(len, newLen); start < end && items[start] === newItems[start]; start++);
+				for (end = len - 1, newEnd = newLen - 1; end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
+					temp[newEnd] = mapped[end];
+					tempdisposers[newEnd] = disposers[end];
+					indexes && (tempIndexes[newEnd] = indexes[end]);
+				}
+				newIndices = /* @__PURE__ */ new Map();
+				newIndicesNext = new Array(newEnd + 1);
+				for (j = newEnd; j >= start; j--) {
+					item = newItems[j];
+					i = newIndices.get(item);
+					newIndicesNext[j] = i === void 0 ? -1 : i;
+					newIndices.set(item, j);
+				}
+				for (i = start; i <= end; i++) {
+					item = items[i];
+					j = newIndices.get(item);
+					if (j !== void 0 && j !== -1) {
+						temp[j] = mapped[i];
+						tempdisposers[j] = disposers[i];
+						indexes && (tempIndexes[j] = indexes[i]);
+						j = newIndicesNext[j];
+						newIndices.set(item, j);
+					} else disposers[i]();
+				}
+				for (j = start; j < newLen; j++) if (j in temp) {
+					mapped[j] = temp[j];
+					disposers[j] = tempdisposers[j];
+					if (indexes) {
+						indexes[j] = tempIndexes[j];
+						indexes[j](j);
+					}
+				} else mapped[j] = createRoot(mapper);
+				mapped = mapped.slice(0, len = newLen);
+				items = newItems.slice(0);
+			}
+			return mapped;
+		});
+		function mapper(disposer) {
+			disposers[j] = disposer;
+			if (indexes) {
+				const [s, set] = createSignal(j);
+				indexes[j] = set;
+				return mapFn(newItems[j], s);
+			}
+			return mapFn(newItems[j]);
+		}
+	};
+}
+function indexArray(list, mapFn, options = {}) {
+	let items = [], mapped = [], disposers = [], signals = [], len = 0, i;
+	onCleanup(() => dispose(disposers));
+	return () => {
+		const newItems = list() || [], newLen = newItems.length;
+		newItems[$TRACK];
+		return untrack(() => {
+			if (newLen === 0) {
+				if (len !== 0) {
+					dispose(disposers);
+					disposers = [];
+					items = [];
+					mapped = [];
+					len = 0;
+					signals = [];
+				}
+				if (options.fallback) {
+					items = [FALLBACK];
+					mapped[0] = createRoot((disposer) => {
+						disposers[0] = disposer;
+						return options.fallback();
+					});
+					len = 1;
+				}
+				return mapped;
+			}
+			if (items[0] === FALLBACK) {
+				disposers[0]();
+				disposers = [];
+				items = [];
+				mapped = [];
+				len = 0;
+			}
+			for (i = 0; i < newLen; i++) if (i < items.length && items[i] !== newItems[i]) signals[i](() => newItems[i]);
+			else if (i >= items.length) mapped[i] = createRoot(mapper);
+			for (; i < items.length; i++) disposers[i]();
+			len = signals.length = disposers.length = newLen;
+			items = newItems.slice(0);
+			return mapped = mapped.slice(0, len);
+		});
+		function mapper(disposer) {
+			disposers[i] = disposer;
+			const [s, set] = createSignal(newItems[i]);
+			signals[i] = set;
+			return mapFn(s, i);
+		}
+	};
+}
+let hydrationEnabled = false;
+function createComponent(Comp, props) {
+	if (hydrationEnabled) {
+		if (sharedConfig.context) {
+			const c = sharedConfig.context;
+			setHydrateContext(nextHydrateContext());
+			const r = untrack(() => Comp(props || {}));
+			setHydrateContext(c);
+			return r;
+		}
+	}
+	return untrack(() => Comp(props || {}));
+}
+function trueFn() {
+	return true;
+}
+const propTraps = {
+	get(_, property, receiver) {
+		if (property === $PROXY) return receiver;
+		return _.get(property);
+	},
+	has(_, property) {
+		if (property === $PROXY) return true;
+		return _.has(property);
+	},
+	set: trueFn,
+	deleteProperty: trueFn,
+	getOwnPropertyDescriptor(_, property) {
+		return {
+			configurable: true,
+			enumerable: true,
+			get() {
+				return _.get(property);
+			},
+			set: trueFn,
+			deleteProperty: trueFn
+		};
+	},
+	ownKeys(_) {
+		return _.keys();
+	}
+};
+function resolveSource(s) {
+	return !(s = typeof s === "function" ? s() : s) ? {} : s;
+}
+function resolveSources() {
+	for (let i = 0, length = this.length; i < length; ++i) {
+		const v = this[i]();
+		if (v !== void 0) return v;
+	}
+}
+function mergeProps(...sources) {
+	let proxy = false;
+	for (let i = 0; i < sources.length; i++) {
+		const s = sources[i];
+		proxy = proxy || !!s && $PROXY in s;
+		sources[i] = typeof s === "function" ? (proxy = true, createMemo(s)) : s;
+	}
+	if (SUPPORTS_PROXY && proxy) return new Proxy({
+		get(property) {
+			for (let i = sources.length - 1; i >= 0; i--) {
+				const v = resolveSource(sources[i])[property];
+				if (v !== void 0) return v;
+			}
+		},
+		has(property) {
+			for (let i = sources.length - 1; i >= 0; i--) if (property in resolveSource(sources[i])) return true;
+			return false;
+		},
+		keys() {
+			const keys = [];
+			for (let i = 0; i < sources.length; i++) keys.push(...Object.keys(resolveSource(sources[i])));
+			return [...new Set(keys)];
+		}
+	}, propTraps);
+	const sourcesMap = {};
+	const defined = Object.create(null);
+	for (let i = sources.length - 1; i >= 0; i--) {
+		const source = sources[i];
+		if (!source) continue;
+		const sourceKeys = Object.getOwnPropertyNames(source);
+		for (let i = sourceKeys.length - 1; i >= 0; i--) {
+			const key = sourceKeys[i];
+			if (key === "__proto__" || key === "constructor") continue;
+			const desc = Object.getOwnPropertyDescriptor(source, key);
+			if (!defined[key]) defined[key] = desc.get ? {
+				enumerable: true,
+				configurable: true,
+				get: resolveSources.bind(sourcesMap[key] = [desc.get.bind(source)])
+			} : desc.value !== void 0 ? desc : void 0;
+			else {
+				const sources = sourcesMap[key];
+				if (sources) {
+					if (desc.get) sources.push(desc.get.bind(source));
+					else if (desc.value !== void 0) sources.push(() => desc.value);
+				}
+			}
+		}
+	}
+	const target = {};
+	const definedKeys = Object.keys(defined);
+	for (let i = definedKeys.length - 1; i >= 0; i--) {
+		const key = definedKeys[i], desc = defined[key];
+		if (desc && desc.get) Object.defineProperty(target, key, desc);
+		else target[key] = desc ? desc.value : void 0;
+	}
+	return target;
+}
+const narrowedError = (name) => `Stale read from <${name}>.`;
+function For(props) {
+	const fallback = "fallback" in props && { fallback: () => props.fallback };
+	return createMemo(mapArray(() => props.each, props.children, fallback || void 0));
+}
+function Index(props) {
+	const fallback = "fallback" in props && { fallback: () => props.fallback };
+	return createMemo(indexArray(() => props.each, props.children, fallback || void 0));
+}
+function Show(props) {
+	const keyed = props.keyed;
+	const conditionValue = createMemo(() => props.when, void 0, void 0);
+	const condition = keyed ? conditionValue : createMemo(conditionValue, void 0, { equals: (a, b) => !a === !b });
+	return createMemo(() => {
+		const c = condition();
+		if (c) {
+			const child = props.children;
+			return typeof child === "function" && child.length > 0 ? untrack(() => child(keyed ? c : () => {
+				if (!untrack(condition)) throw narrowedError("Show");
+				return conditionValue();
+			})) : child;
+		}
+		return props.fallback;
+	}, void 0, void 0);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/solid-js@1.9.10/node_modules/solid-js/web/dist/web.js
+const Properties = /* @__PURE__ */ new Set([
+	"className",
+	"value",
+	"readOnly",
+	"noValidate",
+	"formNoValidate",
+	"isMap",
+	"noModule",
+	"playsInline",
+	"adAuctionHeaders",
+	"allowFullscreen",
+	"browsingTopics",
+	"defaultChecked",
+	"defaultMuted",
+	"defaultSelected",
+	"disablePictureInPicture",
+	"disableRemotePlayback",
+	"preservesPitch",
+	"shadowRootClonable",
+	"shadowRootCustomElementRegistry",
+	"shadowRootDelegatesFocus",
+	"shadowRootSerializable",
+	"sharedStorageWritable",
+	...[
+		"allowfullscreen",
+		"async",
+		"alpha",
+		"autofocus",
+		"autoplay",
+		"checked",
+		"controls",
+		"default",
+		"disabled",
+		"formnovalidate",
+		"hidden",
+		"indeterminate",
+		"inert",
+		"ismap",
+		"loop",
+		"multiple",
+		"muted",
+		"nomodule",
+		"novalidate",
+		"open",
+		"playsinline",
+		"readonly",
+		"required",
+		"reversed",
+		"seamless",
+		"selected",
+		"adauctionheaders",
+		"browsingtopics",
+		"credentialless",
+		"defaultchecked",
+		"defaultmuted",
+		"defaultselected",
+		"defer",
+		"disablepictureinpicture",
+		"disableremoteplayback",
+		"preservespitch",
+		"shadowrootclonable",
+		"shadowrootcustomelementregistry",
+		"shadowrootdelegatesfocus",
+		"shadowrootserializable",
+		"sharedstoragewritable"
+	]
+]);
+const ChildProperties = /* @__PURE__ */ new Set([
+	"innerHTML",
+	"textContent",
+	"innerText",
+	"children"
+]);
+const Aliases = /* @__PURE__ */ Object.assign(Object.create(null), {
+	className: "class",
+	htmlFor: "for"
+});
+const PropAliases = /* @__PURE__ */ Object.assign(Object.create(null), {
+	class: "className",
+	novalidate: {
+		$: "noValidate",
+		FORM: 1
+	},
+	formnovalidate: {
+		$: "formNoValidate",
+		BUTTON: 1,
+		INPUT: 1
+	},
+	ismap: {
+		$: "isMap",
+		IMG: 1
+	},
+	nomodule: {
+		$: "noModule",
+		SCRIPT: 1
+	},
+	playsinline: {
+		$: "playsInline",
+		VIDEO: 1
+	},
+	readonly: {
+		$: "readOnly",
+		INPUT: 1,
+		TEXTAREA: 1
+	},
+	adauctionheaders: {
+		$: "adAuctionHeaders",
+		IFRAME: 1
+	},
+	allowfullscreen: {
+		$: "allowFullscreen",
+		IFRAME: 1
+	},
+	browsingtopics: {
+		$: "browsingTopics",
+		IMG: 1
+	},
+	defaultchecked: {
+		$: "defaultChecked",
+		INPUT: 1
+	},
+	defaultmuted: {
+		$: "defaultMuted",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	defaultselected: {
+		$: "defaultSelected",
+		OPTION: 1
+	},
+	disablepictureinpicture: {
+		$: "disablePictureInPicture",
+		VIDEO: 1
+	},
+	disableremoteplayback: {
+		$: "disableRemotePlayback",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	preservespitch: {
+		$: "preservesPitch",
+		AUDIO: 1,
+		VIDEO: 1
+	},
+	shadowrootclonable: {
+		$: "shadowRootClonable",
+		TEMPLATE: 1
+	},
+	shadowrootdelegatesfocus: {
+		$: "shadowRootDelegatesFocus",
+		TEMPLATE: 1
+	},
+	shadowrootserializable: {
+		$: "shadowRootSerializable",
+		TEMPLATE: 1
+	},
+	sharedstoragewritable: {
+		$: "sharedStorageWritable",
+		IFRAME: 1,
+		IMG: 1
+	}
+});
+function getPropAlias(prop, tagName) {
+	const a = PropAliases[prop];
+	return typeof a === "object" ? a[tagName] ? a["$"] : void 0 : a;
+}
+const DelegatedEvents = /* @__PURE__ */ new Set([
+	"beforeinput",
+	"click",
+	"dblclick",
+	"contextmenu",
+	"focusin",
+	"focusout",
+	"input",
+	"keydown",
+	"keyup",
+	"mousedown",
+	"mousemove",
+	"mouseout",
+	"mouseover",
+	"mouseup",
+	"pointerdown",
+	"pointermove",
+	"pointerout",
+	"pointerover",
+	"pointerup",
+	"touchend",
+	"touchmove",
+	"touchstart"
+]);
+const SVGNamespace = {
+	xlink: "http://www.w3.org/1999/xlink",
+	xml: "http://www.w3.org/XML/1998/namespace"
+};
+const memo = (fn) => createMemo(() => fn());
+function reconcileArrays(parentNode, a, b) {
+	let bLength = b.length, aEnd = a.length, bEnd = bLength, aStart = 0, bStart = 0, after = a[aEnd - 1].nextSibling, map = null;
+	while (aStart < aEnd || bStart < bEnd) {
+		if (a[aStart] === b[bStart]) {
+			aStart++;
+			bStart++;
+			continue;
+		}
+		while (a[aEnd - 1] === b[bEnd - 1]) {
+			aEnd--;
+			bEnd--;
+		}
+		if (aEnd === aStart) {
+			const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart] : after;
+			while (bStart < bEnd) parentNode.insertBefore(b[bStart++], node);
+		} else if (bEnd === bStart) while (aStart < aEnd) {
+			if (!map || !map.has(a[aStart])) a[aStart].remove();
+			aStart++;
+		}
+		else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
+			const node = a[--aEnd].nextSibling;
+			parentNode.insertBefore(b[bStart++], a[aStart++].nextSibling);
+			parentNode.insertBefore(b[--bEnd], node);
+			a[aEnd] = b[bEnd];
+		} else {
+			if (!map) {
+				map = /* @__PURE__ */ new Map();
+				let i = bStart;
+				while (i < bEnd) map.set(b[i], i++);
+			}
+			const index = map.get(a[aStart]);
+			if (index != null) if (bStart < index && index < bEnd) {
+				let i = aStart, sequence = 1, t;
+				while (++i < aEnd && i < bEnd) {
+					if ((t = map.get(a[i])) == null || t !== index + sequence) break;
+					sequence++;
+				}
+				if (sequence > index - bStart) {
+					const node = a[aStart];
+					while (bStart < index) parentNode.insertBefore(b[bStart++], node);
+				} else parentNode.replaceChild(b[bStart++], a[aStart++]);
+			} else aStart++;
+			else a[aStart++].remove();
+		}
+	}
+}
+const $$EVENTS = "_$DX_DELEGATE";
+function render(code, element, init, options = {}) {
+	let disposer;
+	createRoot((dispose) => {
+		disposer = dispose;
+		element === document ? code() : insert(element, code(), element.firstChild ? null : void 0, init);
+	}, options.owner);
+	return () => {
+		disposer();
+		element.textContent = "";
+	};
+}
+function template(html, isImportNode, isSVG, isMathML) {
+	let node;
+	const create = () => {
+		const t = isMathML ? document.createElementNS("http://www.w3.org/1998/Math/MathML", "template") : document.createElement("template");
+		t.innerHTML = html;
+		return isSVG ? t.content.firstChild.firstChild : isMathML ? t.firstChild : t.content.firstChild;
+	};
+	const fn = isImportNode ? () => untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
+	fn.cloneNode = fn;
+	return fn;
+}
+function delegateEvents(eventNames, document = window.document) {
+	const e = document[$$EVENTS] || (document[$$EVENTS] = /* @__PURE__ */ new Set());
+	for (let i = 0, l = eventNames.length; i < l; i++) {
+		const name = eventNames[i];
+		if (!e.has(name)) {
+			e.add(name);
+			document.addEventListener(name, eventHandler);
+		}
+	}
+}
+function setAttribute(node, name, value) {
+	if (isHydrating(node)) return;
+	if (value == null) node.removeAttribute(name);
+	else node.setAttribute(name, value);
+}
+function setAttributeNS(node, namespace, name, value) {
+	if (isHydrating(node)) return;
+	if (value == null) node.removeAttributeNS(namespace, name);
+	else node.setAttributeNS(namespace, name, value);
+}
+function setBoolAttribute(node, name, value) {
+	if (isHydrating(node)) return;
+	value ? node.setAttribute(name, "") : node.removeAttribute(name);
+}
+function className(node, value) {
+	if (isHydrating(node)) return;
+	if (value == null) node.removeAttribute("class");
+	else node.className = value;
+}
+function addEventListener(node, name, handler, delegate) {
+	if (delegate) if (Array.isArray(handler)) {
+		node[`$$${name}`] = handler[0];
+		node[`$$${name}Data`] = handler[1];
+	} else node[`$$${name}`] = handler;
+	else if (Array.isArray(handler)) {
+		const handlerFn = handler[0];
+		node.addEventListener(name, handler[0] = (e) => handlerFn.call(node, handler[1], e));
+	} else node.addEventListener(name, handler, typeof handler !== "function" && handler);
+}
+function classList(node, value, prev = {}) {
+	const classKeys = Object.keys(value || {}), prevKeys = Object.keys(prev);
+	let i, len;
+	for (i = 0, len = prevKeys.length; i < len; i++) {
+		const key = prevKeys[i];
+		if (!key || key === "undefined" || value[key]) continue;
+		toggleClassKey(node, key, false);
+		delete prev[key];
+	}
+	for (i = 0, len = classKeys.length; i < len; i++) {
+		const key = classKeys[i], classValue = !!value[key];
+		if (!key || key === "undefined" || prev[key] === classValue || !classValue) continue;
+		toggleClassKey(node, key, true);
+		prev[key] = classValue;
+	}
+	return prev;
+}
+function style(node, value, prev) {
+	if (!value) return prev ? setAttribute(node, "style") : value;
+	const nodeStyle = node.style;
+	if (typeof value === "string") return nodeStyle.cssText = value;
+	typeof prev === "string" && (nodeStyle.cssText = prev = void 0);
+	prev || (prev = {});
+	value || (value = {});
+	let v, s;
+	for (s in prev) {
+		value[s] ?? nodeStyle.removeProperty(s);
+		delete prev[s];
+	}
+	for (s in value) {
+		v = value[s];
+		if (v !== prev[s]) {
+			nodeStyle.setProperty(s, v);
+			prev[s] = v;
+		}
+	}
+	return prev;
+}
+function setStyleProperty(node, name, value) {
+	value != null ? node.style.setProperty(name, value) : node.style.removeProperty(name);
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+	const prevProps = {};
+	if (!skipChildren) createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children));
+	createRenderEffect(() => typeof props.ref === "function" && use(props.ref, node));
+	createRenderEffect(() => assign(node, props, isSVG, true, prevProps, true));
+	return prevProps;
+}
+function use(fn, element, arg) {
+	return untrack(() => fn(element, arg));
+}
+function insert(parent, accessor, marker, initial) {
+	if (marker !== void 0 && !initial) initial = [];
+	if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
+	createRenderEffect((current) => insertExpression(parent, accessor(), current, marker), initial);
+}
+function assign(node, props, isSVG, skipChildren, prevProps = {}, skipRef = false) {
+	props || (props = {});
+	for (const prop in prevProps) if (!(prop in props)) {
+		if (prop === "children") continue;
+		prevProps[prop] = assignProp(node, prop, null, prevProps[prop], isSVG, skipRef, props);
+	}
+	for (const prop in props) {
+		if (prop === "children") {
+			if (!skipChildren) insertExpression(node, props.children);
+			continue;
+		}
+		const value = props[prop];
+		prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG, skipRef, props);
+	}
+}
+function isHydrating(node) {
+	return !!sharedConfig.context && !sharedConfig.done && (!node || node.isConnected);
+}
+function toPropertyName(name) {
+	return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
+}
+function toggleClassKey(node, key, value) {
+	const classNames = key.trim().split(/\s+/);
+	for (let i = 0, nameLen = classNames.length; i < nameLen; i++) node.classList.toggle(classNames[i], value);
+}
+function assignProp(node, prop, value, prev, isSVG, skipRef, props) {
+	let isCE, isProp, isChildProp, propAlias, forceProp;
+	if (prop === "style") return style(node, value, prev);
+	if (prop === "classList") return classList(node, value, prev);
+	if (value === prev) return prev;
+	if (prop === "ref") {
+		if (!skipRef) value(node);
+	} else if (prop.slice(0, 3) === "on:") {
+		const e = prop.slice(3);
+		prev && node.removeEventListener(e, prev, typeof prev !== "function" && prev);
+		value && node.addEventListener(e, value, typeof value !== "function" && value);
+	} else if (prop.slice(0, 10) === "oncapture:") {
+		const e = prop.slice(10);
+		prev && node.removeEventListener(e, prev, true);
+		value && node.addEventListener(e, value, true);
+	} else if (prop.slice(0, 2) === "on") {
+		const name = prop.slice(2).toLowerCase();
+		const delegate = DelegatedEvents.has(name);
+		if (!delegate && prev) {
+			const h = Array.isArray(prev) ? prev[0] : prev;
+			node.removeEventListener(name, h);
+		}
+		if (delegate || value) {
+			addEventListener(node, name, value, delegate);
+			delegate && delegateEvents([name]);
+		}
+	} else if (prop.slice(0, 5) === "attr:") setAttribute(node, prop.slice(5), value);
+	else if (prop.slice(0, 5) === "bool:") setBoolAttribute(node, prop.slice(5), value);
+	else if ((forceProp = prop.slice(0, 5) === "prop:") || (isChildProp = ChildProperties.has(prop)) || !isSVG && ((propAlias = getPropAlias(prop, node.tagName)) || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-") || "is" in props)) {
+		if (forceProp) {
+			prop = prop.slice(5);
+			isProp = true;
+		} else if (isHydrating(node)) return value;
+		if (prop === "class" || prop === "className") className(node, value);
+		else if (isCE && !isProp && !isChildProp) node[toPropertyName(prop)] = value;
+		else node[propAlias || prop] = value;
+	} else {
+		const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]];
+		if (ns) setAttributeNS(node, ns, prop, value);
+		else setAttribute(node, Aliases[prop] || prop, value);
+	}
+	return value;
+}
+function eventHandler(e) {
+	if (sharedConfig.registry && sharedConfig.events) {
+		if (sharedConfig.events.find(([el, ev]) => ev === e)) return;
+	}
+	let node = e.target;
+	const key = `$$${e.type}`;
+	const oriTarget = e.target;
+	const oriCurrentTarget = e.currentTarget;
+	const retarget = (value) => Object.defineProperty(e, "target", {
+		configurable: true,
+		value
+	});
+	const handleNode = () => {
+		const handler = node[key];
+		if (handler && !node.disabled) {
+			const data = node[`${key}Data`];
+			data !== void 0 ? handler.call(node, data, e) : handler.call(node, e);
+			if (e.cancelBubble) return;
+		}
+		node.host && typeof node.host !== "string" && !node.host._$host && node.contains(e.target) && retarget(node.host);
+		return true;
+	};
+	const walkUpTree = () => {
+		while (handleNode() && (node = node._$host || node.parentNode || node.host));
+	};
+	Object.defineProperty(e, "currentTarget", {
+		configurable: true,
+		get() {
+			return node || document;
+		}
+	});
+	if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = _$HY.done = true;
+	if (e.composedPath) {
+		const path = e.composedPath();
+		retarget(path[0]);
+		for (let i = 0; i < path.length - 2; i++) {
+			node = path[i];
+			if (!handleNode()) break;
+			if (node._$host) {
+				node = node._$host;
+				walkUpTree();
+				break;
+			}
+			if (node.parentNode === oriCurrentTarget) break;
+		}
+	} else walkUpTree();
+	retarget(oriTarget);
+}
+function insertExpression(parent, value, current, marker, unwrapArray) {
+	const hydrating = isHydrating(parent);
+	if (hydrating) {
+		!current && (current = [...parent.childNodes]);
+		let cleaned = [];
+		for (let i = 0; i < current.length; i++) {
+			const node = current[i];
+			if (node.nodeType === 8 && node.data.slice(0, 2) === "!$") node.remove();
+			else cleaned.push(node);
+		}
+		current = cleaned;
+	}
+	while (typeof current === "function") current = current();
+	if (value === current) return current;
+	const t = typeof value, multi = marker !== void 0;
+	parent = multi && current[0] && current[0].parentNode || parent;
+	if (t === "string" || t === "number") {
+		if (hydrating) return current;
+		if (t === "number") {
+			value = value.toString();
+			if (value === current) return current;
+		}
+		if (multi) {
+			let node = current[0];
+			if (node && node.nodeType === 3) node.data !== value && (node.data = value);
+			else node = document.createTextNode(value);
+			current = cleanChildren(parent, current, marker, node);
+		} else if (current !== "" && typeof current === "string") current = parent.firstChild.data = value;
+		else current = parent.textContent = value;
+	} else if (value == null || t === "boolean") {
+		if (hydrating) return current;
+		current = cleanChildren(parent, current, marker);
+	} else if (t === "function") {
+		createRenderEffect(() => {
+			let v = value();
+			while (typeof v === "function") v = v();
+			current = insertExpression(parent, v, current, marker);
+		});
+		return () => current;
+	} else if (Array.isArray(value)) {
+		const array = [];
+		const currentArray = current && Array.isArray(current);
+		if (normalizeIncomingArray(array, value, current, unwrapArray)) {
+			createRenderEffect(() => current = insertExpression(parent, array, current, marker, true));
+			return () => current;
+		}
+		if (hydrating) {
+			if (!array.length) return current;
+			if (marker === void 0) return current = [...parent.childNodes];
+			let node = array[0];
+			if (node.parentNode !== parent) return current;
+			const nodes = [node];
+			while ((node = node.nextSibling) !== marker) nodes.push(node);
+			return current = nodes;
+		}
+		if (array.length === 0) {
+			current = cleanChildren(parent, current, marker);
+			if (multi) return current;
+		} else if (currentArray) if (current.length === 0) appendNodes(parent, array, marker);
+		else reconcileArrays(parent, current, array);
+		else {
+			current && cleanChildren(parent);
+			appendNodes(parent, array);
+		}
+		current = array;
+	} else if (value.nodeType) {
+		if (hydrating && value.parentNode) return current = multi ? [value] : value;
+		if (Array.isArray(current)) {
+			if (multi) return current = cleanChildren(parent, current, marker, value);
+			cleanChildren(parent, current, null, value);
+		} else if (current == null || current === "" || !parent.firstChild) parent.appendChild(value);
+		else parent.replaceChild(value, parent.firstChild);
+		current = value;
+	}
+	return current;
+}
+function normalizeIncomingArray(normalized, array, current, unwrap) {
+	let dynamic = false;
+	for (let i = 0, len = array.length; i < len; i++) {
+		let item = array[i], prev = current && current[normalized.length], t;
+		if (item == null || item === true || item === false);
+		else if ((t = typeof item) === "object" && item.nodeType) normalized.push(item);
+		else if (Array.isArray(item)) dynamic = normalizeIncomingArray(normalized, item, prev) || dynamic;
+		else if (t === "function") if (unwrap) {
+			while (typeof item === "function") item = item();
+			dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item], Array.isArray(prev) ? prev : [prev]) || dynamic;
+		} else {
+			normalized.push(item);
+			dynamic = true;
+		}
+		else {
+			const value = String(item);
+			if (prev && prev.nodeType === 3 && prev.data === value) normalized.push(prev);
+			else normalized.push(document.createTextNode(value));
+		}
+	}
+	return dynamic;
+}
+function appendNodes(parent, array, marker = null) {
+	for (let i = 0, len = array.length; i < len; i++) parent.insertBefore(array[i], marker);
+}
+function cleanChildren(parent, current, marker, replacement) {
+	if (marker === void 0) return parent.textContent = "";
+	const node = replacement || document.createTextNode("");
+	if (current.length) {
+		let inserted = false;
+		for (let i = current.length - 1; i >= 0; i--) {
+			const el = current[i];
+			if (node !== el) {
+				const isParent = el.parentNode === parent;
+				if (!inserted && !i) isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker);
+				else isParent && el.remove();
+			} else inserted = true;
+		}
+	} else parent.insertBefore(node, marker);
+	return [node];
+}
+
+//#endregion
+//#region src/utils/is-element-connected.ts
+const isElementConnected = (element) => Boolean(element?.isConnected ?? element?.ownerDocument?.contains(element));
+
+//#endregion
+//#region src/utils/is-keyboard-event-triggered-by-input.ts
+const EDITABLE_TAGS_AND_ROLES = [
+	"input",
+	"textarea",
+	"select",
+	"searchbox",
+	"slider",
+	"spinbutton",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"option",
+	"radio",
+	"textbox",
+	"combobox"
+];
+const getTargetElement = (event) => {
+	if (event.composed) {
+		const firstElement = event.composedPath()[0];
+		if (firstElement instanceof HTMLElement) return firstElement;
+	} else if (event.target instanceof HTMLElement) return event.target;
+};
+const isKeyboardEventTriggeredByInput = (event) => {
+	if (document.designMode === "on") return true;
+	const targetElement = getTargetElement(event);
+	if (!targetElement) return false;
+	if (targetElement.isContentEditable) return true;
+	const tagName = getTagName(targetElement);
+	return EDITABLE_TAGS_AND_ROLES.some((tagOrRole) => tagOrRole === tagName || tagOrRole === targetElement.role);
+};
+const hasTextSelectionInInput = (event) => {
+	const target = event.target;
+	if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
+		const selectionStart = target.selectionStart ?? 0;
+		return (target.selectionEnd ?? 0) - selectionStart > 0;
+	}
+	return false;
+};
+const hasTextSelectionOnPage = () => {
+	const selection = window.getSelection();
+	if (!selection) return false;
+	return selection.toString().length > 0;
+};
+
+//#endregion
+//#region src/utils/get-visual-viewport.ts
+const getVisualViewport = () => {
+	const visualViewport = window.visualViewport;
+	if (visualViewport) return {
+		width: visualViewport.width,
+		height: visualViewport.height,
+		offsetLeft: visualViewport.offsetLeft,
+		offsetTop: visualViewport.offsetTop
+	};
+	return {
+		width: window.innerWidth,
+		height: window.innerHeight,
+		offsetLeft: 0,
+		offsetTop: 0
+	};
+};
+
+//#endregion
+//#region src/utils/toolbar-position.ts
+const clampToRange = (value, min, max) => Math.max(min, Math.min(value, max));
+const getPositionFromEdgeAndRatio = (edge, ratio, elementWidth, elementHeight) => {
+	const viewport = getVisualViewport();
+	const viewportWidth = viewport.width;
+	const viewportHeight = viewport.height;
+	const minX = viewport.offsetLeft + 16;
+	const maxX = Math.max(minX, viewport.offsetLeft + viewportWidth - elementWidth - 16);
+	const minY = viewport.offsetTop + 16;
+	const maxY = Math.max(minY, viewport.offsetTop + viewportHeight - elementHeight - 16);
+	if (edge === "top" || edge === "bottom") {
+		const availableWidth = Math.max(0, viewportWidth - elementWidth - 16 * 2);
+		return {
+			x: Math.min(maxX, Math.max(minX, viewport.offsetLeft + 16 + availableWidth * ratio)),
+			y: edge === "top" ? minY : maxY
+		};
+	}
+	const availableHeight = Math.max(0, viewportHeight - elementHeight - 16 * 2);
+	const positionY = Math.min(maxY, Math.max(minY, viewport.offsetTop + 16 + availableHeight * ratio));
+	return {
+		x: edge === "left" ? minX : maxX,
+		y: positionY
+	};
+};
+const getRatioFromPosition = (edge, positionX, positionY, elementWidth, elementHeight) => {
+	const viewport = getVisualViewport();
+	const viewportWidth = viewport.width;
+	const viewportHeight = viewport.height;
+	if (edge === "top" || edge === "bottom") {
+		const availableWidth = viewportWidth - elementWidth - 16 * 2;
+		if (availableWidth <= 0) return TOOLBAR_DEFAULT_POSITION_RATIO;
+		return Math.max(0, Math.min(1, (positionX - viewport.offsetLeft - 16) / availableWidth));
+	}
+	const availableHeight = viewportHeight - elementHeight - 16 * 2;
+	if (availableHeight <= 0) return TOOLBAR_DEFAULT_POSITION_RATIO;
+	return Math.max(0, Math.min(1, (positionY - viewport.offsetTop - 16) / availableHeight));
+};
+const calculateExpandedPositionFromCollapsed = (collapsedPosition, edge, expandedDimensions, actualCollapsedWidth, actualCollapsedHeight) => {
+	const viewport = getVisualViewport();
+	const viewportWidth = viewport.width;
+	const viewportHeight = viewport.height;
+	const { width: expandedWidth, height: expandedHeight } = expandedDimensions;
+	let newPosition;
+	if (edge === "top" || edge === "bottom") {
+		const xOffset = (expandedWidth - actualCollapsedWidth) / 2;
+		newPosition = {
+			x: clampToRange(collapsedPosition.x - xOffset, viewport.offsetLeft + 16, viewport.offsetLeft + viewportWidth - expandedWidth - 16),
+			y: edge === "top" ? viewport.offsetTop + 16 : viewport.offsetTop + viewportHeight - expandedHeight - 16
+		};
+	} else {
+		const yOffset = (expandedHeight - actualCollapsedHeight) / 2;
+		const clampedY = clampToRange(collapsedPosition.y - yOffset, viewport.offsetTop + 16, viewport.offsetTop + viewportHeight - expandedHeight - 16);
+		newPosition = {
+			x: edge === "left" ? viewport.offsetLeft + 16 : viewport.offsetLeft + viewportWidth - expandedWidth - 16,
+			y: clampedY
+		};
+	}
+	const ratio = getRatioFromPosition(edge, newPosition.x, newPosition.y, expandedWidth, expandedHeight);
+	return {
+		position: newPosition,
+		ratio
+	};
+};
+const getCollapsedPosition = (edge, expandedPosition, expandedDimensions, collapsedDimensions) => {
+	const viewport = getVisualViewport();
+	const { width: expandedWidth, height: expandedHeight } = expandedDimensions;
+	const { width: collapsedWidth, height: collapsedHeight } = collapsedDimensions;
+	switch (edge) {
+		case "top":
+		case "bottom": {
+			const xOffset = (expandedWidth - collapsedWidth) / 2;
+			return {
+				x: clampToRange(expandedPosition.x + xOffset, viewport.offsetLeft, viewport.offsetLeft + viewport.width - collapsedWidth),
+				y: edge === "top" ? viewport.offsetTop : viewport.offsetTop + viewport.height - collapsedHeight
+			};
+		}
+		case "left":
+		case "right": {
+			const yOffset = (expandedHeight - collapsedHeight) / 2;
+			const clampedY = clampToRange(expandedPosition.y + yOffset, viewport.offsetTop, viewport.offsetTop + viewport.height - collapsedHeight);
+			return {
+				x: edge === "left" ? viewport.offsetLeft : viewport.offsetLeft + viewport.width - collapsedWidth,
+				y: clampedY
+			};
+		}
+	}
+};
+const getSnapPosition = (currentX, currentY, elementWidth, elementHeight, velocityX, velocityY) => {
+	const viewport = getVisualViewport();
+	const viewportWidth = viewport.width;
+	const viewportHeight = viewport.height;
+	const projectedX = currentX + velocityX * 150;
+	const projectedY = currentY + velocityY * 150;
+	const distanceToTop = projectedY - viewport.offsetTop + elementHeight / 2;
+	const distanceToBottom = viewport.offsetTop + viewportHeight - projectedY - elementHeight / 2;
+	const distanceToLeft = projectedX - viewport.offsetLeft + elementWidth / 2;
+	const distanceToRight = viewport.offsetLeft + viewportWidth - projectedX - elementWidth / 2;
+	const minDistance = Math.min(distanceToTop, distanceToBottom, distanceToLeft, distanceToRight);
+	const clampX = (rawX) => clampToRange(rawX, viewport.offsetLeft + 16, viewport.offsetLeft + viewportWidth - elementWidth - 16);
+	const clampY = (rawY) => clampToRange(rawY, viewport.offsetTop + 16, viewport.offsetTop + viewportHeight - elementHeight - 16);
+	if (minDistance === distanceToTop) return {
+		edge: "top",
+		x: clampX(projectedX),
+		y: viewport.offsetTop + 16
+	};
+	if (minDistance === distanceToLeft) return {
+		edge: "left",
+		x: viewport.offsetLeft + 16,
+		y: clampY(projectedY)
+	};
+	if (minDistance === distanceToRight) return {
+		edge: "right",
+		x: viewport.offsetLeft + viewportWidth - elementWidth - 16,
+		y: clampY(projectedY)
+	};
+	return {
+		edge: "bottom",
+		x: clampX(projectedX),
+		y: viewport.offsetTop + viewportHeight - elementHeight - 16
+	};
+};
+
+//#endregion
+//#region src/utils/is-mac.ts
+let cachedIsMac = null;
+const getPlatformFromUserAgentData = () => {
+	if (typeof navigator === "undefined") return null;
+	if (!("userAgentData" in navigator)) return null;
+	const userAgentData = navigator.userAgentData;
+	if (typeof userAgentData !== "object" || userAgentData === null) return null;
+	if (!("platform" in userAgentData)) return null;
+	const platform = userAgentData.platform;
+	if (typeof platform !== "string") return null;
+	return platform;
+};
+const isMac = () => {
+	if (cachedIsMac === null) {
+		if (typeof navigator === "undefined") {
+			cachedIsMac = false;
+			return cachedIsMac;
+		}
+		const platform = navigator.platform ?? getPlatformFromUserAgentData() ?? navigator.userAgent;
+		cachedIsMac = /Mac|iPhone|iPad|iPod/i.test(platform);
+	}
+	return cachedIsMac;
+};
+
+//#endregion
+//#region src/utils/is-event-from-overlay.ts
+const isEventFromOverlay = (event, attribute) => {
+	try {
+		return event.composedPath().some((target) => target instanceof HTMLElement && target.hasAttribute(attribute));
+	} catch {
+		return false;
+	}
+};
+
+//#endregion
+//#region src/utils/resolve-action-enabled.ts
+const resolveBooleanEnabled = (enabled) => enabled ?? true;
+const resolveActionEnabled = (action, context) => {
+	if (typeof action.enabled === "function") {
+		if (!context) return false;
+		return action.enabled(context);
+	}
+	return resolveBooleanEnabled(action.enabled);
+};
+
+//#endregion
+//#region src/components/toolbar/state.ts
+const STORAGE_KEY = "react-grab-toolbar-state";
+const loadToolbarState = () => {
+	try {
+		const serializedToolbarState = localStorage.getItem(STORAGE_KEY);
+		if (!serializedToolbarState) return null;
+		const parsed = JSON.parse(serializedToolbarState);
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const record = parsed;
+		return {
+			edge: record.edge === "top" || record.edge === "bottom" || record.edge === "left" || record.edge === "right" ? record.edge : "bottom",
+			ratio: typeof record.ratio === "number" ? record.ratio : TOOLBAR_DEFAULT_POSITION_RATIO,
+			collapsed: typeof record.collapsed === "boolean" ? record.collapsed : false,
+			enabled: typeof record.enabled === "boolean" ? record.enabled : true,
+			defaultAction: typeof record.defaultAction === "string" ? record.defaultAction : DEFAULT_ACTION_ID
+		};
+	} catch (error) {
+		console.warn("[react-grab] Failed to load toolbar state from localStorage:", error);
+	}
+	return null;
+};
+const saveToolbarState = (state) => {
+	try {
+		localStorage.setItem(STORAGE_KEY, JSON.stringify(state));
+	} catch (error) {
+		console.warn("[react-grab] Failed to save toolbar state to localStorage:", error);
+	}
+};
+
+//#endregion
+export { $PROXY as A, createResource as B, render as C, style as D, spread as E, batch as F, on as G, createSignal as H, createComponent as I, onCleanup as K, createEffect as L, For as M, Index as N, template as O, Show as P, createMemo as R, memo as S, setStyleProperty as T, getListener as U, createRoot as V, mergeProps as W, addEventListener as _, isMac as a, delegateEvents as b, getCollapsedPosition as c, getSnapPosition as d, getVisualViewport as f, isElementConnected as g, isKeyboardEventTriggeredByInput as h, isEventFromOverlay as i, $TRACK as j, use as k, getPositionFromEdgeAndRatio as l, hasTextSelectionOnPage as m, saveToolbarState as n, calculateExpandedPositionFromCollapsed as o, hasTextSelectionInInput as p, onMount as q, resolveActionEnabled as r, clampToRange as s, loadToolbarState as t, getRatioFromPosition as u, classList as v, setAttribute as w, insert as x, className as y, createRenderEffect as z };