@fest-lib/fl-ui 0.1.1

package/dist/assets/OPFS.uniform.worker-Ddx6J_37.js

@@ -0,0 +1,2982 @@
+(function() {
+	var ee = Object.defineProperty, Me = (e, t, n) => () => {
+		if (n) throw n[0];
+		try {
+			return e && (t = e(e = 0)), t;
+		} catch (s) {
+			throw n = [s], s;
+		}
+	}, De = (e, t) => {
+		let n = {};
+		for (var s in e) ee(n, s, {
+			get: e[s],
+			enumerable: !0
+		});
+		return t || ee(n, Symbol.toStringTag, { value: "Module" }), n;
+	};
+	let h = (function(e) {
+		return e.GET = "get", e.SET = "set", e.CALL = "call", e.APPLY = "apply", e.CONSTRUCT = "construct", e.DELETE = "delete", e.DELETE_PROPERTY = "deleteProperty", e.HAS = "has", e.OWN_KEYS = "ownKeys", e.GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor", e.GET_PROPERTY_DESCRIPTOR = "getPropertyDescriptor", e.GET_PROTOTYPE_OF = "getPrototypeOf", e.SET_PROTOTYPE_OF = "setPrototypeOf", e.IS_EXTENSIBLE = "isExtensible", e.PREVENT_EXTENSIONS = "preventExtensions", e.TRANSFER = "transfer", e.IMPORT = "import", e.DISPOSE = "dispose", e;
+	})({});
+	const Ne = {
+		ws: "websocket",
+		socket: "websocket",
+		socketio: "socket-io",
+		service: "service-worker",
+		sw: "service-worker",
+		"service-worker-client": "service-worker",
+		"service-worker-host": "service-worker",
+		"ring-buffer": "atomics"
+	};
+	function Le(e) {
+		const t = String(e ?? "").trim().toLowerCase();
+		return t ? Ne[t] ?? t : "internal";
+	}
+	function Be(e) {
+		return typeof e == "string" ? Le(e) : typeof Worker < "u" && e instanceof Worker ? "worker" : typeof SharedWorker < "u" && e instanceof SharedWorker ? "shared-worker" : typeof MessagePort < "u" && e instanceof MessagePort ? "message-port" : typeof BroadcastChannel < "u" && e instanceof BroadcastChannel ? "broadcast" : typeof WebSocket < "u" && e instanceof WebSocket ? "websocket" : typeof RTCDataChannel < "u" && e instanceof RTCDataChannel ? "rtc-data" : typeof chrome < "u" && e && typeof e == "object" && typeof e.postMessage == "function" && e.onMessage?.addListener ? "chrome-port" : "internal";
+	}
+	const te = Symbol.for("@fix"), C = (e) => typeof e == "string" || typeof e == "number" || typeof e == "boolean" || typeof e == "bigint" || typeof e > "u" || e == null, qe = (e, t) => C(e) ? t == "number" ? Number(e) || 0 : t == "string" ? String(e) || "" : t == "boolean" ? !!e : e : null, p = (e, t) => e?.[te] ?? e ?? t ?? t, Fe = (e) => {
+		if (typeof e == "function" || e == null) return e;
+		const t = function() {};
+		return t[te] = e, t;
+	}, He = (e) => crypto?.getRandomValues ? crypto?.getRandomValues?.(e) : (() => {
+		const t = new Uint8Array(e.length);
+		for (let n = 0; n < e.length; n++) t[n] = Math.floor(Math.random() * 256);
+		return t;
+	})(), d = () => crypto?.randomUUID ? crypto?.randomUUID?.() : "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (e) => (+e ^ He?.(/* @__PURE__ */ new Uint8Array(1))?.[0] & 15 >> +e / 4).toString(16)), ne = (e) => Array.isArray(e) ? e?.flatMap?.((t) => Array.isArray(t) ? ne(t) : t) : e, $ = (e) => ne(e)?.every?.(x), x = (e) => C(e) || typeof SharedArrayBuffer == "function" && e instanceof SharedArrayBuffer || Ge(e) || Array.isArray(e) && $(e), Ge = (e) => ArrayBuffer.isView(e) && !(e instanceof DataView), z = (e) => C(e) || typeof ArrayBuffer == "function" && e instanceof ArrayBuffer || typeof MessagePort == "function" && e instanceof MessagePort || typeof ReadableStream == "function" && e instanceof ReadableStream || typeof WritableStream == "function" && e instanceof WritableStream || typeof TransformStream == "function" && e instanceof TransformStream || typeof ImageBitmap == "function" && e instanceof ImageBitmap || typeof VideoFrame == "function" && e instanceof VideoFrame || typeof OffscreenCanvas == "function" && e instanceof OffscreenCanvas || typeof RTCDataChannel == "function" && e instanceof RTCDataChannel || typeof AudioData == "function" && e instanceof AudioData || typeof WebTransportReceiveStream == "function" && e instanceof WebTransportReceiveStream || typeof WebTransportSendStream == "function" && e instanceof WebTransportSendStream || typeof WebTransportReceiveStream == "function" && e instanceof WebTransportReceiveStream, k = (e, t, n) => {
+		if (Array.isArray(e)) return e.every(x) ? e.map(t) : e.map((s, r) => k(s, t, [e, r]));
+		if (e instanceof Map) {
+			const s = Array.from(e.entries());
+			return s.map(([r, i]) => i).every(x) ? new Map(s.map(([r, i]) => [r, t(i, r, e)])) : new Map(s.map(([r, i]) => [r, k(i, t, [e, r])]));
+		}
+		if (e instanceof Set) {
+			const s = Array.from(e.entries()), r = s.map(([i, o]) => o);
+			return s.every(x) ? new Set(r.map(t)) : new Set(r.map((i) => k(i, t, [e, i])));
+		}
+		if (typeof e == "object" && e?.constructor == Object && Object.prototype.toString.call(e) == "[object Object]") {
+			const s = Array.from(Object.entries(e));
+			return s.map(([r, i]) => i).every(x) ? Object.fromEntries(s.map(([r, i]) => [r, t(i, r, e)])) : Object.fromEntries(s.map(([r, i]) => [r, k(i, t, [e, r])]));
+		}
+		return t(e, n?.[1] ?? "", n?.[0] ?? null);
+	}, S = /* @__PURE__ */ new WeakMap(), se = /* @__PURE__ */ new WeakMap(), g = (e, t) => e instanceof Promise || typeof e?.then == "function" ? S?.has?.(e) ? t(S?.get?.(e)) : Promise.try?.(async () => {
+		const n = await e;
+		return S?.set?.(e, n), n;
+	})?.then?.(t) : t(e);
+	var Ue = class {
+		#e;
+		#t;
+		constructor(e, t) {
+			this.#e = e, this.#t = t;
+		}
+		defineProperty(e, t, n) {
+			return p(e) instanceof Promise ? Reflect.defineProperty(e, t, n) : g(p(e), (s) => Reflect.defineProperty(s, t, n));
+		}
+		deleteProperty(e, t) {
+			return p(e) instanceof Promise ? Reflect.deleteProperty(e, t) : g(p(e), (n) => Reflect.deleteProperty(n, t));
+		}
+		getPrototypeOf(e) {
+			return p(e) instanceof Promise ? Reflect.getPrototypeOf(e) : g(p(e), (t) => Reflect.getPrototypeOf(t));
+		}
+		setPrototypeOf(e, t) {
+			return p(e) instanceof Promise ? Reflect.setPrototypeOf(e, t) : g(p(e), (n) => Reflect.setPrototypeOf(n, t));
+		}
+		isExtensible(e) {
+			return p(e) instanceof Promise ? Reflect.isExtensible(e) : g(p(e), (t) => Reflect.isExtensible(t));
+		}
+		preventExtensions(e) {
+			return p(e) instanceof Promise ? Reflect.ownKeys(e) : g(p(e), (t) => Reflect.preventExtensions(t));
+		}
+		ownKeys(e) {
+			const t = p(e);
+			return t instanceof Promise ? Object.keys(t) : g(t, (n) => (typeof n == "object" || typeof n == "function") && n != null ? Object.keys(n) : []) ?? [];
+		}
+		getOwnPropertyDescriptor(e, t) {
+			return p(e) instanceof Promise ? Reflect.getOwnPropertyDescriptor(e, t) : g(p(e), (n) => Reflect.getOwnPropertyDescriptor(n, t));
+		}
+		construct(e, t, n) {
+			return g(p(e), (s) => Reflect.construct(s, t, n));
+		}
+		has(e, t) {
+			return p(e) instanceof Promise ? Reflect.has(e, t) : g(p(e), (n) => Reflect.has(n, t));
+		}
+		get(e, t, n) {
+			if (e = p(e), t == "promise") return e;
+			if (t == "resolve" && this.#e) return (...r) => {
+				const i = this.#e?.(...r);
+				return this.#e = null, i;
+			};
+			if (t == "reject" && this.#t) return (...r) => {
+				const i = this.#t?.(...r);
+				return this.#t = null, i;
+			};
+			if (t == "then" || t == "catch" || t == "finally") {
+				if (e instanceof Promise) return e?.[t]?.bind?.(e);
+				{
+					const r = Promise.try(() => e);
+					return r?.[t]?.bind?.(r);
+				}
+			}
+			let s;
+			return S?.has?.(e) && (s = S?.get?.(e))?.[t] != null ? s = S?.get?.(e)?.[t] : s = re(g(e, async (r) => {
+				if (p(r) instanceof Promise) return Reflect.get(r, t, n);
+				if (C(r)) return t == Symbol.toPrimitive || t == Symbol.toStringTag ? r : void 0;
+				let i;
+				try {
+					i = Reflect.get(r, t, n);
+				} catch {
+					i = e?.[t];
+				}
+				return typeof i == "function" ? i?.bind?.(r) : i;
+			})), t == Symbol.toStringTag ? C(s) ? String(s ?? "") || "" : s?.[Symbol.toStringTag]?.() || String(s ?? "") || "" : t == Symbol.toPrimitive ? (r) => {
+				if (C(s)) return qe(s, r);
+			} : s;
+		}
+		set(e, t, n) {
+			return g(p(e), (s) => Reflect.set(s, t, n));
+		}
+		apply(e, t, n) {
+			if (this.#e) {
+				const s = this.#e?.(...n);
+				return this.#e = null, s;
+			}
+			return g(p(e, this.#e), (s) => {
+				if (typeof s == "function") return p(s) instanceof Promise, Reflect.apply(s, t, n);
+			});
+		}
+	};
+	function re(e, t, n) {
+		return e instanceof Promise || typeof e?.then == "function" ? S?.has?.(e) ? S?.get?.(e) : (se?.has?.(e) || e?.then?.((s) => S?.set?.(e, s)), se?.getOrInsertComputed?.(e, () => new Proxy(Fe(e), new Ue(t, n)))) : e;
+	}
+	var oe = class {
+		_unsubscribe;
+		_closed = !1;
+		constructor(e) {
+			this._unsubscribe = e;
+		}
+		get closed() {
+			return this._closed;
+		}
+		unsubscribe() {
+			this._closed || (this._closed = !0, this._unsubscribe());
+		}
+	}, We = class {
+		_producer;
+		constructor(e) {
+			this._producer = e;
+		}
+		subscribe(e, t) {
+			const n = typeof e == "function" ? { next: e } : e ?? {}, s = new AbortController();
+			t?.signal?.addEventListener("abort", () => s.abort());
+			let r = !0, i;
+			const o = () => {
+				r = !1, s.abort(), i?.();
+			}, a = {
+				next: (c) => r && n.next?.(c),
+				error: (c) => {
+					r && (n.error?.(c), o());
+				},
+				complete: () => {
+					r && (n.complete?.(), o());
+				},
+				signal: s.signal,
+				get active() {
+					return r && !s.signal.aborted;
+				}
+			};
+			try {
+				i = this._producer(a);
+			} catch (c) {
+				a.error(c);
+			}
+			return new oe(o);
+		}
+		pipe(...e) {
+			return e.reduce((t, n) => n(t), this);
+		}
+	}, y = class {
+		_subs = /* @__PURE__ */ new Set();
+		_buffer = [];
+		_maxBuffer;
+		_replay;
+		constructor(e = {}) {
+			this._maxBuffer = e.bufferSize ?? 0, this._replay = e.replayOnSubscribe ?? !1;
+		}
+		next(e) {
+			this._maxBuffer > 0 && (this._buffer.push(e), this._buffer.length > this._maxBuffer && this._buffer.shift());
+			for (const t of this._subs) try {
+				t.next?.(e);
+			} catch (n) {
+				t.error?.(n);
+			}
+		}
+		error(e) {
+			for (const t of this._subs) t.error?.(e);
+		}
+		complete() {
+			for (const e of this._subs) e.complete?.();
+			this._subs.clear();
+		}
+		subscribe(e) {
+			const t = typeof e == "function" ? { next: e } : e;
+			if (this._subs.add(t), this._replay) for (const n of this._buffer) try {
+				t.next?.(n);
+			} catch (s) {
+				t.error?.(s);
+			}
+			return new oe(() => {
+				this._subs.delete(t);
+			});
+		}
+		getValue() {
+			return this._buffer.at(-1);
+		}
+		getBuffer() {
+			return [...this._buffer];
+		}
+		get subscriberCount() {
+			return this._subs.size;
+		}
+	};
+	const $e = (e) => (t) => new We((n) => {
+		const s = t.subscribe({
+			next: (r) => e(r) && n.next(r),
+			error: (r) => n.error(r),
+			complete: () => n.complete()
+		});
+		return () => s.unsubscribe();
+	});
+	function ie() {
+		if (typeof globalThis.Deno < "u") return "deno";
+		if (typeof globalThis.process < "u" && globalThis.process?.versions?.node) return "node";
+		const e = globalThis.ServiceWorkerGlobalScope, t = globalThis.SharedWorkerGlobalScope, n = globalThis.DedicatedWorkerGlobalScope;
+		if (e && self instanceof e) return "service-worker";
+		if (t && self instanceof t) return "shared-worker";
+		if (n && self instanceof n) return "worker";
+		if (typeof chrome < "u" && chrome.runtime?.id) {
+			if (typeof chrome.runtime.getBackgroundPage == "function" || chrome.runtime.getManifest?.()?.background?.service_worker) return "chrome-background";
+			if (typeof chrome.devtools < "u") return "chrome-devtools";
+			if (typeof document < "u" && globalThis?.location?.protocol === "chrome-extension:" && (chrome.extension?.getViews?.({ type: "popup" }) ?? []).includes(globalThis)) return "chrome-popup";
+			if (typeof document < "u" && globalThis?.location?.protocol !== "chrome-extension:") return "chrome-content";
+		}
+		return typeof globalThis < "u" && typeof document < "u" ? "window" : "unknown";
+	}
+	function ae(e) {
+		if (typeof RTCDataChannel < "u" && e instanceof RTCDataChannel) return "rtc-data";
+		const t = Be(e);
+		return t && t !== "internal" ? t : e === self || e === globalThis || e === "self" ? "self" : "internal";
+	}
+	function ze(e) {
+		if (!e) return "unknown";
+		if (e.contextType) return e.contextType;
+		const t = e.sender ?? "";
+		return t.includes("worker") ? "worker" : t.includes("sw") || t.includes("service") ? "service-worker" : t.includes("chrome") || t.includes("crx") ? "chrome-content" : t.includes("background") ? "chrome-background" : "unknown";
+	}
+	const Ye = {
+		get: (e, t) => Reflect.get(e, t),
+		set: (e, t, n) => Reflect.set(e, t, n),
+		has: (e, t) => Reflect.has(e, t),
+		apply: (e, t, n) => Reflect.apply(e, t, n),
+		construct: (e, t) => Reflect.construct(e, t),
+		deleteProperty: (e, t) => Reflect.deleteProperty(e, t),
+		ownKeys: (e) => Reflect.ownKeys(e),
+		getOwnPropertyDescriptor: (e, t) => Reflect.getOwnPropertyDescriptor(e, t),
+		getPrototypeOf: (e) => Reflect.getPrototypeOf(e),
+		setPrototypeOf: (e, t) => Reflect.setPrototypeOf(e, t),
+		isExtensible: (e) => Reflect.isExtensible(e),
+		preventExtensions: (e) => Reflect.preventExtensions(e)
+	}, Ke = Symbol.for("uniform.proxy"), Ve = Symbol.for("uniform.proxy.internals");
+	var Xe = class {
+		_invoker;
+		_config;
+		_childCache = /* @__PURE__ */ new Map();
+		constructor(e, t) {
+			this._invoker = e, this._config = {
+				channel: t.channel,
+				basePath: t.basePath ?? [],
+				invoker: e,
+				cache: t.cache ?? !0,
+				timeout: t.timeout ?? 3e4
+			};
+		}
+		get(e, t, n) {
+			const s = String(t);
+			if (t === Ke) return !0;
+			if (t === Ve) return this._config;
+			if (t === it) return !0;
+			if (t === D) return this._getDescriptor();
+			if (t === "then" || t === "catch" || t === "finally" || typeof t == "symbol") return;
+			if (t === "$path") return this._config.basePath;
+			if (t === "$channel") return this._config.channel;
+			if (t === "$descriptor") return this._getDescriptor();
+			if (t === "$invoke") return this._invoker;
+			const r = [...this._config.basePath, s];
+			if (this._config.cache && this._childCache.has(s)) return this._childCache.get(s);
+			const i = H(this._invoker, {
+				...this._config,
+				basePath: r
+			});
+			return this._config.cache && this._childCache.set(s, i), i;
+		}
+		set(e, t, n, s) {
+			return typeof t == "symbol" || this._invoker(h.SET, [...this._config.basePath, String(t)], [n]), !0;
+		}
+		apply(e, t, n) {
+			return this._invoker(h.APPLY, this._config.basePath, [n]);
+		}
+		construct(e, t, n) {
+			return this._invoker(h.CONSTRUCT, this._config.basePath, [t]);
+		}
+		has(e, t) {
+			return typeof t == "symbol" ? !1 : this._invoker(h.HAS, this._config.basePath, [t]);
+		}
+		deleteProperty(e, t) {
+			return typeof t == "symbol" ? !0 : this._invoker(h.DELETE_PROPERTY, [...this._config.basePath, String(t)], []);
+		}
+		ownKeys(e) {
+			return [];
+		}
+		getOwnPropertyDescriptor(e, t) {
+			return {
+				configurable: !0,
+				enumerable: !0,
+				writable: !0
+			};
+		}
+		getPrototypeOf(e) {
+			return Function.prototype;
+		}
+		setPrototypeOf(e, t) {
+			return this._invoker(h.SET_PROTOTYPE_OF, this._config.basePath, [t]);
+		}
+		isExtensible(e) {
+			return !0;
+		}
+		preventExtensions(e) {
+			return this._invoker(h.PREVENT_EXTENSIONS, this._config.basePath, []);
+		}
+		_getDescriptor() {
+			return {
+				path: this._config.basePath,
+				channel: this._config.channel,
+				primitive: !1
+			};
+		}
+	};
+	function H(e, t) {
+		const n = function() {}, s = new Xe(e, t);
+		return new Proxy(n, s);
+	}
+	function ce(e, t, n) {
+		if (!e || typeof e != "object" || e.primitive) return e;
+		const s = _e.get(e);
+		if (s) return s;
+		const r = H(t, {
+			channel: n ?? e.channel ?? "unknown",
+			basePath: e.path ?? []
+		});
+		return _e.set(e, r), V.set(r, e), r;
+	}
+	const Qe = ce;
+	function Ze(e) {
+		return [
+			e.localChannel,
+			e.remoteChannel,
+			e.sender,
+			e.transportType,
+			e.direction
+		].join("::");
+	}
+	function et(e, t = {}) {
+		const n = t.includeClosed ?? !1, s = t.status ?? (n ? void 0 : "active");
+		return [...e].filter((r) => !(s && r.status !== s || t.channel && r.localChannel !== t.channel && r.remoteChannel !== t.channel || t.localChannel && r.localChannel !== t.localChannel || t.remoteChannel && r.remoteChannel !== t.remoteChannel || t.sender && r.sender !== t.sender || t.transportType && r.transportType !== t.transportType || t.direction && r.direction !== t.direction)).sort((r, i) => i.updatedAt - r.updatedAt);
+	}
+	var le = class {
+		_createId;
+		_emitEvent;
+		_connections = /* @__PURE__ */ new Map();
+		constructor(e, t) {
+			this._createId = e, this._emitEvent = t;
+		}
+		register(e) {
+			const t = Ze(e), n = Date.now(), s = this._connections.get(t);
+			if (s) return s.updatedAt = n, s.status = "active", s.metadata = {
+				...s.metadata,
+				...e.metadata
+			}, s;
+			const r = {
+				id: this._createId(),
+				localChannel: e.localChannel,
+				remoteChannel: e.remoteChannel,
+				sender: e.sender,
+				transportType: e.transportType,
+				direction: e.direction,
+				status: "active",
+				createdAt: n,
+				updatedAt: n,
+				metadata: e.metadata
+			};
+			return this._connections.set(t, r), this._emitEvent?.({
+				type: "connected",
+				connection: r,
+				timestamp: n
+			}), r;
+		}
+		markNotified(e, t) {
+			const n = Date.now();
+			e.lastNotifyAt = n, e.updatedAt = n, this._emitEvent?.({
+				type: "notified",
+				connection: e,
+				timestamp: n,
+				payload: t
+			});
+		}
+		closeByChannel(e) {
+			const t = Date.now();
+			for (const n of this._connections.values()) n.localChannel !== e && n.remoteChannel !== e || n.status !== "closed" && (n.status = "closed", n.updatedAt = t, this._emitEvent?.({
+				type: "disconnected",
+				connection: n,
+				timestamp: t
+			}));
+		}
+		closeAll() {
+			const e = Date.now();
+			for (const t of this._connections.values()) t.status !== "closed" && (t.status = "closed", t.updatedAt = e, this._emitEvent?.({
+				type: "disconnected",
+				connection: t,
+				timestamp: e
+			}));
+		}
+		query(e = {}) {
+			return et(this._connections.values(), e);
+		}
+		values() {
+			return [...this._connections.values()];
+		}
+		clear() {
+			this._connections.clear();
+		}
+	}, ue = class {
+		_name;
+		_contextType;
+		_config;
+		_transports = /* @__PURE__ */ new Map();
+		_defaultTransport = null;
+		_connectionEvents = new y({ bufferSize: 200 });
+		_connectionRegistry = new le(() => d(), (e) => this._connectionEvents.next(e));
+		_pending = /* @__PURE__ */ new Map();
+		_subscriptions = [];
+		_inbound = new y({ bufferSize: 100 });
+		_outbound = new y({ bufferSize: 100 });
+		_invocations = new y({ bufferSize: 100 });
+		_responses = new y({ bufferSize: 100 });
+		_exposed = /* @__PURE__ */ new Map();
+		_proxyCache = /* @__PURE__ */ new WeakMap();
+		__getPrivate(e) {
+			return this[e];
+		}
+		__setPrivate(e, t) {
+			this[e] = t;
+		}
+		constructor(e) {
+			const t = typeof e == "string" ? { name: e } : e;
+			this._name = t.name, this._contextType = t.autoDetect !== !1 ? ie() : "unknown", this._config = {
+				name: t.name,
+				autoDetect: t.autoDetect ?? !0,
+				timeout: t.timeout ?? 3e4,
+				reflect: t.reflect ?? Ye,
+				bufferSize: t.bufferSize ?? 100,
+				autoListen: t.autoListen ?? !0
+			}, this._config.autoListen && this._isWorkerContext() && this.listen(self);
+		}
+		connect(e, t = {}) {
+			const n = ae(e), s = t.targetChannel ?? this._inferTargetChannel(e, n), r = this._createTransportBinding(e, n, s, t);
+			this._transports.set(s, r), this._defaultTransport || (this._defaultTransport = r);
+			const i = this._registerConnection({
+				localChannel: this._name,
+				remoteChannel: s,
+				sender: this._name,
+				transportType: n,
+				direction: "outgoing",
+				metadata: { phase: "connect" }
+			});
+			return this._emitConnectionSignal(r, "connect", {
+				connectionId: i.id,
+				from: this._name,
+				to: s
+			}), this;
+		}
+		listen(e, t = {}) {
+			const n = ae(e), s = t.targetChannel ?? this._inferTargetChannel(e, n), r = (o) => this._handleIncoming(o), i = this._registerConnection({
+				localChannel: this._name,
+				remoteChannel: s,
+				sender: s,
+				transportType: n,
+				direction: "incoming",
+				metadata: { phase: "listen" }
+			});
+			switch (n) {
+				case "worker":
+				case "message-port":
+				case "broadcast":
+					t.autoStart !== !1 && e.start && e.start(), e.addEventListener?.("message", ((o) => r(o.data)));
+					break;
+				case "websocket":
+					e.addEventListener?.("message", ((o) => {
+						try {
+							r(JSON.parse(o.data));
+						} catch {}
+					}));
+					break;
+				case "chrome-runtime":
+					chrome.runtime.onMessage?.addListener?.((o, a, c) => (r(o), !0));
+					break;
+				case "chrome-tabs":
+					chrome.runtime.onMessage?.addListener?.((o, a) => t.tabId != null && a?.tab?.id !== t.tabId ? !1 : (r(o), !0));
+					break;
+				case "chrome-port":
+					e?.onMessage?.addListener?.((o) => {
+						r(o);
+					});
+					break;
+				case "chrome-external":
+					chrome.runtime.onMessageExternal?.addListener?.((o) => (r(o), !0));
+					break;
+				case "self":
+					addEventListener?.("message", ((o) => r(o.data)));
+					break;
+				default: t.onMessage && t.onMessage(r);
+			}
+			return this._sendSignalToTarget(e, n, {
+				connectionId: i.id,
+				from: this._name,
+				to: s,
+				tabId: t.tabId,
+				externalId: t.externalId
+			}, "notify"), this;
+		}
+		attach(e, t = {}) {
+			return this.connect(e, t);
+		}
+		expose(e, t) {
+			const n = [e];
+			return U(n, t), this._exposed.set(e, {
+				name: e,
+				obj: t,
+				path: n
+			}), this;
+		}
+		exposeAll(e) {
+			for (const [t, n] of Object.entries(e)) this.expose(t, n);
+			return this;
+		}
+		async import(e, t) {
+			return this.invoke(t ?? this._getDefaultTarget(), h.IMPORT, [], [e]);
+		}
+		invoke(e, t, n, s = []) {
+			const r = d(), i = Promise.withResolvers();
+			this._pending.set(r, i);
+			const o = setTimeout(() => {
+				this._pending.has(r) && (this._pending.delete(r), i.reject(/* @__PURE__ */ new Error(`Request timeout: ${t} on ${n.join(".")}`)));
+			}, this._config.timeout), a = {
+				id: r,
+				channel: e,
+				sender: this._name,
+				type: "request",
+				payload: {
+					channel: e,
+					sender: this._name,
+					action: t,
+					path: n,
+					args: s
+				},
+				timestamp: Date.now()
+			};
+			return this._send(e, a), this._outbound.next(a), i.promise.finally(() => clearTimeout(o));
+		}
+		get(e, t, n) {
+			return this.invoke(e, h.GET, t, [n]);
+		}
+		set(e, t, n, s) {
+			return this.invoke(e, h.SET, t, [n, s]);
+		}
+		call(e, t, n = []) {
+			return this.invoke(e, h.APPLY, t, [n]);
+		}
+		construct(e, t, n = []) {
+			return this.invoke(e, h.CONSTRUCT, t, [n]);
+		}
+		proxy(e, t = []) {
+			const n = e ?? this._getDefaultTarget();
+			return this._createProxy(n, t);
+		}
+		remote(e, t) {
+			return this.proxy(t, [e]);
+		}
+		wrapDescriptor(e, t) {
+			return ce(e, (s, r, i) => {
+				const o = t ?? e?.channel ?? this._getDefaultTarget();
+				return this.invoke(o, s, r, i);
+			}, t ?? e?.channel ?? this._getDefaultTarget());
+		}
+		subscribe(e) {
+			return this._inbound.subscribe(e);
+		}
+		next(e) {
+			this._send(e.channel, e), this._outbound.next(e);
+		}
+		emit(e, t, n) {
+			const s = {
+				id: d(),
+				channel: e,
+				sender: this._name,
+				type: "event",
+				payload: {
+					type: t,
+					data: n
+				},
+				timestamp: Date.now()
+			};
+			this.next(s);
+		}
+		notify(e, t = {}, n = "notify") {
+			const s = this._transports.get(e);
+			return s ? (this._emitConnectionSignal(s, n, {
+				from: this._name,
+				to: e,
+				...t
+			}), !0) : !1;
+		}
+		get onMessage() {
+			return this._inbound;
+		}
+		get onOutbound() {
+			return this._outbound;
+		}
+		get onInvocation() {
+			return this._invocations;
+		}
+		get onResponse() {
+			return this._responses;
+		}
+		get onConnection() {
+			return this._connectionEvents;
+		}
+		subscribeConnections(e) {
+			return this._connectionEvents.subscribe(e);
+		}
+		queryConnections(e = {}) {
+			return this._connectionRegistry.query(e);
+		}
+		notifyConnections(e = {}, t = {}) {
+			let n = 0;
+			const s = this.queryConnections({
+				...t,
+				status: "active",
+				includeClosed: !1
+			});
+			for (const r of s) {
+				const i = this._transports.get(r.remoteChannel);
+				i && (this._emitConnectionSignal(i, "notify", {
+					connectionId: r.id,
+					from: this._name,
+					to: r.remoteChannel,
+					...e
+				}), n++);
+			}
+			return n;
+		}
+		get name() {
+			return this._name;
+		}
+		get contextType() {
+			return this._contextType;
+		}
+		get config() {
+			return this._config;
+		}
+		get connectedChannels() {
+			return [...this._transports.keys()];
+		}
+		get exposedModules() {
+			return [...this._exposed.keys()];
+		}
+		close() {
+			this._subscriptions.forEach((e) => e.unsubscribe()), this._subscriptions = [], this._pending.clear(), this._markAllConnectionsClosed();
+			for (const e of this._transports.values()) {
+				try {
+					e.cleanup?.();
+				} catch {}
+				if (e.transportType === "message-port" || e.transportType === "broadcast") try {
+					e.target?.close?.();
+				} catch {}
+			}
+			this._transports.clear(), this._defaultTransport = null, this._connectionRegistry.clear(), this._inbound.complete(), this._outbound.complete(), this._invocations.complete(), this._responses.complete(), this._connectionEvents.complete();
+		}
+		_handleIncoming(e) {
+			if (!(!e || typeof e != "object")) switch (this._inbound.next(e), e.type) {
+				case "request":
+					e.channel === this._name && this._handleRequest(e);
+					break;
+				case "response":
+					this._handleResponse(e);
+					break;
+				case "event": break;
+				case "signal":
+					this._handleSignal(e);
+					break;
+			}
+		}
+		_handleResponse(e) {
+			const t = e.reqId ?? e.id, n = this._pending.get(t);
+			if (n) {
+				if (this._pending.delete(t), e.payload?.error) n.reject(new Error(e.payload.error));
+				else {
+					const s = e.payload?.result, r = e.payload?.descriptor;
+					s != null ? n.resolve(s) : r ? n.resolve(this.wrapDescriptor(r, e.sender)) : n.resolve(void 0);
+				}
+				this._responses.next({
+					id: t,
+					channel: e.channel,
+					sender: e.sender,
+					result: e.payload?.result,
+					descriptor: e.payload?.descriptor,
+					timestamp: Date.now()
+				});
+			}
+		}
+		async _handleRequest(e) {
+			const t = e.payload;
+			if (!t) return;
+			const { action: n, path: s, args: r, sender: i } = t, o = e.reqId ?? e.id;
+			this._invocations.next({
+				id: o,
+				channel: this._name,
+				sender: i,
+				action: n,
+				path: s,
+				args: r ?? [],
+				timestamp: Date.now(),
+				contextType: ze(e)
+			});
+			const { result: a, toTransfer: c, newPath: l } = await this._executeAction(n, s, r ?? [], i);
+			await this._sendResponse(o, n, i, l, a, c);
+		}
+		async _executeAction(e, t, n, s) {
+			const { result: r, toTransfer: i, path: o } = me(e, t, n, {
+				channel: this._name,
+				sender: s,
+				reflect: this._config.reflect
+			});
+			return {
+				result: await r,
+				toTransfer: i,
+				newPath: o
+			};
+		}
+		async _sendResponse(e, t, n, s, r, i) {
+			const { response: o, transfer: a } = await we(e, t, this._name, n, s, r, i), c = {
+				id: e,
+				...o,
+				timestamp: Date.now(),
+				transferable: a
+			};
+			this._send(n, c, a);
+		}
+		_handleSignal(e) {
+			const t = e?.payload ?? {}, n = t.from ?? e.sender ?? "unknown", s = e.transportType ?? this._transports.get(e.channel)?.transportType ?? "internal", r = this._registerConnection({
+				localChannel: this._name,
+				remoteChannel: n,
+				sender: e.sender ?? n,
+				transportType: s,
+				direction: "incoming"
+			});
+			this._markConnectionNotified(r, t);
+		}
+		_registerConnection(e) {
+			return this._connectionRegistry.register(e);
+		}
+		_markConnectionNotified(e, t) {
+			this._connectionRegistry.markNotified(e, t);
+		}
+		_emitConnectionSignal(e, t, n = {}) {
+			const s = {
+				id: d(),
+				type: "signal",
+				channel: e.targetChannel,
+				sender: this._name,
+				transportType: e.transportType,
+				payload: {
+					type: t,
+					from: this._name,
+					to: e.targetChannel,
+					...n
+				},
+				timestamp: Date.now()
+			};
+			(e?.sender ?? e?.postMessage)?.call(e, s);
+			const r = this._registerConnection({
+				localChannel: this._name,
+				remoteChannel: e.targetChannel,
+				sender: this._name,
+				transportType: e.transportType,
+				direction: "outgoing"
+			});
+			this._markConnectionNotified(r, s.payload);
+		}
+		_sendSignalToTarget(e, t, n, s) {
+			const r = {
+				id: d(),
+				type: "signal",
+				channel: n.to ?? this._name,
+				sender: this._name,
+				transportType: t,
+				payload: {
+					type: s,
+					...n
+				},
+				timestamp: Date.now()
+			};
+			try {
+				if (t === "websocket") {
+					e?.send?.(JSON.stringify(r));
+					return;
+				}
+				if (t === "chrome-runtime") {
+					chrome.runtime?.sendMessage?.(r);
+					return;
+				}
+				if (t === "chrome-tabs") {
+					const i = n.tabId;
+					i != null && chrome.tabs?.sendMessage?.(i, r);
+					return;
+				}
+				if (t === "chrome-port") {
+					e?.postMessage?.(r);
+					return;
+				}
+				if (t === "chrome-external") {
+					n.externalId && chrome.runtime?.sendMessage?.(n.externalId, r);
+					return;
+				}
+				e?.postMessage?.(r, { transfer: [] });
+			} catch {}
+		}
+		_markAllConnectionsClosed() {
+			this._connectionRegistry.closeAll();
+		}
+		_createTransportBinding(e, t, n, s) {
+			let r, i;
+			switch (t) {
+				case "worker":
+				case "message-port":
+				case "broadcast":
+					s.autoStart !== !1 && e.start && e.start(), r = (o, a) => e.postMessage(o, { transfer: a });
+					{
+						const o = ((a) => this._handleIncoming(a.data));
+						e.addEventListener?.("message", o), i = () => e.removeEventListener?.("message", o);
+					}
+					break;
+				case "websocket":
+					r = (o) => e.send(JSON.stringify(o));
+					{
+						const o = ((a) => {
+							try {
+								this._handleIncoming(JSON.parse(a.data));
+							} catch {}
+						});
+						e.addEventListener?.("message", o), i = () => e.removeEventListener?.("message", o);
+					}
+					break;
+				case "chrome-runtime":
+					r = (o) => chrome.runtime.sendMessage(o);
+					{
+						const o = (a) => this._handleIncoming(a);
+						chrome.runtime.onMessage?.addListener?.(o), i = () => chrome.runtime.onMessage?.removeListener?.(o);
+					}
+					break;
+				case "chrome-tabs":
+					r = (o) => {
+						s.tabId != null && chrome.tabs?.sendMessage?.(s.tabId, o);
+					};
+					{
+						const o = (a, c) => s.tabId != null && c?.tab?.id !== s.tabId ? !1 : (this._handleIncoming(a), !0);
+						chrome.runtime.onMessage?.addListener?.(o), i = () => chrome.runtime.onMessage?.removeListener?.(o);
+					}
+					break;
+				case "chrome-port":
+					if (e?.postMessage && e?.onMessage?.addListener) {
+						r = (a) => e.postMessage(a);
+						const o = (a) => this._handleIncoming(a);
+						e.onMessage.addListener(o), i = () => {
+							try {
+								e.onMessage.removeListener(o);
+							} catch {}
+							try {
+								e.disconnect?.();
+							} catch {}
+						};
+					} else {
+						const o = s.portName ?? n, a = s.tabId != null && chrome.tabs?.connect ? chrome.tabs.connect(s.tabId, { name: o }) : chrome.runtime.connect({ name: o });
+						r = (l) => a.postMessage(l);
+						const c = (l) => this._handleIncoming(l);
+						a.onMessage.addListener(c), i = () => {
+							try {
+								a.onMessage.removeListener(c);
+							} catch {}
+							try {
+								a.disconnect();
+							} catch {}
+						};
+					}
+					break;
+				case "chrome-external":
+					r = (o) => {
+						s.externalId && chrome.runtime.sendMessage(s.externalId, o);
+					};
+					{
+						const o = (a) => (this._handleIncoming(a), !0);
+						chrome.runtime.onMessageExternal?.addListener?.(o), i = () => chrome.runtime.onMessageExternal?.removeListener?.(o);
+					}
+					break;
+				case "self":
+					r = (o, a) => globalThis.postMessage?.(o, { transfer: a ?? [] });
+					{
+						const o = ((a) => this._handleIncoming(a.data));
+						globalThis.addEventListener?.("message", o), i = () => globalThis.removeEventListener?.("message", o);
+					}
+					break;
+				default: s.onMessage && (i = s.onMessage((o) => this._handleIncoming(o))), r = (o) => e?.postMessage?.(o);
+			}
+			return {
+				target: e,
+				targetChannel: n,
+				transportType: t,
+				sender: r,
+				cleanup: i,
+				postMessage: (o, a) => r?.(o, a),
+				start: () => e?.start?.(),
+				close: () => e?.close?.()
+			};
+		}
+		_send(e, t, n) {
+			const s = this._transports.get(e) ?? this._defaultTransport;
+			(s?.sender ?? s?.postMessage)?.call(s, t, n);
+		}
+		_getDefaultTarget() {
+			return this._defaultTransport ? this._defaultTransport.targetChannel : "worker";
+		}
+		_inferTargetChannel(e, t) {
+			return t === "worker" ? "worker" : t === "broadcast" && e.name ? e.name : t === "self" ? "self" : `${t}-${d().slice(0, 8)}`;
+		}
+		_createProxy(e, t) {
+			return H((s, r, i) => this.invoke(e, s, r, i), {
+				channel: e,
+				basePath: t,
+				cache: !0,
+				timeout: this._config.timeout
+			});
+		}
+		_isWorkerContext() {
+			return [
+				"worker",
+				"shared-worker",
+				"service-worker"
+			].includes(this._contextType);
+		}
+	};
+	function Y(e) {
+		return new ue(e);
+	}
+	let G = null;
+	function tt() {
+		if (!G) {
+			const e = ie();
+			[
+				"worker",
+				"shared-worker",
+				"service-worker"
+			].includes(e) ? G = Y({
+				name: "worker",
+				autoListen: !0
+			}) : G = Y({
+				name: "host",
+				autoListen: !1
+			});
+		}
+		return G;
+	}
+	const m = {
+		rjb: "rejectBy",
+		rvb: "resolveBy",
+		rj: "reject",
+		rv: "resolve",
+		cr: "create",
+		cs: "createSync",
+		a: "array",
+		ta: "typedarray",
+		udf: "undefined"
+	};
+	[
+		typeof ArrayBuffer != m.udf ? ArrayBuffer : null,
+		typeof MessagePort != m.udf ? MessagePort : null,
+		typeof ReadableStream != m.udf ? ReadableStream : null,
+		typeof WritableStream != m.udf ? WritableStream : null,
+		typeof TransformStream != m.udf ? TransformStream : null,
+		typeof WebTransportReceiveStream != m.udf ? WebTransportReceiveStream : null,
+		typeof WebTransportSendStream != m.udf ? WebTransportSendStream : null,
+		typeof AudioData != m.udf ? AudioData : null,
+		typeof ImageBitmap != m.udf ? ImageBitmap : null,
+		typeof VideoFrame != m.udf ? VideoFrame : null,
+		typeof OffscreenCanvas != m.udf ? OffscreenCanvas : null,
+		typeof RTCDataChannel != m.udf ? RTCDataChannel : null
+	].filter((e) => e != null);
+	function he() {
+		try {
+			const e = globalThis.location?.href;
+			if (typeof e == "string" && e.length > 0) return e;
+		} catch {}
+		try {
+			if (typeof document < "u" && typeof document.baseURI == "string" && document.baseURI.length > 0) return document.baseURI;
+		} catch {}
+		return "";
+	}
+	function de(e) {
+		const t = he();
+		if (!t.length) throw new TypeError("[uniform] No base URL for worker resolution (missing location / document.baseURI)");
+		const n = e.startsWith("/") ? e.replace(/^\//, "./") : e;
+		return new URL(n, t).href;
+	}
+	const w = {
+		name: "unknown",
+		instance: null
+	}, K = /* @__PURE__ */ new Map(), fe = (e) => [...Object.values(h)].includes(e);
+	var nt = class {
+		channelName;
+		options;
+		_channel;
+		constructor(e, t = {}) {
+			this.channelName = e, this.options = t, this._channel = tt();
+		}
+		request(e, t, n, s = {}) {
+			return typeof e == "string" && (e = [e]), Array.isArray(t) && fe(e) && (s = n, n = t, t = e, e = []), this._channel.invoke(this.channelName, t, e, n);
+		}
+		doImportModule(e, t) {
+			return this._channel.import(e, this.channelName);
+		}
+	}, st = class {
+		channel;
+		options;
+		_unified;
+		broadcasts = {};
+		constructor(e, t = {}) {
+			this.channel = e, this.options = t, this._unified = Y({
+				name: e,
+				autoListen: !1
+			}), w.name = e, w.instance = this;
+		}
+		createRemoteChannel(e, t = {}, n) {
+			return n && (this._unified.attach(n, { targetChannel: e }), this.broadcasts[e] = n), Promise.resolve(new nt(e, t));
+		}
+		getChannel() {
+			return this.channel;
+		}
+		request(e, t, n, s = {}, r = "worker") {
+			return typeof e == "string" && (e = [e]), Array.isArray(t) && fe(e) && (r = s, s = n, n = t, t = e, e = []), this._unified.invoke(r, t, e, n);
+		}
+		resolveResponse(e, t) {
+			return Promise.resolve(t);
+		}
+		async handleAndResponse(e, t, n) {
+			const s = await lt(e, t, this.channel);
+			s && n?.(s.response, s.transfer);
+		}
+		close() {
+			this._unified.close();
+		}
+	};
+	const rt = (e = "$host$") => {
+		if (w?.instance && e === "$host$") return w.instance;
+		if (K.has(e)) return K.get(e) ?? null;
+		const t = new st(e);
+		return e === "$host$" && (w.name = e, w.instance = t), K.set(e, t), t;
+	}, pe = /* @__PURE__ */ new WeakMap(), V = /* @__PURE__ */ new WeakMap(), _e = /* @__PURE__ */ new WeakMap(), ot = (e, t = w?.name, n) => typeof e == "object" && e != null || typeof e == "function" && e != null ? V.has(e) ? V.get(e) : pe.has(e) ? pe.get(e) : $(e) || n?.includes?.(e) || t == w?.name ? e : {
+		$isDescriptor: !0,
+		path: E.get(e) ?? (() => {
+			const s = [d()];
+			return U(s, e), s;
+		})(),
+		owner: w?.name,
+		channel: t,
+		primitive: C(e),
+		writable: !0,
+		enumerable: !0,
+		configurable: !0,
+		argumentCount: e instanceof Function ? e.length : -1
+	} : x(e) ? e : null, it = Symbol.for("@requestHandler"), D = Symbol.for("@descriptor"), X = (e) => x(e) || e?.[D] ? e : e?.$isDescriptor ? Qe(e, async () => {}) : $(e) ? e : null, L = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new WeakMap(), j = (e, t) => {
+		if (t != null && !Array.isArray(t) && (t = [t]), t == null || t?.length < 1) return e;
+		const n = e?.[D] ?? (e?.$isDescriptor ? e : null);
+		if (n && n?.owner == w?.name && (e = R(n?.path) ?? e), C(e)) return e;
+		for (const s of t) if (e = e?.[s], e == null) return e;
+		return e;
+	}, R = (e) => {
+		if (e != null && !Array.isArray(e) && (e = [e]), e == null || e?.length < 1) return null;
+		const t = L?.get?.(e?.[0]) ?? null;
+		return t != null ? j(t, e?.slice?.(1)) : null;
+	}, U = (e, t) => {
+		const n = t?.[D] ?? (t?.$isDescriptor ? t : null);
+		if (n && n?.owner == w?.name && (t = R(n?.path) ?? t), e != null && !Array.isArray(e) && (e = [e]), e == null || e?.length < 1) return null;
+		const s = L?.get?.(e?.[0]) ?? null;
+		return e?.length > 1 ? j(s, e?.slice?.(1, -1))[e?.[e?.length - 1]] = t : L?.set?.(e?.[0], t), (typeof t == "object" || typeof t == "function") && E?.set?.(t, e), t;
+	}, ye = (e) => {
+		if (e != null && !Array.isArray(e) && (e = [e]), e == null || e?.length < 1) return !1;
+		return !(L?.get?.(e?.[0]) ?? null) && e?.length <= 1 ? (L?.delete?.(e?.[0]), !0) : !1;
+	}, at = (e) => {
+		const t = e?.[D] ?? (e?.$isDescriptor ? e : null);
+		t && t?.owner == w?.name && (e = R(t?.path) ?? e);
+		const n = E?.get?.(e) ?? t?.path;
+		return n == null || n?.length < 1 ? !1 : (ye(n), (typeof e == "object" || typeof e == "function") && E?.delete?.(e), !0);
+	}, ct = (e) => {
+		const t = e?.[D] ?? (e?.$isDescriptor ? e : null);
+		return (E?.get?.(e) ?? t?.path) == null;
+	}, P = (e) => (typeof e == "object" || typeof e == "function") && e != null, ge = {
+		get: (e, t) => e?.[t],
+		set: (e, t, n) => (e[t] = n, !0),
+		has: (e, t) => t in e,
+		apply: (e, t, n) => e.apply(t, n),
+		construct: (e, t) => new e(...t),
+		deleteProperty: (e, t) => delete e[t],
+		ownKeys: (e) => Object.keys(e),
+		getOwnPropertyDescriptor: (e, t) => Object.getOwnPropertyDescriptor(e, t),
+		getPrototypeOf: (e) => Object.getPrototypeOf(e),
+		setPrototypeOf: (e, t) => Object.setPrototypeOf(e, t),
+		isExtensible: (e) => Object.isExtensible(e),
+		preventExtensions: (e) => Object.preventExtensions(e)
+	};
+	function me(e, t, n, s = {}) {
+		const { channel: r = "", sender: i = "", reflect: o = ge } = s, a = s.target ?? R(t), c = [];
+		let l = null, _ = t;
+		switch (String(e).toLowerCase()) {
+			case "import":
+			case h.IMPORT:
+				l = import(n?.[0]);
+				break;
+			case "transfer":
+			case h.TRANSFER:
+				z(a) && r !== i && c.push(a), l = a;
+				break;
+			case "get":
+			case h.GET: {
+				const f = n?.[0], b = o.get?.(a, f) ?? a?.[f];
+				l = typeof b == "function" && a != null ? b.bind(a) : b, _ = [...t, String(f)];
+				break;
+			}
+			case "set":
+			case h.SET: {
+				const [f, b] = n, N = k(b, X);
+				s.target ? l = o.set?.(a, f, N) ?? (a[f] = N, !0) : l = o.set?.(a, f, N) ?? U([...t, String(f)], N);
+				break;
+			}
+			case "apply":
+			case "call":
+			case h.APPLY:
+			case h.CALL:
+				if (typeof a == "function") {
+					const f = s.context ?? (s.target ? void 0 : R(t.slice(0, -1))), b = k(n?.[0] ?? n ?? [], X);
+					l = o.apply?.(a, f, b) ?? a.apply(f, b), z(l) && t?.at(-1) === "transfer" && r !== i && c.push(l);
+				}
+				break;
+			case "construct":
+			case h.CONSTRUCT:
+				if (typeof a == "function") {
+					const f = k(n?.[0] ?? n ?? [], X);
+					l = o.construct?.(a, f) ?? new a(...f);
+				}
+				break;
+			case "delete":
+			case "deleteproperty":
+			case "dispose":
+			case h.DELETE:
+			case h.DELETE_PROPERTY:
+			case h.DISPOSE:
+				if (s.target) {
+					const f = t[t.length - 1];
+					l = o.deleteProperty?.(a, f) ?? delete a[f];
+				} else l = t?.length > 0 ? ye(t) : at(a), l && (_ = E.get(a) ?? []);
+				break;
+			case "has":
+			case h.HAS:
+				l = o.has?.(a, n?.[0]) ?? (P(a) ? n?.[0] in a : !1);
+				break;
+			case "ownkeys":
+			case h.OWN_KEYS:
+				l = o.ownKeys?.(a) ?? (P(a) ? Object.keys(a) : []);
+				break;
+			case "getownpropertydescriptor":
+			case "getpropertydescriptor":
+			case h.GET_OWN_PROPERTY_DESCRIPTOR:
+			case h.GET_PROPERTY_DESCRIPTOR:
+				l = o.getOwnPropertyDescriptor?.(a, n?.[0] ?? t?.at(-1) ?? "") ?? (P(a) ? Object.getOwnPropertyDescriptor(a, n?.[0] ?? t?.at(-1) ?? "") : void 0);
+				break;
+			case "getprototypeof":
+			case h.GET_PROTOTYPE_OF:
+				l = o.getPrototypeOf?.(a) ?? (P(a) ? Object.getPrototypeOf(a) : null);
+				break;
+			case "setprototypeof":
+			case h.SET_PROTOTYPE_OF:
+				l = o.setPrototypeOf?.(a, n?.[0]) ?? (P(a) ? Object.setPrototypeOf(a, n?.[0]) : !1);
+				break;
+			case "isextensible":
+			case h.IS_EXTENSIBLE:
+				l = o.isExtensible?.(a) ?? (P(a) ? Object.isExtensible(a) : !0);
+				break;
+			case "preventextensions":
+			case h.PREVENT_EXTENSIONS:
+				l = o.preventExtensions?.(a) ?? (P(a) ? Object.preventExtensions(a) : !1);
+				break;
+		}
+		return {
+			result: l,
+			toTransfer: c,
+			path: _
+		};
+	}
+	async function we(e, t, n, s, r, i, o) {
+		const a = await i, c = z(a) && o.includes(a) || x(a);
+		let l = r;
+		!c && t !== "get" && t !== h.GET && (typeof a == "object" || typeof a == "function") && (ct(a) ? (l = [d()], U(l, a)) : l = E.get(a) ?? []);
+		const _ = R(l), f = t === "get" || t === h.GET ? l?.at(-1) : void 0, b = R(r), N = k(a, (It) => ot(It, n, o)) ?? a;
+		return {
+			response: {
+				channel: s,
+				sender: n,
+				reqId: e,
+				action: t,
+				type: "response",
+				payload: {
+					result: c ? N : null,
+					type: typeof a,
+					channel: s,
+					sender: n,
+					descriptor: {
+						$isDescriptor: !0,
+						path: l,
+						owner: n,
+						channel: n,
+						primitive: C(a),
+						writable: !0,
+						enumerable: !0,
+						configurable: !0,
+						argumentCount: b instanceof Function ? b.length : -1,
+						...P(_) && f != null ? Object.getOwnPropertyDescriptor(_, f) : {}
+					}
+				}
+			},
+			transfer: o
+		};
+	}
+	async function lt(e, t, n, s) {
+		const { channel: r, sender: i, path: o, action: a, args: c } = e;
+		if (r !== n) return null;
+		const { result: l, toTransfer: _, path: f } = me(a, o, c, {
+			channel: r,
+			sender: i,
+			...s
+		});
+		return we(t, a, n, i, f, l, _);
+	}
+	var ht = class {
+		_name;
+		_transportType;
+		_id = d();
+		_state = "disconnected";
+		_inbound = new y({ bufferSize: 1e3 });
+		_outbound = new y({ bufferSize: 1e3 });
+		_stateChanges = new y();
+		_connectedPeers = /* @__PURE__ */ new Map();
+		_subs = [];
+		_stats = {
+			messagesSent: 0,
+			messagesReceived: 0,
+			bytesTransferred: 0,
+			latencyMs: 0,
+			uptime: 0,
+			reconnectCount: 0
+		};
+		_startTime = 0;
+		_pending = /* @__PURE__ */ new Map();
+		_buffer = [];
+		_opts;
+		constructor(e, t = "internal", n = {}) {
+			this._name = e, this._transportType = t, this._opts = {
+				timeout: 3e4,
+				autoReconnect: !0,
+				reconnectInterval: 1e3,
+				maxReconnectAttempts: 5,
+				bufferMessages: !0,
+				bufferSize: 1e3,
+				metadata: {},
+				...n
+			}, this._setupSubscriptions();
+		}
+		subscribe(e, t) {
+			return (t ? $e((n) => n.sender === t)(this._inbound) : this._inbound).subscribe(typeof e == "function" ? { next: e } : e);
+		}
+		next(e) {
+			if (this._state !== "connected") {
+				this._opts.bufferMessages && this._buffer.length < this._opts.bufferSize && this._buffer.push(e);
+				return;
+			}
+			this._outbound.next(e), this._stats.messagesSent++;
+		}
+		async request(e, t, n = {}) {
+			const s = d(), r = Promise.withResolvers();
+			this._pending.set(s, r);
+			const i = setTimeout(() => {
+				this._pending.has(s) && (this._pending.delete(s), r.reject(/* @__PURE__ */ new Error("Request timeout")));
+			}, n.timeout ?? this._opts.timeout);
+			return this.next({
+				id: d(),
+				channel: e,
+				sender: this._name,
+				type: "request",
+				reqId: s,
+				payload: {
+					...t,
+					action: n.action,
+					path: n.path
+				},
+				timestamp: Date.now()
+			}), r.promise.finally(() => clearTimeout(i));
+		}
+		respond(e, t) {
+			this.next({
+				id: d(),
+				channel: e.sender,
+				sender: this._name,
+				type: "response",
+				reqId: e.reqId,
+				payload: t,
+				timestamp: Date.now()
+			});
+		}
+		emit(e, t, n) {
+			this.next({
+				id: d(),
+				channel: e,
+				sender: this._name,
+				type: "event",
+				payload: {
+					type: t,
+					data: n
+				},
+				timestamp: Date.now()
+			});
+		}
+		subscribeOutbound(e) {
+			return this._outbound.subscribe(typeof e == "function" ? { next: e } : e);
+		}
+		pushInbound(e) {
+			if (this._stats.messagesReceived++, e.type === "response" && e.reqId) {
+				const t = this._pending.get(e.reqId);
+				if (t) {
+					this._pending.delete(e.reqId), t.resolve(e.payload);
+					return;
+				}
+			}
+			this._inbound.next(e);
+		}
+		async connect() {
+			this._state !== "connected" && (this._setState("connecting"), this._startTime = Date.now(), this._setState("connected"), this._flushBuffer());
+		}
+		disconnect() {
+			this._state === "disconnected" || this._state === "closed" || (this._setState("disconnected"), this._subs.forEach((e) => e.unsubscribe()), this._subs = []);
+		}
+		close() {
+			this.disconnect(), this._setState("closed"), this._inbound.complete(), this._outbound.complete(), this._stateChanges.complete();
+		}
+		markConnected() {
+			this._setState("connected"), this._flushBuffer();
+		}
+		markDisconnected() {
+			this._setState("disconnected");
+		}
+		_setState(e) {
+			this._state !== e && (this._state = e, this._stateChanges.next(e));
+		}
+		_flushBuffer() {
+			for (const e of this._buffer) this._outbound.next(e);
+			this._buffer = [];
+		}
+		_setupSubscriptions() {
+			this._subs.push(this._inbound.subscribe({ next: (e) => {
+				e.type === "signal" && e.payload?.type === "connect" && this._connectedPeers.set(e.sender, {
+					name: e.sender,
+					state: "connected",
+					isHost: !1
+				});
+			} }));
+		}
+		get id() {
+			return this._id;
+		}
+		get name() {
+			return this._name;
+		}
+		get state() {
+			return this._state;
+		}
+		get transportType() {
+			return this._transportType;
+		}
+		get stats() {
+			return {
+				...this._stats,
+				uptime: this._startTime ? Date.now() - this._startTime : 0
+			};
+		}
+		get stateChanges() {
+			return this._stateChanges;
+		}
+		get connectedPeers() {
+			return [...this._connectedPeers.keys()];
+		}
+		get meta() {
+			return {
+				id: this._id,
+				name: this._name,
+				state: this._state,
+				isHost: !1,
+				connectedChannels: new Set(this._connectedPeers.keys())
+			};
+		}
+	}, dt = class F {
+		_connections = /* @__PURE__ */ new Map();
+		static _instance = null;
+		static getInstance() {
+			return F._instance || (F._instance = new F()), F._instance;
+		}
+		getOrCreate(t, n = "internal", s = {}) {
+			return this._connections.has(t) || this._connections.set(t, new ht(t, n, s)), this._connections.get(t);
+		}
+		get(t) {
+			return this._connections.get(t);
+		}
+		has(t) {
+			return this._connections.has(t);
+		}
+		delete(t) {
+			return this._connections.get(t)?.close(), this._connections.delete(t);
+		}
+		clear() {
+			this._connections.forEach((t) => t.close()), this._connections.clear();
+		}
+		get size() {
+			return this._connections.size;
+		}
+		get names() {
+			return [...this._connections.keys()];
+		}
+	};
+	const be = () => dt.getInstance(), ft = (e, t, n) => be().getOrCreate(e, t, n), pt = "uniform_channels", _t = 1, u = {
+		MESSAGES: "messages",
+		MAILBOX: "mailbox",
+		PENDING: "pending",
+		EXCHANGE: "exchange",
+		TRANSACTIONS: "transactions"
+	};
+	var yt = class {
+		_db = null;
+		_isOpen = !1;
+		_openPromise = null;
+		_channelName;
+		_messageUpdates = new y();
+		_exchangeUpdates = new y();
+		constructor(e) {
+			this._channelName = e;
+		}
+		async open() {
+			return this._db && this._isOpen ? this._db : this._openPromise ? this._openPromise : (this._openPromise = new Promise((e, t) => {
+				const n = indexedDB.open(pt, _t);
+				n.onerror = () => {
+					this._openPromise = null, t(/* @__PURE__ */ new Error("Failed to open IndexedDB"));
+				}, n.onsuccess = () => {
+					this._db = n.result, this._isOpen = !0, this._openPromise = null, e(this._db);
+				}, n.onupgradeneeded = (s) => {
+					const r = s.target.result;
+					this._createStores(r);
+				};
+			}), this._openPromise);
+		}
+		close() {
+			this._db && (this._db.close(), this._db = null, this._isOpen = !1);
+		}
+		_createStores(e) {
+			if (!e.objectStoreNames.contains(u.MESSAGES)) {
+				const t = e.createObjectStore(u.MESSAGES, { keyPath: "id" });
+				t.createIndex("channel", "channel", { unique: !1 }), t.createIndex("status", "status", { unique: !1 }), t.createIndex("recipient", "recipient", { unique: !1 }), t.createIndex("createdAt", "createdAt", { unique: !1 }), t.createIndex("channel_status", ["channel", "status"], { unique: !1 });
+			}
+			if (!e.objectStoreNames.contains(u.MAILBOX)) {
+				const t = e.createObjectStore(u.MAILBOX, { keyPath: "id" });
+				t.createIndex("channel", "channel", { unique: !1 }), t.createIndex("priority", "priority", { unique: !1 }), t.createIndex("expiresAt", "expiresAt", { unique: !1 });
+			}
+			if (!e.objectStoreNames.contains(u.PENDING)) {
+				const t = e.createObjectStore(u.PENDING, { keyPath: "id" });
+				t.createIndex("channel", "channel", { unique: !1 }), t.createIndex("createdAt", "createdAt", { unique: !1 });
+			}
+			if (!e.objectStoreNames.contains(u.EXCHANGE)) {
+				const t = e.createObjectStore(u.EXCHANGE, { keyPath: "id" });
+				t.createIndex("key", "key", { unique: !0 }), t.createIndex("owner", "owner", { unique: !1 });
+			}
+			e.objectStoreNames.contains(u.TRANSACTIONS) || e.createObjectStore(u.TRANSACTIONS, { keyPath: "id" }).createIndex("createdAt", "createdAt", { unique: !1 });
+		}
+		async defer(e, t = {}) {
+			const n = await this.open(), s = {
+				id: d(),
+				channel: e.channel,
+				sender: e.sender ?? this._channelName,
+				recipient: e.channel,
+				type: e.type,
+				payload: e.payload,
+				status: "pending",
+				priority: t.priority ?? 0,
+				createdAt: Date.now(),
+				updatedAt: Date.now(),
+				expiresAt: t.expiresIn ? Date.now() + t.expiresIn : null,
+				retryCount: 0,
+				maxRetries: t.maxRetries ?? 3,
+				metadata: t.metadata
+			};
+			return new Promise((r, i) => {
+				const o = n.transaction([u.MESSAGES, u.MAILBOX], "readwrite"), a = o.objectStore(u.MESSAGES), c = o.objectStore(u.MAILBOX);
+				a.add(s), c.add(s), o.oncomplete = () => {
+					this._messageUpdates.next(s), r(s.id);
+				}, o.onerror = () => i(/* @__PURE__ */ new Error("Failed to defer message"));
+			});
+		}
+		async getDeferredMessages(e, t = {}) {
+			const n = await this.open();
+			return new Promise((s, r) => {
+				const i = n.transaction(u.MESSAGES, "readonly").objectStore(u.MESSAGES), o = t.status ? i.index("channel_status") : i.index("channel"), a = t.status ? IDBKeyRange.only([e, t.status]) : IDBKeyRange.only(e), c = o.getAll(a, t.limit);
+				c.onsuccess = () => {
+					let l = c.result;
+					t.offset && (l = l.slice(t.offset)), s(l);
+				}, c.onerror = () => r(/* @__PURE__ */ new Error("Failed to get deferred messages"));
+			});
+		}
+		async processNextPending(e) {
+			const t = await this.open();
+			return new Promise((n, s) => {
+				const r = t.transaction(u.MESSAGES, "readwrite").objectStore(u.MESSAGES).index("channel_status").openCursor(IDBKeyRange.only([e, "pending"]));
+				r.onsuccess = () => {
+					const i = r.result;
+					if (i) {
+						const o = i.value;
+						o.status = "processing", o.updatedAt = Date.now(), i.update(o), this._messageUpdates.next(o), n(o);
+					} else n(null);
+				}, r.onerror = () => s(/* @__PURE__ */ new Error("Failed to process pending message"));
+			});
+		}
+		async markDelivered(e) {
+			await this._updateMessageStatus(e, "delivered");
+		}
+		async markFailed(e) {
+			const t = await this.open();
+			return new Promise((n, s) => {
+				const r = t.transaction(u.MESSAGES, "readwrite").objectStore(u.MESSAGES), i = r.get(e);
+				i.onsuccess = () => {
+					const o = i.result;
+					if (!o) {
+						n(!1);
+						return;
+					}
+					o.retryCount++, o.updatedAt = Date.now(), o.retryCount < o.maxRetries ? o.status = "pending" : o.status = "failed", r.put(o), this._messageUpdates.next(o), n(o.status === "pending");
+				}, i.onerror = () => s(/* @__PURE__ */ new Error("Failed to mark message as failed"));
+			});
+		}
+		async _updateMessageStatus(e, t) {
+			const n = await this.open();
+			return new Promise((s, r) => {
+				const i = n.transaction(u.MESSAGES, "readwrite").objectStore(u.MESSAGES), o = i.get(e);
+				o.onsuccess = () => {
+					const a = o.result;
+					a && (a.status = t, a.updatedAt = Date.now(), i.put(a), this._messageUpdates.next(a)), s();
+				}, o.onerror = () => r(/* @__PURE__ */ new Error("Failed to update message status"));
+			});
+		}
+		async getMailbox(e, t = {}) {
+			const n = await this.open();
+			return new Promise((s, r) => {
+				const i = n.transaction(u.MAILBOX, "readonly").objectStore(u.MAILBOX).index("channel").getAll(IDBKeyRange.only(e), t.limit);
+				i.onsuccess = () => {
+					let o = i.result;
+					t.sortBy === "priority" ? o.sort((a, c) => c.priority - a.priority) : o.sort((a, c) => c.createdAt - a.createdAt), s(o);
+				}, i.onerror = () => r(/* @__PURE__ */ new Error("Failed to get mailbox"));
+			});
+		}
+		async getMailboxStats(e) {
+			const t = await this.getDeferredMessages(e), n = {
+				total: t.length,
+				pending: 0,
+				processing: 0,
+				delivered: 0,
+				failed: 0,
+				expired: 0
+			}, s = Date.now();
+			for (const r of t) r.expiresAt && r.expiresAt < s ? n.expired++ : n[r.status]++;
+			return n;
+		}
+		async clearMailbox(e) {
+			const t = await this.open();
+			return new Promise((n, s) => {
+				const r = t.transaction(u.MAILBOX, "readwrite"), i = r.objectStore(u.MAILBOX).index("channel");
+				let o = 0;
+				const a = i.openCursor(IDBKeyRange.only(e));
+				a.onsuccess = () => {
+					const c = a.result;
+					c && (c.delete(), o++, c.continue());
+				}, r.oncomplete = () => n(o), r.onerror = () => s(/* @__PURE__ */ new Error("Failed to clear mailbox"));
+			});
+		}
+		async registerPending(e) {
+			const t = await this.open(), n = {
+				id: d(),
+				channel: this._channelName,
+				type: e.type,
+				data: e.data,
+				metadata: e.metadata,
+				createdAt: Date.now(),
+				status: "pending"
+			};
+			return new Promise((s, r) => {
+				const i = t.transaction(u.PENDING, "readwrite");
+				i.objectStore(u.PENDING).add(n), i.oncomplete = () => s(n.id), i.onerror = () => r(/* @__PURE__ */ new Error("Failed to register pending operation"));
+			});
+		}
+		async getPendingOperations() {
+			const e = await this.open();
+			return new Promise((t, n) => {
+				const s = e.transaction(u.PENDING, "readonly").objectStore(u.PENDING).index("channel").getAll(IDBKeyRange.only(this._channelName));
+				s.onsuccess = () => t(s.result), s.onerror = () => n(/* @__PURE__ */ new Error("Failed to get pending operations"));
+			});
+		}
+		async completePending(e) {
+			const t = await this.open();
+			return new Promise((n, s) => {
+				const r = t.transaction(u.PENDING, "readwrite");
+				r.objectStore(u.PENDING).delete(e), r.oncomplete = () => n(), r.onerror = () => s(/* @__PURE__ */ new Error("Failed to complete pending operation"));
+			});
+		}
+		async awaitPending(e, t = {}) {
+			const n = t.timeout ?? 3e4, s = t.pollInterval ?? 100, r = Date.now();
+			for (; Date.now() - r < n;) {
+				const i = await this._getPendingById(e);
+				if (!i) return null;
+				if (i.status === "completed") return await this.completePending(e), i.result;
+				await new Promise((o) => setTimeout(o, s));
+			}
+			throw new Error(`Pending operation ${e} timed out`);
+		}
+		async _getPendingById(e) {
+			const t = await this.open();
+			return new Promise((n, s) => {
+				const r = t.transaction(u.PENDING, "readonly").objectStore(u.PENDING).get(e);
+				r.onsuccess = () => n(r.result ?? null), r.onerror = () => s(/* @__PURE__ */ new Error("Failed to get pending operation"));
+			});
+		}
+		async exchangePut(e, t, n = {}) {
+			const s = await this.open(), r = {
+				id: d(),
+				key: e,
+				value: t,
+				owner: this._channelName,
+				sharedWith: n.sharedWith ?? ["*"],
+				version: 1,
+				createdAt: Date.now(),
+				updatedAt: Date.now()
+			};
+			return new Promise((i, o) => {
+				const a = s.transaction(u.EXCHANGE, "readwrite"), c = a.objectStore(u.EXCHANGE), l = c.index("key").get(e);
+				l.onsuccess = () => {
+					const _ = l.result;
+					_ && (r.id = _.id, r.version = _.version + 1, r.createdAt = _.createdAt), c.put(r);
+				}, a.oncomplete = () => {
+					this._exchangeUpdates.next(r), i(r.id);
+				}, a.onerror = () => o(/* @__PURE__ */ new Error("Failed to put exchange data"));
+			});
+		}
+		async exchangeGet(e) {
+			const t = await this.open();
+			return new Promise((n, s) => {
+				const r = t.transaction(u.EXCHANGE, "readonly").objectStore(u.EXCHANGE).index("key").get(e);
+				r.onsuccess = () => {
+					const i = r.result;
+					if (!i) {
+						n(null);
+						return;
+					}
+					if (!this._canAccessExchange(i)) {
+						n(null);
+						return;
+					}
+					n(i.value);
+				}, r.onerror = () => s(/* @__PURE__ */ new Error("Failed to get exchange data"));
+			});
+		}
+		async exchangeDelete(e) {
+			const t = await this.open();
+			return new Promise((n, s) => {
+				const r = t.transaction(u.EXCHANGE, "readwrite"), i = r.objectStore(u.EXCHANGE), o = i.index("key").get(e);
+				o.onsuccess = () => {
+					const a = o.result;
+					if (!a) {
+						n(!1);
+						return;
+					}
+					if (a.owner !== this._channelName) {
+						n(!1);
+						return;
+					}
+					i.delete(a.id);
+				}, r.oncomplete = () => n(!0), r.onerror = () => s(/* @__PURE__ */ new Error("Failed to delete exchange data"));
+			});
+		}
+		async exchangeLock(e, t = {}) {
+			const n = await this.open(), s = t.timeout ?? 3e4;
+			return new Promise((r, i) => {
+				const o = n.transaction(u.EXCHANGE, "readwrite"), a = o.objectStore(u.EXCHANGE), c = a.index("key").get(e);
+				c.onsuccess = () => {
+					const l = c.result;
+					if (!l) {
+						r(!1);
+						return;
+					}
+					if (l.lock && l.lock.holder !== this._channelName && l.lock.expiresAt > Date.now()) {
+						r(!1);
+						return;
+					}
+					l.lock = {
+						holder: this._channelName,
+						acquiredAt: Date.now(),
+						expiresAt: Date.now() + s
+					}, l.updatedAt = Date.now(), a.put(l);
+				}, o.oncomplete = () => r(!0), o.onerror = () => i(/* @__PURE__ */ new Error("Failed to acquire lock"));
+			});
+		}
+		async exchangeUnlock(e) {
+			const t = await this.open();
+			return new Promise((n, s) => {
+				const r = t.transaction(u.EXCHANGE, "readwrite"), i = r.objectStore(u.EXCHANGE), o = i.index("key").get(e);
+				o.onsuccess = () => {
+					const a = o.result;
+					a && a.lock?.holder === this._channelName && (delete a.lock, a.updatedAt = Date.now(), i.put(a));
+				}, r.oncomplete = () => n(), r.onerror = () => s(/* @__PURE__ */ new Error("Failed to release lock"));
+			});
+		}
+		_canAccessExchange(e) {
+			return e.owner === this._channelName || e.sharedWith.includes("*") ? !0 : e.sharedWith.includes(this._channelName);
+		}
+		async beginTransaction() {
+			return new gt(this);
+		}
+		async executeTransaction(e) {
+			const t = await this.open(), n = new Set(e.map((s) => s.store));
+			return new Promise((s, r) => {
+				const i = t.transaction(Array.from(n), "readwrite");
+				for (const o of e) {
+					const a = i.objectStore(o.store);
+					switch (o.type) {
+						case "put":
+							o.value !== void 0 && a.put(o.value);
+							break;
+						case "delete":
+							o.key !== void 0 && a.delete(o.key);
+							break;
+						case "update":
+							if (o.key !== void 0) {
+								const c = a.get(o.key);
+								c.onsuccess = () => {
+									c.result && o.value && a.put({
+										...c.result,
+										...o.value
+									});
+								};
+							}
+							break;
+					}
+				}
+				i.oncomplete = () => s(), i.onerror = () => r(/* @__PURE__ */ new Error("Transaction failed"));
+			});
+		}
+		onMessageUpdate(e) {
+			return this._messageUpdates.subscribe({ next: e });
+		}
+		onExchangeUpdate(e) {
+			return this._exchangeUpdates.subscribe({ next: e });
+		}
+		async cleanupExpired() {
+			const e = await this.open(), t = Date.now();
+			return new Promise((n, s) => {
+				const r = e.transaction([u.MESSAGES, u.MAILBOX], "readwrite"), i = r.objectStore(u.MESSAGES), o = r.objectStore(u.MAILBOX);
+				let a = 0;
+				const c = i.openCursor();
+				c.onsuccess = () => {
+					const _ = c.result;
+					if (_) {
+						const f = _.value;
+						f.expiresAt && f.expiresAt < t && (_.delete(), a++), _.continue();
+					}
+				};
+				const l = o.openCursor();
+				l.onsuccess = () => {
+					const _ = l.result;
+					if (_) {
+						const f = _.value;
+						f.expiresAt && f.expiresAt < t && (_.delete(), a++), _.continue();
+					}
+				}, r.oncomplete = () => n(a), r.onerror = () => s(/* @__PURE__ */ new Error("Failed to cleanup expired"));
+			});
+		}
+	}, gt = class {
+		_storage;
+		_operations = [];
+		_isCommitted = !1;
+		_isRolledBack = !1;
+		constructor(e) {
+			this._storage = e;
+		}
+		put(e, t) {
+			return this._checkState(), this._operations.push({
+				id: d(),
+				type: "put",
+				store: e,
+				value: t,
+				timestamp: Date.now()
+			}), this;
+		}
+		delete(e, t) {
+			return this._checkState(), this._operations.push({
+				id: d(),
+				type: "delete",
+				store: e,
+				key: t,
+				timestamp: Date.now()
+			}), this;
+		}
+		update(e, t, n) {
+			return this._checkState(), this._operations.push({
+				id: d(),
+				type: "update",
+				store: e,
+				key: t,
+				value: n,
+				timestamp: Date.now()
+			}), this;
+		}
+		async commit() {
+			if (this._checkState(), this._operations.length === 0) {
+				this._isCommitted = !0;
+				return;
+			}
+			await this._storage.executeTransaction(this._operations), this._isCommitted = !0;
+		}
+		rollback() {
+			this._operations = [], this._isRolledBack = !0;
+		}
+		get operationCount() {
+			return this._operations.length;
+		}
+		_checkState() {
+			if (this._isCommitted) throw new Error("Transaction already committed");
+			if (this._isRolledBack) throw new Error("Transaction already rolled back");
+		}
+	};
+	const J = /* @__PURE__ */ new Map();
+	function mt(e) {
+		return J.has(e) || J.set(e, new yt(e)), J.get(e);
+	}
+	const Ce = he(), wt = Ce.length > 0 ? new URL("../transport/Worker.ts", Ce) : "";
+	var Se = class {
+		_channel;
+		_context;
+		_options;
+		_connection;
+		_storage;
+		constructor(e, t, n = {}) {
+			this._channel = e, this._context = t, this._options = n, this._connection = ft(e), this._storage = mt(e);
+		}
+		async request(e, t, n, s = {}) {
+			let r = typeof e == "string" ? [e] : e, i = t, o = n;
+			return Array.isArray(t) && xe(e) && (s = n, o = t, i = e, r = []), this._context.getHost()?.request(r, i, o, s, this._channel);
+		}
+		async doImportModule(e, t = {}) {
+			return this.request([], h.IMPORT, [e], t);
+		}
+		async deferMessage(e, t = {}) {
+			return this._storage.defer({
+				channel: this._channel,
+				sender: this._context.hostName,
+				type: "request",
+				payload: e
+			}, t);
+		}
+		async getPendingMessages() {
+			return this._storage.getDeferredMessages(this._channel, { status: "pending" });
+		}
+		get connection() {
+			return this._connection;
+		}
+		get channelName() {
+			return this._channel;
+		}
+		get context() {
+			return this._context;
+		}
+	}, v = class {
+		_channel;
+		_context;
+		_options;
+		_connection;
+		_unified;
+		get _forResolves() {
+			return this._unified.__getPrivate("_pending");
+		}
+		get _subscriptions() {
+			return this._unified.__getPrivate("_subscriptions");
+		}
+		get _broadcasts() {
+			return this._unified.__getPrivate("_transports");
+		}
+		constructor(e, t, n = {}) {
+			this._channel = e, this._context = t, this._options = n, this._connection = be().getOrCreate(e, "internal", n), this._unified = new ue({
+				name: e,
+				autoListen: !1,
+				timeout: n?.timeout
+			});
+		}
+		createRemoteChannel(e, t = {}, n) {
+			const s = Ct(n ?? this._context.$createOrUseExistingRemote(e, t, n ?? null)?.messageChannel?.port1), r = Ee(s?.target ?? s);
+			return this._unified.listen(s?.target, { targetChannel: e }), s && (this._broadcasts?.set?.(e, s), r === "self" && typeof postMessage > "u" || this._unified.connect(s, { targetChannel: e }), this._context.$registerConnection({
+				localChannel: this._channel,
+				remoteChannel: e,
+				sender: this._channel,
+				direction: "outgoing",
+				transportType: r
+			}), this.notifyChannel(e, {
+				contextId: this._context.id,
+				contextName: this._context.hostName
+			}, "connect")), new Se(e, this._context, t);
+		}
+		getChannel() {
+			return this._channel;
+		}
+		get connection() {
+			return this._connection;
+		}
+		request(e, t, n, s = {}, r = "worker") {
+			let i = typeof e == "string" ? [e] : e, o = n;
+			return Array.isArray(t) && xe(e) && (r = s, s = n, o = t, t = e, i = []), this._unified.invoke(r, t, i ?? [], Array.isArray(o) ? o : [o]);
+		}
+		resolveResponse(e, t) {
+			this._forResolves.get(e)?.resolve?.(t);
+			const n = this._forResolves.get(e)?.promise;
+			return this._forResolves.delete(e), n;
+		}
+		async handleAndResponse(e, t, n) {}
+		notifyChannel(e, t = {}, n = "notify") {
+			return this._unified.notify(e, {
+				...t,
+				from: this._channel,
+				to: e
+			}, n);
+		}
+		getConnectedChannels() {
+			return this._unified.connectedChannels;
+		}
+		close() {
+			this._subscriptions.forEach((e) => e.unsubscribe()), this._forResolves.clear(), this._broadcasts?.values?.()?.forEach((e) => e.close?.()), this._broadcasts?.clear?.(), this._unified.close();
+		}
+		get unified() {
+			return this._unified;
+		}
+	}, bt = class {
+		_options;
+		_id = d();
+		_hostName;
+		_host = null;
+		_endpoints = /* @__PURE__ */ new Map();
+		_unifiedByChannel = /* @__PURE__ */ new Map();
+		_unifiedConnectionSubs = /* @__PURE__ */ new Map();
+		_remoteChannels = /* @__PURE__ */ new Map();
+		_deferredChannels = /* @__PURE__ */ new Map();
+		_connectionEvents = new y({ bufferSize: 200 });
+		_connectionRegistry = new le(() => d(), (e) => this._emitConnectionEvent(e));
+		_closed = !1;
+		_globalSelf = null;
+		constructor(e = {}) {
+			this._options = e, this._hostName = e.name ?? `ctx-${this._id.slice(0, 8)}`, e.useGlobalSelf !== !1 && (this._globalSelf = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : null);
+		}
+		initHost(e) {
+			if (this._host && !e) return this._host;
+			const t = e ?? this._hostName;
+			if (this._hostName = t, this._endpoints.has(t)) return this._host = this._endpoints.get(t).handler, this._host;
+			this._host = new v(t, this, this._options.defaultOptions);
+			const n = {
+				name: t,
+				handler: this._host,
+				connection: this._host.connection,
+				subscriptions: [],
+				ready: Promise.resolve(null),
+				unified: this._host.unified
+			};
+			return this._endpoints.set(t, n), this._registerUnifiedChannel(t, this._host.unified), this._host;
+		}
+		getHost() {
+			return this._host ?? this.initHost();
+		}
+		get hostName() {
+			return this._hostName;
+		}
+		get id() {
+			return this._id;
+		}
+		get onConnection() {
+			return this._connectionEvents;
+		}
+		subscribeConnections(e) {
+			return this._connectionEvents.subscribe(e);
+		}
+		notifyConnections(e = {}, t = {}) {
+			let n = 0;
+			for (const s of this._endpoints.values()) {
+				const r = s.handler.getConnectedChannels();
+				for (const i of r) {
+					if (t.localChannel && t.localChannel !== s.name || t.remoteChannel && t.remoteChannel !== i) continue;
+					const o = this.queryConnections({
+						localChannel: s.name,
+						remoteChannel: i,
+						status: "active"
+					})[0];
+					t.sender && o?.sender !== t.sender || t.transportType && o?.transportType !== t.transportType || t.channel && t.channel !== s.name && t.channel !== i || s.handler.notifyChannel(i, e, "notify") && n++;
+				}
+			}
+			return n;
+		}
+		queryConnections(e = {}) {
+			return this._connectionRegistry.query(e).map((t) => ({
+				...t,
+				contextId: this._id
+			}));
+		}
+		createChannel(e, t = {}) {
+			if (this._endpoints.has(e)) return this._endpoints.get(e);
+			const n = new v(e, this, {
+				...this._options.defaultOptions,
+				...t
+			}), s = {
+				name: e,
+				handler: n,
+				connection: n.connection,
+				subscriptions: [],
+				ready: Promise.resolve(null),
+				unified: n.unified
+			};
+			return this._endpoints.set(e, s), this._registerUnifiedChannel(e, n.unified), s;
+		}
+		createChannels(e, t = {}) {
+			const n = /* @__PURE__ */ new Map();
+			for (const s of e) n.set(s, this.createChannel(s, t));
+			return n;
+		}
+		getChannel(e) {
+			return this._endpoints.get(e);
+		}
+		getOrCreateChannel(e, t = {}) {
+			return this._endpoints.get(e) ?? this.createChannel(e, t);
+		}
+		hasChannel(e) {
+			return this._endpoints.has(e);
+		}
+		getChannelNames() {
+			return [...this._endpoints.keys()];
+		}
+		get size() {
+			return this._endpoints.size;
+		}
+		defer(e, t) {
+			this._deferredChannels.set(e, t);
+		}
+		async initDeferred(e) {
+			const t = this._deferredChannels.get(e);
+			if (!t) return null;
+			const n = await t();
+			return this._endpoints.set(e, n), this._deferredChannels.delete(e), n;
+		}
+		isDeferred(e) {
+			return this._deferredChannels.has(e);
+		}
+		async getChannelAsync(e) {
+			return this._endpoints.has(e) ? this._endpoints.get(e) : this._deferredChannels.has(e) ? this.initDeferred(e) : null;
+		}
+		async addWorker(e, t, n = {}) {
+			const s = Pe(t);
+			if (!s) throw new Error(`Failed to create worker for channel: ${e}`);
+			const r = new v(e, this, {
+				...this._options.defaultOptions,
+				...n
+			}), i = r.createRemoteChannel(e, n, s), o = {
+				name: e,
+				handler: r,
+				connection: r.connection,
+				subscriptions: [],
+				transportType: "worker",
+				ready: Promise.resolve(i),
+				unified: r.unified
+			};
+			return this._endpoints.set(e, o), this._registerUnifiedChannel(e, r.unified), this._remoteChannels.set(e, {
+				channel: e,
+				context: this,
+				remote: Promise.resolve(i),
+				transport: s,
+				transportType: "worker"
+			}), o;
+		}
+		async addPort(e, t, n = {}) {
+			const s = new v(e, this, {
+				...this._options.defaultOptions,
+				...n
+			});
+			t.start?.();
+			const r = s.createRemoteChannel(e, n, t), i = {
+				name: e,
+				handler: s,
+				connection: s.connection,
+				subscriptions: [],
+				transportType: "message-port",
+				ready: Promise.resolve(r),
+				unified: s.unified
+			};
+			return this._endpoints.set(e, i), this._registerUnifiedChannel(e, s.unified), this._remoteChannels.set(e, {
+				channel: e,
+				context: this,
+				remote: Promise.resolve(r),
+				transport: t,
+				transportType: "message-port"
+			}), i;
+		}
+		async addBroadcast(e, t, n = {}) {
+			const s = new BroadcastChannel(t ?? e), r = new v(e, this, {
+				...this._options.defaultOptions,
+				...n
+			}), i = r.createRemoteChannel(e, n, s), o = {
+				name: e,
+				handler: r,
+				connection: r.connection,
+				subscriptions: [],
+				transportType: "broadcast",
+				ready: Promise.resolve(i),
+				unified: r.unified
+			};
+			return this._endpoints.set(e, o), this._registerUnifiedChannel(e, r.unified), this._remoteChannels.set(e, {
+				channel: e,
+				context: this,
+				remote: Promise.resolve(i),
+				transport: s,
+				transportType: "broadcast"
+			}), o;
+		}
+		addSelfChannel(e, t = {}) {
+			const n = new v(e, this, {
+				...this._options.defaultOptions,
+				...t
+			}), s = this._globalSelf ?? (typeof self < "u" ? self : null), r = {
+				name: e,
+				handler: n,
+				connection: n.connection,
+				subscriptions: [],
+				transportType: "self",
+				ready: Promise.resolve(s ? n.createRemoteChannel(e, t, s) : null),
+				unified: n.unified
+			};
+			return this._endpoints.set(e, r), this._registerUnifiedChannel(e, n.unified), r;
+		}
+		async addTransport(e, t) {
+			const n = t.options ?? {};
+			switch (t.type) {
+				case "worker":
+					if (!t.worker) throw new Error("Worker required for worker transport");
+					return this.addWorker(e, t.worker, n);
+				case "message-port":
+					if (!t.port) throw new Error("Port required for message-port transport");
+					return this.addPort(e, t.port, n);
+				case "broadcast":
+					const s = typeof t.broadcast == "string" ? t.broadcast : void 0;
+					return this.addBroadcast(e, s, n);
+				case "self": return this.addSelfChannel(e, n);
+				default: return this.createChannel(e, n);
+			}
+		}
+		createChannelPair(e, t, n = {}) {
+			const s = new MessageChannel(), r = new v(e, this, {
+				...this._options.defaultOptions,
+				...n
+			}), i = new v(t, this, {
+				...this._options.defaultOptions,
+				...n
+			});
+			s.port1.start(), s.port2.start();
+			const o = Promise.resolve(r.createRemoteChannel(t, n, s.port1)), a = Promise.resolve(i.createRemoteChannel(e, n, s.port2)), c = {
+				name: e,
+				handler: r,
+				connection: r.connection,
+				subscriptions: [],
+				transportType: "message-port",
+				ready: o,
+				unified: r.unified
+			}, l = {
+				name: t,
+				handler: i,
+				connection: i.connection,
+				subscriptions: [],
+				transportType: "message-port",
+				ready: a,
+				unified: i.unified
+			};
+			return this._endpoints.set(e, c), this._endpoints.set(t, l), this._registerUnifiedChannel(e, r.unified), this._registerUnifiedChannel(t, i.unified), {
+				channel1: c,
+				channel2: l,
+				messageChannel: s
+			};
+		}
+		get globalSelf() {
+			return this._globalSelf;
+		}
+		async connectRemote(e, t = {}, n) {
+			return this.initHost(), this._host.createRemoteChannel(e, t, n);
+		}
+		async importModuleInChannel(e, t, n = {}, s) {
+			return (await this.connectRemote(e, n.channelOptions, s))?.doImportModule?.(t, n.importOptions);
+		}
+		$createOrUseExistingRemote(e, t = {}, n) {
+			if (e == null || n) return null;
+			if (this._remoteChannels.has(e)) return this._remoteChannels.get(e);
+			const s = new MessageChannel(), r = re(new Promise((o) => {
+				const a = Pe(wt);
+				a?.addEventListener?.("message", (c) => {
+					c.data.type === "channelCreated" && (s.port1?.start?.(), o(new Se(c.data.channel, this, t)));
+				}), a?.postMessage?.({
+					type: "createChannel",
+					channel: e,
+					sender: this._hostName,
+					options: t,
+					messagePort: s.port2
+				}, { transfer: [s.port2] });
+			})), i = {
+				channel: e,
+				context: this,
+				messageChannel: s,
+				remote: r
+			};
+			return this._remoteChannels.set(e, i), i;
+		}
+		$registerConnection(e) {
+			return {
+				...this._connectionRegistry.register(e),
+				contextId: this._id
+			};
+		}
+		$markNotified(e) {
+			const t = this._connectionRegistry.register({
+				localChannel: e.localChannel,
+				remoteChannel: e.remoteChannel,
+				sender: e.sender,
+				direction: e.direction,
+				transportType: e.transportType
+			});
+			this._connectionRegistry.markNotified(t, e.payload);
+		}
+		$observeSignal(e) {
+			const t = (e.payload?.type, "incoming");
+			this.$markNotified({
+				localChannel: e.localChannel,
+				remoteChannel: e.remoteChannel,
+				sender: e.sender,
+				direction: t,
+				transportType: e.transportType,
+				payload: e.payload
+			});
+		}
+		$forwardUnifiedConnectionEvent(e, t) {
+			const n = t.connection.transportType ?? "internal", s = this._connectionRegistry.register({
+				localChannel: t.connection.localChannel || e,
+				remoteChannel: t.connection.remoteChannel,
+				sender: t.connection.sender,
+				direction: t.connection.direction,
+				transportType: n,
+				metadata: t.connection.metadata
+			});
+			t.type === "notified" ? this._connectionRegistry.markNotified(s, t.payload) : t.type === "disconnected" && this._connectionRegistry.closeByChannel(t.connection.localChannel);
+		}
+		closeChannel(e) {
+			const t = this._endpoints.get(e);
+			return t ? (t.subscriptions.forEach((n) => n.unsubscribe()), t.handler.close(), t.transport?.detach(), this._unifiedConnectionSubs.get(e)?.unsubscribe(), this._unifiedConnectionSubs.delete(e), this._unifiedByChannel.delete(e), this._endpoints.delete(e), e === this._hostName && (this._host = null), this._connectionRegistry.closeByChannel(e), !0) : !1;
+		}
+		close() {
+			if (!this._closed) {
+				this._closed = !0;
+				for (const [e] of this._endpoints) this.closeChannel(e);
+				this._remoteChannels.clear(), this._host = null, this._unifiedConnectionSubs.forEach((e) => e.unsubscribe()), this._unifiedConnectionSubs.clear(), this._unifiedByChannel.clear(), this._connectionRegistry.clear(), this._connectionEvents.complete();
+			}
+		}
+		get closed() {
+			return this._closed;
+		}
+		_registerUnifiedChannel(e, t) {
+			this._unifiedByChannel.set(e, t), this._unifiedConnectionSubs.get(e)?.unsubscribe();
+			const n = t.subscribeConnections((s) => {
+				this.$forwardUnifiedConnectionEvent(e, s);
+			});
+			this._unifiedConnectionSubs.set(e, n);
+		}
+		_emitConnectionEvent(e) {
+			this._connectionEvents.next({
+				...e,
+				connection: {
+					...e.connection,
+					contextId: this._id
+				}
+			});
+		}
+	};
+	function xe(e) {
+		return [...Object.values(h)].includes(e);
+	}
+	function Ct(e) {
+		if (!e) return null;
+		if (ke(e)) return e;
+		const t = e, n = Ee(t);
+		return {
+			target: t,
+			targetChannel: "unknown",
+			transportType: n === "internal" ? "self" : n,
+			sender: (s, r) => {
+				if (typeof WebSocket < "u" && t instanceof WebSocket) {
+					t.send(JSON.stringify(s));
+					return;
+				}
+				t.postMessage?.(s, r?.length ? { transfer: r } : void 0);
+			},
+			postMessage: (s, r) => {
+				t.postMessage?.(s, r);
+			},
+			addEventListener: t.addEventListener?.bind(t),
+			removeEventListener: t.removeEventListener?.bind(t),
+			start: t.start?.bind(t),
+			close: t.close?.bind(t)
+		};
+	}
+	function ke(e) {
+		return !!e && typeof e == "object" && "target" in e && typeof e.postMessage == "function";
+	}
+	function Ee(e) {
+		const t = ke(e) ? e.target : e;
+		return t ? t === "chrome-runtime" ? "chrome-runtime" : t === "chrome-tabs" ? "chrome-tabs" : t === "chrome-port" ? "chrome-port" : t === "chrome-external" ? "chrome-external" : typeof MessagePort < "u" && t instanceof MessagePort ? "message-port" : typeof BroadcastChannel < "u" && t instanceof BroadcastChannel ? "broadcast" : typeof Worker < "u" && t instanceof Worker ? "worker" : typeof WebSocket < "u" && t instanceof WebSocket ? "websocket" : typeof chrome < "u" && typeof t == "object" && t && typeof t.postMessage == "function" && t.onMessage?.addListener ? "chrome-port" : typeof self < "u" && t === self ? "self" : "internal" : "internal";
+	}
+	function Pe(e) {
+		if (e instanceof Worker) return e;
+		if (e instanceof URL) return new Worker(e.href, { type: "module" });
+		if (typeof e == "function") try {
+			return new e({ type: "module" });
+		} catch {
+			return e({ type: "module" });
+		}
+		return typeof e == "string" ? e.startsWith("/") ? new Worker(de(e.replace(/^\//, "./")), { type: "module" }) : URL.canParse(e) || e.startsWith("./") ? new Worker(de(e), { type: "module" }) : new Worker(URL.createObjectURL(new Blob([e], { type: "application/javascript" })), { type: "module" }) : e instanceof Blob || e instanceof File ? new Worker(URL.createObjectURL(e), { type: "module" }) : e ?? (typeof self < "u" ? self : null);
+	}
+	const St = /* @__PURE__ */ new Map();
+	function xt(e = {}) {
+		const t = new bt(e);
+		return e.name && St.set(e.name, t), t;
+	}
+	var kt = class {
+		_context;
+		_config;
+		_subscriptions = [];
+		_incomingConnections = new y({ bufferSize: 100 });
+		_channelCreated = new y({ bufferSize: 100 });
+		_channelClosed = new y();
+		constructor(e = {}) {
+			this._config = {
+				name: e.name ?? "worker",
+				workerName: e.workerName ?? `worker-${d().slice(0, 8)}`,
+				autoAcceptChannels: e.autoAcceptChannels ?? !0,
+				allowedChannels: e.allowedChannels ?? [],
+				maxChannels: e.maxChannels ?? 100,
+				autoConnect: e.autoConnect ?? !0,
+				useGlobalSelf: !0,
+				defaultOptions: e.defaultOptions ?? {},
+				isolatedStorage: e.isolatedStorage ?? !1,
+				...e
+			}, this._context = xt({
+				name: this._config.name,
+				useGlobalSelf: !0,
+				defaultOptions: e.defaultOptions
+			}), this._setupMessageListener();
+		}
+		get onConnection() {
+			return this._incomingConnections;
+		}
+		get onChannelCreated() {
+			return this._channelCreated;
+		}
+		get onChannelClosed() {
+			return this._channelClosed;
+		}
+		subscribeConnections(e) {
+			return this._incomingConnections.subscribe(e);
+		}
+		subscribeChannelCreated(e) {
+			return this._channelCreated.subscribe(e);
+		}
+		acceptConnection(e) {
+			if (!this._canAcceptChannel(e.channel)) return null;
+			const t = this._context.createChannel(e.channel, e.options);
+			return e.port && (e.port.start?.(), t.handler.createRemoteChannel(e.sender, e.options, e.port)), this._channelCreated.next({
+				channel: e.channel,
+				endpoint: t,
+				sender: e.sender,
+				timestamp: Date.now()
+			}), this._postChannelCreated(e.channel, e.sender, e.id), t;
+		}
+		createChannel(e, t) {
+			return this._context.createChannel(e, t);
+		}
+		getChannel(e) {
+			return this._context.getChannel(e);
+		}
+		hasChannel(e) {
+			return this._context.hasChannel(e);
+		}
+		getChannelNames() {
+			return this._context.getChannelNames();
+		}
+		queryConnections(e = {}) {
+			return this._context.queryConnections(e);
+		}
+		notifyConnections(e = {}, t = {}) {
+			return this._context.notifyConnections(e, t);
+		}
+		closeChannel(e) {
+			const t = this._context.closeChannel(e);
+			return t && this._channelClosed.next({
+				channel: e,
+				timestamp: Date.now()
+			}), t;
+		}
+		get context() {
+			return this._context;
+		}
+		get config() {
+			return this._config;
+		}
+		_setupMessageListener() {
+			addEventListener("message", ((e) => {
+				this._handleIncomingMessage(e);
+			}));
+		}
+		_handleIncomingMessage(e) {
+			const t = e.data;
+			if (!(!t || typeof t != "object")) switch (t.type) {
+				case "createChannel":
+					this._handleCreateChannel(t);
+					break;
+				case "connectChannel":
+					this._handleConnectChannel(t);
+					break;
+				case "addPort":
+					this._handleAddPort(t);
+					break;
+				case "listChannels":
+					this._handleListChannels(t);
+					break;
+				case "closeChannel":
+					this._handleCloseChannel(t);
+					break;
+				case "ping":
+					postMessage({
+						type: "pong",
+						id: t.id,
+						timestamp: Date.now()
+					});
+					break;
+				default: t.channel && this._context.hasChannel(t.channel) && this._context.getChannel(t.channel)?.handler?.handleAndResponse?.(t.payload, t.reqId);
+			}
+		}
+		_handleCreateChannel(e) {
+			const t = {
+				id: e.reqId ?? d(),
+				channel: e.channel,
+				sender: e.sender ?? "unknown",
+				type: "channel",
+				port: e.messagePort,
+				timestamp: Date.now(),
+				options: e.options
+			};
+			this._incomingConnections.next(t), this._config.autoAcceptChannels && this.acceptConnection(t);
+		}
+		_handleConnectChannel(e) {
+			const t = {
+				id: e.reqId ?? d(),
+				channel: e.channel,
+				sender: e.sender ?? "unknown",
+				type: e.portType ?? "channel",
+				port: e.port,
+				timestamp: Date.now(),
+				options: e.options
+			};
+			if (this._incomingConnections.next(t), this._config.autoAcceptChannels && this._canAcceptChannel(e.channel)) {
+				const n = this._context.getOrCreateChannel(e.channel, e.options);
+				e.port && (e.port.start?.(), n.handler.createRemoteChannel(e.sender, e.options, e.port)), postMessage({
+					type: "channelConnected",
+					channel: e.channel,
+					reqId: e.reqId
+				});
+			}
+		}
+		_handleAddPort(e) {
+			if (!e.port || !e.channel) return;
+			const t = {
+				id: e.reqId ?? d(),
+				channel: e.channel,
+				sender: e.sender ?? "unknown",
+				type: "port",
+				port: e.port,
+				timestamp: Date.now(),
+				options: e.options
+			};
+			this._incomingConnections.next(t), this._config.autoAcceptChannels && this.acceptConnection(t);
+		}
+		_handleListChannels(e) {
+			postMessage({
+				type: "channelList",
+				channels: this.getChannelNames(),
+				reqId: e.reqId
+			});
+		}
+		_handleCloseChannel(e) {
+			e.channel && (this.closeChannel(e.channel), postMessage({
+				type: "channelClosed",
+				channel: e.channel,
+				reqId: e.reqId
+			}));
+		}
+		_canAcceptChannel(e) {
+			return this._context.size >= this._config.maxChannels ? !1 : this._config.allowedChannels.length > 0 ? this._config.allowedChannels.includes(e) : !0;
+		}
+		_postChannelCreated(e, t, n) {
+			postMessage({
+				type: "channelCreated",
+				channel: e,
+				sender: t,
+				reqId: n,
+				timestamp: Date.now()
+			});
+		}
+		close() {
+			this._subscriptions.forEach((e) => e.unsubscribe()), this._subscriptions = [], this._incomingConnections.complete(), this._channelCreated.complete(), this._channelClosed.complete(), this._context.close();
+		}
+	};
+	let Q = null;
+	function Et(e) {
+		return Q || (Q = new kt(e)), Q;
+	}
+	Et({ name: "worker" });
+	var W = class {
+		_channelName;
+		_config;
+		_port;
+		_subs = /* @__PURE__ */ new Set();
+		_pending = /* @__PURE__ */ new Map();
+		_listening = !1;
+		_cleanup = null;
+		_portId = d();
+		_state = new y();
+		_keepAliveTimer = null;
+		constructor(e, t, n = {}) {
+			this._channelName = t, this._config = n, this._port = e, this._setupPort(), n.autoStart !== !1 && this.start();
+		}
+		_setupPort() {
+			const e = (n) => {
+				const s = n.data;
+				if (s.type === "response" && s.reqId) {
+					const r = this._pending.get(s.reqId);
+					if (r) {
+						this._pending.delete(s.reqId), s.payload?.error ? r.reject(new Error(s.payload.error)) : r.resolve(s.payload?.result ?? s.payload);
+						return;
+					}
+				}
+				if (s.type === "signal" && s.payload?.action === "ping") {
+					this.send({
+						id: d(),
+						channel: this._channelName,
+						sender: this._portId,
+						type: "signal",
+						payload: { action: "pong" }
+					});
+					return;
+				}
+				s.portId = s.portId ?? this._portId;
+				for (const r of this._subs) try {
+					r.next?.(s);
+				} catch (i) {
+					r.error?.(i);
+				}
+			}, t = () => {
+				this._state.next("error");
+				const n = /* @__PURE__ */ new Error("Port error");
+				for (const s of this._subs) s.error?.(n);
+			};
+			this._port.addEventListener("message", e), this._port.addEventListener("messageerror", t), this._cleanup = () => {
+				this._port.removeEventListener("message", e), this._port.removeEventListener("messageerror", t);
+			};
+		}
+		start() {
+			this._listening || (this._port.start(), this._listening = !0, this._state.next("ready"), this._config.keepAlive && this._startKeepAlive());
+		}
+		send(e, t) {
+			const { transferable: n, ...s } = e;
+			this._port.postMessage({
+				...s,
+				portId: this._portId
+			}, t ?? []);
+		}
+		request(e) {
+			const t = e.reqId ?? d();
+			return new Promise((n, s) => {
+				const r = setTimeout(() => {
+					this._pending.delete(t), s(/* @__PURE__ */ new Error("Request timeout"));
+				}, this._config.timeout ?? 3e4);
+				this._pending.set(t, {
+					resolve: (i) => {
+						clearTimeout(r), n(i);
+					},
+					reject: (i) => {
+						clearTimeout(r), s(i);
+					},
+					timestamp: Date.now()
+				}), this.send({
+					...e,
+					reqId: t,
+					type: "request"
+				});
+			});
+		}
+		subscribe(e) {
+			const t = typeof e == "function" ? { next: e } : e;
+			return this._subs.add(t), {
+				closed: !1,
+				unsubscribe: () => {
+					this._subs.delete(t);
+				}
+			};
+		}
+		_startKeepAlive() {
+			this._keepAliveTimer = setInterval(() => {
+				this.send({
+					id: d(),
+					channel: this._channelName,
+					sender: this._portId,
+					type: "signal",
+					payload: { action: "ping" }
+				});
+			}, this._config.keepAliveInterval ?? 3e4);
+		}
+		close() {
+			this._keepAliveTimer && (clearInterval(this._keepAliveTimer), this._keepAliveTimer = null), this._cleanup?.(), this._subs.forEach((e) => e.complete?.()), this._subs.clear(), this._port.close(), this._state.next("closed");
+		}
+		get port() {
+			return this._port;
+		}
+		get portId() {
+			return this._portId;
+		}
+		get isListening() {
+			return this._listening;
+		}
+		get state() {
+			return this._state;
+		}
+		get channelName() {
+			return this._channelName;
+		}
+	};
+	function Z(e, t) {
+		const n = new MessageChannel();
+		return {
+			local: new W(n.port1, e, t),
+			remote: n.port2,
+			transfer: () => n.port2
+		};
+	}
+	var ve = class {
+		_target;
+		_channelName;
+		_config;
+		_transport = null;
+		_state = new y();
+		_handshakeComplete = !1;
+		constructor(e, t, n = {}) {
+			this._target = e, this._channelName = t, this._config = n;
+		}
+		async connect() {
+			if (this._transport && this._handshakeComplete) return this._transport;
+			this._state.next("connecting");
+			const { local: e, remote: t } = Z(this._channelName, this._config);
+			return this._target.postMessage({
+				type: "port-connect",
+				channelName: this._channelName,
+				portId: e.portId
+			}, this._config.targetOrigin ?? "*", [t]), new Promise((n, s) => {
+				const r = setTimeout(() => {
+					s(/* @__PURE__ */ new Error("Handshake timeout")), this._state.next("error");
+				}, this._config.handshakeTimeout ?? 1e4), i = e.subscribe({ next: (o) => {
+					o.type === "signal" && o.payload?.action === "handshake-ack" && (clearTimeout(r), this._handshakeComplete = !0, this._transport = e, this._state.next("connected"), i.unsubscribe(), n(e));
+				} });
+			});
+		}
+		static listen(e, t, n) {
+			const s = (r) => {
+				if (r.data?.type !== "port-connect" || r.data?.channelName !== e || !r.ports[0]) return;
+				const i = new W(r.ports[0], e, n);
+				i.send({
+					id: d(),
+					channel: e,
+					sender: i.portId,
+					type: "signal",
+					payload: { action: "handshake-ack" }
+				}), t(i);
+			};
+			return globalThis.addEventListener("message", s), () => globalThis.removeEventListener("message", s);
+		}
+		disconnect() {
+			this._transport?.close(), this._transport = null, this._handshakeComplete = !1, this._state.next("disconnected");
+		}
+		get isConnected() {
+			return this._handshakeComplete;
+		}
+		get state() {
+			return this._state;
+		}
+		get transport() {
+			return this._transport;
+		}
+	};
+	ve.listen;
+	const Te = (e, t = "worker") => {
+		const n = rt(t ?? "worker");
+		return Object.keys(e).forEach((s) => {
+			e[s];
+		}), n;
+	};
+	var Rt = De({
+		getDirHandle: () => O,
+		getFileSystemRoot: () => A,
+		handlers: () => T,
+		normalizePath: () => I,
+		resolveFileSystemHandle: () => Re
+	}), B, q, A, I, Re, O, T, Ae, M, Ie = Me((() => {
+		B = /* @__PURE__ */ new Map(), q = /* @__PURE__ */ new Map(), A = async (e = "") => e && B.has(e) ? B.get(e) : await navigator.storage.getDirectory(), I = (e) => e?.trim?.()?.replace(/\/+/g, "/") || "/", Re = async (e, t, n = !1) => {
+			const s = I(t).split("/").filter((i) => i && i !== ".");
+			let r = e;
+			for (let i = 0; i < s.length; i++) {
+				const o = s[i];
+				if (i === s.length - 1) try {
+					return await r.getDirectoryHandle(o, { create: n });
+				} catch {
+					try {
+						return await r.getFileHandle(o, { create: n });
+					} catch (a) {
+						if (n) throw a;
+						return null;
+					}
+				}
+				else r = await r.getDirectoryHandle(o, { create: n });
+			}
+			return r;
+		}, O = async (e, t, n) => {
+			const s = I(t).split("/").filter((i) => i);
+			let r = e;
+			for (const i of s) r = await r.getDirectoryHandle(i, { create: n });
+			return r;
+		}, T = {
+			mount: async ({ id: e, handle: t }) => (B.set(e, t), !0),
+			unmount: async ({ id: e }) => (B.delete(e), !0),
+			readDirectory: async ({ rootId: e, path: t, create: n }) => {
+				try {
+					const s = await A(e), r = await O(s, t, n), i = [];
+					for await (const [o, a] of r.entries()) i.push([o, a]);
+					return i;
+				} catch (s) {
+					return console.warn("Worker readDirectory error:", s), [];
+				}
+			},
+			readFile: async ({ rootId: e, path: t, type: n }) => {
+				try {
+					const s = await A(e), r = I(t).split("/").filter((c) => c), i = r.pop(), o = r.join("/"), a = await (await (await O(s, o, !1)).getFileHandle(i, { create: !1 })).getFile();
+					return n === "text" ? await a.text() : n === "arrayBuffer" ? await a.arrayBuffer() : a;
+				} catch (s) {
+					return console.warn("Worker readFile error:", s), null;
+				}
+			},
+			writeFile: async ({ rootId: e, path: t, data: n }) => {
+				try {
+					const s = await A(e), r = I(t).split("/").filter((c) => c), i = r.pop(), o = r.join("/"), a = await (await (await O(s, o, !0)).getFileHandle(i, { create: !0 })).createWritable();
+					return await a.write(n), await a.close(), !0;
+				} catch (s) {
+					return console.warn("Worker writeFile error:", s), !1;
+				}
+			},
+			remove: async ({ rootId: e, path: t, recursive: n }) => {
+				try {
+					const s = await A(e), r = I(t).split("/").filter((a) => a), i = r.pop(), o = r.join("/");
+					return await (await O(s, o, !1)).removeEntry(i, { recursive: n }), !0;
+				} catch {
+					return !1;
+				}
+			},
+			observe: async ({ rootId: e, path: t, id: n }) => {
+				try {
+					if (q.has(n)) return !0;
+					const s = await A(e), r = await O(s, t, !1);
+					if (typeof FileSystemObserver < "u") {
+						const i = new FileSystemObserver((o) => {
+							const a = o.map((c) => {
+								const l = c.changedHandle?.name || c.relativePathComponents?.at(-1);
+								return {
+									type: c.type,
+									name: l,
+									kind: c.changedHandle?.kind || (l?.includes(".") ? "file" : "directory"),
+									handle: c.changedHandle,
+									path: c.relativePathComponents.join("/")
+								};
+							});
+							self.postMessage({
+								type: "observation",
+								id: n,
+								changes: a
+							});
+						});
+						return i.observe(r), q.set(n, i), !0;
+					}
+					return !1;
+				} catch {
+					return !1;
+				}
+			},
+			unobserve: async ({ id: e }) => {
+				const t = q.get(e);
+				return t && (t.disconnect(), q.delete(e)), !0;
+			},
+			copy: async ({ from: e, to: t }) => {
+				try {
+					const n = async (s, r) => {
+						if (s.kind === "directory") for await (const [i, o] of s.entries()) if (o.kind === "directory") {
+							const a = await r.getDirectoryHandle(i, { create: !0 });
+							await n(o, a);
+						} else {
+							const a = await o.getFile(), c = await (await r.getFileHandle(i, { create: !0 })).createWritable();
+							await c.write(a), await c.close();
+						}
+						else {
+							const i = await s.getFile(), o = await r.createWritable();
+							await o.write(i), await o.close();
+						}
+					};
+					return await n(e, t), !0;
+				} catch (n) {
+					return console.warn("Worker copy error:", n), !1;
+				}
+			}
+		}, Ae = "opfs-sw-bridge-v1", M = null;
+		try {
+			typeof BroadcastChannel < "u" && (M = new BroadcastChannel(Ae), M.onmessage = async (e) => {
+				const t = e?.data || {};
+				if (!t || typeof t != "object" || t?.type !== "opfs-sw-request") return;
+				const n = String(t?.requestId || ""), s = String(t?.action || ""), r = t?.payload;
+				if (!n || !s) return;
+				const i = T[s];
+				if (!i) {
+					M?.postMessage?.({
+						type: "opfs-sw-response",
+						requestId: n,
+						ok: !1,
+						error: `Unknown operation type: ${s}`
+					});
+					return;
+				}
+				try {
+					const o = await i(r);
+					M?.postMessage?.({
+						type: "opfs-sw-response",
+						requestId: n,
+						ok: !0,
+						result: o
+					});
+				} catch (o) {
+					M?.postMessage?.({
+						type: "opfs-sw-response",
+						requestId: n,
+						ok: !1,
+						error: o?.message || String(o)
+					});
+				}
+			});
+		} catch {
+			M = null;
+		}
+		self.addEventListener("message", async (e) => {
+			if (!e.data || typeof e.data != "object") return;
+			const { id: t, type: n, payload: s } = e.data;
+			if (T[n]) try {
+				const r = await T[n](s);
+				self.postMessage({
+					id: t,
+					result: r
+				});
+			} catch (r) {
+				self.postMessage({
+					id: t,
+					error: r?.message || String(r)
+				});
+			}
+			else t && self.postMessage({
+				id: t,
+				error: `Unknown operation type: ${n}`
+			});
+		});
+	}));
+	Ie(), T && Te(T);
+	const At = async (e) => {
+		try {
+			if (e.type === "batch") {
+				const t = [];
+				for (const n of e.payload) {
+					const s = await Oe(n);
+					t.push(s);
+				}
+				return t;
+			} else return await Oe(e);
+		} catch (t) {
+			throw console.error("[OPFS Worker] Message processing error:", t), t;
+		}
+	}, Oe = async (e) => {
+		const t = T[e.type];
+		if (!t) throw new Error(`Unknown message type: ${e.type}`);
+		return await t(e.payload);
+	};
+	globalThis.processMessage = At, (async () => {
+		try {
+			const e = (await Promise.resolve().then(() => (Ie(), Rt))).handlers;
+			e && Te(e), console.log("[OPFS Worker] Initialized with handlers:", Object.keys(e || {}));
+		} catch (e) {
+			console.error("[OPFS Worker] Failed to initialize:", e);
+		}
+	})();
+})();