rayzee 10.0.0 → 11.0.0

package/dist/openStorage-DwcBRUj7.js

@@ -0,0 +1,820 @@
+import { n as e } from "./EngineIssues-CIZnXHsF.js";
+import { i as t, r as n, t as r } from "./shared-BGBcSxBQ.js";
+import { t as i } from "./identity-DrQsGT2o.js";
+//#region src/Storage/locks.js
+var a = /* @__PURE__ */ new Map();
+function o(e, t) {
+	return e.exclusive || t === "exclusive" && e.shared > 0 ? !1 : (t === "exclusive" ? e.exclusive = !0 : e.shared++, !0);
+}
+function s(e, t, n) {
+	let r = a.get(e);
+	r || (r = {
+		shared: 0,
+		exclusive: !1,
+		queue: []
+	}, a.set(e, r));
+	let i = c(() => {
+		for (t === "exclusive" ? r.exclusive = !1 : r.shared--; r.queue.length && o(r, r.queue[0].mode);) r.queue.shift().grant();
+		!r.exclusive && r.shared === 0 && r.queue.length === 0 && a.delete(e);
+	});
+	return r.queue.length === 0 && o(r, t) ? Promise.resolve(i) : n ? (!r.exclusive && r.shared === 0 && r.queue.length === 0 && a.delete(e), Promise.resolve(null)) : new Promise((e) => r.queue.push({
+		mode: t,
+		grant: () => e(i)
+	}));
+}
+function c(e) {
+	let t = !1;
+	return () => {
+		t || (t = !0, e());
+	};
+}
+var l = () => typeof navigator < "u" && navigator.locks?.request ? navigator.locks : null;
+function u(e, { mode: t = "exclusive", ifAvailable: n = !1 } = {}) {
+	let r = l();
+	return r ? new Promise((i, a) => {
+		r.request(e, {
+			mode: t,
+			ifAvailable: n
+		}, (e) => {
+			if (!e) {
+				i(null);
+				return;
+			}
+			return new Promise((e) => i(c(e)));
+		}).catch(a);
+	}) : s(e, t, n);
+}
+async function d() {
+	let e = l();
+	if (!e) return new Set(a.keys());
+	let { held: t = [] } = await e.query();
+	return new Set(t.map((e) => e.name));
+}
+//#endregion
+//#region src/Storage/events.js
+var f = class {
+	constructor() {
+		this._handlers = /* @__PURE__ */ new Map();
+	}
+	addEventListener(e, t) {
+		this._handlers.has(e) || this._handlers.set(e, /* @__PURE__ */ new Set()), this._handlers.get(e).add(t);
+	}
+	removeEventListener(e, t) {
+		this._handlers.get(e)?.delete(t);
+	}
+	dispatchEvent(e) {
+		for (let t of [...this._handlers.get(e.type) ?? []]) t.call(this, e);
+	}
+}, p = class {
+	constructor(e) {
+		this._root = e, this._writers = /* @__PURE__ */ new Map(), this._nextId = 1;
+	}
+	async _dir(e, t) {
+		let n = await this._root;
+		for (let r of e) n = await n.getDirectoryHandle(r, { create: t });
+		return n;
+	}
+	async openWriter({ path: e, name: t, truncate: n = !0, length: r }) {
+		let i = await (await (await this._dir(e, !0)).getFileHandle(t, { create: !0 })).createSyncAccessHandle();
+		n ? i.truncate(0) : r !== void 0 && i.getSize() > r && i.truncate(r);
+		let a = this._nextId++;
+		return this._writers.set(a, {
+			handle: i,
+			end: i.getSize()
+		}), { id: a };
+	}
+	write({ id: e, buffer: t, byteOffset: n = 0, byteLength: r, at: i }) {
+		let a = this._writers.get(e);
+		if (!a) throw Error(`storage: writer ${e} is not open`);
+		let o = new Uint8Array(t, n, r ?? t.byteLength - n), s = i ?? a.end, c = 0;
+		for (; c < o.length;) {
+			let e = a.handle.write(o.subarray(c), { at: s + c });
+			if (e <= 0) throw Error("storage: write made no progress");
+			c += e;
+		}
+		return a.end = Math.max(a.end, s + o.length), { bytes: o.length };
+	}
+	closeWriter({ id: e, abort: t = !1 }) {
+		let n = this._writers.get(e);
+		if (!n) return { size: 0 };
+		this._writers.delete(e);
+		try {
+			return t || n.handle.flush(), { size: n.handle.getSize() };
+		} finally {
+			n.handle.close();
+		}
+	}
+	async writeFile({ path: e, name: t, buffer: n, byteOffset: r = 0, byteLength: i }) {
+		let { id: a } = await this.openWriter({
+			path: e,
+			name: t
+		});
+		try {
+			return this.write({
+				id: a,
+				buffer: n,
+				byteOffset: r,
+				byteLength: i
+			}), this.closeWriter({ id: a });
+		} catch (e) {
+			throw this.closeWriter({
+				id: a,
+				abort: !0
+			}), e;
+		}
+	}
+	async readRange({ path: e, name: t, offset: n = 0, length: r }) {
+		let i = await (await this._dir(e, !1)).getFileHandle(t), a = null;
+		try {
+			a = await i.createSyncAccessHandle();
+		} catch (e) {
+			if (e.name !== "NoModificationAllowedError") throw e;
+		}
+		if (!a) {
+			let e = await i.getFile(), t = r === void 0 ? e.size : n + r;
+			return { buffer: await e.slice(n, t).arrayBuffer() };
+		}
+		try {
+			let e = a.getSize(), t = Math.max(0, Math.min(r ?? e - n, e - n)), i = new ArrayBuffer(t);
+			return a.read(i, { at: n }), { buffer: i };
+		} finally {
+			a.close();
+		}
+	}
+	dispose() {
+		for (let e of [...this._writers.keys()]) this.closeWriter({
+			id: e,
+			abort: !0
+		});
+	}
+}, m = class {
+	constructor(e) {
+		this._ops = new p(e);
+	}
+	async call(e, t) {
+		return this._ops[e](t);
+	}
+	dispose() {
+		this._ops.dispose();
+	}
+}, h = "meta.json", g = 1, _ = 36e5, v = .3, y = 100 * 1024 ** 3, b = 64 * 1024 ** 2, x = 8 * 1024 ** 2, S = 4, C = 3e4, w = new TextEncoder();
+function T(e, { copy: t, transfer: n }) {
+	if (typeof e == "string" && (e = w.encode(e)), e instanceof ArrayBuffer) {
+		if (!t || n) return {
+			args: { buffer: e },
+			list: [e]
+		};
+		let r = e.slice(0);
+		return {
+			args: { buffer: r },
+			list: [r]
+		};
+	}
+	if (!ArrayBuffer.isView(e)) throw TypeError("storage: write expects an ArrayBuffer, a typed array, a Blob or a string");
+	let { buffer: r, byteOffset: i, byteLength: a } = e, o = typeof SharedArrayBuffer < "u" && r instanceof SharedArrayBuffer;
+	if (!t) return {
+		args: {
+			buffer: r,
+			byteOffset: i,
+			byteLength: a
+		},
+		list: []
+	};
+	if (o) {
+		let e = new Uint8Array(a);
+		return e.set(new Uint8Array(r, i, a)), {
+			args: { buffer: e.buffer },
+			list: [e.buffer]
+		};
+	}
+	if (n && i === 0 && a === r.byteLength) return {
+		args: { buffer: r },
+		list: [r]
+	};
+	let s = r.slice(i, i + a);
+	return {
+		args: { buffer: s },
+		list: [s]
+	};
+}
+async function E(e, t) {
+	try {
+		let n = await (await e.getFileHandle(t)).getFile();
+		return JSON.parse(await n.text());
+	} catch {
+		return null;
+	}
+}
+async function* D(e) {
+	for await (let [t, n] of e.entries()) n.kind === "directory" && (yield [t, n]);
+}
+var O = class {
+	constructor(e, t, n, r, i) {
+		this.area = e, this.id = t, this.key = n.key, this.meta = n, this._dir = r, this._release = i;
+	}
+	get bytes() {
+		return this.meta.bytes;
+	}
+	get extra() {
+		return this.meta.extra ?? {};
+	}
+	async file(t) {
+		try {
+			return await (await this._dir.getFileHandle(t)).getFile();
+		} catch (n) {
+			return this.area.manager._issue(e.STORAGE_READ_FAILED, `could not read ${this.area.name}/${this.id}/${t}`, { error: n.message }), null;
+		}
+	}
+	async json(e) {
+		let t = await this.file(e);
+		return t ? JSON.parse(await t.text()) : null;
+	}
+	release() {
+		this._release?.(), this._release = null;
+	}
+}, k = class {
+	constructor(e, t, n, r, i, { sizes: a = {}, append: o = !1 } = {}) {
+		this.area = e, this.id = t, this.key = n, this._info = r, this._release = i, this._writers = /* @__PURE__ */ new Map(), this._sizes = { ...a }, this._append = o, this._done = !1, this._committedBytes = o ? Object.values(a).reduce((e, t) => e + t, 0) : 0;
+	}
+	get _transport() {
+		return this.area.manager._transport;
+	}
+	get _path() {
+		return [this.area.name, this.id];
+	}
+	async _writer(e) {
+		let t = this._writers.get(e);
+		if (!t) {
+			let n = this._append && e in this._sizes, r = n && (this._info.growable ?? []).includes(e) ? this._sizes[e] : void 0;
+			t = this._transport.call("openWriter", {
+				path: this._path,
+				name: e,
+				truncate: !n,
+				length: r
+			}), this._writers.set(e, t);
+		}
+		return (await t).id;
+	}
+	async write(e, t, { at: n, transfer: r = !1 } = {}) {
+		this._assertOpen();
+		let { args: i, list: a } = (typeof Blob < "u" && t instanceof Blob ? null : T(t, {
+			copy: !0,
+			transfer: r
+		})) ?? T(await t.arrayBuffer(), {
+			copy: !0,
+			transfer: !0
+		}), o = await this._writer(e);
+		return this._transport.call("write", {
+			id: o,
+			at: n,
+			...i
+		}, a);
+	}
+	async writeFile(e, t) {
+		this._assertOpen(), typeof Blob < "u" && t instanceof Blob && (t = await t.arrayBuffer());
+		let { args: n, list: r } = T(t, {
+			copy: !0,
+			transfer: !0
+		}), { size: i } = await this._transport.call("writeFile", {
+			path: this._path,
+			name: e,
+			...n
+		}, r);
+		return this._sizes[e] = i, i;
+	}
+	writeJSON(e, t) {
+		return this.writeFile(e, JSON.stringify(t));
+	}
+	async writeStream(e, t, { onProgress: n = null, signal: r = null, batchBytes: i = x } = {}) {
+		let a = t.getReader(), o = [], s = new Uint8Array(i), c = 0, l = 0, u = async () => {
+			if (c === 0) return;
+			let t = c === i ? s : s.slice(0, c);
+			s = new Uint8Array(i), c = 0, o.push(this.write(e, t, { transfer: !0 })), o.length >= S && await o.shift();
+		};
+		try {
+			for (;;) {
+				if (r?.aborted) throw r.reason ?? new DOMException("aborted", "AbortError");
+				let { done: e, value: t } = await a.read();
+				if (e) break;
+				let o = 0;
+				for (; o < t.length;) {
+					let e = Math.min(t.length - o, i - c);
+					s.set(t.subarray(o, o + e), c), c += e, o += e, l += e, c === i && await u();
+				}
+				n?.(l);
+			}
+			return await u(), await Promise.all(o), l;
+		} catch (e) {
+			throw a.cancel().catch(() => {}), await Promise.allSettled(o), e;
+		}
+	}
+	async commit(e = {}) {
+		this._assertOpen(), this._done = !0;
+		try {
+			for (let [e, t] of this._writers) {
+				let { size: n } = await this._transport.call("closeWriter", { id: (await t).id });
+				this._sizes[e] = n;
+			}
+			this._writers.clear();
+			let n = Date.now(), r = {
+				v: g,
+				key: this.key,
+				label: this._info.label ?? "",
+				kind: this.area.kind,
+				files: { ...this._sizes },
+				bytes: Object.values(this._sizes).reduce((e, t) => e + t, 0),
+				createdAt: this._info.createdAt ?? n,
+				lastUsed: n,
+				pinned: this._info.pinned === !0,
+				extra: {
+					...this._info.extra,
+					...e
+				}
+			}, i = this._info.growable ?? [];
+			i.length && (r.growable = i);
+			let { args: a, list: o } = T(JSON.stringify(r), { copy: !1 });
+			return await this._transport.call("writeFile", {
+				path: this._path,
+				name: h,
+				...a
+			}, o), this.area.kind === t.CACHE && this.area.manager._countCacheBytes(r.bytes - this._committedBytes), this.area.manager._changed(this.area.name), r;
+		} catch (e) {
+			throw await this._discard(), this.area.manager._writeFailed(this.area.name, e), e;
+		} finally {
+			this._release?.(), this._release = null;
+		}
+	}
+	async abort() {
+		if (!this._done) {
+			this._done = !0;
+			try {
+				this._append ? await this._closeAll(!0) : await this._discard();
+			} finally {
+				this._release?.(), this._release = null;
+			}
+		}
+	}
+	async _closeAll(e) {
+		for (let t of this._writers.values()) try {
+			await this._transport.call("closeWriter", {
+				id: (await t).id,
+				abort: e
+			});
+		} catch {}
+		this._writers.clear();
+	}
+	async _discard() {
+		await this._closeAll(!0), await this.area._removeDir(this.id);
+	}
+	_assertOpen() {
+		if (this._done) throw Error(`storage: entry ${this.area.name}/${this.id} is already committed or aborted`);
+	}
+}, A = class {
+	constructor(e, t, n) {
+		this.manager = e, this.name = t, this.kind = n;
+	}
+	_lockName(e) {
+		return `${this.manager.namespace}:store:${this.name}:${e}`;
+	}
+	async _dir(e = !1) {
+		try {
+			return await this.manager._root.getDirectoryHandle(this.name, { create: e });
+		} catch (e) {
+			if (e.name === "NotFoundError") return null;
+			throw e;
+		}
+	}
+	async _entryDir(e, t = !1) {
+		let n = await this._dir(t);
+		if (!n) return null;
+		try {
+			return await n.getDirectoryHandle(e, { create: t });
+		} catch (e) {
+			if (e.name === "NotFoundError") return null;
+			throw e;
+		}
+	}
+	async _removeDir(e) {
+		let t = await this._dir(!1);
+		if (t) try {
+			await t.removeEntry(e, { recursive: !0 });
+		} catch (e) {
+			if (e.name !== "NotFoundError") throw e;
+		}
+	}
+	async _validMeta(e, t = null) {
+		let n = await E(e, h);
+		if (!n || n.v !== g || typeof n.key != "string" || t !== null && n.key !== t) return null;
+		let r = n.growable ?? [];
+		for (let [t, i] of Object.entries(n.files ?? {})) try {
+			let n = await (await e.getFileHandle(t)).getFile();
+			if (n.size !== i && !(r.includes(t) && n.size > i)) return null;
+		} catch {
+			return null;
+		}
+		return n;
+	}
+	async open(t, { wait: n = !1 } = {}) {
+		let r = await i(t), a = await u(this._lockName(r), {
+			mode: "shared",
+			ifAvailable: !n
+		});
+		if (!a) return null;
+		try {
+			let e = await this._entryDir(r), n = e ? await this._validMeta(e, t) : null;
+			return n ? (Date.now() - n.lastUsed > _ && this._touch(r, n), new O(this, r, n, e, a)) : (a(), null);
+		} catch (t) {
+			return a(), this.manager._issue(e.STORAGE_READ_FAILED, `could not open ${this.name} entry`, { error: t.message }), null;
+		}
+	}
+	async has(e) {
+		let t = await this.open(e);
+		return t?.release(), !!t;
+	}
+	_touch(e, t) {
+		let n = {
+			...t,
+			lastUsed: Date.now()
+		}, { args: r, list: i } = T(JSON.stringify(n), { copy: !1 });
+		this.manager._transport.call("writeFile", {
+			path: [this.name, e],
+			name: h,
+			...r
+		}, i).catch(() => {}), t.lastUsed = n.lastUsed;
+	}
+	async create(t, { label: n = "", pinned: r = !1, expectedBytes: a = 0, extra: o = {}, growable: s = [] } = {}) {
+		let c = await i(t), l = await u(this._lockName(c), { mode: "exclusive" });
+		try {
+			return a > 0 && !await this.manager.ensureSpace(a, this.kind) ? (l(), this.manager._issue(e.STORAGE_QUOTA_EXCEEDED, `no room for ${(a / 1048576).toFixed(0)} MB in ${this.name}`, {
+				area: this.name,
+				expectedBytes: a
+			}), null) : (await this._removeDir(c), await this._entryDir(c, !0), new k(this, c, t, {
+				label: n,
+				pinned: r,
+				extra: o,
+				growable: s
+			}, l));
+		} catch (e) {
+			return l(), this.manager._writeFailed(this.name, e), null;
+		}
+	}
+	async patchMeta(e, t) {
+		let n = await i(e), r = await u(this._lockName(n), {
+			mode: "shared",
+			ifAvailable: !0
+		});
+		if (!r) return !1;
+		try {
+			let r = await this._entryDir(n), i = r ? await this._validMeta(r, e) : null;
+			if (!i) return !1;
+			let { args: a, list: o } = T(JSON.stringify({
+				...i,
+				...t,
+				v: g,
+				key: e
+			}), { copy: !1 });
+			return await this.manager._transport.call("writeFile", {
+				path: [this.name, n],
+				name: h,
+				...a
+			}, o), !0;
+		} finally {
+			r();
+		}
+	}
+	async edit(e) {
+		let t = await i(e), n = await u(this._lockName(t), { mode: "exclusive" });
+		try {
+			let r = await this._entryDir(t), i = r ? await this._validMeta(r, e) : null;
+			if (!i) return n(), null;
+			let a = {
+				label: i.label,
+				pinned: i.pinned,
+				extra: i.extra,
+				createdAt: i.createdAt,
+				growable: i.growable
+			};
+			return new k(this, t, e, a, n, {
+				sizes: i.files,
+				append: !0
+			});
+		} catch (e) {
+			return n(), this.manager._writeFailed(this.name, e), null;
+		}
+	}
+	async remove(e) {
+		return this.removeById(await i(e));
+	}
+	async removeById(e) {
+		let t = await u(this._lockName(e), {
+			mode: "exclusive",
+			ifAvailable: !0
+		});
+		if (!t) return !1;
+		try {
+			return await this._removeDir(e), this.manager._changed(this.name), !0;
+		} finally {
+			t();
+		}
+	}
+	async list() {
+		let e = await this._dir(!1);
+		if (!e) return [];
+		let t = [];
+		for await (let [n, r] of D(e)) {
+			let e = await E(r, h);
+			e?.v === g && t.push({
+				...e,
+				id: n
+			});
+		}
+		return t;
+	}
+	async clear() {
+		let e = 0;
+		for (let { id: t } of await this.list()) await this.removeById(t) && e++;
+		return e;
+	}
+	async sweep() {
+		let e = await this._dir(!1);
+		if (!e) return 0;
+		let t = await d(), n = 0;
+		for await (let [r, i] of D(e)) t.has(this._lockName(r)) || await this._validMeta(i) || await this.removeById(r) && n++;
+		return n;
+	}
+}, j = class extends f {
+	constructor({ root: e, transport: r, namespace: i }) {
+		super(), this.namespace = i, this._root = e, this._transport = r, this._areas = /* @__PURE__ */ new Map(), this._budget = null, this._cacheTotal = null;
+		for (let e of Object.values(n)) this.defineArea(e, { kind: e === n.SPILL ? t.SCRATCH : t.CACHE });
+	}
+	defineArea(e, { kind: n = t.CACHE } = {}) {
+		let r = this._areas.get(e);
+		if (r) {
+			if (r.kind !== n) throw Error(`storage: area "${e}" is already defined as ${r.kind}`);
+			return r;
+		}
+		let i = new A(this, e, n);
+		return this._areas.set(e, i), i;
+	}
+	area(e) {
+		let t = this._areas.get(e);
+		if (!t) throw Error(`storage: unknown area "${e}"`);
+		return t;
+	}
+	get areaNames() {
+		return [...this._areas.keys()];
+	}
+	async estimate() {
+		let e = typeof navigator < "u" ? navigator.storage : null;
+		if (!e?.estimate) return {
+			quota: Infinity,
+			usage: 0
+		};
+		let { quota: t = Infinity, usage: n = 0 } = await e.estimate();
+		return {
+			quota: t,
+			usage: n
+		};
+	}
+	async persisted() {
+		return await globalThis.navigator?.storage?.persisted?.() === !0;
+	}
+	async persist() {
+		let e = await globalThis.navigator?.storage?.persist?.() === !0;
+		return this._changed(null), e;
+	}
+	async budget() {
+		if (this._budget !== null) return this._budget;
+		let { quota: e } = await this.estimate();
+		return Math.min(e * v, y);
+	}
+	setBudget(e) {
+		this._budget = e === null ? null : Math.max(0, e), this._changed(null);
+	}
+	async _cacheBytes() {
+		let e = this._cacheTotal;
+		return (!e || Date.now() - e.at > C) && (e = this._cacheTotal = {
+			at: Date.now(),
+			bytes: 0,
+			ready: null
+		}, e.ready = this._cacheEntries().then((t) => {
+			e.bytes += t.reduce((e, t) => e + (t.meta.bytes ?? 0), 0);
+		}), e.ready.catch(() => {
+			this._cacheTotal === e && (this._cacheTotal = null);
+		})), await e.ready, e.bytes;
+	}
+	_countCacheBytes(e) {
+		this._cacheTotal && (this._cacheTotal.bytes += e);
+	}
+	async _cacheEntries() {
+		let e = [];
+		for (let n of this._areas.values()) if (n.kind === t.CACHE) for (let t of await n.list()) e.push({
+			area: n,
+			meta: t
+		});
+		return e;
+	}
+	async usage() {
+		let { quota: e, usage: n } = await this.estimate(), r = {}, i = 0;
+		for (let e of this._areas.values()) {
+			let n = await e.list(), a = n.reduce((e, t) => e + (t.bytes ?? 0), 0);
+			r[e.name] = {
+				kind: e.kind,
+				bytes: a,
+				entries: n.length
+			}, e.kind === t.CACHE && (i += a);
+		}
+		return {
+			quota: e,
+			usage: n,
+			persisted: await this.persisted(),
+			budget: await this.budget(),
+			cacheBytes: i,
+			areas: r
+		};
+	}
+	async collect({ freeBytes: e = null } = {}) {
+		let t = await this._cacheEntries(), n = await this.budget(), r = this._cacheTotal = {
+			at: Date.now(),
+			bytes: t.reduce((e, t) => e + (t.meta.bytes ?? 0), 0),
+			ready: null
+		}, i = e ?? Math.max(0, r.bytes - n);
+		if (i <= 0) return 0;
+		let a = await d(), o = t.filter(({ area: e, meta: t }) => !t.pinned && !a.has(e._lockName(t.id))).sort((e, t) => e.meta.lastUsed - t.meta.lastUsed), s = 0;
+		for (let { area: e, meta: t } of o) {
+			if (s >= i) break;
+			await e.removeById(t.id) && (s += t.bytes ?? 0, r.bytes -= t.bytes ?? 0);
+		}
+		return s;
+	}
+	async ensureSpace(e, n = t.CACHE) {
+		let r = async () => {
+			let { quota: r, usage: i } = await this.estimate(), a = e + b - (r - i);
+			return n === t.CACHE ? {
+				free: a,
+				budget: await this._cacheBytes() + e - await this.budget()
+			} : {
+				free: a,
+				budget: 0
+			};
+		}, i = await r();
+		return i.free <= 0 && i.budget <= 0 ? !0 : (await this.collect({ freeBytes: Math.max(i.free, i.budget) }), (await r()).free <= 0);
+	}
+	async sweep() {
+		let e = 0;
+		for (let n of this._areas.values()) e += await n.sweep(), n.kind === t.SCRATCH && (e += await n.clear());
+		return e;
+	}
+	_changed(e) {
+		this.dispatchEvent({
+			type: "change",
+			area: e
+		});
+	}
+	_issue(e, t, n = {}) {
+		this.dispatchEvent({
+			type: "issue",
+			code: e,
+			message: t,
+			detail: n
+		});
+	}
+	_writeFailed(t, n) {
+		let r = n?.name === "QuotaExceededError";
+		this._issue(r ? e.STORAGE_QUOTA_EXCEEDED : e.STORAGE_WRITE_FAILED, `${t}: ${n?.message ?? n}`, {
+			area: t,
+			error: n?.name
+		});
+	}
+	dispose() {
+		this._transport?.dispose(), this._transport = null, this._areas.clear();
+	}
+};
+function M({ namespace: e, root: t }) {
+	let n = new m(t);
+	n.inline = !0;
+	let r = new j({
+		root: t,
+		transport: n,
+		namespace: e
+	});
+	return r.sweep().catch(() => {}), r;
+}
+//#endregion
+//#region src/Storage/StorageWorker.js?worker&inline
+var N = "var e=class{constructor(e){this._root=e,this._writers=new Map,this._nextId=1}async _dir(e,t){let n=await this._root;for(let r of e)n=await n.getDirectoryHandle(r,{create:t});return n}async openWriter({path:e,name:t,truncate:n=!0,length:r}){let i=await(await(await this._dir(e,!0)).getFileHandle(t,{create:!0})).createSyncAccessHandle();n?i.truncate(0):r!==void 0&&i.getSize()>r&&i.truncate(r);let a=this._nextId++;return this._writers.set(a,{handle:i,end:i.getSize()}),{id:a}}write({id:e,buffer:t,byteOffset:n=0,byteLength:r,at:i}){let a=this._writers.get(e);if(!a)throw Error(`storage: writer ${e} is not open`);let o=new Uint8Array(t,n,r??t.byteLength-n),s=i??a.end,c=0;for(;c<o.length;){let e=a.handle.write(o.subarray(c),{at:s+c});if(e<=0)throw Error(`storage: write made no progress`);c+=e}return a.end=Math.max(a.end,s+o.length),{bytes:o.length}}closeWriter({id:e,abort:t=!1}){let n=this._writers.get(e);if(!n)return{size:0};this._writers.delete(e);try{return t||n.handle.flush(),{size:n.handle.getSize()}}finally{n.handle.close()}}async writeFile({path:e,name:t,buffer:n,byteOffset:r=0,byteLength:i}){let{id:a}=await this.openWriter({path:e,name:t});try{return this.write({id:a,buffer:n,byteOffset:r,byteLength:i}),this.closeWriter({id:a})}catch(e){throw this.closeWriter({id:a,abort:!0}),e}}async readRange({path:e,name:t,offset:n=0,length:r}){let i=await(await this._dir(e,!1)).getFileHandle(t),a=null;try{a=await i.createSyncAccessHandle()}catch(e){if(e.name!==`NoModificationAllowedError`)throw e}if(!a){let e=await i.getFile(),t=r===void 0?e.size:n+r;return{buffer:await e.slice(n,t).arrayBuffer()}}try{let e=a.getSize(),t=Math.max(0,Math.min(r??e-n,e-n)),i=new ArrayBuffer(t);return a.read(i,{at:n}),{buffer:i}}finally{a.close()}}dispose(){for(let e of[...this._writers.keys()])this.closeWriter({id:e,abort:!0})}};let t=null;async function n(e,t){return t||(await navigator.storage.getDirectory()).getDirectoryHandle(e,{create:!0})}self.onmessage=async({data:r})=>{let{id:i,op:a,args:o}=r;try{if(a===`init`){t=new e(n(o.namespace,o.root)),postMessage({id:i,result:{}});return}let r=await t[a](o),s=r?.buffer instanceof ArrayBuffer?[r.buffer]:[];postMessage({id:i,result:r},s)}catch(e){postMessage({id:i,error:{name:e.name,message:e.message}})}};", P = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", N], { type: "text/javascript;charset=utf-8" });
+function F(e) {
+	let t;
+	try {
+		if (t = P && (self.URL || self.webkitURL).createObjectURL(P), !t) throw "";
+		let n = new Worker(t, {
+			type: "module",
+			name: e?.name
+		});
+		return n.addEventListener("error", () => {
+			(self.URL || self.webkitURL).revokeObjectURL(t);
+		}), n;
+	} catch {
+		return new Worker("data:text/javascript;charset=utf-8," + encodeURIComponent(N), {
+			type: "module",
+			name: e?.name
+		});
+	}
+}
+//#endregion
+//#region src/Storage/transport.js
+function I({ name: e, message: t }) {
+	let n = Error(t);
+	return n.name = e, n;
+}
+var L = class {
+	constructor({ namespace: e, root: t = null }) {
+		this._worker = new F(), this._pending = /* @__PURE__ */ new Map(), this._nextId = 0, this._worker.onmessage = ({ data: e }) => {
+			let t = this._pending.get(e.id);
+			t && (this._pending.delete(e.id), e.error ? t.reject(I(e.error)) : t.resolve(e.result));
+		}, this._ready = this.call("init", {
+			namespace: e,
+			root: t
+		});
+	}
+	call(e, t, n = []) {
+		return this._worker ? new Promise((r, i) => {
+			let a = this._nextId++;
+			this._pending.set(a, {
+				resolve: r,
+				reject: i
+			}), this._worker.postMessage({
+				id: a,
+				op: e,
+				args: t
+			}, n);
+		}) : Promise.reject(/* @__PURE__ */ Error("storage: transport disposed"));
+	}
+	dispose() {
+		this._worker?.terminate(), this._worker = null;
+		for (let { reject: e } of this._pending.values()) e(/* @__PURE__ */ Error("storage: transport disposed"));
+		this._pending.clear();
+	}
+};
+function R() {
+	return typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
+}
+//#endregion
+//#region src/Storage/openStorage.js
+async function z(e) {
+	let t = typeof navigator < "u" ? navigator.storage : null;
+	if (!t?.getDirectory) return {
+		root: null,
+		reason: "this browser has no origin private file system"
+	};
+	try {
+		return { root: await (await t.getDirectory()).getDirectoryHandle(e, { create: !0 }) };
+	} catch (e) {
+		return {
+			root: null,
+			reason: `${e.name}: ${e.message}`
+		};
+	}
+}
+async function B({ namespace: e, root: t = null, transport: n = "auto" } = {}) {
+	let r = t ? { root: t } : await z(e);
+	if (!r.root) return {
+		storage: null,
+		reason: r.reason
+	};
+	if (n === "inline" || n === "auto" && (R() || typeof Worker > "u")) return { storage: M({
+		namespace: e,
+		root: r.root
+	}) };
+	let i = new L({
+		namespace: e,
+		root: t
+	}), a = new j({
+		root: r.root,
+		transport: i,
+		namespace: e
+	});
+	return a.sweep().catch(() => {}), { storage: a };
+}
+async function V(e) {
+	let t = r.get(e);
+	t || (t = {
+		refs: 0,
+		opened: B({ namespace: e })
+	}, r.set(e, t)), t.refs++;
+	let { storage: n, reason: i } = await t.opened;
+	t.storage = n;
+	let a = !1, o = () => {
+		a || (a = !0, t.refs--, !(t.refs > 0) && (r.get(e) === t && r.delete(e), n?.dispose()));
+	};
+	return n ? {
+		storage: n,
+		release: o
+	} : (o(), {
+		storage: null,
+		reason: i,
+		release: () => {}
+	});
+}
+//#endregion
+export { O as a, u as c, A as i, d as l, B as n, j as o, k as r, M as s, V as t };