@sheetxl/mcp 0.0.0-stage → 0.8.0-beta.15

package/assets/_d5XJ7dn1CKKYrep.js

@@ -0,0 +1,1131 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.15
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { B as t, ht as e, p as s, u as i } from "./BQMDOjNBMjAx9WiW.js";
+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;
+}, c = class extends Error {
+	constructor(t, e, s) {
+		super("open" === t ? `Transaction conflict: an operation is open on commit '${e}' and this write is not part of it.` : `Transaction conflict: expected commit '${e}' but current is '${s}'.`), this.name = "TransactionConflictError", this.reason = t, this.expectedCommitId = e, this.actualCommitId = s;
+	}
+}, h = (t, e, s = 0) => {
+	for (let i = s; i < e.length; i++) {
+		const [s, n] = e[i];
+		t[s] = "function" == typeof n ? n(t[s]) : n;
+	}
+}, l = 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 });
+	}
+}, _ = 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 l(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 u && 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(t) {
+		const s = e.uuidV4();
+		if (void 0 !== t) {
+			const e = this.beginCommit();
+			try {
+				e.updateState(s, t), e.commit();
+			} catch (t) {
+				throw e.rollback(), t;
+			}
+		}
+		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);
+		const r = this._current.commit;
+		this._current = s, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, this._notifyStates("onAfterStateChange", s, i, !1, !0, !0, s, r), 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);
+		const o = this._current.commit;
+		this._current = i, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, this._notifyStates("onAfterStateChange", i, r, !0, !1, !0, s, o), 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(t, s) {
+		const i = this._transactionStack;
+		i.length > 0 && i[i.length - 1]._flush();
+		const n = i.length;
+		"string" == typeof t && (t = { description: t });
+		const r = t?.expectedCommitId;
+		if (void 0 !== r) {
+			const t = this._current.record.id;
+			if (n > 0 || this._restoring) throw new c("open", r, t);
+			if (t !== r) throw new c("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 = t?.preventFurtherTransactions, a = this, h = (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: e.uuidV4(),
+				description: "string" == typeof t ? t : t?.description ?? null,
+				meta: {},
+				timestamp: Date.now(),
+				author: ("object" == typeof t ? t?.author : void 0) ?? this._author ?? null,
+				version: s.version + 1,
+				previousId: s.id,
+				intents: {},
+				intentWrites: [],
+				operation: t?.operation
+			}, n = {
+				record: i,
+				commit: new l(i)
+			};
+			this._pending = n, this._notify("onCommitStart", n.commit), _ = new u(this, n, s?.states, t, h);
+		} else _ = i[i.length - 1].beginTransaction(t, h);
+		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);
+		return s || (s = /* @__PURE__ */ new Set(), this._listenersState.set(t, s)), 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(t, s, i) {
+		let n = t.record, r = t.commit;
+		const o = t, 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, c = this._commits.get(i) ?? a, l = c.record, _ = c !== a, d = _ ? l.states : a.record.states;
+				if (n.states.forEach((t, e) => {
+					d.set(e, t);
+				}), h(l.intents, n.intentWrites), l.meta = {
+					...l.meta,
+					...n.meta
+				}, l.timestamp = n.timestamp, s = !0, _) return void (o.record.intentWrites = e.EmptyArray);
+				n = a.record, r = a.commit, t = a;
+			}
+			this._commits.set(n.id, t), s || (n.previousId !== this._tipId && this._pruneForwards(n.previousId), this._tipId = n.id, this._trimOldest());
+		}
+		this._current = t, this._states = this._current.record.states, this._cacheId = null, this._cacheState = null, o.record.intentWrites = e.EmptyArray, null === i && this._notify("onCommitChange", r);
+		const c = n.previousId ? this._commits.get(n.previousId)?.commit ?? null : null;
+		this._notifyStates("onAfterStateChange", t, s, !1, !1, !0, o, c), this._notify(null === i ? "onCommitEnd" : "onAmendEnd", r, !0);
+	}
+	_notifyStates(t, e, s, i = !1, n = !1, r = !1, o = e, a = null) {
+		const c = e.commit, h = o.record.intents, l = this._listenersState;
+		s.forEach((e, s) => {
+			const o = l.get(s);
+			o && this.dispatchEvents(() => {
+				o.forEach((s) => {
+					s[t]?.(e, c, i, n, h, a);
+				});
+			}, 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);
+	}
+}, d = 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._intentMark = -1, 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 || s?.onChildCommit) {
+			const t = {
+				flush: s.flush,
+				writes: s.writes,
+				onCommit: s.onCommit,
+				onRollback: s.onRollback,
+				onChildCommit: s.onChildCommit
+			};
+			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;
+	}
+	_childCommitted(t) {
+		const e = this._hooks?.onChildCommit;
+		if (!e) return;
+		const s = {};
+		h(s, this._container.record.intentWrites, t._intentMark), e(t, s);
+	}
+	_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 p(this._store, this, this._container, "string" == typeof t ? { description: t } : t, e);
+		return this._hooks?.onChildCommit && (s._intentMark = this._container.record.intentWrites.length), 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(t) {
+		return this._ensureOpen(), "string" == typeof t && (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__ */ 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;
+	}
+}, u = class extends d {
+	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;
+	}
+}, p = class extends d {
+	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._intentMark >= 0 && this._parent._childCommitted(this), 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 = class t {
+	constructor(t) {
+		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 = t;
+	}
+	getStore() {
+		return this._store;
+	}
+	getCommitId() {
+		return this._commitId;
+	}
+	isClosed() {
+		return this._closed;
+	}
+	close() {
+		this._closed || (this._closed = !0, this._stepListeners && S(this._store, -1), this._stepListeners = null);
+	}
+	addStepListener(t) {
+		return this._closed ? D : (this._stepListeners || (this._stepListeners = /* @__PURE__ */ new Set(), S(this._store, 1)), this._stepListeners.add(t), () => {
+			this._stepListeners?.delete(t);
+		});
+	}
+	_onStep(t, e) {
+		const s = this._stepListeners;
+		if (s && 0 !== s.size) for (const i of [...s]) i(t, e);
+	}
+	wrap(t) {
+		if ("function" == typeof t) return this._wrapFunction(t, !0);
+		if (null === t || "object" != typeof t) return t;
+		const e = t;
+		if (g.has(e)) return t;
+		const s = this._toWrapped.get(e);
+		return void 0 !== s ? s : e instanceof Promise ? e.then((t) => this.wrap(t)) : Array.isArray(e) ? this._wrapArray(e) : I(e) ? this._wrapModel(e) : E(e) ? this._wrapIterator(e) : t;
+	}
+	unwrap(t) {
+		if (null === t || "object" != typeof t) return t;
+		const e = t, s = f.get(e);
+		return void 0 !== s ? s : Array.isArray(e) ? A(e) : Object.getPrototypeOf(e) === Object.prototype ? M(e) : t;
+	}
+	_wrapModel(t) {
+		const e = this, s = new Proxy(t, {
+			get(t, s) {
+				const i = Reflect.get(t, s, t);
+				if (null === i || "object" != typeof i && "function" != typeof i) return i;
+				const n = Object.getOwnPropertyDescriptor(t, s);
+				return !n || n.configurable || n.writable ? "function" == typeof i ? e._wrapMethod(t, i) : e.wrap(i) : i;
+			},
+			set: (t, s, i) => Reflect.set(t, s, e.unwrap(i), t)
+		});
+		return this._toWrapped.set(t, s), f.set(s, t), g.set(s, this), s;
+	}
+	_wrapMethod(t, e) {
+		let s = this._methods.get(t);
+		s || (s = /* @__PURE__ */ new Map(), this._methods.set(t, s));
+		let i = s.get(e);
+		if (i) return i;
+		const n = this;
+		return i = function(...s) {
+			const i = s.length;
+			for (let t = 0; t < i; t++) s[t] = n._unwrapArg(s[t]);
+			return n._inScope(() => n.wrap(e.apply(t, s)));
+		}, s.set(e, i), i;
+	}
+	_unwrapArg(t) {
+		return "function" == typeof t ? this._wrapFunction(t, !1) : null === t || "object" != typeof t || Object.getPrototypeOf(t) !== Object.prototype || f.has(t) ? this.unwrap(t) : this._unwrapCallbacks(t);
+	}
+	_unwrapCallbacks(t) {
+		let e = !1;
+		for (const s in t) if ("function" == typeof t[s]) {
+			e = !0;
+			break;
+		}
+		if (!e) return this.unwrap(t);
+		const s = this._callbacks.get(t);
+		if (s) return s;
+		const i = {};
+		for (const e in t) {
+			const s = t[e];
+			i[e] = "function" == typeof s ? this._wrapFunction(s, !1) : this.unwrap(s);
+		}
+		return this._callbacks.set(t, i), i;
+	}
+	_wrapFunction(t, e) {
+		const s = e ? this._outward : this._inward;
+		let i = s.get(t);
+		if (i) return i;
+		const n = this;
+		return i = e ? function(...e) {
+			const s = e.length;
+			for (let t = 0; t < s; t++) e[t] = n._unwrapArg(e[t]);
+			return n._inScope(() => n.wrap(t.apply(n.unwrap(this), e)));
+		} : function(...e) {
+			const s = e.length;
+			for (let t = 0; t < s; t++) e[t] = n.wrap(e[t]);
+			return n.unwrap(t.apply(n.wrap(this), e));
+		}, s.set(t, i), i;
+	}
+	_wrapArray(t) {
+		const e = t.length > 0 ? t[0] : void 0;
+		return null === e || "object" != typeof e || Array.isArray(e) || !I(e) ? t : t.map((t) => this.wrap(t));
+	}
+	_wrapIterator(t) {
+		const e = this, s = {
+			next(...s) {
+				const i = t.next(...s);
+				return i.done ? i : {
+					done: !1,
+					value: e.wrap(i.value)
+				};
+			},
+			[Symbol.iterator]: () => s
+		};
+		return t.return && (s.return = (e) => t.return(e)), s;
+	}
+	_inScope(t) {
+		if (this._closed) return t();
+		const e = y;
+		y = this;
+		try {
+			return t();
+		} finally {
+			y = e;
+		}
+	}
+	static bind(e, s, i) {
+		const n = new t(e);
+		return {
+			callback: (t) => {
+				n._commitId = t.getId();
+				const e = i(t, n.wrap(s));
+				return e instanceof Promise ? e.then((t) => n.unwrap(t)) : n.unwrap(e);
+			},
+			close: () => n.close(),
+			onChildCommit: (t, s) => {
+				n._onStep(e.getCurrentCommit(), s);
+			}
+		};
+	}
+	static isStepping(t) {
+		return (w.get(t) ?? 0) > 0;
+	}
+	static of(t) {
+		return null === t || "object" != typeof t && "function" != typeof t ? null : g.get(t) ?? null;
+	}
+}, f = /* @__PURE__ */ new WeakMap(), g = /* @__PURE__ */ new WeakMap(), y = null, w = /* @__PURE__ */ new WeakMap(), S = (t, e) => {
+	w.set(t, (w.get(t) ?? 0) + e);
+}, C = () => y, v = (t) => null !== y && y.getStore() === t, b = /* @__PURE__ */ new WeakMap(), O = [
+	"addListener",
+	"addListeners",
+	"doBatch",
+	"getWorkbook",
+	"getWorksheet",
+	"update"
+], I = (t) => {
+	const e = Object.getPrototypeOf(t);
+	if (null === e || e === Object.prototype || e === Array.prototype) return !1;
+	let s = b.get(e);
+	return void 0 === s && (s = !k(t) && R(e), b.set(e, s)), s;
+}, k = (t) => t instanceof Date || t instanceof RegExp || t instanceof Map || t instanceof Set || t instanceof WeakMap || t instanceof WeakSet || t instanceof Error || t instanceof ArrayBuffer || ArrayBuffer.isView(t), R = (t) => {
+	for (let e = 0; e < O.length; e++) if ("function" == typeof t[O[e]]) return !0;
+	let e = t;
+	for (; e && e !== Object.prototype;) {
+		const t = Object.getOwnPropertyNames(e);
+		for (let s = 0; s < t.length; s++) {
+			const i = t[s];
+			if (i.length > 3 && i.startsWith("set") && i.charCodeAt(3) >= 65 && i.charCodeAt(3) <= 90 && "function" == typeof Object.getOwnPropertyDescriptor(e, i)?.value) return !0;
+		}
+		e = Object.getPrototypeOf(e);
+	}
+	return !1;
+}, E = (t) => "function" == typeof t.next && "function" == typeof t[Symbol.iterator], A = (t) => {
+	let e = null;
+	const s = t.length;
+	for (let i = 0; i < s; i++) {
+		const s = t[i];
+		if (null === s || "object" != typeof s) continue;
+		const n = W(s);
+		n !== s && (e ??= t.slice(), e[i] = n);
+	}
+	return e ?? t;
+}, M = (t) => {
+	let e = null;
+	for (const s in t) {
+		const i = t[s];
+		if (null === i || "object" != typeof i) continue;
+		const n = W(i);
+		n !== i && (e ??= { ...t }, e[s] = n);
+	}
+	return e ?? t;
+}, W = (t) => {
+	const e = f.get(t);
+	return void 0 !== e ? e : Array.isArray(t) ? A(t) : Object.getPrototypeOf(t) === Object.prototype ? M(t) : t;
+}, D = () => {}, T = (t, e, ...s) => {
+	const i = globalThis.__SXL_LOG_EVENTS;
+	i && ("string" != typeof i || t.includes(i)) && console.log(`[sxl:${t}] ${e}`, ...s);
+}, j = class {
+	constructor(t, e) {
+		this._listeners = /* @__PURE__ */ new Set(), this._pending = null, this._landing = null, this._listeners = /* @__PURE__ */ new Set(), this._transactions = e ?? new _({ transient: !0 }), this._stateId = this._transactions.create(), this._src = t;
+		const s = this, i = () => {
+			const t = s._landing;
+			if (T(s._label(), `drain landing=${t ? t.length : "null"}`), !t) return;
+			s._landing = null;
+			const e = /* @__PURE__ */ new Set(), i = t.length;
+			let n = null;
+			for (let e = 0; e < i; e++) {
+				const s = t[e].options, i = s?.merge;
+				if (!i) continue;
+				n ??= /* @__PURE__ */ new Map();
+				const r = t[e].listeners;
+				for (let t = 0; t < r.length; t++) {
+					const e = r[t];
+					n.set(e, n.has(e) ? i(n.get(e), s.params) : s.params);
+				}
+			}
+			for (let r = 0; r < i; r++) {
+				const i = t[r];
+				s._doNotify(i.listeners, i.removes, i.options, e, n);
+			}
+		};
+		this._transactionsRemoveListener = this._transactions.addListener({
+			onCommitClose(t, e, n) {
+				const r = s._pending;
+				T(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 ?? v(this._transactions), 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, n) {
+		const r = s?.source ?? this._src, o = [], a = s?.params, c = t.length;
+		for (let e = 0; e < c; e++) {
+			const s = t[e];
+			i && i.has(s) || (i?.add(s), o.push(s(r, n?.has(s) ? n.get(s) : a)));
+		}
+		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(o);
+				h?.(), t(e);
+			} catch (t) {
+				h?.(), e(t);
+			}
+		});
+		h?.();
+	}
+	hasTransactional(t) {
+		const e = this._transactions.getState(this._stateId)?.listeners;
+		if (!e || 0 === e.size) return !1;
+		for (const s of e) if (s.listeners[t]) return !0;
+		return !1;
+	}
+	_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 ? (T(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 T(this._label(), `notify ${String(t)} QUEUED (open transaction) pending=${this._pending.length}`));
+		T(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;
+	}
+}, $ = "Item has been closed. No further operations are allowed.", x = (t = i("op.update")) => s("error.anchor.protected", { description: s(t) }), L = class {
+	constructor(t) {
+		this._closed = !1, this._options = { ...t };
+		const e = this;
+		this._transactions = this._options?.transactions ?? new _({ transient: !0 }), this._id = this._transactions.create({ isDeleted: !1 }), this._emitter = new j(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(s("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, i, n = !1) {
+		if (this._closed) throw new Error(s("error.model.modelClosed"));
+		if (!t) return this;
+		const r = this._beginCommit(e?.description);
+		try {
+			r.updateState(this._id, t);
+			let s = !1;
+			const o = i ? i.length : 0;
+			for (let t = 0; t < o; t++) {
+				const e = i[t];
+				s = s || "onAnyChange" === e, this._emitter.notify(e);
+			}
+			!s && i && 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") ?? i("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));
+	}
+}, P = 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 s = t.name ?? null;
+		!s && this._getMovable && (s = `${this.getTypeDescription()} ${++e.instanceCounter}`);
+		const i = t.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: i("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: i("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.getWorksheet().getId()}!${n.getAddress()}`;
+				e.has(r) || (e.add(r), t.push(n));
+			}
+		}
+		return 0 === t.length ? null : t[0].getWorksheet().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().getWorksheet(), s = e ? e.getRange(t) : this._resolveRange(t);
+			return s && !s.isInvalid() ? s.getWorksheet().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 s = t(), n = this._getState()?.data ?? {};
+		return this._updateState({ data: {
+			...n,
+			sourceId: s
+		} }, { description: i("op.connectShape") }), s;
+	}
+	_protectionCheck(e) {
+		if (this.isReadOnly()) throw new t(x(e));
+	}
+};
+export { _ as a, m as c, P as i, v as l, C as n, c as o, L as r, j as s, x as t, $ as u };