@mhmo91/schmancy 0.9.27 → 0.10.1

package/dist/state-ClRXrqDA.js

@@ -0,0 +1,846 @@
+import { t as e } from "./decorate-23nYs4Le.js";
+import { n as t, r as n } from "./active-host-D-a1X-nq.js";
+import { Observable as r } from "rxjs";
+import { ContextEvent as i, ContextProvider as a, createContext as o } from "@lit/context";
+import { property as s } from "lit/decorators.js";
+import { LitElement as c, html as l } from "lit";
+import { Signal as u, Signal as d, computed as ee } from "@lit-labs/signals";
+var f = Symbol.for("immer-nothing"), p = Symbol.for("immer-draftable"), m = Symbol.for("immer-state"), te = process.env.NODE_ENV === "production" ? [] : [
+	function(e) {
+		return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+	},
+	function(e) {
+		return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${e}'`;
+	},
+	"This object has been frozen and should not be mutated",
+	function(e) {
+		return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+	},
+	"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+	"Immer forbids circular references",
+	"The first or second argument to `produce` must be a function",
+	"The third argument to `produce` must be a function or undefined",
+	"First argument to `createDraft` must be a plain object, an array, or an immerable object",
+	"First argument to `finishDraft` must be a draft returned by `createDraft`",
+	function(e) {
+		return `'current' expects a draft, got: ${e}`;
+	},
+	"Object.defineProperty() cannot be used on an Immer draft",
+	"Object.setPrototypeOf() cannot be used on an Immer draft",
+	"Immer only supports deleting array indices",
+	"Immer only supports setting array indices and the 'length' property",
+	function(e) {
+		return `'original' expects a draft, got: ${e}`;
+	}
+];
+function h(e, ...t) {
+	if (process.env.NODE_ENV !== "production") {
+		let n = te[e], r = M(n) ? n.apply(null, t) : n;
+		throw Error(`[Immer] ${r}`);
+	}
+	throw Error(`[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`);
+}
+var g = Object, _ = g.getPrototypeOf, v = "constructor", y = "prototype", b = "configurable", x = "enumerable", S = "writable", C = "value", w = (e) => !!e && !!e[m];
+function T(e) {
+	return !!e && (ie(e) || k(e) || !!e[p] || !!e[v]?.[p] || A(e) || j(e));
+}
+var ne = g[y][v].toString(), re = /* @__PURE__ */ new WeakMap();
+function ie(e) {
+	if (!e || !se(e)) return !1;
+	let t = _(e);
+	if (t === null || t === g[y]) return !0;
+	let n = g.hasOwnProperty.call(t, v) && t[v];
+	if (n === Object) return !0;
+	if (!M(n)) return !1;
+	let r = re.get(n);
+	return r === void 0 && (r = Function.toString.call(n), re.set(n, r)), r === ne;
+}
+function E(e, t, n = !0) {
+	D(e) === 0 ? (n ? Reflect.ownKeys(e) : g.keys(e)).forEach((n) => {
+		t(n, e[n], e);
+	}) : e.forEach((n, r) => t(r, n, e));
+}
+function D(e) {
+	let t = e[m];
+	return t ? t.type_ : k(e) ? 1 : A(e) ? 2 : j(e) ? 3 : 0;
+}
+var ae = (e, t, n = D(e)) => n === 2 ? e.has(t) : g[y].hasOwnProperty.call(e, t), oe = (e, t, n = D(e)) => n === 2 ? e.get(t) : e[t], O = (e, t, n, r = D(e)) => {
+	r === 2 ? e.set(t, n) : r === 3 ? e.add(n) : e[t] = n;
+}, k = Array.isArray, A = (e) => e instanceof Map, j = (e) => e instanceof Set, se = (e) => typeof e == "object", M = (e) => typeof e == "function", N = (e) => typeof e == "boolean", P = (e) => e.copy_ || e.base_, ce = (e) => e.modified_ ? e.copy_ : e.base_;
+function F(e, t) {
+	if (A(e)) return new Map(e);
+	if (j(e)) return new Set(e);
+	if (k(e)) return Array[y].slice.call(e);
+	let n = ie(e);
+	if (!0 === t || t === "class_only" && !n) {
+		let t = g.getOwnPropertyDescriptors(e);
+		delete t[m];
+		let n = Reflect.ownKeys(t);
+		for (let r = 0; r < n.length; r++) {
+			let i = n[r], a = t[i];
+			!1 === a[S] && (a[S] = !0, a[b] = !0), (a.get || a.set) && (t[i] = {
+				[b]: !0,
+				[S]: !0,
+				[x]: a[x],
+				[C]: e[i]
+			});
+		}
+		return g.create(_(e), t);
+	}
+	{
+		let t = _(e);
+		if (t !== null && n) return { ...e };
+		let r = g.create(t);
+		return g.assign(r, e);
+	}
+}
+function I(e, t = !1) {
+	return R(e) || w(e) || !T(e) || (D(e) > 1 && g.defineProperties(e, {
+		set: L,
+		add: L,
+		clear: L,
+		delete: L
+	}), g.freeze(e), t && E(e, (e, t) => {
+		I(t, !0);
+	}, !1)), e;
+}
+var L = { [C]: function() {
+	h(2);
+} };
+function R(e) {
+	return e === null || !se(e) || g.isFrozen(e);
+}
+var z = "MapSet", le = "Patches", ue = "ArrayMethods", de = {};
+function B(e) {
+	let t = de[e];
+	return t || h(0, e), t;
+}
+var V, fe = (e) => !!de[e], pe = () => V;
+function me(e, t) {
+	t && (e.patchPlugin_ = B(le), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function he(e) {
+	H(e), e.drafts_.forEach(_e), e.drafts_ = null;
+}
+function H(e) {
+	e === V && (V = e.parent_);
+}
+var ge = (e) => V = {
+	drafts_: [],
+	parent_: V,
+	immer_: e,
+	canAutoFreeze_: !0,
+	unfinalizedDrafts_: 0,
+	handledSet_: /* @__PURE__ */ new Set(),
+	processedForPatches_: /* @__PURE__ */ new Set(),
+	mapSetPlugin_: fe(z) ? B(z) : void 0,
+	arrayMethodsPlugin_: fe(ue) ? B(ue) : void 0
+};
+function _e(e) {
+	let t = e[m];
+	t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function ve(e, t) {
+	t.unfinalizedDrafts_ = t.drafts_.length;
+	let n = t.drafts_[0];
+	if (e !== void 0 && e !== n) {
+		n[m].modified_ && (he(t), h(4)), T(e) && (e = ye(t, e));
+		let { patchPlugin_: r } = t;
+		r && r.generateReplacementPatches_(n[m].base_, e, t);
+	} else e = ye(t, n);
+	return function(e, t, n = !1) {
+		!e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && I(t, n);
+	}(t, e, !0), he(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e === f ? void 0 : e;
+}
+function ye(e, t) {
+	if (R(t)) return t;
+	let n = t[m];
+	if (!n) return W(t, e.handledSet_, e);
+	if (!U(n, e)) return t;
+	if (!n.modified_) return n.base_;
+	if (!n.finalized_) {
+		let { callbacks_: t } = n;
+		if (t) for (; t.length > 0;) t.pop()(e);
+		Ce(n, e);
+	}
+	return n.copy_;
+}
+function be(e) {
+	e.finalized_ = !0, e.scope_.unfinalizedDrafts_--;
+}
+var U = (e, t) => e.scope_ === t, xe = [];
+function Se(e, t, n, r) {
+	let i = P(e), a = e.type_;
+	if (r !== void 0 && oe(i, r, a) === t) return void O(i, r, n, a);
+	if (!e.draftLocations_) {
+		let t = e.draftLocations_ = /* @__PURE__ */ new Map();
+		E(i, (e, n) => {
+			if (w(n)) {
+				let r = t.get(n) || [];
+				r.push(e), t.set(n, r);
+			}
+		});
+	}
+	let o = e.draftLocations_.get(t) ?? xe;
+	for (let e of o) O(i, e, n, a);
+}
+function Ce(e, t) {
+	if (e.modified_ && !e.finalized_ && (e.type_ === 3 || e.type_ === 1 && e.allIndicesReassigned_ || (e.assigned_?.size ?? 0) > 0)) {
+		let { patchPlugin_: n } = t;
+		if (n) {
+			let r = n.getPath(e);
+			r && n.generatePatches_(e, r, t);
+		}
+		be(e);
+	}
+}
+function W(e, t, n) {
+	return !n.immer_.autoFreeze_ && n.unfinalizedDrafts_ < 1 || w(e) || t.has(e) || !T(e) || R(e) || (t.add(e), E(e, (r, i) => {
+		if (w(i)) {
+			let t = i[m];
+			U(t, n) && (O(e, r, ce(t), e.type_), be(t));
+		} else T(i) && W(i, t, n);
+	})), e;
+}
+var G = {
+	get(e, t) {
+		if (t === m) return e;
+		let n = e.scope_.arrayMethodsPlugin_, r = e.type_ === 1 && typeof t == "string";
+		if (r && n?.isArrayOperationMethod(t)) return n.createMethodInterceptor(e, t);
+		let i = P(e);
+		if (!ae(i, t, e.type_)) return function(e, t, n) {
+			let r = we(t, n);
+			return r ? C in r ? r[C] : r.get?.call(e.draft_) : void 0;
+		}(e, i, t);
+		let a = i[t];
+		if (e.finalized_ || !T(a) || r && e.operationMethod && n?.isMutatingArrayMethod(e.operationMethod) && function(e) {
+			let t = +e;
+			return Number.isInteger(t) && String(t) === e;
+		}(t)) return a;
+		if (a === q(e.base_, t)) {
+			Y(e);
+			let n = e.type_ === 1 ? +t : t, r = Te(e.scope_, a, e, n);
+			return e.copy_[n] = r;
+		}
+		return a;
+	},
+	has: (e, t) => t in P(e),
+	ownKeys: (e) => Reflect.ownKeys(P(e)),
+	set(e, t, n) {
+		let r = we(P(e), t);
+		if (r?.set) return r.set.call(e.draft_, n), !0;
+		if (!e.modified_) {
+			let r = q(P(e), t), o = r?.[m];
+			if (o && o.base_ === n) return e.copy_[t] = n, e.assigned_.set(t, !1), !0;
+			if (((i = n) === (a = r) ? i !== 0 || 1 / i == 1 / a : i != i && a != a) && (n !== void 0 || ae(e.base_, t, e.type_))) return !0;
+			Y(e), J(e);
+		}
+		var i, a;
+		return e.copy_[t] === n && (n !== void 0 || t in e.copy_) || Number.isNaN(n) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = n, e.assigned_.set(t, !0), function(e, t, n) {
+			let { scope_: r } = e;
+			if (w(n)) {
+				let i = n[m];
+				U(i, r) && i.callbacks_.push(function() {
+					Y(e), Se(e, n, ce(i), t);
+				});
+			} else T(n) && e.callbacks_.push(function() {
+				let i = P(e);
+				e.type_ === 3 ? i.has(n) && W(n, r.handledSet_, r) : oe(i, t, e.type_) === n && r.drafts_.length > 1 && !0 === (e.assigned_.get(t) ?? !1) && e.copy_ && W(oe(e.copy_, t, e.type_), r.handledSet_, r);
+			});
+		}(e, t, n)), !0;
+	},
+	deleteProperty: (e, t) => (Y(e), q(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_.set(t, !1), J(e)) : e.assigned_.delete(t), e.copy_ && delete e.copy_[t], !0),
+	getOwnPropertyDescriptor(e, t) {
+		let n = P(e), r = Reflect.getOwnPropertyDescriptor(n, t);
+		return r && {
+			[S]: !0,
+			[b]: e.type_ !== 1 || t !== "length",
+			[x]: r[x],
+			[C]: n[t]
+		};
+	},
+	defineProperty() {
+		h(11);
+	},
+	getPrototypeOf: (e) => _(e.base_),
+	setPrototypeOf() {
+		h(12);
+	}
+}, K = {};
+for (let e in G) {
+	let t = G[e];
+	K[e] = function() {
+		let e = arguments;
+		return e[0] = e[0][0], t.apply(this, e);
+	};
+}
+function q(e, t) {
+	let n = e[m];
+	return (n ? P(n) : e)[t];
+}
+function we(e, t) {
+	if (!(t in e)) return;
+	let n = _(e);
+	for (; n;) {
+		let e = Object.getOwnPropertyDescriptor(n, t);
+		if (e) return e;
+		n = _(n);
+	}
+}
+function J(e) {
+	e.modified_ || (e.modified_ = !0, e.parent_ && J(e.parent_));
+}
+function Y(e) {
+	e.copy_ ||= (e.assigned_ = /* @__PURE__ */ new Map(), F(e.base_, e.scope_.immer_.useStrictShallowCopy_));
+}
+K.deleteProperty = function(e, t) {
+	return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && h(13), K.set.call(this, e, t, void 0);
+}, K.set = function(e, t, n) {
+	return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && h(14), G.set.call(this, e[0], t, n, e[0]);
+};
+function Te(e, t, n, r) {
+	let [i, a] = A(t) ? B(z).proxyMap_(t, n) : j(t) ? B(z).proxySet_(t, n) : function(e, t) {
+		let n = k(e), r = {
+			type_: +!!n,
+			scope_: t ? t.scope_ : pe(),
+			modified_: !1,
+			finalized_: !1,
+			assigned_: void 0,
+			parent_: t,
+			base_: e,
+			draft_: null,
+			copy_: null,
+			revoke_: null,
+			isManual_: !1,
+			callbacks_: void 0
+		}, i = r, a = G;
+		n && (i = [r], a = K);
+		let { revoke: o, proxy: s } = Proxy.revocable(i, a);
+		return r.draft_ = s, r.revoke_ = o, [s, r];
+	}(t, n);
+	return (n?.scope_ ?? pe()).drafts_.push(i), a.callbacks_ = n?.callbacks_ ?? [], a.key_ = r, n && r !== void 0 ? function(e, t, n) {
+		e.callbacks_.push(function(r) {
+			let i = t;
+			if (!i || !U(i, r)) return;
+			r.mapSetPlugin_?.fixSetContents(i);
+			let a = ce(i);
+			Se(e, i.draft_ ?? i, a, n), Ce(i, r);
+		});
+	}(n, a, r) : a.callbacks_.push(function(e) {
+		e.mapSetPlugin_?.fixSetContents(a);
+		let { patchPlugin_: t } = e;
+		a.modified_ && t && t.generatePatches_(a, [], e);
+	}), i;
+}
+function Ee(e) {
+	if (!T(e) || R(e)) return e;
+	let t = e[m], n, r = !0;
+	if (t) {
+		if (!t.modified_) return t.base_;
+		t.finalized_ = !0, n = F(e, t.scope_.immer_.useStrictShallowCopy_), r = t.scope_.immer_.shouldUseStrictIteration();
+	} else n = F(e, !0);
+	return E(n, (e, t) => {
+		O(n, e, Ee(t));
+	}, r), t && (t.finalized_ = !1), n;
+}
+var De = new class {
+	constructor(e) {
+		this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !1, this.produce = (e, t, n) => {
+			if (M(e) && !M(t)) {
+				let n = t;
+				t = e;
+				let r = this;
+				return function(e = n, ...i) {
+					return r.produce(e, (e) => t.call(this, e, ...i));
+				};
+			}
+			let r;
+			if (M(t) || h(6), n === void 0 || M(n) || h(7), T(e)) {
+				let i = ge(this), a = Te(i, e, void 0), o = !0;
+				try {
+					r = t(a), o = !1;
+				} finally {
+					o ? he(i) : H(i);
+				}
+				return me(i, n), ve(r, i);
+			}
+			if (!e || !se(e)) {
+				if (r = t(e), r === void 0 && (r = e), r === f && (r = void 0), this.autoFreeze_ && I(r, !0), n) {
+					let t = [], i = [];
+					B(le).generateReplacementPatches_(e, r, {
+						patches_: t,
+						inversePatches_: i
+					}), n(t, i);
+				}
+				return r;
+			}
+			h(1, e);
+		}, this.produceWithPatches = (e, t) => {
+			if (M(e)) return (t, ...n) => this.produceWithPatches(t, (t) => e(t, ...n));
+			let n, r;
+			return [
+				this.produce(e, t, (e, t) => {
+					n = e, r = t;
+				}),
+				n,
+				r
+			];
+		}, N(e?.autoFreeze) && this.setAutoFreeze(e.autoFreeze), N(e?.useStrictShallowCopy) && this.setUseStrictShallowCopy(e.useStrictShallowCopy), N(e?.useStrictIteration) && this.setUseStrictIteration(e.useStrictIteration);
+	}
+	createDraft(e) {
+		T(e) || h(8), w(e) && (e = function(e) {
+			return w(e) || h(10, e), Ee(e);
+		}(e));
+		let t = ge(this), n = Te(t, e, void 0);
+		return n[m].isManual_ = !0, H(t), n;
+	}
+	finishDraft(e, t) {
+		let n = e && e[m];
+		n && n.isManual_ || h(9);
+		let { scope_: r } = n;
+		return me(r, t), ve(void 0, r);
+	}
+	setAutoFreeze(e) {
+		this.autoFreeze_ = e;
+	}
+	setUseStrictShallowCopy(e) {
+		this.useStrictShallowCopy_ = e;
+	}
+	setUseStrictIteration(e) {
+		this.useStrictIteration_ = e;
+	}
+	shouldUseStrictIteration() {
+		return this.useStrictIteration_;
+	}
+	applyPatches(e, t) {
+		let n;
+		for (n = t.length - 1; n >= 0; n--) {
+			let r = t[n];
+			if (r.path.length === 0 && r.op === "replace") {
+				e = r.value;
+				break;
+			}
+		}
+		n > -1 && (t = t.slice(n + 1));
+		let r = B(le).applyPatches_;
+		return w(e) ? r(e, t) : this.produce(e, (e) => r(e, t));
+	}
+}().produce, Oe = class extends Error {
+	constructor(e, t, n) {
+		super(e), this.name = "StateStorageError", this.cause = t, this.context = n, this.timestamp = /* @__PURE__ */ new Date();
+	}
+}, ke = "__schmancy_state_Map", Ae = "__schmancy_state_Set";
+function je(e, t) {
+	return t instanceof Map ? {
+		$kind: ke,
+		entries: Array.from(t.entries())
+	} : t instanceof Set ? {
+		$kind: Ae,
+		values: Array.from(t.values())
+	} : t;
+}
+function Me(e, t) {
+	if (t && typeof t == "object" && "$kind" in t) {
+		let e = t, n = e.$kind;
+		if (n === ke) return Array.isArray(e.entries) && e.entries.every((e) => Array.isArray(e) && e.length === 2) ? new Map(e.entries) : t;
+		if (n === Ae) return Array.isArray(e.values) ? new Set(e.values) : t;
+	}
+	return t;
+}
+var Ne = class {
+	#e = null;
+	async load() {
+		return this.#e;
+	}
+	async save(e) {
+		this.#e = e;
+	}
+	async clear() {
+		this.#e = null;
+	}
+}, Pe = class {
+	constructor(e, t, n) {
+		this.storage = e, this.key = t, this.label = n;
+	}
+	async load() {
+		try {
+			let e = this.storage.getItem(this.key);
+			return e ? JSON.parse(e, Me) : null;
+		} catch {
+			return null;
+		}
+	}
+	async save(e) {
+		try {
+			this.storage.setItem(this.key, JSON.stringify(e, je));
+		} catch (e) {
+			throw new Oe(`[state] ${this.label} save failed (${this.key})`, e);
+		}
+	}
+	async clear() {
+		this.storage.removeItem(this.key);
+	}
+}, Fe = class e {
+	static {
+		this.DB_NAME = "SchmancyState";
+	}
+	static {
+		this.STORE_NAME = "states";
+	}
+	static {
+		this.DB_VERSION = 1;
+	}
+	#e = null;
+	#t = null;
+	constructor(e) {
+		this.key = e;
+	}
+	openDB() {
+		return this.#e ? Promise.resolve(this.#e) : (this.#t ||= new Promise((t, n) => {
+			let r = indexedDB.open(e.DB_NAME, e.DB_VERSION);
+			r.onupgradeneeded = () => {
+				let t = r.result;
+				t.objectStoreNames.contains(e.STORE_NAME) || t.createObjectStore(e.STORE_NAME);
+			}, r.addEventListener("success", () => {
+				this.#e = r.result, t(r.result);
+			}, { once: !0 }), r.addEventListener("error", () => n(r.error), { once: !0 });
+		}), this.#t);
+	}
+	async load() {
+		try {
+			let t = await this.openDB();
+			return await new Promise((n, r) => {
+				let i = t.transaction(e.STORE_NAME, "readonly").objectStore(e.STORE_NAME).get(this.key);
+				i.addEventListener("success", () => n(i.result ?? null), { once: !0 }), i.addEventListener("error", () => r(i.error), { once: !0 });
+			});
+		} catch {
+			return null;
+		}
+	}
+	async save(t) {
+		let n = await this.openDB();
+		return new Promise((r, i) => {
+			let a = n.transaction(e.STORE_NAME, "readwrite").objectStore(e.STORE_NAME).put(t, this.key);
+			a.addEventListener("success", () => r(), { once: !0 }), a.addEventListener("error", () => i(new Oe(`[state] IDB save failed (${this.key})`, a.error)), { once: !0 });
+		});
+	}
+	async clear() {
+		let t = await this.openDB();
+		return new Promise((n, r) => {
+			let i = t.transaction(e.STORE_NAME, "readwrite").objectStore(e.STORE_NAME).delete(this.key);
+			i.addEventListener("success", () => n(), { once: !0 }), i.addEventListener("error", () => r(i.error), { once: !0 });
+		});
+	}
+	async close() {
+		this.#e &&= (this.#e.close(), null), this.#t = null;
+	}
+}, X = class extends c {
+	constructor(...e) {
+		super(...e), this.provides = [], this._scoped = [];
+	}
+	connectedCallback() {
+		super.connectedCallback();
+		for (let e of this.provides) {
+			let t = e._isolatedInstance(), r = o(n(e.namespace)), i = new a(this, {
+				context: r,
+				initialValue: t
+			});
+			this._scoped.push({
+				isolated: t,
+				provider: i
+			});
+		}
+	}
+	disconnectedCallback() {
+		for (let e of this._scoped) e.isolated.destroy();
+		this._scoped = [], super.disconnectedCallback();
+	}
+	render() {
+		return l`<slot></slot>`;
+	}
+};
+e([s({ attribute: !1 })], X.prototype, "provides", void 0), customElements.get("schmancy-context") || customElements.define("schmancy-context", X);
+var Ie = Symbol("schmancy.state"), Le = Symbol.for("schmancy.state.claimed"), Re = globalThis;
+Re[Le] ??= /* @__PURE__ */ new Set();
+var Z = Re[Le], ze = Symbol.for("schmancy.state.hostResolverCache"), Be = globalThis;
+Be[ze] ??= /* @__PURE__ */ new WeakMap();
+var Ve = Be[ze];
+function Q(e, r) {
+	let a = t();
+	if (a === void 0) return r;
+	let s = Ve.get(a)?.get(e);
+	if (s !== void 0) return s;
+	let c, l = o(n(e));
+	a.dispatchEvent(new i(l, a, (e) => {
+		c = e;
+	}));
+	let u = c === void 0 ? r : c, d = Ve.get(a);
+	return d || (d = /* @__PURE__ */ new Map(), Ve.set(a, d)), d.set(e, u), u;
+}
+function He(e, t) {
+	let n = (t) => {
+		e.disposed || (e.signal.set(t), function(e) {
+			e.scheduledWrite || e.disposed || (e.scheduledWrite = !0, queueMicrotask(() => {
+				e.scheduledWrite = !1, e.disposed || (e.pendingWrite = e.adapter.save(e.signal.get()).catch((e) => {}));
+			}));
+		}(e));
+	}, r = { replace: (e) => n(e) };
+	switch (t) {
+		case "object": return {
+			...r,
+			set(t, r = !0) {
+				let i = e.signal.get();
+				n(r ? {
+					...i,
+					...t
+				} : t);
+			},
+			update(t) {
+				n(De(e.signal.get(), t));
+			},
+			delete(t) {
+				let r = { ...e.signal.get() };
+				delete r[t], n(r);
+			}
+		};
+		case "map": return {
+			...r,
+			set(t, r) {
+				let i = e.signal.get(), a = new Map(i);
+				a.set(t, r), n(a);
+			},
+			delete(t) {
+				let r = e.signal.get(), i = new Map(r);
+				i.delete(t), n(i);
+			},
+			clear() {
+				n(/* @__PURE__ */ new Map());
+			}
+		};
+		case "set": return {
+			...r,
+			add(t) {
+				let r = e.signal.get();
+				if (r.has(t)) return;
+				let i = new Set(r);
+				i.add(t), n(i);
+			},
+			delete(t) {
+				let r = e.signal.get();
+				if (!r.has(t)) return !1;
+				let i = new Set(r);
+				return i.delete(t), n(i), !0;
+			},
+			toggle(t) {
+				let r = e.signal.get(), i = new Set(r);
+				i.has(t) ? i.delete(t) : i.add(t), n(i);
+			},
+			clear() {
+				n(/* @__PURE__ */ new Set());
+			}
+		};
+		case "array": return {
+			...r,
+			push(...t) {
+				n([...e.signal.get(), ...t]);
+			},
+			update(t) {
+				n(De(e.signal.get(), t));
+			},
+			clear() {
+				n([]);
+			}
+		};
+		default: return {
+			...r,
+			set(e) {
+				n(e);
+			}
+		};
+	}
+}
+function Ue(e) {}
+function $(e, t = {}) {
+	let { namespace: n, initial: i, storage: a } = e, o = !0 === t.isolated, s = function(e, t) {
+		switch (e) {
+			case "local": return new Pe(localStorage, t, "localStorage");
+			case "session": return new Pe(sessionStorage, t, "sessionStorage");
+			case "indexeddb": return new Fe(t);
+			default: return new Ne();
+		}
+	}(a, n), c = new u.State(i), l = {
+		signal: c,
+		storage: a,
+		adapter: s,
+		pendingWrite: null,
+		scheduledWrite: !1,
+		disposed: !1
+	}, d = !1, ee = s.load().then((e) => {
+		l.disposed || e != null && l.signal.set(e);
+	}, Ue).then(() => d = !0).then(() => {}), f = function(e) {
+		return new r((t) => {
+			t.next(e.get());
+			let n = !1, r = new u.subtle.Watcher(() => {
+				n || (n = !0, queueMicrotask(() => {
+					n = !1, t.closed || (t.next(e.get()), r.watch(e));
+				}));
+			});
+			return r.watch(e), () => r.unwatch(e);
+		});
+	}(c), p = He(l, (m = i) instanceof Map ? "map" : m instanceof Set ? "set" : Array.isArray(m) ? "array" : typeof m != "object" || !m ? "scalar" : "object");
+	var m;
+	async function te() {
+		l.pendingWrite && await l.pendingWrite, await new Promise((e) => queueMicrotask(e)), l.pendingWrite && await l.pendingWrite, s.close && await s.close();
+	}
+	let h = () => {
+		l.disposed || (l.disposed = !0, te(), Z.delete(n));
+	}, g = Object.assign(Object.create(null), {
+		[Ie]: !0,
+		namespace: n,
+		storage: a,
+		defaultValue: i,
+		ready: ee,
+		destroy: h,
+		[Symbol.dispose]: h
+	});
+	if (Object.defineProperty(g, "loaded", {
+		get: () => d,
+		enumerable: !0
+	}), a === "indexeddb" && (g[Symbol.asyncDispose] = async () => {
+		l.disposed || (l.disposed = !0, await te(), Z.delete(n));
+	}), o) return Object.defineProperty(g, "value", {
+		get: () => c.get(),
+		enumerable: !0
+	}), g.signal = c, g.$ = f, Object.assign(g, p), g;
+	let _ = Object.assign(Object.create(null), {
+		signal: c,
+		$: f,
+		...p
+	});
+	Object.defineProperty(_, "value", {
+		get: () => c.get(),
+		enumerable: !0
+	}), Object.defineProperty(g, "value", {
+		get: () => Q(n, _).value,
+		enumerable: !0
+	}), Object.defineProperty(g, "signal", {
+		get: () => Q(n, _).signal,
+		enumerable: !0
+	}), Object.defineProperty(g, "$", {
+		get: () => Q(n, _).$,
+		enumerable: !0
+	});
+	for (let e of Object.keys(p)) g[e] = (...t) => Q(n, _)[e](...t);
+	return g._isolatedInstance = () => $({
+		namespace: n,
+		initial: c.get(),
+		storage: "memory"
+	}, { isolated: !0 }), g;
+}
+function We(e) {
+	if (Z.has(e)) throw Error(`[state] namespace "${e}" already registered. Each namespace must be unique.`);
+	return Z.add(e), {
+		memory: (t) => $({
+			namespace: e,
+			initial: t,
+			storage: "memory"
+		}),
+		local: (t) => $({
+			namespace: e,
+			initial: t,
+			storage: "local"
+		}),
+		session: (t) => $({
+			namespace: e,
+			initial: t,
+			storage: "session"
+		}),
+		idb: (t) => $({
+			namespace: e,
+			initial: t,
+			storage: "indexeddb"
+		})
+	};
+}
+function Ge(e) {
+	if (typeof e != "string") throw TypeError("[state] namespace must be a string");
+	if (!e.includes("/")) throw TypeError(`[state] namespace "${e}" must follow the "feature/name" convention.`);
+	return We(e);
+}
+function Ke(e) {
+	let t, n = !1, r = !1, i = () => {
+		if (r) return;
+		let a = new u.Computed(() => {
+			e();
+		});
+		t?.unwatch(), t = new u.subtle.Watcher(() => {
+			n || r || (n = !0, queueMicrotask(() => {
+				n = !1, r || i();
+			}));
+		}), t.watch(a), a.get();
+	};
+	return i(), { [Symbol.dispose]() {
+		r || (r = !0, t?.unwatch(), t = void 0);
+	} };
+}
+function qe(e, t, n, r = {}) {
+	let i = r.storage ?? "memory", a = We(t)[i](n), o = e.subscribe({
+		next: (e) => a.signal.set(e),
+		error: (e) => {}
+	}), s = a[Symbol.dispose].bind(a);
+	return a[Symbol.dispose] = () => {
+		o.unsubscribe(), s();
+	}, a;
+}
+var Je = class {
+	constructor(e, t) {
+		this.host = e, this.source = t, this.latest = t.value, e.addController(this);
+	}
+	get value() {
+		return this.latest;
+	}
+	get $() {
+		return this.source.$;
+	}
+	hostConnected() {
+		this.subscription = this.source.$.subscribe((e) => {
+			this.latest = e, this.host.requestUpdate();
+		});
+	}
+	hostDisconnected() {
+		this.subscription?.unsubscribe(), this.subscription = void 0;
+	}
+};
+function Ye(e, t) {
+	return new Je(e, t);
+}
+function Xe(e) {
+	return function(t, n) {
+		let r = Symbol(`__observe_${String(n)}`);
+		Object.defineProperty(t, n, {
+			get() {
+				let t = this[r];
+				return t === void 0 ? e.value : t;
+			},
+			set(e) {},
+			configurable: !0,
+			enumerable: !0
+		});
+		let i = t.constructor;
+		if (typeof i.addInitializer != "function") throw TypeError(`@observe requires a Lit ReactiveElement subclass — ${t.constructor.name} does not provide static addInitializer.`);
+		i.addInitializer((t) => {
+			let n;
+			t.addController({
+				hostConnected() {
+					n = e.$.subscribe((e) => {
+						t[r] = e, t.requestUpdate();
+					});
+				},
+				hostDisconnected() {
+					n?.unsubscribe(), n = void 0;
+				}
+			});
+		});
+	};
+}
+export { Xe as a, X as c, Ke as i, Ye as n, Ge as o, ee as r, qe as s, d as t };