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

package/node/esm/CnSQ7MTXAUAyBOoS.mjs

@@ -0,0 +1,911 @@
+/**
+* @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 t, ProtectedError as e, messageKey as s, t as i } from "@sheetxl/utils";
+var n = (t, e) => {
+	const s = /* @__PURE__ */ new Map();
+	return t.forEach((t, i) => {
+		e.get(i) !== t && s.set(i, t);
+	}), s;
+}, r = !1, o = 0, a = (t) => {
+	if ("string" != typeof t) throw new Error("A stateId (string) is required. Register with 'ITransaction.IStore.create'.");
+	return t;
+}, h = class extends Error {
+	constructor(t, e, s) {
+		super("open" === t ? `Transaction conflict: a transaction is already open (expected commit '${e}').` : `Transaction conflict: expected commit '${e}' but current is '${s}'.`), this.name = "TransactionConflictError", this.reason = t, this.expectedCommitId = e, this.actualCommitId = s;
+	}
+}, c = class {
+	constructor(t) {
+		this._record = t;
+	}
+	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 });
+	}
+}, l = class {
+	constructor(t) {
+		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 = t?.sync ?? r, this._isTransient = t?.transient ?? !1, this._author = t?.author, this._maxCommits = t?.maxCommits ?? 1e3;
+		const e = {
+			id: "0",
+			description: "initial",
+			meta: {},
+			author: this._author,
+			timestamp: Date.now(),
+			states: /* @__PURE__ */ new Map(),
+			intents: {},
+			intentWrites: [],
+			version: 0,
+			previousId: null
+		}, s = {
+			record: e,
+			commit: new c(e)
+		};
+		this._current = s, this._cacheId = null, this._cacheState = null, this._states = e.states, this._transactionStack = [], this._restoring = !1;
+		const i = /* @__PURE__ */ new Map();
+		i.set(e.id, s), this._commits = i, this._tipId = e.id;
+	}
+	static {
+		this.setDefaultSync = (t) => {
+			r = t;
+		};
+	}
+	getLog(t, e = 100) {
+		const s = [];
+		let i = t;
+		do {
+			const t = this._commits.get(i);
+			if (!t) throw new Error(`Invalid commit id: '${i}'`);
+			if (s.push(t.commit), i = t.record.previousId, !i) return s;
+		} while (s.length < e);
+		return s;
+	}
+	getCommitCount() {
+		return this._commits.size;
+	}
+	isOpenTransaction() {
+		return this._transactionStack.length > 0;
+	}
+	isRestoring() {
+		return this._restoring;
+	}
+	isAmendingOtherCommit() {
+		const t = this._transactionStack[0];
+		return t instanceof d && t._isRetargeted();
+	}
+	getPendingTransaction() {
+		return this._transactionStack[0] ?? null;
+	}
+	getCurrentTransaction() {
+		const t = this._transactionStack;
+		return t[t.length - 1] ?? null;
+	}
+	amend(t, e) {
+		const s = this.beginCommit(), i = 0 === s.getDepth() ? this._commits.get(t) : void 0;
+		0 === s.getDepth() && (s._setAmendOf(t), i && i !== this._current && s._retarget(i));
+		try {
+			const t = e(i ? i.commit : this._current.commit);
+			return s.commit(), t;
+		} catch (t) {
+			throw s.rollback(), t;
+		}
+	}
+	_squashTip(t) {
+		if (this._transactionStack.length > 0) return !1;
+		const e = this._commits.get(this._tipId), s = e?.record.previousId;
+		if (!e || !s) return !1;
+		const i = this._commits.get(s);
+		return !!i && (i.record.states = e.record.states, i.record.intents = t(i.record.intents, e.record.intents), i.record.timestamp = e.record.timestamp, this._commits.delete(e.record.id), this._tipId = s, this._current === e && (this._current = i, this._states = i.record.states, this._cacheId = null, this._cacheState = null), !0);
+	}
+	create(e) {
+		const s = t.uuidV4();
+		if (void 0 !== e) {
+			const t = this.beginCommit();
+			try {
+				t.updateState(s, e), t.commit();
+			} catch (e) {
+				throw t.rollback(), e;
+			}
+		}
+		return s;
+	}
+	getStateAt(t, e) {
+		return a(e), this._commits.get(t)?.record.states.get(e);
+	}
+	getState(t) {
+		a(t);
+		const e = this._transactionStack;
+		if (0 === e.length) {
+			if (this._cacheId === t) return this._cacheState;
+			const e = this._states.get(t);
+			return this._cacheId = t, this._cacheState = e, e;
+		}
+		if (this._flushOnRead > 0) for (let s = e.length - 1; s >= 0; s--) e[s]._isFlushedBy(t) && e[s]._flush();
+		return e[e.length - 1].getState(t);
+	}
+	getCurrentCommit(t = !0) {
+		return (t ? this._pending?.commit : null) ?? this._current.commit;
+	}
+	getTipCommit() {
+		return this._commits.get(this._tipId).commit;
+	}
+	getVersionId(t) {
+		return a(t), this._states.get(t)?.version ?? 0;
+	}
+	restore(t, e) {
+		const s = this._getCommitContainer(t, e);
+		if (this._current.commit.getId() === s.commit.getId()) return s.commit;
+		const i = n(s.record.states, this._current.record.states);
+		this._notifyStates("onBeforeCommitStart", this._current, i, !0, !1, !1, s), this._current = s, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, this._notifyStates("onAfterStateChange", s, i, !1, !0, !0), this._notify("onCommitChange", s.commit, !0), this._restoring = !0;
+		try {
+			this._notifyStates("onRestoreOrRevert", s, s.record.states, !1, !0);
+		} finally {
+			this._restoring = !1;
+		}
+		return s.commit;
+	}
+	revert(t, e) {
+		const s = this._getCommitContainer(t, e), i = this._commits.get(s.record.previousId);
+		if (!i) throw new Error(`Invalid commit id: '${s.record.previousId}'`);
+		const r = n(i.record.states, this._current.record.states);
+		this._notifyStates("onBeforeCommitStart", this._current, r, !0, !1, !1, s), this._current = i, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, this._notifyStates("onAfterStateChange", i, r, !0, !1, !0, s), this._notify("onCommitChange", i.commit, !0), this._restoring = !0;
+		try {
+			this._notifyStates("onRestoreOrRevert", i, i.record.states, !0, !0, !1, s);
+		} finally {
+			this._restoring = !1;
+		}
+		return i.commit;
+	}
+	_getCommitContainer(t, e) {
+		const s = this._commits.get(t);
+		if (!s) throw new Error(`Invalid commit id: '${t}'`);
+		if (this._isTransient) throw new Error("Cannot revert transient store");
+		if (e?.force && this._transactionStack.length > 0 && this._transactionStack[0].rollback(), 0 !== this._transactionStack.length) throw new Error("Open transactions.");
+		return s;
+	}
+	_pruneForwards(t) {
+		let e = this._tipId;
+		for (; e && e !== t;) {
+			const t = this._commits.get(e);
+			if (!t) break;
+			this._commits.delete(e), e = t.record.previousId;
+		}
+	}
+	_trimOldest() {
+		if (this._commits.size <= this._maxCommits) return;
+		const t = this._commits.keys();
+		for (; this._commits.size > this._maxCommits;) this._commits.delete(t.next().value);
+		const e = this._commits.get(t.next().value);
+		e && (e.record.previousId = null);
+	}
+	beginCommit(e, s) {
+		const i = this._transactionStack;
+		i.length > 0 && i[i.length - 1]._flush();
+		const n = i.length;
+		"string" == typeof e && (e = { description: e });
+		const r = e?.expectedCommitId;
+		if (void 0 !== r) {
+			const t = this._current.record.id;
+			if (n > 0 || this._restoring) throw new h("open", r, t);
+			if (t !== r) throw new h("stale", r, t);
+		}
+		if (this._locked) throw console.warn("TransactionStore locked", i), /* @__PURE__ */ new Error(`TransactionStore is locked by '${i[n - 1].getDescription()}`);
+		const o = e?.preventFurtherTransactions, a = this, l = (t, e, i) => {
+			const r = a._transactionStack;
+			n !== r.length - 1 && console.warn("Transaction stack out of sync", n, r.length, r), o && (this._locked = !1), r.pop(), t._isFlushedOnRead() && a._flushOnRead--, s?.(t, e, i), 0 === r.length && (a._pending = null, a._notifyClose(t._getCommit(), e, t._isElided(), t._isAmendClose()));
+		};
+		let _;
+		if (0 === i.length) {
+			const s = this._current.record, i = {
+				states: /* @__PURE__ */ new Map(),
+				id: t.uuidV4(),
+				description: "string" == typeof e ? e : e?.description ?? null,
+				meta: {},
+				timestamp: Date.now(),
+				author: ("object" == typeof e ? e?.author : void 0) ?? this._author ?? null,
+				version: s.version + 1,
+				previousId: s.id,
+				intents: {},
+				intentWrites: [],
+				operation: e?.operation
+			}, n = {
+				record: i,
+				commit: new c(i)
+			};
+			this._pending = n, this._notify("onCommitStart", n.commit), _ = new d(this, n, s?.states, e, l);
+		} else _ = i[i.length - 1].beginTransaction(e, l);
+		return o && (this._locked = !0), this._transactionStack.push(_), _._isFlushedOnRead() && this._flushOnRead++, _;
+	}
+	doBatch(t, e, s) {
+		let i;
+		const n = this.beginCommit(e, s), r = this.getCurrentCommit();
+		try {
+			i = t?.(r);
+			const s = () => {
+				n.commit(e);
+			};
+			if (i && "function" == typeof i.then) return new Promise((t, e) => {
+				i.then((i) => {
+					try {
+						s(), t(i);
+					} catch (t) {
+						e(t);
+					}
+				}).catch((t) => {
+					n.rollback(), e(t);
+				});
+			});
+			s();
+		} catch (t) {
+			throw n.rollback(), t;
+		}
+		return i;
+	}
+	remove(t) {
+		a(t);
+		let e = !1;
+		const s = this._listenersState.get(t);
+		if (s) {
+			const i = this.getCurrentCommit();
+			s.forEach((t) => {
+				t.onClose?.(i);
+			}), this._listenersState.delete(t), e = !0;
+		}
+		this._current.record.states.delete(t) && (e = !0), this._commits.forEach((s) => {
+			s.record.states.delete(t) && (e = !0);
+		});
+		const i = this._transactionStack;
+		return i.length > 0 && i[0]._purgeState(t), this._cacheId = null, this._cacheState = null, e;
+	}
+	addListener(t) {
+		const e = this._listeners;
+		return e.add(t), () => {
+			e.delete(t);
+		};
+	}
+	addStateListener(t, e) {
+		if (a(t), !e) throw new Error("Listener is required");
+		let s = this._listenersState.get(t);
+		s || (s = /* @__PURE__ */ new Set(), this._listenersState.set(t, s));
+		return s.add(e), () => {
+			s.delete(e), 0 === s.size && this._listenersState.delete(t);
+		};
+	}
+	dispatchEvents(t, e = !1) {
+		!e || this._isSync ? t() : setTimeout(t, 0);
+	}
+	_commitRecord(e, s, i) {
+		let n = e.record, r = e.commit;
+		const o = e, a = ++this._versionCounter;
+		if (s.forEach((t, e) => {
+			null != t && ((t, e, s) => {
+				Object.defineProperty(t, "id", {
+					value: e,
+					enumerable: !1,
+					configurable: !0,
+					writable: !1
+				}), Object.defineProperty(t, "version", {
+					value: s,
+					enumerable: !1,
+					configurable: !0,
+					writable: !1
+				});
+			})(t, e, a);
+		}), !this._isTransient) {
+			let s = !1;
+			if (null !== i) {
+				const a = this._current, h = this._commits.get(i) ?? a, c = h.record, l = h !== a, _ = l ? c.states : a.record.states;
+				if (n.states.forEach((t, e) => {
+					_.set(e, t);
+				}), ((t, e) => {
+					for (let s = 0; s < e.length; s++) {
+						const [i, n] = e[s];
+						t[i] = "function" == typeof n ? n(t[i]) : n;
+					}
+				})(c.intents, n.intentWrites), c.meta = {
+					...c.meta,
+					...n.meta
+				}, c.timestamp = n.timestamp, s = !0, l) return void (o.record.intentWrites = t.EmptyArray);
+				n = a.record, r = a.commit, e = a;
+			}
+			this._commits.set(n.id, e), s || (n.previousId !== this._tipId && this._pruneForwards(n.previousId), this._tipId = n.id, this._trimOldest());
+		}
+		this._current = e, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, o.record.intentWrites = t.EmptyArray, null === i && this._notify("onCommitChange", r), this._notifyStates("onAfterStateChange", e, s, !1, !1, !0, o), this._notify(null === i ? "onCommitEnd" : "onAmendEnd", r, !0);
+	}
+	_notifyStates(t, e, s, i = !1, n = !1, r = !1, o = e) {
+		const a = e.commit, h = o.record.intents, c = this._listenersState;
+		s.forEach((e, s) => {
+			const o = c.get(s);
+			o && this.dispatchEvents(() => {
+				o.forEach((s) => {
+					s[t]?.(e, a, i, n, h);
+				});
+			}, r);
+		});
+	}
+	_notifyClose(t, e, s = !1, i = !1) {
+		this._listeners.forEach((n) => {
+			n.onCommitClose?.(t, e, s, i);
+		});
+	}
+	_notify(t, e, s = !1) {
+		return this.dispatchEvents(() => {
+			this._listeners.forEach((s) => {
+				s[t]?.(e);
+			});
+		}, s);
+	}
+}, _ = class {
+	constructor(t, e, s) {
+		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 = t, this._container = e, s = "string" == typeof s ? { description: s } : s, this._description = s?.description ?? "", this._operation = s?.operation ?? null, this._readOnly = s?.readOnly ?? !1, s?.flush || s?.onCommit || s?.onRollback) {
+			const t = {
+				flush: s.flush,
+				writes: s.writes,
+				onCommit: s.onCommit,
+				onRollback: s.onRollback
+			};
+			this._hooks = t, (t.onCommit || t.onRollback) && (this._outcomes = [t]);
+		}
+	}
+	_isFlushedOnRead() {
+		return !(!this._hooks?.flush || !this._hooks.writes?.length);
+	}
+	_isFlushedBy(t) {
+		const e = this._hooks?.writes;
+		return !!e && e.includes(t);
+	}
+	_flush() {
+		const t = this._hooks?.flush;
+		if (t && !this._flushing) {
+			this._flushing = !0;
+			try {
+				t();
+			} finally {
+				this._flushing = !1;
+			}
+		}
+	}
+	_settle(t) {
+		const e = this._children;
+		for (; e.size > 0;) e.values().next().value.commit(t);
+		this._flush();
+	}
+	_adoptOutcomes(t) {
+		const e = t._outcomes;
+		if (e) if (this._outcomes) for (let t = 0; t < e.length; t++) this._outcomes.push(e[t]);
+		else this._outcomes = e;
+	}
+	_notifyOutcome(t) {
+		const e = this._outcomes;
+		if (e) {
+			this._outcomes = null;
+			for (let s = 0; s < e.length; s++) try {
+				t ? e[s].onCommit?.(t) : e[s].onRollback?.();
+			} catch (t) {
+				console.warn(t);
+			}
+		}
+	}
+	_getCommit() {
+		return this._container.commit;
+	}
+	_isElided() {
+		return !1;
+	}
+	_setAmendOf(t) {
+		this._container.amendOf = t;
+	}
+	_isAmendClose() {
+		return this._isAmend || void 0 !== this._container.amendOf;
+	}
+	getIntent(t) {
+		return this._container.record.intents?.[t];
+	}
+	setIntent(t, e) {
+		const s = this._container.record, i = s.intents ??= {};
+		i[t] = "function" == typeof e ? e(i[t]) : e, (s.intentWrites ??= []).push([t, e]);
+	}
+	getDepth() {
+		return this._depth;
+	}
+	getDescription() {
+		return this._description;
+	}
+	getOperation() {
+		return this._operation;
+	}
+	getStates() {
+		return this._states;
+	}
+	beginTransaction(t, e) {
+		this._ensureOpen();
+		const s = new u(this._store, this, this._container, "string" == typeof t ? { description: t } : t, e);
+		return this._children || this._children, this._children.add(s), s;
+	}
+	isReadOnly() {
+		return this._readOnly;
+	}
+	updateState(t, e) {
+		if (this._ensureOpen(), a(t), this._readOnly) throw new Error("Transaction is read-only" + (this._description ? `: '${this._description}'` : ""));
+		const s = this.getState(t);
+		let i;
+		if ("function" == typeof e) {
+			if (i = e(s), i === s) return s;
+			i && (i = { ...i });
+		} else {
+			if (void 0 === e) return s;
+			i = {
+				...s,
+				...e
+			};
+		}
+		if (i) {
+			let e = this._states;
+			e || (e = /* @__PURE__ */ new Map(), this._states = e), e.set(t, i);
+		}
+		return i;
+	}
+	amend(t) {
+		return this._isAmend = !0, this.commit(t);
+	}
+	commit(e) {
+		return this._ensureOpen(), "string" == typeof e && (e = { description: e }), e && (e.description && (this._description = e.description), e.meta && (this._meta = t.mergeContentful(e.meta, this._meta))), this._children && this._children.forEach((t) => {
+			t.commit(e);
+		}), 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__ */ new Error("Transaction already closed");
+	}
+	_removeChild(t, e = !1) {
+		this._children.delete(t), e || this._mergeStates(t._states);
+	}
+	_purgeState(t) {
+		this._states?.delete(t), this._children.forEach((e) => {
+			e._purgeState(t);
+		});
+	}
+	_mergeStates(t) {
+		if (!t || 0 === t.size) return;
+		let e = this._states;
+		return e ? (t.forEach((t, s) => {
+			e.set(s, t);
+		}), e) : (this._states = t, t);
+	}
+	get isITransaction() {
+		return !0;
+	}
+}, d = class extends _ {
+	constructor(t, e, s, i, n) {
+		super(t, e, i), this._retargeted = !1, this._elided = !1, this._prevStates = s, this._onClose = n, this._states = /* @__PURE__ */ new Map(), this._meta = e.record.meta;
+	}
+	_isElided() {
+		return this._elided;
+	}
+	_retarget(t) {
+		this._prevStates = t.record.states, this._retargeted = !0;
+	}
+	_isRetargeted() {
+		return this._retargeted;
+	}
+	getId() {
+		return this._container.commit.getId();
+	}
+	getSavepointId() {
+		return this.getId();
+	}
+	getParent() {
+		return this;
+	}
+	commit(t) {
+		this._ensureOpen(), this._settle(t);
+		const e = this._states, s = this._container;
+		if (this._store._notifyStates("onBeforeCommitStart", s, e, !1, !1), super.commit(t), 0 === this._states.size) return this._closed = !0, this._elided = !0, this._onClose?.(this, !1, t), this._notifyOutcome(s.commit), this;
+		this._store._notifyStates("onBeforeCommitEnd", s, e, !1, !1), this._settle(t);
+		const i = new Map(this._prevStates);
+		this._states.forEach((t, e) => {
+			null === t ? i.delete(e) : i.set(e, t);
+		}), this._states = i, this._description && (s.record.description = this._description), this._meta && (s.record.meta = this._meta), s.record.states = i, this._closed = !0, this._onClose?.(this, !1, t);
+		const n = s.amendOf ?? (this._isAmend ? s.record.previousId : null);
+		return this._store._commitRecord(s, e, n), this._notifyOutcome(s.commit), this;
+	}
+	rollback() {
+		return this._ensureOpen(), this._children && this._children.forEach((t) => {
+			t.rollback();
+		}), this._notifyOutcome(null), this._closed = !0, this._onClose?.(this, !0, null), this;
+	}
+	updateState(t, e) {
+		const s = this.getState(t), i = super.updateState(t, e);
+		return i === s || this._states.set(t, i), i;
+	}
+	getState(t) {
+		a(t);
+		let e = this._states.get(t);
+		return e || (e = this._prevStates.get(t)), e;
+	}
+}, u = class extends _ {
+	constructor(t, e, s, i, n) {
+		if (super(t, s, i), this._savepointId = null, !e) throw new Error("Parent transaction required");
+		this._parent = e, this._depth = this._parent.getDepth() + 1, !1 !== ("string" == typeof i ? void 0 : i?.savepoint) && (this._savepointId = `${e.getId()}:${++o}`), e.isReadOnly() && (this._readOnly = !0), this._onClose = n;
+	}
+	getId() {
+		return this._parent.getId();
+	}
+	getSavepointId() {
+		return this._savepointId ?? this._parent.getSavepointId();
+	}
+	getParent() {
+		return this._parent;
+	}
+	getState(t) {
+		if (this._states) {
+			const e = this._states.get(t);
+			if (void 0 !== e) return e;
+		}
+		return this._parent.getState(t);
+	}
+	commit(t) {
+		return this._ensureOpen(), this._settle(t), super.commit(t), this._parent._removeChild(this), this._parent._adoptOutcomes(this), this._closed = !0, this._onClose?.(this, !1, t), this._parent ?? this;
+	}
+	rollback() {
+		return this._ensureOpen(), this._children && this._children.forEach((t) => {
+			t.rollback();
+		}), this._notifyOutcome(null), this._parent._removeChild(this, !0), this._closed = !0, this._onClose?.(this, !0, null), this._parent ?? this;
+	}
+}, m = (t, e, ...s) => {
+	const i = globalThis.__SXL_LOG_EVENTS;
+	i && ("string" != typeof i || t.includes(i)) && console.log(`[sxl:${t}] ${e}`, ...s);
+}, p = class {
+	constructor(t, e) {
+		this._listeners = /* @__PURE__ */ new Set(), this._pending = null, this._landing = null, this._listeners = /* @__PURE__ */ new Set(), this._transactions = e ?? new l({ transient: !0 }), this._stateId = this._transactions.create(), this._src = t;
+		const s = this, i = () => {
+			const t = s._landing;
+			if (m(s._label(), `drain landing=${t ? t.length : "null"}`), !t) return;
+			s._landing = null;
+			const e = /* @__PURE__ */ new Set(), i = t.length;
+			for (let n = 0; n < i; n++) {
+				const i = t[n];
+				s._doNotify(i.listeners, i.removes, i.options, e);
+			}
+		};
+		this._transactionsRemoveListener = this._transactions.addListener({
+			onCommitClose(t, e, n) {
+				const r = s._pending;
+				m(s._label(), `commitClose rollback=${e} elided=${n} pending=${r ? r.length : "null"}`), s._pending = null, e || (r && (s._landing ? s._landing.push(...r) : s._landing = r), n && i());
+			},
+			onCommitEnd: i,
+			onAmendEnd: i
+		});
+	}
+	_label() {
+		return this._src?.constructor?.name ?? "unknown";
+	}
+	_inOperation() {
+		return this._transactions.isOpenTransaction() || this._transactions.isRestoring();
+	}
+	addListeners(t, e) {
+		const s = e?.transactional ?? this._inOperation(), i = { listeners: t }, n = this, r = () => {
+			s ? n._updateEntries((t) => {
+				t.delete(i);
+			}) : n._listeners.delete(i);
+		};
+		return i.remove = e?.once ? r : null, s ? n._updateEntries((t) => {
+			t.add(i);
+		}) : n._listeners.add(i), r;
+	}
+	_updateEntries(t) {
+		const e = this._transactions, s = e.getState(this._stateId)?.listeners, i = new Set(s);
+		t(i);
+		const n = e.beginCommit();
+		try {
+			n.updateState(this._stateId, { listeners: i }), n.amend();
+		} catch (t) {
+			throw n.rollback(), t;
+		}
+	}
+	async _doNotify(t, e = null, s, i) {
+		const n = s?.source ?? this._src, r = [], o = s?.params, a = t.length;
+		for (let e = 0; e < a; e++) {
+			const s = t[e];
+			i && i.has(s) || (i?.add(s), r.push(s(n, o)));
+		}
+		let h = null;
+		if (e && (h = () => {
+			const t = e.length;
+			for (let s = 0; s < t; s++) e[s]();
+		}), s?.async) return new Promise(async (t, e) => {
+			try {
+				const e = await Promise.all(r);
+				h?.(), t(e);
+			} catch (t) {
+				h?.(), e(t);
+			}
+		});
+		h?.();
+	}
+	_collect(t, e) {
+		if (!t) return null;
+		let s = null, i = null;
+		return t.forEach((t) => {
+			const n = t.listeners[e];
+			n && ((s ??= []).push(n), t.remove && (i ??= []).push(t.remove));
+		}), s ? {
+			listeners: s,
+			removes: i
+		} : null;
+	}
+	notify(t, e) {
+		const s = this._transactions, i = e?.transactional ?? this._inOperation();
+		if (i) {
+			const i = this._collect(s.getState(this._stateId)?.listeners, t);
+			i && this._doNotify(i.listeners, i.removes, e);
+		}
+		const n = this._collect(this._listeners, t);
+		if (n) return !i || s.isRestoring() || e?.async ? (m(this._label(), `notify ${String(t)} delivered to ${n.listeners.length}`), this._doNotify(n.listeners, n.removes, e)) : ((this._pending ??= []).push({
+			listeners: n.listeners,
+			removes: n.removes,
+			options: e
+		}), void m(this._label(), `notify ${String(t)} QUEUED (open transaction) pending=${this._pending.length}`));
+		m(this._label(), `notify ${String(t)} inOperation=${i} 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.", f = (t = s("op.update")) => i("error.anchor.protected", { description: i(t) }), S = class {
+	constructor(t) {
+		this._closed = !1, this._options = { ...t };
+		const e = this;
+		this._transactions = this._options?.transactions ?? new l({ transient: !0 }), this._id = this._transactions.create({ isDeleted: !1 }), this._emitter = new p(this, this._transactions), t?.json && this._fromJSON(t.json), this._options?.setContainerReadOnlyCallback?.(() => {
+			e._processOnContainerReadOnly();
+		}), this._transactionsRemoveListener = this._transactions.addStateListener(this._id, {
+			onAfterStateChange(t, s) {
+				e._processAfterStateChange(t, s);
+			},
+			onRestoreOrRevert(t, s) {
+				e._processRestoreOrRevert(t, s);
+			}
+		}), this._processInit();
+	}
+	_fromJSON(t) {}
+	isReadOnly() {
+		return this._options.isReadOnly?.() ?? !1;
+	}
+	isDeleted() {
+		const t = this._getState();
+		return void 0 === t || (t.isDeleted ?? !1);
+	}
+	getType() {
+		return this._options.type;
+	}
+	get isIModel() {
+		return !0;
+	}
+	_processTransactionDone(t) {}
+	_getActionDescription(t) {
+		return null;
+	}
+	_getState() {
+		if (this._closed) throw new Error(i("error.model.modelClosed"));
+		return this._transactions.getState(this._id);
+	}
+	_beginCommit(t) {
+		return this._transactions.beginCommit("string" == typeof t ? { description: t } : t);
+	}
+	_getTransactions() {
+		return this._transactions;
+	}
+	_updateState(t, e, s) {
+		return this._writeState(t, e, s, !1);
+	}
+	_amendState(t, e, s) {
+		return this._writeState(t, e, s, !0);
+	}
+	_writeState(t, e, s, n = !1) {
+		if (this._closed) throw new Error(i("error.model.modelClosed"));
+		if (!t) return this;
+		const r = this._beginCommit(e?.description);
+		try {
+			r.updateState(this._id, t);
+			let i = !1;
+			const o = s ? s.length : 0;
+			for (let t = 0; t < o; t++) {
+				const e = s[t];
+				i = i || "onAnyChange" === e, this._emitter.notify(e);
+			}
+			!i && s && o > 0 && this._emitter.notify("onAnyChange"), n ? r.amend(e) : r.commit(e);
+		} catch (t) {
+			throw r.rollback(), t;
+		}
+		return this;
+	}
+	_getEmitter() {
+		return this._emitter;
+	}
+	_processInit() {}
+	_processAfterStateChange(t, e) {}
+	_processRestoreOrRevert(t, e) {
+		this._emitter.notify("onInvalidated");
+	}
+	delete(t) {
+		this._getState().isDeleted || this._delete(t);
+	}
+	_delete(t) {
+		t = {
+			description: this._getActionDescription("delete") ?? s("op.delete"),
+			...t
+		};
+		const e = this._beginCommit(t?.description);
+		try {
+			this._options.deleteFromContainer && this._options.deleteFromContainer?.(t), this._processDelete(), e.commit();
+		} catch (t) {
+			throw e.rollback(), t;
+		}
+	}
+	_processOnContainerDeleted() {
+		this._processDelete();
+	}
+	_processDelete() {
+		this._updateState({ isDeleted: !0 }, void 0, ["onDelete"]);
+	}
+	_processOnContainerReadOnly() {
+		this._emitter.notify("onReadOnlyChange");
+	}
+	addListeners(t, e) {
+		return this._emitter.addListeners(t, e);
+	}
+	getId() {
+		return this._id;
+	}
+	getVersionId() {
+		return this._transactions.getVersionId(this._id);
+	}
+	beginCommit(t) {
+		return this._beginCommit(t);
+	}
+	doBatch(t, e) {
+		const s = this;
+		return this._transactions.doBatch(t, "string" == typeof e ? { description: e } : e, (t) => {
+			s._processTransactionDone(t);
+		});
+	}
+	isClosed() {
+		return this._closed;
+	}
+	close() {
+		this._closed || (this._emitter.notify("onClose"), this._closed = !0, this._transactionsRemoveListener?.(), this._transactions.remove(this._id));
+	}
+}, y = class t extends S {
+	static {
+		this.instanceCounter = 0;
+	}
+	constructor(e) {
+		super(e), this._watches = /* @__PURE__ */ new Set(), this._watchesReleased = !1, this._getMovable = e.getMovable ?? null, this._addWatchOption = e.addWatch ?? null, this._getRangeOption = e.getRange ?? null;
+		let s = e.name ?? null;
+		!s && this._getMovable && (s = `${this.getTypeDescription()} ${++t.instanceCounter}`);
+		const i = e.description ?? null;
+		null === s && null === i || this._updateState({
+			name: s,
+			description: i
+		});
+	}
+	getName() {
+		return this._closed ? null : this._getState()?.name ?? null;
+	}
+	setName(t) {
+		const e = { description: s("op.setMovableName") };
+		return this._protectionCheck(e.description), this._updateState({ name: t }, e, ["onAnyChange"]), this;
+	}
+	getDescription() {
+		return this._closed ? null : this._getState()?.description ?? null;
+	}
+	setDescription(t) {
+		const e = { description: s("op.setMovableDescription") };
+		return this._protectionCheck(e.description), this._updateState({ description: t || null }, e, ["onAnyChange"]), this;
+	}
+	getMovable() {
+		return this._getMovable?.() ?? null;
+	}
+	getReferences() {
+		if (this._closed || this._watchesReleased || 0 === this._watches.size) return null;
+		const t = [], e = /* @__PURE__ */ new Set();
+		for (const s of this._watches) {
+			const i = s.formula?.getReferences() ?? this._parseReference(s.expression);
+			if (!i) continue;
+			const n = i.getCount();
+			for (let s = 0; s < n; s++) {
+				const n = i.at(s);
+				if (n.isInvalid()) continue;
+				const r = `${n.getSheet().getId()}!${n.getAddress()}`;
+				e.has(r) || (e.add(r), t.push(n));
+			}
+		}
+		return 0 === t.length ? null : t[0].getSheet().getRanges(t);
+	}
+	_addWatch(t, e, s) {
+		const i = "string" == typeof t ? t : t.getExpression(), n = {
+			expression: i.startsWith("=") ? i.substring(1) : i,
+			formula: null,
+			callback: e,
+			options: s,
+			release: null
+		};
+		return this._watches.add(n), this._watchesReleased || this._hold(n, "string" == typeof t ? void 0 : t), () => {
+			this._watches.delete(n) && (n.release?.(), n.release = null, this._notifyReferencesChange());
+		};
+	}
+	_resolveRange(t) {
+		return this._getRangeOption?.(t) ?? null;
+	}
+	_hold(t, e) {
+		const s = this._addWatchOption;
+		s && (t.release = s(e ?? t.expression, (e) => {
+			t.formula = e.formula, t.expression = e.formula.getExpression(), t.callback?.(e), this._notifyReferencesChange();
+		}, t.options));
+	}
+	_parseReference(t) {
+		if (!t || t.includes("#REF!")) return null;
+		try {
+			const e = t.includes("!") ? null : this.getMovable()?.getRange().getSheet(), s = e ? e.getRange(t) : this._resolveRange(t);
+			return s && !s.isInvalid() ? s.getSheet().getRanges([s]) : null;
+		} catch {
+			return null;
+		}
+	}
+	_notifyReferencesChange() {
+		this._closed || (this._emitter.notify("onReferencesChange"), this._emitter.notify("onAnyChange"));
+	}
+	_releaseWatches() {
+		this._watchesReleased = !0;
+		for (const t of this._watches) t.release?.(), t.release = null;
+	}
+	_holdWatches() {
+		this._watchesReleased = !1;
+		for (const t of this._watches) this._hold(t, t.formula ?? void 0);
+	}
+	_processDelete() {
+		this._releaseWatches(), super._processDelete();
+	}
+	_processRestoreOrRevert(t, e) {
+		super._processRestoreOrRevert(t, e);
+		const s = void 0 === t || !0 === t.isDeleted;
+		s && !this._watchesReleased ? this._releaseWatches() : !s && this._watchesReleased && this._holdWatches();
+	}
+	_getSourceId() {
+		const t = this._getState()?.data;
+		return "number" == typeof t?.sourceId ? t.sourceId : void 0;
+	}
+	_ensureSourceId(t) {
+		const e = this._getSourceId();
+		if (void 0 !== e) return e;
+		const i = t(), n = this._getState()?.data ?? {};
+		return this._updateState({ data: {
+			...n,
+			sourceId: i
+		} }, { description: s("op.connectShape") }), i;
+	}
+	_protectionCheck(t) {
+		if (this.isReadOnly()) throw new e(f(t));
+	}
+};
+export { p as a, g as i, S as n, h as o, f as r, l as s, y as t };