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

package/browser/esm/D4uVlrG0xEFctsSM.mjs

@@ -0,0 +1,905 @@
+/**
+* @license @sheetxl/sdk - SDK - A high-performance, embeddable spreadsheet engine. - v0.8.0-beta.10
+*
+* (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: a transaction is already open (expected commit '${t}').` : `Transaction conflict: expected commit '${t}' but current is '${n}'.`), this.name = "TransactionConflictError", this.reason = e, this.expectedCommitId = t, this.actualCommitId = n;
+	}
+}, l = 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 });
+	}
+}, u = 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 l(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 f && 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), this._current = n, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, this._notifyStates("onAfterStateChange", n, r, !1, !0, !0), 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), this._current = r, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, this._notifyStates("onAfterStateChange", r, a, !0, !1, !0, n), 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, u = (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 l(r)
+			};
+			this._pending = i, this._notify("onCommitStart", i.commit), d = new f(this, i, n?.states, t, u);
+		} else d = r[r.length - 1].beginTransaction(t, u);
+		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, l = c.record, u = c !== s, d = u ? l.states : s.record.states;
+				if (i.states.forEach((e, t) => {
+					d.set(t, e);
+				}), ((e, t) => {
+					for (let n = 0; n < t.length; n++) {
+						let [r, i] = t[n];
+						e[r] = typeof i == "function" ? i(e[r]) : i;
+					}
+				})(l.intents, i.intentWrites), l.meta = {
+					...l.meta,
+					...i.meta
+				}, l.timestamp = i.timestamp, n = !0, u) 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), this._notifyStates("onAfterStateChange", t, n, !1, !1, !0, o), this._notify(r === null ? "onCommitEnd" : "onAmendEnd", a, !0);
+	}
+	_notifyStates(e, t, n, r = !1, i = !1, a = !1, o = t) {
+		let s = t.commit, c = o.record.intents, l = this._listenersState;
+		n.forEach((t, n) => {
+			let o = l.get(n);
+			o && this.dispatchEvents(() => {
+				o.forEach((n) => {
+					n[e]?.(t, s, r, i, c);
+				});
+			}, 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);
+	}
+}, d = 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._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) {
+			let e = {
+				flush: n.flush,
+				writes: n.writes,
+				onCommit: n.onCommit,
+				onRollback: n.onRollback
+			};
+			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;
+		}
+	}
+	_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 p(this._store, this, this._container, typeof e == "string" ? { description: e } : e, t);
+		return 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;
+	}
+}, f = class extends d {
+	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;
+	}
+}, p = class extends d {
+	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._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;
+	}
+}, m = (e, t, ...n) => {
+	let r = globalThis.__SXL_LOG_EVENTS;
+	r && (typeof r != "string" || e.includes(r)) && console.log(`[sxl:${e}] ${t}`, ...n);
+}, h = class {
+	constructor(e, t) {
+		this._listeners = /* @__PURE__ */ new Set(), this._pending = null, this._landing = null, this._listeners = /* @__PURE__ */ new Set(), this._transactions = t ?? new u({ transient: !0 }), this._stateId = this._transactions.create(), this._src = e;
+		let n = this, r = () => {
+			let e = n._landing;
+			if (m(n._label(), `drain landing=${e ? e.length : "null"}`), !e) return;
+			n._landing = null;
+			let t = /* @__PURE__ */ new Set(), r = e.length;
+			for (let i = 0; i < r; i++) {
+				let r = e[i];
+				n._doNotify(r.listeners, r.removes, r.options, t);
+			}
+		};
+		this._transactionsRemoveListener = this._transactions.addListener({
+			onCommitClose(e, t, i) {
+				let a = n._pending;
+				m(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 ?? this._inOperation(), 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) {
+		let i = n?.source ?? this._src, a = [], o = n?.params, s = e.length;
+		for (let t = 0; t < s; t++) {
+			let n = e[t];
+			r && r.has(n) || (r?.add(n), a.push(n(i, o)));
+		}
+		let c = null;
+		if (t && (c = () => {
+			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(a);
+				c?.(), e(t);
+			} catch (e) {
+				c?.(), t(e);
+			}
+		});
+		c?.();
+	}
+	_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 ? (m(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 m(this._label(), `notify ${String(e)} QUEUED (open transaction) pending=${this._pending.length}`));
+		m(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;
+	}
+}, g = "Item has been closed. No further operations are allowed.", _ = (e = n("op.update")) => r("error.anchor.protected", { description: r(e) }), v = class {
+	constructor(e) {
+		this._closed = !1, this._options = { ...e };
+		let t = this;
+		this._transactions = this._options?.transactions ?? new u({ transient: !0 }), this._id = this._transactions.create({ isDeleted: !1 }), this._emitter = new h(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));
+	}
+}, y = class e extends v {
+	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.getSheet().getId()}!${i.getAddress()}`;
+				t.has(a) || (t.add(a), e.push(i));
+			}
+		}
+		return e.length === 0 ? null : e[0].getSheet().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().getSheet(), n = t ? t.getRange(e) : this._resolveRange(e);
+			return n && !n.isInvalid() ? n.getSheet().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(_(e));
+	}
+};
+export { h as a, g as i, v as n, c as o, _ as r, u as s, y as t };