react-grab 0.1.29 → 0.1.30

package/dist/state-dFAAWOP9.cjs

@@ -0,0 +1,1488 @@
+/**
+ * @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.
+ */
+const require_freeze_updates = require('./freeze-updates-CPNAwtsl.cjs');
+
+//#region ../../node_modules/.pnpm/solid-js@1.9.10/node_modules/solid-js/dist/server.js
+const ERROR = Symbol("error");
+function castError(err) {
+	if (err instanceof Error) return err;
+	return new Error(typeof err === "string" ? err : "Unknown error", { cause: err });
+}
+function handleError(err, owner = Owner) {
+	const fns = owner && owner.context && owner.context[ERROR];
+	const error = castError(err);
+	if (!fns) throw error;
+	try {
+		for (const f of fns) f(error);
+	} catch (e) {
+		handleError(e, owner && owner.owner || null);
+	}
+}
+const UNOWNED = {
+	context: null,
+	owner: null,
+	owned: null,
+	cleanups: null
+};
+let Owner = null;
+function createOwner() {
+	const o = {
+		owner: Owner,
+		context: Owner ? Owner.context : null,
+		owned: null,
+		cleanups: null
+	};
+	if (Owner) if (!Owner.owned) Owner.owned = [o];
+	else Owner.owned.push(o);
+	return o;
+}
+function createRoot(fn, detachedOwner) {
+	const owner = Owner, current = detachedOwner === void 0 ? owner : detachedOwner, root = fn.length === 0 ? UNOWNED : {
+		context: current ? current.context : null,
+		owner: current,
+		owned: null,
+		cleanups: null
+	};
+	Owner = root;
+	let result;
+	try {
+		result = fn(fn.length === 0 ? () => {} : () => cleanNode(root));
+	} catch (err) {
+		handleError(err);
+	} finally {
+		Owner = owner;
+	}
+	return result;
+}
+function createSignal(value, options) {
+	return [() => value, (v) => {
+		return value = typeof v === "function" ? v(value) : v;
+	}];
+}
+function createComputed(fn, value) {
+	Owner = createOwner();
+	try {
+		fn(value);
+	} catch (err) {
+		handleError(err);
+	} finally {
+		Owner = Owner.owner;
+	}
+}
+const createRenderEffect = createComputed;
+function createEffect(fn, value) {}
+function createMemo(fn, value) {
+	Owner = createOwner();
+	let v;
+	try {
+		v = fn(value);
+	} catch (err) {
+		handleError(err);
+	} finally {
+		Owner = Owner.owner;
+	}
+	return () => v;
+}
+function batch(fn) {
+	return fn();
+}
+const untrack = batch;
+function on(deps, fn, options = {}) {
+	const isArray = Array.isArray(deps);
+	const defer = options.defer;
+	return () => {
+		if (defer) return void 0;
+		let value;
+		if (isArray) {
+			value = [];
+			for (let i = 0; i < deps.length; i++) value.push(deps[i]());
+		} else value = deps();
+		return fn(value);
+	};
+}
+function onMount(fn) {}
+function onCleanup(fn) {
+	if (Owner) if (!Owner.cleanups) Owner.cleanups = [fn];
+	else Owner.cleanups.push(fn);
+	return fn;
+}
+function cleanNode(node) {
+	if (node.owned) {
+		for (let i = 0; i < node.owned.length; i++) cleanNode(node.owned[i]);
+		node.owned = null;
+	}
+	if (node.cleanups) {
+		for (let i = 0; i < node.cleanups.length; i++) node.cleanups[i]();
+		node.cleanups = null;
+	}
+}
+function createContext(defaultValue) {
+	const id = Symbol("context");
+	return {
+		id,
+		Provider: createProvider(id),
+		defaultValue
+	};
+}
+function useContext(context) {
+	return Owner && Owner.context && Owner.context[context.id] !== void 0 ? Owner.context[context.id] : context.defaultValue;
+}
+function children(fn) {
+	const memo = createMemo(() => resolveChildren(fn()));
+	memo.toArray = () => {
+		const c = memo();
+		return Array.isArray(c) ? c : c != null ? [c] : [];
+	};
+	return memo;
+}
+function resolveChildren(children) {
+	if (typeof children === "function" && !children.length) return resolveChildren(children());
+	if (Array.isArray(children)) {
+		const results = [];
+		for (let i = 0; i < children.length; i++) {
+			const result = resolveChildren(children[i]);
+			Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+		}
+		return results;
+	}
+	return children;
+}
+function createProvider(id) {
+	return function provider(props) {
+		return createMemo(() => {
+			Owner.context = {
+				...Owner.context,
+				[id]: props.value
+			};
+			return children(() => props.children);
+		});
+	};
+}
+const sharedConfig = {
+	context: void 0,
+	getContextId() {
+		if (!this.context) throw new Error(`getContextId cannot be used under non-hydrating context`);
+		return getContextId(this.context.count);
+	},
+	getNextContextId() {
+		if (!this.context) throw new Error(`getNextContextId cannot be used under non-hydrating context`);
+		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 ? {
+		...sharedConfig.context,
+		id: sharedConfig.getNextContextId(),
+		count: 0
+	} : void 0;
+}
+function createComponent(Comp, props) {
+	if (sharedConfig.context && !sharedConfig.context.noHydrate) {
+		const c = sharedConfig.context;
+		setHydrateContext(nextHydrateContext());
+		const r = Comp(props || {});
+		setHydrateContext(c);
+		return r;
+	}
+	return Comp(props || {});
+}
+function mergeProps(...sources) {
+	const target = {};
+	for (let i = 0; i < sources.length; i++) {
+		let source = sources[i];
+		if (typeof source === "function") source = source();
+		if (source) {
+			const descriptors = Object.getOwnPropertyDescriptors(source);
+			for (const key in descriptors) {
+				if (key in target) continue;
+				Object.defineProperty(target, key, {
+					enumerable: true,
+					get() {
+						for (let i = sources.length - 1; i >= 0; i--) {
+							let v, s = sources[i];
+							if (typeof s === "function") s = s();
+							v = (s || {})[key];
+							if (v !== void 0) return v;
+						}
+					}
+				});
+			}
+		}
+	}
+	return target;
+}
+function simpleMap(props, wrap) {
+	const list = props.each || [], len = list.length, fn = props.children;
+	if (len) {
+		let mapped = Array(len);
+		for (let i = 0; i < len; i++) mapped[i] = wrap(fn, list[i], i);
+		return mapped;
+	}
+	return props.fallback;
+}
+function For(props) {
+	return simpleMap(props, (fn, item, i) => fn(item, () => i));
+}
+function Index(props) {
+	return simpleMap(props, (fn, item, i) => fn(() => item, i));
+}
+function Show(props) {
+	let c;
+	return props.when ? typeof (c = props.children) === "function" ? c(props.keyed ? props.when : () => props.when) : c : props.fallback || "";
+}
+const SuspenseContext = createContext();
+let resourceContext = null;
+function createResource(source, fetcher, options = {}) {
+	if (typeof fetcher !== "function") {
+		options = fetcher || {};
+		fetcher = source;
+		source = true;
+	}
+	const contexts = /* @__PURE__ */ new Set();
+	const id = sharedConfig.getNextContextId();
+	let resource = {};
+	let value = options.storage ? options.storage(options.initialValue)[0]() : options.initialValue;
+	let p;
+	let error;
+	if (sharedConfig.context.async && options.ssrLoadFrom !== "initial") {
+		resource = sharedConfig.context.resources[id] || (sharedConfig.context.resources[id] = {});
+		if (resource.ref) {
+			if (!resource.data && !resource.ref[0]._loading && !resource.ref[0].error) resource.ref[1].refetch();
+			return resource.ref;
+		}
+	}
+	const prepareResource = () => {
+		if (error) throw error;
+		const resolved = options.ssrLoadFrom !== "initial" && sharedConfig.context.async && "data" in sharedConfig.context.resources[id];
+		if (!resolved && resourceContext) resourceContext.push(id);
+		if (!resolved && read._loading) {
+			const ctx = useContext(SuspenseContext);
+			if (ctx) {
+				ctx.resources.set(id, read);
+				contexts.add(ctx);
+			}
+		}
+		return resolved;
+	};
+	const read = () => {
+		return prepareResource() ? sharedConfig.context.resources[id].data : value;
+	};
+	const loading = () => {
+		prepareResource();
+		return read._loading;
+	};
+	read._loading = false;
+	read.error = void 0;
+	read.state = "initialValue" in options ? "ready" : "unresolved";
+	Object.defineProperties(read, {
+		latest: { get() {
+			return read();
+		} },
+		loading: { get() {
+			return loading();
+		} }
+	});
+	function load() {
+		const ctx = sharedConfig.context;
+		if (!ctx.async) return read._loading = !!(typeof source === "function" ? source() : source);
+		if (ctx.resources && id in ctx.resources && "data" in ctx.resources[id]) {
+			value = ctx.resources[id].data;
+			return;
+		}
+		let lookup;
+		try {
+			resourceContext = [];
+			lookup = typeof source === "function" ? source() : source;
+			if (resourceContext.length) return;
+		} finally {
+			resourceContext = null;
+		}
+		if (!p) {
+			if (lookup == null || lookup === false) return;
+			p = fetcher(lookup, { value });
+		}
+		if (p != void 0 && typeof p === "object" && "then" in p) {
+			read._loading = true;
+			read.state = "pending";
+			p = p.then((res) => {
+				read._loading = false;
+				read.state = "ready";
+				ctx.resources[id].data = res;
+				p = null;
+				notifySuspense(contexts);
+				return res;
+			}).catch((err) => {
+				read._loading = false;
+				read.state = "errored";
+				read.error = error = castError(err);
+				p = null;
+				notifySuspense(contexts);
+				throw error;
+			});
+			if (ctx.serialize) ctx.serialize(id, p, options.deferStream);
+			return p;
+		}
+		ctx.resources[id].data = p;
+		if (ctx.serialize) ctx.serialize(id, p);
+		p = null;
+		return ctx.resources[id].data;
+	}
+	if (options.ssrLoadFrom !== "initial") load();
+	const ref = [read, {
+		refetch: load,
+		mutate: (v) => value = v
+	}];
+	if (p) resource.ref = ref;
+	return ref;
+}
+function suspenseComplete(c) {
+	for (const r of c.resources.values()) if (r._loading) return false;
+	return true;
+}
+function notifySuspense(contexts) {
+	for (const c of contexts) {
+		if (!suspenseComplete(c)) continue;
+		c.completed();
+		contexts.delete(c);
+	}
+}
+
+//#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 = require_freeze_updates.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 require_freeze_updates.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 require_freeze_updates.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 : require_freeze_updates.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 : require_freeze_updates.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
+Object.defineProperty(exports, 'For', {
+  enumerable: true,
+  get: function () {
+    return For;
+  }
+});
+Object.defineProperty(exports, 'Index', {
+  enumerable: true,
+  get: function () {
+    return Index;
+  }
+});
+Object.defineProperty(exports, 'Show', {
+  enumerable: true,
+  get: function () {
+    return Show;
+  }
+});
+Object.defineProperty(exports, 'addEventListener', {
+  enumerable: true,
+  get: function () {
+    return addEventListener;
+  }
+});
+Object.defineProperty(exports, 'batch', {
+  enumerable: true,
+  get: function () {
+    return batch;
+  }
+});
+Object.defineProperty(exports, 'calculateExpandedPositionFromCollapsed', {
+  enumerable: true,
+  get: function () {
+    return calculateExpandedPositionFromCollapsed;
+  }
+});
+Object.defineProperty(exports, 'clampToRange', {
+  enumerable: true,
+  get: function () {
+    return clampToRange;
+  }
+});
+Object.defineProperty(exports, 'classList', {
+  enumerable: true,
+  get: function () {
+    return classList;
+  }
+});
+Object.defineProperty(exports, 'className', {
+  enumerable: true,
+  get: function () {
+    return className;
+  }
+});
+Object.defineProperty(exports, 'createComponent', {
+  enumerable: true,
+  get: function () {
+    return createComponent;
+  }
+});
+Object.defineProperty(exports, 'createEffect', {
+  enumerable: true,
+  get: function () {
+    return createEffect;
+  }
+});
+Object.defineProperty(exports, 'createMemo', {
+  enumerable: true,
+  get: function () {
+    return createMemo;
+  }
+});
+Object.defineProperty(exports, 'createRenderEffect', {
+  enumerable: true,
+  get: function () {
+    return createRenderEffect;
+  }
+});
+Object.defineProperty(exports, 'createResource', {
+  enumerable: true,
+  get: function () {
+    return createResource;
+  }
+});
+Object.defineProperty(exports, 'createRoot', {
+  enumerable: true,
+  get: function () {
+    return createRoot;
+  }
+});
+Object.defineProperty(exports, 'createSignal', {
+  enumerable: true,
+  get: function () {
+    return createSignal;
+  }
+});
+Object.defineProperty(exports, 'delegateEvents', {
+  enumerable: true,
+  get: function () {
+    return delegateEvents;
+  }
+});
+Object.defineProperty(exports, 'getCollapsedPosition', {
+  enumerable: true,
+  get: function () {
+    return getCollapsedPosition;
+  }
+});
+Object.defineProperty(exports, 'getPositionFromEdgeAndRatio', {
+  enumerable: true,
+  get: function () {
+    return getPositionFromEdgeAndRatio;
+  }
+});
+Object.defineProperty(exports, 'getRatioFromPosition', {
+  enumerable: true,
+  get: function () {
+    return getRatioFromPosition;
+  }
+});
+Object.defineProperty(exports, 'getSnapPosition', {
+  enumerable: true,
+  get: function () {
+    return getSnapPosition;
+  }
+});
+Object.defineProperty(exports, 'getVisualViewport', {
+  enumerable: true,
+  get: function () {
+    return getVisualViewport;
+  }
+});
+Object.defineProperty(exports, 'hasTextSelectionInInput', {
+  enumerable: true,
+  get: function () {
+    return hasTextSelectionInInput;
+  }
+});
+Object.defineProperty(exports, 'hasTextSelectionOnPage', {
+  enumerable: true,
+  get: function () {
+    return hasTextSelectionOnPage;
+  }
+});
+Object.defineProperty(exports, 'insert', {
+  enumerable: true,
+  get: function () {
+    return insert;
+  }
+});
+Object.defineProperty(exports, 'isElementConnected', {
+  enumerable: true,
+  get: function () {
+    return isElementConnected;
+  }
+});
+Object.defineProperty(exports, 'isEventFromOverlay', {
+  enumerable: true,
+  get: function () {
+    return isEventFromOverlay;
+  }
+});
+Object.defineProperty(exports, 'isKeyboardEventTriggeredByInput', {
+  enumerable: true,
+  get: function () {
+    return isKeyboardEventTriggeredByInput;
+  }
+});
+Object.defineProperty(exports, 'isMac', {
+  enumerable: true,
+  get: function () {
+    return isMac;
+  }
+});
+Object.defineProperty(exports, 'loadToolbarState', {
+  enumerable: true,
+  get: function () {
+    return loadToolbarState;
+  }
+});
+Object.defineProperty(exports, 'memo', {
+  enumerable: true,
+  get: function () {
+    return memo;
+  }
+});
+Object.defineProperty(exports, 'mergeProps', {
+  enumerable: true,
+  get: function () {
+    return mergeProps;
+  }
+});
+Object.defineProperty(exports, 'on', {
+  enumerable: true,
+  get: function () {
+    return on;
+  }
+});
+Object.defineProperty(exports, 'onCleanup', {
+  enumerable: true,
+  get: function () {
+    return onCleanup;
+  }
+});
+Object.defineProperty(exports, 'onMount', {
+  enumerable: true,
+  get: function () {
+    return onMount;
+  }
+});
+Object.defineProperty(exports, 'render', {
+  enumerable: true,
+  get: function () {
+    return render;
+  }
+});
+Object.defineProperty(exports, 'resolveActionEnabled', {
+  enumerable: true,
+  get: function () {
+    return resolveActionEnabled;
+  }
+});
+Object.defineProperty(exports, 'saveToolbarState', {
+  enumerable: true,
+  get: function () {
+    return saveToolbarState;
+  }
+});
+Object.defineProperty(exports, 'setAttribute', {
+  enumerable: true,
+  get: function () {
+    return setAttribute;
+  }
+});
+Object.defineProperty(exports, 'setStyleProperty', {
+  enumerable: true,
+  get: function () {
+    return setStyleProperty;
+  }
+});
+Object.defineProperty(exports, 'spread', {
+  enumerable: true,
+  get: function () {
+    return spread;
+  }
+});
+Object.defineProperty(exports, 'style', {
+  enumerable: true,
+  get: function () {
+    return style;
+  }
+});
+Object.defineProperty(exports, 'template', {
+  enumerable: true,
+  get: function () {
+    return template;
+  }
+});
+Object.defineProperty(exports, 'use', {
+  enumerable: true,
+  get: function () {
+    return use;
+  }
+});