@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.11

package/browser/esm/CU3DmJ-YnVVrC1_k.mjs

@@ -0,0 +1,1123 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.8.0-beta.11
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { CommonUtils as e, ProtectedError as t, messageKey as n, t as r } from "@sheetxl/utils";
+var i = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	return e.forEach((e, r) => {
+		t.get(r) !== e && n.set(r, e);
+	}), n;
+}, a = !1, o = 0, s = (e) => {
+	if (typeof e != "string") throw Error("A stateId (string) is required. Register with 'ITransaction.IStore.create'.");
+	return e;
+}, c = class extends Error {
+	constructor(e, t, n) {
+		super(e === "open" ? `Transaction conflict: an operation is open on commit '${t}' and this write is not part of it.` : `Transaction conflict: expected commit '${t}' but current is '${n}'.`), this.name = "TransactionConflictError", this.reason = e, this.expectedCommitId = t, this.actualCommitId = n;
+	}
+}, l = (e, t, n = 0) => {
+	for (let r = n; r < t.length; r++) {
+		let [n, i] = t[r];
+		e[n] = typeof i == "function" ? i(e[n]) : i;
+	}
+}, u = class {
+	constructor(e) {
+		this._record = e;
+	}
+	getId() {
+		return this._record.id;
+	}
+	getDescription() {
+		return this._record.description;
+	}
+	getMeta() {
+		return Object.freeze(this._record.meta);
+	}
+	getAuthor() {
+		return this._record.author;
+	}
+	getTimestamp() {
+		return this._record.timestamp;
+	}
+	getOperation() {
+		return this._record.operation;
+	}
+	getIntents() {
+		return Object.freeze({ ...this._record.intents });
+	}
+}, d = class {
+	constructor(e) {
+		this._listeners = /* @__PURE__ */ new Set(), this._listenersState = /* @__PURE__ */ new Map(), this._commits = /* @__PURE__ */ new Map(), this._locked = !1, this._pending = null, this._versionCounter = 0, this._flushOnRead = 0, this._isSync = e?.sync ?? a, this._isTransient = e?.transient ?? !1, this._author = e?.author, this._maxCommits = e?.maxCommits ?? 1e3;
+		let t = {
+			id: "0",
+			description: "initial",
+			meta: {},
+			author: this._author,
+			timestamp: Date.now(),
+			states: /* @__PURE__ */ new Map(),
+			intents: {},
+			intentWrites: [],
+			version: 0,
+			previousId: null
+		}, n = {
+			record: t,
+			commit: new u(t)
+		};
+		this._current = n, this._cacheId = null, this._cacheState = null, this._states = t.states, this._transactionStack = [], this._restoring = !1;
+		let r = /* @__PURE__ */ new Map();
+		r.set(t.id, n), this._commits = r, this._tipId = t.id;
+	}
+	static {
+		this.setDefaultSync = (e) => {
+			a = e;
+		};
+	}
+	getLog(e, t = 100) {
+		let n = [], r = e;
+		do {
+			let e = this._commits.get(r);
+			if (!e) throw Error(`Invalid commit id: '${r}'`);
+			if (n.push(e.commit), r = e.record.previousId, !r) return n;
+		} while (n.length < t);
+		return n;
+	}
+	getCommitCount() {
+		return this._commits.size;
+	}
+	isOpenTransaction() {
+		return this._transactionStack.length > 0;
+	}
+	isRestoring() {
+		return this._restoring;
+	}
+	isAmendingOtherCommit() {
+		let e = this._transactionStack[0];
+		return e instanceof p && e._isRetargeted();
+	}
+	getPendingTransaction() {
+		return this._transactionStack[0] ?? null;
+	}
+	getCurrentTransaction() {
+		let e = this._transactionStack;
+		return e[e.length - 1] ?? null;
+	}
+	amend(e, t) {
+		let n = this.beginCommit(), r = n.getDepth() === 0 ? this._commits.get(e) : void 0;
+		n.getDepth() === 0 && (n._setAmendOf(e), r && r !== this._current && n._retarget(r));
+		try {
+			let e = t(r ? r.commit : this._current.commit);
+			return n.commit(), e;
+		} catch (e) {
+			throw n.rollback(), e;
+		}
+	}
+	_squashTip(e) {
+		if (this._transactionStack.length > 0) return !1;
+		let t = this._commits.get(this._tipId), n = t?.record.previousId;
+		if (!t || !n) return !1;
+		let r = this._commits.get(n);
+		return !!r && (r.record.states = t.record.states, r.record.intents = e(r.record.intents, t.record.intents), r.record.timestamp = t.record.timestamp, this._commits.delete(t.record.id), this._tipId = n, this._current === t && (this._current = r, this._states = r.record.states, this._cacheId = null, this._cacheState = null), !0);
+	}
+	create(t) {
+		let n = e.uuidV4();
+		if (t !== void 0) {
+			let e = this.beginCommit();
+			try {
+				e.updateState(n, t), e.commit();
+			} catch (t) {
+				throw e.rollback(), t;
+			}
+		}
+		return n;
+	}
+	getStateAt(e, t) {
+		return s(t), this._commits.get(e)?.record.states.get(t);
+	}
+	getState(e) {
+		s(e);
+		let t = this._transactionStack;
+		if (t.length === 0) {
+			if (this._cacheId === e) return this._cacheState;
+			let t = this._states.get(e);
+			return this._cacheId = e, this._cacheState = t, t;
+		}
+		if (this._flushOnRead > 0) for (let n = t.length - 1; n >= 0; n--) t[n]._isFlushedBy(e) && t[n]._flush();
+		return t[t.length - 1].getState(e);
+	}
+	getCurrentCommit(e = !0) {
+		return (e ? this._pending?.commit : null) ?? this._current.commit;
+	}
+	getTipCommit() {
+		return this._commits.get(this._tipId).commit;
+	}
+	getVersionId(e) {
+		return s(e), this._states.get(e)?.version ?? 0;
+	}
+	restore(e, t) {
+		let n = this._getCommitContainer(e, t);
+		if (this._current.commit.getId() === n.commit.getId()) return n.commit;
+		let r = i(n.record.states, this._current.record.states);
+		this._notifyStates("onBeforeCommitStart", this._current, r, !0, !1, !1, n);
+		let a = this._current.commit;
+		this._current = n, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, this._notifyStates("onAfterStateChange", n, r, !1, !0, !0, n, a), this._notify("onCommitChange", n.commit, !0), this._restoring = !0;
+		try {
+			this._notifyStates("onRestoreOrRevert", n, n.record.states, !1, !0);
+		} finally {
+			this._restoring = !1;
+		}
+		return n.commit;
+	}
+	revert(e, t) {
+		let n = this._getCommitContainer(e, t), r = this._commits.get(n.record.previousId);
+		if (!r) throw Error(`Invalid commit id: '${n.record.previousId}'`);
+		let a = i(r.record.states, this._current.record.states);
+		this._notifyStates("onBeforeCommitStart", this._current, a, !0, !1, !1, n);
+		let o = this._current.commit;
+		this._current = r, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, this._notifyStates("onAfterStateChange", r, a, !0, !1, !0, n, o), this._notify("onCommitChange", r.commit, !0), this._restoring = !0;
+		try {
+			this._notifyStates("onRestoreOrRevert", r, r.record.states, !0, !0, !1, n);
+		} finally {
+			this._restoring = !1;
+		}
+		return r.commit;
+	}
+	_getCommitContainer(e, t) {
+		let n = this._commits.get(e);
+		if (!n) throw Error(`Invalid commit id: '${e}'`);
+		if (this._isTransient) throw Error("Cannot revert transient store");
+		if (t?.force && this._transactionStack.length > 0 && this._transactionStack[0].rollback(), this._transactionStack.length !== 0) throw Error("Open transactions.");
+		return n;
+	}
+	_pruneForwards(e) {
+		let t = this._tipId;
+		for (; t && t !== e;) {
+			let e = this._commits.get(t);
+			if (!e) break;
+			this._commits.delete(t), t = e.record.previousId;
+		}
+	}
+	_trimOldest() {
+		if (this._commits.size <= this._maxCommits) return;
+		let e = this._commits.keys();
+		for (; this._commits.size > this._maxCommits;) this._commits.delete(e.next().value);
+		let t = this._commits.get(e.next().value);
+		t && (t.record.previousId = null);
+	}
+	beginCommit(t, n) {
+		let r = this._transactionStack;
+		r.length > 0 && r[r.length - 1]._flush();
+		let i = r.length;
+		typeof t == "string" && (t = { description: t });
+		let a = t?.expectedCommitId;
+		if (a !== void 0) {
+			let e = this._current.record.id;
+			if (i > 0 || this._restoring) throw new c("open", a, e);
+			if (e !== a) throw new c("stale", a, e);
+		}
+		if (this._locked) throw console.warn("TransactionStore locked", r), /* @__PURE__ */ Error(`TransactionStore is locked by '${r[i - 1].getDescription()}`);
+		let o = t?.preventFurtherTransactions, s = this, l = (e, t, r) => {
+			let a = s._transactionStack;
+			i !== a.length - 1 && console.warn("Transaction stack out of sync", i, a.length, a), o && (this._locked = !1), a.pop(), e._isFlushedOnRead() && s._flushOnRead--, n?.(e, t, r), a.length === 0 && (s._pending = null, s._notifyClose(e._getCommit(), t, e._isElided(), e._isAmendClose()));
+		}, d;
+		if (r.length === 0) {
+			let n = this._current.record, r = {
+				states: /* @__PURE__ */ new Map(),
+				id: e.uuidV4(),
+				description: typeof t == "string" ? t : t?.description ?? null,
+				meta: {},
+				timestamp: Date.now(),
+				author: (typeof t == "object" ? t?.author : void 0) ?? this._author ?? null,
+				version: n.version + 1,
+				previousId: n.id,
+				intents: {},
+				intentWrites: [],
+				operation: t?.operation
+			}, i = {
+				record: r,
+				commit: new u(r)
+			};
+			this._pending = i, this._notify("onCommitStart", i.commit), d = new p(this, i, n?.states, t, l);
+		} else d = r[r.length - 1].beginTransaction(t, l);
+		return o && (this._locked = !0), this._transactionStack.push(d), d._isFlushedOnRead() && this._flushOnRead++, d;
+	}
+	doBatch(e, t, n) {
+		let r, i = this.beginCommit(t, n), a = this.getCurrentCommit();
+		try {
+			r = e?.(a);
+			let n = () => {
+				i.commit(t);
+			};
+			if (r && typeof r.then == "function") return new Promise((e, t) => {
+				r.then((r) => {
+					try {
+						n(), e(r);
+					} catch (e) {
+						t(e);
+					}
+				}).catch((e) => {
+					i.rollback(), t(e);
+				});
+			});
+			n();
+		} catch (e) {
+			throw i.rollback(), e;
+		}
+		return r;
+	}
+	remove(e) {
+		s(e);
+		let t = !1, n = this._listenersState.get(e);
+		if (n) {
+			let r = this.getCurrentCommit();
+			n.forEach((e) => {
+				e.onClose?.(r);
+			}), this._listenersState.delete(e), t = !0;
+		}
+		this._current.record.states.delete(e) && (t = !0), this._commits.forEach((n) => {
+			n.record.states.delete(e) && (t = !0);
+		});
+		let r = this._transactionStack;
+		return r.length > 0 && r[0]._purgeState(e), this._cacheId = null, this._cacheState = null, t;
+	}
+	addListener(e) {
+		let t = this._listeners;
+		return t.add(e), () => {
+			t.delete(e);
+		};
+	}
+	addStateListener(e, t) {
+		if (s(e), !t) throw Error("Listener is required");
+		let n = this._listenersState.get(e);
+		return n || (n = /* @__PURE__ */ new Set(), this._listenersState.set(e, n)), n.add(t), () => {
+			n.delete(t), n.size === 0 && this._listenersState.delete(e);
+		};
+	}
+	dispatchEvents(e, t = !1) {
+		!t || this._isSync ? e() : setTimeout(e, 0);
+	}
+	_commitRecord(t, n, r) {
+		let i = t.record, a = t.commit, o = t, s = ++this._versionCounter;
+		if (n.forEach((e, t) => {
+			e != null && ((e, t, n) => {
+				Object.defineProperty(e, "id", {
+					value: t,
+					enumerable: !1,
+					configurable: !0,
+					writable: !1
+				}), Object.defineProperty(e, "version", {
+					value: n,
+					enumerable: !1,
+					configurable: !0,
+					writable: !1
+				});
+			})(e, t, s);
+		}), !this._isTransient) {
+			let n = !1;
+			if (r !== null) {
+				let s = this._current, c = this._commits.get(r) ?? s, u = c.record, d = c !== s, f = d ? u.states : s.record.states;
+				if (i.states.forEach((e, t) => {
+					f.set(t, e);
+				}), l(u.intents, i.intentWrites), u.meta = {
+					...u.meta,
+					...i.meta
+				}, u.timestamp = i.timestamp, n = !0, d) return void (o.record.intentWrites = e.EmptyArray);
+				i = s.record, a = s.commit, t = s;
+			}
+			this._commits.set(i.id, t), n || (i.previousId !== this._tipId && this._pruneForwards(i.previousId), this._tipId = i.id, this._trimOldest());
+		}
+		this._current = t, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, o.record.intentWrites = e.EmptyArray, r === null && this._notify("onCommitChange", a);
+		let c = i.previousId ? this._commits.get(i.previousId)?.commit ?? null : null;
+		this._notifyStates("onAfterStateChange", t, n, !1, !1, !0, o, c), this._notify(r === null ? "onCommitEnd" : "onAmendEnd", a, !0);
+	}
+	_notifyStates(e, t, n, r = !1, i = !1, a = !1, o = t, s = null) {
+		let c = t.commit, l = o.record.intents, u = this._listenersState;
+		n.forEach((t, n) => {
+			let o = u.get(n);
+			o && this.dispatchEvents(() => {
+				o.forEach((n) => {
+					n[e]?.(t, c, r, i, l, s);
+				});
+			}, a);
+		});
+	}
+	_notifyClose(e, t, n = !1, r = !1) {
+		this._listeners.forEach((i) => {
+			i.onCommitClose?.(e, t, n, r);
+		});
+	}
+	_notify(e, t, n = !1) {
+		return this.dispatchEvents(() => {
+			this._listeners.forEach((n) => {
+				n[e]?.(t);
+			});
+		}, n);
+	}
+}, f = class {
+	constructor(e, t, n) {
+		if (this._children = /* @__PURE__ */ new Set(), this._depth = 0, this._closed = !1, this._isAmend = !1, this._readOnly = !1, this._hooks = null, this._flushing = !1, this._outcomes = null, this._intentMark = -1, this._store = e, this._container = t, n = typeof n == "string" ? { description: n } : n, this._description = n?.description ?? "", this._operation = n?.operation ?? null, this._readOnly = n?.readOnly ?? !1, n?.flush || n?.onCommit || n?.onRollback || n?.onChildCommit) {
+			let e = {
+				flush: n.flush,
+				writes: n.writes,
+				onCommit: n.onCommit,
+				onRollback: n.onRollback,
+				onChildCommit: n.onChildCommit
+			};
+			this._hooks = e, (e.onCommit || e.onRollback) && (this._outcomes = [e]);
+		}
+	}
+	_isFlushedOnRead() {
+		return !(!this._hooks?.flush || !this._hooks.writes?.length);
+	}
+	_isFlushedBy(e) {
+		let t = this._hooks?.writes;
+		return !!t && t.includes(e);
+	}
+	_flush() {
+		let e = this._hooks?.flush;
+		if (e && !this._flushing) {
+			this._flushing = !0;
+			try {
+				e();
+			} finally {
+				this._flushing = !1;
+			}
+		}
+	}
+	_settle(e) {
+		let t = this._children;
+		for (; t.size > 0;) t.values().next().value.commit(e);
+		this._flush();
+	}
+	_adoptOutcomes(e) {
+		let t = e._outcomes;
+		if (t) {
+			if (this._outcomes) for (let e = 0; e < t.length; e++) this._outcomes.push(t[e]);
+			else this._outcomes = t;
+		}
+	}
+	_childCommitted(e) {
+		let t = this._hooks?.onChildCommit;
+		if (!t) return;
+		let n = {};
+		l(n, this._container.record.intentWrites, e._intentMark), t(e, n);
+	}
+	_notifyOutcome(e) {
+		let t = this._outcomes;
+		if (t) {
+			this._outcomes = null;
+			for (let n = 0; n < t.length; n++) try {
+				e ? t[n].onCommit?.(e) : t[n].onRollback?.();
+			} catch (e) {
+				console.warn(e);
+			}
+		}
+	}
+	_getCommit() {
+		return this._container.commit;
+	}
+	_isElided() {
+		return !1;
+	}
+	_setAmendOf(e) {
+		this._container.amendOf = e;
+	}
+	_isAmendClose() {
+		return this._isAmend || this._container.amendOf !== void 0;
+	}
+	getIntent(e) {
+		return this._container.record.intents?.[e];
+	}
+	setIntent(e, t) {
+		let n = this._container.record, r = n.intents ??= {};
+		r[e] = typeof t == "function" ? t(r[e]) : t, (n.intentWrites ??= []).push([e, t]);
+	}
+	getDepth() {
+		return this._depth;
+	}
+	getDescription() {
+		return this._description;
+	}
+	getOperation() {
+		return this._operation;
+	}
+	getStates() {
+		return this._states;
+	}
+	beginTransaction(e, t) {
+		this._ensureOpen();
+		let n = new m(this._store, this, this._container, typeof e == "string" ? { description: e } : e, t);
+		return this._hooks?.onChildCommit && (n._intentMark = this._container.record.intentWrites.length), this._children || this._children, this._children.add(n), n;
+	}
+	isReadOnly() {
+		return this._readOnly;
+	}
+	updateState(e, t) {
+		if (this._ensureOpen(), s(e), this._readOnly) throw Error("Transaction is read-only" + (this._description ? `: '${this._description}'` : ""));
+		let n = this.getState(e), r;
+		if (typeof t == "function") {
+			if (r = t(n), r === n) return n;
+			r &&= { ...r };
+		} else {
+			if (t === void 0) return n;
+			r = {
+				...n,
+				...t
+			};
+		}
+		if (r) {
+			let t = this._states;
+			t || (t = /* @__PURE__ */ new Map(), this._states = t), t.set(e, r);
+		}
+		return r;
+	}
+	amend(e) {
+		return this._isAmend = !0, this.commit(e);
+	}
+	commit(t) {
+		return this._ensureOpen(), typeof t == "string" && (t = { description: t }), t && (t.description && (this._description = t.description), t.meta && (this._meta = e.mergeContentful(t.meta, this._meta))), this._children && this._children.forEach((e) => {
+			e.commit(t);
+		}), this;
+	}
+	isClose() {
+		return this._closed;
+	}
+	_ensureOpen() {
+		if (this._closed) throw this._descriptions ? console.warn(`stack: [${this._descriptions.join(",")}]`) : this._description && console.warn(`description: [${this._description}]`), /* @__PURE__ */ Error("Transaction already closed");
+	}
+	_removeChild(e, t = !1) {
+		this._children.delete(e), t || this._mergeStates(e._states);
+	}
+	_purgeState(e) {
+		this._states?.delete(e), this._children.forEach((t) => {
+			t._purgeState(e);
+		});
+	}
+	_mergeStates(e) {
+		if (!e || e.size === 0) return;
+		let t = this._states;
+		return t ? (e.forEach((e, n) => {
+			t.set(n, e);
+		}), t) : (this._states = e, e);
+	}
+	get isITransaction() {
+		return !0;
+	}
+}, p = class extends f {
+	constructor(e, t, n, r, i) {
+		super(e, t, r), this._retargeted = !1, this._elided = !1, this._prevStates = n, this._onClose = i, this._states = /* @__PURE__ */ new Map(), this._meta = t.record.meta;
+	}
+	_isElided() {
+		return this._elided;
+	}
+	_retarget(e) {
+		this._prevStates = e.record.states, this._retargeted = !0;
+	}
+	_isRetargeted() {
+		return this._retargeted;
+	}
+	getId() {
+		return this._container.commit.getId();
+	}
+	getSavepointId() {
+		return this.getId();
+	}
+	getParent() {
+		return this;
+	}
+	commit(e) {
+		this._ensureOpen(), this._settle(e);
+		let t = this._states, n = this._container;
+		if (this._store._notifyStates("onBeforeCommitStart", n, t, !1, !1), super.commit(e), this._states.size === 0) return this._closed = !0, this._elided = !0, this._onClose?.(this, !1, e), this._notifyOutcome(n.commit), this;
+		this._store._notifyStates("onBeforeCommitEnd", n, t, !1, !1), this._settle(e);
+		let r = new Map(this._prevStates);
+		this._states.forEach((e, t) => {
+			e === null ? r.delete(t) : r.set(t, e);
+		}), this._states = r, this._description && (n.record.description = this._description), this._meta && (n.record.meta = this._meta), n.record.states = r, this._closed = !0, this._onClose?.(this, !1, e);
+		let i = n.amendOf ?? (this._isAmend ? n.record.previousId : null);
+		return this._store._commitRecord(n, t, i), this._notifyOutcome(n.commit), this;
+	}
+	rollback() {
+		return this._ensureOpen(), this._children && this._children.forEach((e) => {
+			e.rollback();
+		}), this._notifyOutcome(null), this._closed = !0, this._onClose?.(this, !0, null), this;
+	}
+	updateState(e, t) {
+		let n = this.getState(e), r = super.updateState(e, t);
+		return r === n || this._states.set(e, r), r;
+	}
+	getState(e) {
+		s(e);
+		let t = this._states.get(e);
+		return t ||= this._prevStates.get(e), t;
+	}
+}, m = class extends f {
+	constructor(e, t, n, r, i) {
+		if (super(e, n, r), this._savepointId = null, !t) throw Error("Parent transaction required");
+		this._parent = t, this._depth = this._parent.getDepth() + 1, !1 !== (typeof r == "string" ? void 0 : r?.savepoint) && (this._savepointId = `${t.getId()}:${++o}`), t.isReadOnly() && (this._readOnly = !0), this._onClose = i;
+	}
+	getId() {
+		return this._parent.getId();
+	}
+	getSavepointId() {
+		return this._savepointId ?? this._parent.getSavepointId();
+	}
+	getParent() {
+		return this._parent;
+	}
+	getState(e) {
+		if (this._states) {
+			let t = this._states.get(e);
+			if (t !== void 0) return t;
+		}
+		return this._parent.getState(e);
+	}
+	commit(e) {
+		return this._ensureOpen(), this._settle(e), super.commit(e), this._parent._removeChild(this), this._parent._adoptOutcomes(this), this._closed = !0, this._onClose?.(this, !1, e), this._intentMark >= 0 && this._parent._childCommitted(this), this._parent ?? this;
+	}
+	rollback() {
+		return this._ensureOpen(), this._children && this._children.forEach((e) => {
+			e.rollback();
+		}), this._notifyOutcome(null), this._parent._removeChild(this, !0), this._closed = !0, this._onClose?.(this, !0, null), this._parent ?? this;
+	}
+}, h = class e {
+	constructor(e) {
+		this._closed = !1, this._commitId = null, this._stepListeners = null, this._toWrapped = /* @__PURE__ */ new WeakMap(), this._methods = /* @__PURE__ */ new WeakMap(), this._callbacks = /* @__PURE__ */ new WeakMap(), this._outward = /* @__PURE__ */ new WeakMap(), this._inward = /* @__PURE__ */ new WeakMap(), this._store = e;
+	}
+	getStore() {
+		return this._store;
+	}
+	getCommitId() {
+		return this._commitId;
+	}
+	isClosed() {
+		return this._closed;
+	}
+	close() {
+		this._closed || (this._closed = !0, this._stepListeners && b(this._store, -1), this._stepListeners = null);
+	}
+	addStepListener(e) {
+		return this._closed ? M : (this._stepListeners || (this._stepListeners = /* @__PURE__ */ new Set(), b(this._store, 1)), this._stepListeners.add(e), () => {
+			this._stepListeners?.delete(e);
+		});
+	}
+	_onStep(e, t) {
+		let n = this._stepListeners;
+		if (n && n.size !== 0) for (let r of [...n]) r(e, t);
+	}
+	wrap(e) {
+		if (typeof e == "function") return this._wrapFunction(e, !0);
+		if (typeof e != "object" || !e) return e;
+		let t = e;
+		if (_.has(t)) return e;
+		let n = this._toWrapped.get(t);
+		return n === void 0 ? t instanceof Promise ? t.then((e) => this.wrap(e)) : Array.isArray(t) ? this._wrapArray(t) : T(t) ? this._wrapModel(t) : O(t) ? this._wrapIterator(t) : e : n;
+	}
+	unwrap(e) {
+		if (typeof e != "object" || !e) return e;
+		let t = e, n = g.get(t);
+		return n === void 0 ? Array.isArray(t) ? k(t) : Object.getPrototypeOf(t) === Object.prototype ? A(t) : e : n;
+	}
+	_wrapModel(e) {
+		let t = this, n = new Proxy(e, {
+			get(e, n) {
+				let r = Reflect.get(e, n, e);
+				if (r === null || typeof r != "object" && typeof r != "function") return r;
+				let i = Object.getOwnPropertyDescriptor(e, n);
+				return !i || i.configurable || i.writable ? typeof r == "function" ? t._wrapMethod(e, r) : t.wrap(r) : r;
+			},
+			set: (e, n, r) => Reflect.set(e, n, t.unwrap(r), e)
+		});
+		return this._toWrapped.set(e, n), g.set(n, e), _.set(n, this), n;
+	}
+	_wrapMethod(e, t) {
+		let n = this._methods.get(e);
+		n || (n = /* @__PURE__ */ new Map(), this._methods.set(e, n));
+		let r = n.get(t);
+		if (r) return r;
+		let i = this;
+		return r = function(...n) {
+			let r = n.length;
+			for (let e = 0; e < r; e++) n[e] = i._unwrapArg(n[e]);
+			return i._inScope(() => i.wrap(t.apply(e, n)));
+		}, n.set(t, r), r;
+	}
+	_unwrapArg(e) {
+		return typeof e == "function" ? this._wrapFunction(e, !1) : typeof e != "object" || !e || Object.getPrototypeOf(e) !== Object.prototype || g.has(e) ? this.unwrap(e) : this._unwrapCallbacks(e);
+	}
+	_unwrapCallbacks(e) {
+		let t = !1;
+		for (let n in e) if (typeof e[n] == "function") {
+			t = !0;
+			break;
+		}
+		if (!t) return this.unwrap(e);
+		let n = this._callbacks.get(e);
+		if (n) return n;
+		let r = {};
+		for (let t in e) {
+			let n = e[t];
+			r[t] = typeof n == "function" ? this._wrapFunction(n, !1) : this.unwrap(n);
+		}
+		return this._callbacks.set(e, r), r;
+	}
+	_wrapFunction(e, t) {
+		let n = t ? this._outward : this._inward, r = n.get(e);
+		if (r) return r;
+		let i = this;
+		return r = t ? function(...t) {
+			let n = t.length;
+			for (let e = 0; e < n; e++) t[e] = i._unwrapArg(t[e]);
+			return i._inScope(() => i.wrap(e.apply(i.unwrap(this), t)));
+		} : function(...t) {
+			let n = t.length;
+			for (let e = 0; e < n; e++) t[e] = i.wrap(t[e]);
+			return i.unwrap(e.apply(i.wrap(this), t));
+		}, n.set(e, r), r;
+	}
+	_wrapArray(e) {
+		let t = e.length > 0 ? e[0] : void 0;
+		return typeof t != "object" || !t || Array.isArray(t) || !T(t) ? e : e.map((e) => this.wrap(e));
+	}
+	_wrapIterator(e) {
+		let t = this, n = {
+			next(...n) {
+				let r = e.next(...n);
+				return r.done ? r : {
+					done: !1,
+					value: t.wrap(r.value)
+				};
+			},
+			[Symbol.iterator]: () => n
+		};
+		return e.return && (n.return = (t) => e.return(t)), n;
+	}
+	_inScope(e) {
+		if (this._closed) return e();
+		let t = v;
+		v = this;
+		try {
+			return e();
+		} finally {
+			v = t;
+		}
+	}
+	static bind(t, n, r) {
+		let i = new e(t);
+		return {
+			callback: (e) => {
+				i._commitId = e.getId();
+				let t = r(e, i.wrap(n));
+				return t instanceof Promise ? t.then((e) => i.unwrap(e)) : i.unwrap(t);
+			},
+			close: () => i.close(),
+			onChildCommit: (e, n) => {
+				i._onStep(t.getCurrentCommit(), n);
+			}
+		};
+	}
+	static isStepping(e) {
+		return (y.get(e) ?? 0) > 0;
+	}
+	static of(e) {
+		return e === null || typeof e != "object" && typeof e != "function" ? null : _.get(e) ?? null;
+	}
+}, g = /* @__PURE__ */ new WeakMap(), _ = /* @__PURE__ */ new WeakMap(), v = null, y = /* @__PURE__ */ new WeakMap(), b = (e, t) => {
+	y.set(e, (y.get(e) ?? 0) + t);
+}, x = () => v, S = (e) => v !== null && v.getStore() === e, C = /* @__PURE__ */ new WeakMap(), w = [
+	"addListener",
+	"addListeners",
+	"doBatch",
+	"getWorkbook",
+	"getWorksheet",
+	"update"
+], T = (e) => {
+	let t = Object.getPrototypeOf(e);
+	if (t === null || t === Object.prototype || t === Array.prototype) return !1;
+	let n = C.get(t);
+	return n === void 0 && (n = !E(e) && D(t), C.set(t, n)), n;
+}, E = (e) => e instanceof Date || e instanceof RegExp || e instanceof Map || e instanceof Set || e instanceof WeakMap || e instanceof WeakSet || e instanceof Error || e instanceof ArrayBuffer || ArrayBuffer.isView(e), D = (e) => {
+	for (let t = 0; t < w.length; t++) if (typeof e[w[t]] == "function") return !0;
+	let t = e;
+	for (; t && t !== Object.prototype;) {
+		let e = Object.getOwnPropertyNames(t);
+		for (let n = 0; n < e.length; n++) {
+			let r = e[n];
+			if (r.length > 3 && r.startsWith("set") && r.charCodeAt(3) >= 65 && r.charCodeAt(3) <= 90 && typeof Object.getOwnPropertyDescriptor(t, r)?.value == "function") return !0;
+		}
+		t = Object.getPrototypeOf(t);
+	}
+	return !1;
+}, O = (e) => typeof e.next == "function" && typeof e[Symbol.iterator] == "function", k = (e) => {
+	let t = null, n = e.length;
+	for (let r = 0; r < n; r++) {
+		let n = e[r];
+		if (typeof n != "object" || !n) continue;
+		let i = j(n);
+		i !== n && (t ??= e.slice(), t[r] = i);
+	}
+	return t ?? e;
+}, A = (e) => {
+	let t = null;
+	for (let n in e) {
+		let r = e[n];
+		if (typeof r != "object" || !r) continue;
+		let i = j(r);
+		i !== r && (t ??= { ...e }, t[n] = i);
+	}
+	return t ?? e;
+}, j = (e) => {
+	let t = g.get(e);
+	return t === void 0 ? Array.isArray(e) ? k(e) : Object.getPrototypeOf(e) === Object.prototype ? A(e) : e : t;
+}, M = () => {}, N = (e, t, ...n) => {
+	let r = globalThis.__SXL_LOG_EVENTS;
+	r && (typeof r != "string" || e.includes(r)) && console.log(`[sxl:${e}] ${t}`, ...n);
+}, P = class {
+	constructor(e, t) {
+		this._listeners = /* @__PURE__ */ new Set(), this._pending = null, this._landing = null, this._listeners = /* @__PURE__ */ new Set(), this._transactions = t ?? new d({ transient: !0 }), this._stateId = this._transactions.create(), this._src = e;
+		let n = this, r = () => {
+			let e = n._landing;
+			if (N(n._label(), `drain landing=${e ? e.length : "null"}`), !e) return;
+			n._landing = null;
+			let t = /* @__PURE__ */ new Set(), r = e.length, i = null;
+			for (let t = 0; t < r; t++) {
+				let n = e[t].options, r = n?.merge;
+				if (!r) continue;
+				i ??= /* @__PURE__ */ new Map();
+				let a = e[t].listeners;
+				for (let e = 0; e < a.length; e++) {
+					let t = a[e];
+					i.set(t, i.has(t) ? r(i.get(t), n.params) : n.params);
+				}
+			}
+			for (let a = 0; a < r; a++) {
+				let r = e[a];
+				n._doNotify(r.listeners, r.removes, r.options, t, i);
+			}
+		};
+		this._transactionsRemoveListener = this._transactions.addListener({
+			onCommitClose(e, t, i) {
+				let a = n._pending;
+				N(n._label(), `commitClose rollback=${t} elided=${i} pending=${a ? a.length : "null"}`), n._pending = null, t || (a && (n._landing ? n._landing.push(...a) : n._landing = a), i && r());
+			},
+			onCommitEnd: r,
+			onAmendEnd: r
+		});
+	}
+	_label() {
+		return this._src?.constructor?.name ?? "unknown";
+	}
+	_inOperation() {
+		return this._transactions.isOpenTransaction() || this._transactions.isRestoring();
+	}
+	addListeners(e, t) {
+		let n = t?.transactional ?? S(this._transactions), r = { listeners: e }, i = this, a = () => {
+			n ? i._updateEntries((e) => {
+				e.delete(r);
+			}) : i._listeners.delete(r);
+		};
+		return r.remove = t?.once ? a : null, n ? i._updateEntries((e) => {
+			e.add(r);
+		}) : i._listeners.add(r), a;
+	}
+	_updateEntries(e) {
+		let t = this._transactions, n = t.getState(this._stateId)?.listeners, r = new Set(n);
+		e(r);
+		let i = t.beginCommit();
+		try {
+			i.updateState(this._stateId, { listeners: r }), i.amend();
+		} catch (e) {
+			throw i.rollback(), e;
+		}
+	}
+	async _doNotify(e, t = null, n, r, i) {
+		let a = n?.source ?? this._src, o = [], s = n?.params, c = e.length;
+		for (let t = 0; t < c; t++) {
+			let n = e[t];
+			r && r.has(n) || (r?.add(n), o.push(n(a, i?.has(n) ? i.get(n) : s)));
+		}
+		let l = null;
+		if (t && (l = () => {
+			let e = t.length;
+			for (let n = 0; n < e; n++) t[n]();
+		}), n?.async) return new Promise(async (e, t) => {
+			try {
+				let t = await Promise.all(o);
+				l?.(), e(t);
+			} catch (e) {
+				l?.(), t(e);
+			}
+		});
+		l?.();
+	}
+	hasTransactional(e) {
+		let t = this._transactions.getState(this._stateId)?.listeners;
+		if (!t || t.size === 0) return !1;
+		for (let n of t) if (n.listeners[e]) return !0;
+		return !1;
+	}
+	_collect(e, t) {
+		if (!e) return null;
+		let n = null, r = null;
+		return e.forEach((e) => {
+			let i = e.listeners[t];
+			i && ((n ??= []).push(i), e.remove && (r ??= []).push(e.remove));
+		}), n ? {
+			listeners: n,
+			removes: r
+		} : null;
+	}
+	notify(e, t) {
+		let n = this._transactions, r = t?.transactional ?? this._inOperation();
+		if (r) {
+			let r = this._collect(n.getState(this._stateId)?.listeners, e);
+			r && this._doNotify(r.listeners, r.removes, t);
+		}
+		let i = this._collect(this._listeners, e);
+		if (i) return !r || n.isRestoring() || t?.async ? (N(this._label(), `notify ${String(e)} delivered to ${i.listeners.length}`), this._doNotify(i.listeners, i.removes, t)) : ((this._pending ??= []).push({
+			listeners: i.listeners,
+			removes: i.removes,
+			options: t
+		}), void N(this._label(), `notify ${String(e)} QUEUED (open transaction) pending=${this._pending.length}`));
+		N(this._label(), `notify ${String(e)} inOperation=${r} listeners=0`);
+	}
+	close() {
+		this._transactions.remove(this._stateId), this._transactionsRemoveListener(), this._listeners.clear(), this._pending = null, this._landing = null;
+	}
+}, F = "Item has been closed. No further operations are allowed.", I = (e = n("op.update")) => r("error.anchor.protected", { description: r(e) }), L = class {
+	constructor(e) {
+		this._closed = !1, this._options = { ...e };
+		let t = this;
+		this._transactions = this._options?.transactions ?? new d({ transient: !0 }), this._id = this._transactions.create({ isDeleted: !1 }), this._emitter = new P(this, this._transactions), e?.json && this._fromJSON(e.json), this._options?.setContainerReadOnlyCallback?.(() => {
+			t._processOnContainerReadOnly();
+		}), this._transactionsRemoveListener = this._transactions.addStateListener(this._id, {
+			onAfterStateChange(e, n) {
+				t._processAfterStateChange(e, n);
+			},
+			onRestoreOrRevert(e, n) {
+				t._processRestoreOrRevert(e, n);
+			}
+		}), this._processInit();
+	}
+	_fromJSON(e) {}
+	isReadOnly() {
+		return this._options.isReadOnly?.() ?? !1;
+	}
+	isDeleted() {
+		let e = this._getState();
+		return e === void 0 || (e.isDeleted ?? !1);
+	}
+	getType() {
+		return this._options.type;
+	}
+	get isIModel() {
+		return !0;
+	}
+	_processTransactionDone(e) {}
+	_getActionDescription(e) {
+		return null;
+	}
+	_getState() {
+		if (this._closed) throw Error(r("error.model.modelClosed"));
+		return this._transactions.getState(this._id);
+	}
+	_beginCommit(e) {
+		return this._transactions.beginCommit(typeof e == "string" ? { description: e } : e);
+	}
+	_getTransactions() {
+		return this._transactions;
+	}
+	_updateState(e, t, n) {
+		return this._writeState(e, t, n, !1);
+	}
+	_amendState(e, t, n) {
+		return this._writeState(e, t, n, !0);
+	}
+	_writeState(e, t, n, i = !1) {
+		if (this._closed) throw Error(r("error.model.modelClosed"));
+		if (!e) return this;
+		let a = this._beginCommit(t?.description);
+		try {
+			a.updateState(this._id, e);
+			let r = !1, o = n ? n.length : 0;
+			for (let e = 0; e < o; e++) {
+				let t = n[e];
+				r ||= t === "onAnyChange", this._emitter.notify(t);
+			}
+			!r && n && o > 0 && this._emitter.notify("onAnyChange"), i ? a.amend(t) : a.commit(t);
+		} catch (e) {
+			throw a.rollback(), e;
+		}
+		return this;
+	}
+	_getEmitter() {
+		return this._emitter;
+	}
+	_processInit() {}
+	_processAfterStateChange(e, t) {}
+	_processRestoreOrRevert(e, t) {
+		this._emitter.notify("onInvalidated");
+	}
+	delete(e) {
+		this._getState().isDeleted || this._delete(e);
+	}
+	_delete(e) {
+		e = {
+			description: this._getActionDescription("delete") ?? n("op.delete"),
+			...e
+		};
+		let t = this._beginCommit(e?.description);
+		try {
+			this._options.deleteFromContainer && this._options.deleteFromContainer?.(e), this._processDelete(), t.commit();
+		} catch (e) {
+			throw t.rollback(), e;
+		}
+	}
+	_processOnContainerDeleted() {
+		this._processDelete();
+	}
+	_processDelete() {
+		this._updateState({ isDeleted: !0 }, void 0, ["onDelete"]);
+	}
+	_processOnContainerReadOnly() {
+		this._emitter.notify("onReadOnlyChange");
+	}
+	addListeners(e, t) {
+		return this._emitter.addListeners(e, t);
+	}
+	getId() {
+		return this._id;
+	}
+	getVersionId() {
+		return this._transactions.getVersionId(this._id);
+	}
+	beginCommit(e) {
+		return this._beginCommit(e);
+	}
+	doBatch(e, t) {
+		let n = this;
+		return this._transactions.doBatch(e, typeof t == "string" ? { description: t } : t, (e) => {
+			n._processTransactionDone(e);
+		});
+	}
+	isClosed() {
+		return this._closed;
+	}
+	close() {
+		this._closed || (this._emitter.notify("onClose"), this._closed = !0, this._transactionsRemoveListener?.(), this._transactions.remove(this._id));
+	}
+}, R = class e extends L {
+	static {
+		this.instanceCounter = 0;
+	}
+	constructor(t) {
+		super(t), this._watches = /* @__PURE__ */ new Set(), this._watchesReleased = !1, this._getMovable = t.getMovable ?? null, this._addWatchOption = t.addWatch ?? null, this._getRangeOption = t.getRange ?? null;
+		let n = t.name ?? null;
+		!n && this._getMovable && (n = `${this.getTypeDescription()} ${++e.instanceCounter}`);
+		let r = t.description ?? null;
+		n === null && r === null || this._updateState({
+			name: n,
+			description: r
+		});
+	}
+	getName() {
+		return this._closed ? null : this._getState()?.name ?? null;
+	}
+	setName(e) {
+		let t = { description: n("op.setMovableName") };
+		return this._protectionCheck(t.description), this._updateState({ name: e }, t, ["onAnyChange"]), this;
+	}
+	getDescription() {
+		return this._closed ? null : this._getState()?.description ?? null;
+	}
+	setDescription(e) {
+		let t = { description: n("op.setMovableDescription") };
+		return this._protectionCheck(t.description), this._updateState({ description: e || null }, t, ["onAnyChange"]), this;
+	}
+	getMovable() {
+		return this._getMovable?.() ?? null;
+	}
+	getReferences() {
+		if (this._closed || this._watchesReleased || this._watches.size === 0) return null;
+		let e = [], t = /* @__PURE__ */ new Set();
+		for (let n of this._watches) {
+			let r = n.formula?.getReferences() ?? this._parseReference(n.expression);
+			if (!r) continue;
+			let i = r.getCount();
+			for (let n = 0; n < i; n++) {
+				let i = r.at(n);
+				if (i.isInvalid()) continue;
+				let a = `${i.getWorksheet().getId()}!${i.getAddress()}`;
+				t.has(a) || (t.add(a), e.push(i));
+			}
+		}
+		return e.length === 0 ? null : e[0].getWorksheet().getRanges(e);
+	}
+	_addWatch(e, t, n) {
+		let r = typeof e == "string" ? e : e.getExpression(), i = {
+			expression: r.startsWith("=") ? r.substring(1) : r,
+			formula: null,
+			callback: t,
+			options: n,
+			release: null
+		};
+		return this._watches.add(i), this._watchesReleased || this._hold(i, typeof e == "string" ? void 0 : e), () => {
+			this._watches.delete(i) && (i.release?.(), i.release = null, this._notifyReferencesChange());
+		};
+	}
+	_resolveRange(e) {
+		return this._getRangeOption?.(e) ?? null;
+	}
+	_hold(e, t) {
+		let n = this._addWatchOption;
+		n && (e.release = n(t ?? e.expression, (t) => {
+			e.formula = t.formula, e.expression = t.formula.getExpression(), e.callback?.(t), this._notifyReferencesChange();
+		}, e.options));
+	}
+	_parseReference(e) {
+		if (!e || e.includes("#REF!")) return null;
+		try {
+			let t = e.includes("!") ? null : this.getMovable()?.getRange().getWorksheet(), n = t ? t.getRange(e) : this._resolveRange(e);
+			return n && !n.isInvalid() ? n.getWorksheet().getRanges([n]) : null;
+		} catch {
+			return null;
+		}
+	}
+	_notifyReferencesChange() {
+		this._closed || (this._emitter.notify("onReferencesChange"), this._emitter.notify("onAnyChange"));
+	}
+	_releaseWatches() {
+		this._watchesReleased = !0;
+		for (let e of this._watches) e.release?.(), e.release = null;
+	}
+	_holdWatches() {
+		this._watchesReleased = !1;
+		for (let e of this._watches) this._hold(e, e.formula ?? void 0);
+	}
+	_processDelete() {
+		this._releaseWatches(), super._processDelete();
+	}
+	_processRestoreOrRevert(e, t) {
+		super._processRestoreOrRevert(e, t);
+		let n = e === void 0 || !0 === e.isDeleted;
+		n && !this._watchesReleased ? this._releaseWatches() : !n && this._watchesReleased && this._holdWatches();
+	}
+	_getSourceId() {
+		let e = this._getState()?.data;
+		return typeof e?.sourceId == "number" ? e.sourceId : void 0;
+	}
+	_ensureSourceId(e) {
+		let t = this._getSourceId();
+		if (t !== void 0) return t;
+		let r = e(), i = this._getState()?.data ?? {};
+		return this._updateState({ data: {
+			...i,
+			sourceId: r
+		} }, { description: n("op.connectShape") }), r;
+	}
+	_protectionCheck(e) {
+		if (this.isReadOnly()) throw new t(I(e));
+	}
+};
+export { P as a, S as c, F as i, c as l, L as n, h as o, I as r, x as s, R as t, d as u };