@gridsheet/core 3.0.0-rc.8

package/dist/lib/sheet.js

@@ -0,0 +1,1530 @@
+import { getMaxSizesFromCells as wt, expandRange as xt, createMatrix as St, matrixShape as W, areaShape as Rt } from "./spatial.js";
+import { p2a as _, x2c as Z, a2p as A, grantAddressAbsolute as Ct, y2r as It } from "./coords.js";
+import { Lexer as Q } from "../formula/evaluator.js";
+import { FormulaError as z } from "../formula/formula-error.js";
+import { solveFormula as tt, stripSheet as et, solveSheet as Et } from "../formula/solver.js";
+import { ensureSys as k } from "./cell.js";
+import { escapeSheetName as _t, toSheetPrefix as vt } from "./sheet_utils.js";
+import { DEFAULT_WIDTH as $, DEFAULT_HEIGHT as U, HEADER_HEIGHT as st, HEADER_WIDTH as it, DEFAULT_KEY as rt, DEFAULT_COL_KEY as ot, DEFAULT_ROW_KEY as nt } from "../constants.js";
+import { Pending as Mt, SOLVING as at } from "../sentinels.js";
+import { hasOperation as Y, MoveFrom as ht, MoveTo as lt, Copy as bt, Update as X, Write as K, Style as Tt, Resize as Ot, RemoveRows as At, RemoveCols as Dt } from "./operation.js";
+import { createRegistry as Pt } from "./book.js";
+import { nonePolicy as Ft, DEFAULT_POLICY_NAME as B } from "../policy/core.js";
+import { evaluateFilterConfig as Nt } from "./filter.js";
+import { ReferencePreserver as L } from "./reference.js";
+const dt = (ct) => {
+  switch (ct) {
+    case "INSERT_ROWS":
+    case "INSERT_COLS":
+    case "REMOVE_ROWS":
+    case "REMOVE_COLS":
+    case "MOVE":
+    case "SORT_ROWS":
+      return !0;
+  }
+  return !1;
+}, Yt = () => !0;
+class V {
+  constructor({ limits: t = {}, name: e, registry: s = Pt({}) }) {
+    this.__gsType = "Sheet", this.area = { top: 0, left: 0, bottom: 0, right: 0 }, this.id = 0, this.name = "", this.prevName = "", this.status = 0, this.idsToBeIdentified = [], this.totalWidth = 0, this.totalHeight = 0, this.fullHeight = 0, this.defaultColWidth = $, this.defaultRowHeight = U, this.version = 0, this.addressCaches = /* @__PURE__ */ new Map(), this.lastChangedAddresses = [], this.idMatrix = [], this.changedTime = Date.now(), this._limits = {
+      minRows: t.minRows ?? 1,
+      maxRows: t.maxRows ?? -1,
+      minCols: t.minCols ?? 1,
+      maxCols: t.maxCols ?? -1
+    }, this.name = e || "", this.prevName = this.name, this.registry = s;
+  }
+  get minNumRows() {
+    return this._limits.minRows;
+  }
+  get maxNumRows() {
+    return this._limits.maxRows;
+  }
+  get minNumCols() {
+    return this._limits.minCols;
+  }
+  get maxNumCols() {
+    return this._limits.maxCols;
+  }
+  static is(t) {
+    return (t == null ? void 0 : t.__gsType) === "Sheet";
+  }
+  toString() {
+    return `Sheet(name=${_t(this.name)}, size=${this.numRows}x${this.numCols})`;
+  }
+  get headerHeight() {
+    var t;
+    return ((t = this.getCell({ y: 0, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : t.height) || st;
+  }
+  setHeaderHeight(t, e = !0) {
+    return this.update({
+      diff: { 0: { height: t } },
+      partial: !0,
+      historicize: e
+    });
+  }
+  get headerWidth() {
+    var t;
+    return ((t = this.getCell({ y: 0, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : t.width) || it;
+  }
+  setHeaderWidth(t, e = !0) {
+    return this.update({
+      diff: { 0: { width: t } },
+      partial: !0,
+      historicize: e
+    });
+  }
+  /**
+   * Get the raw (mutable) cell data for a point. Unlike getCell, this returns the actual registry.data reference.
+   * @internal
+   */
+  _pointToRawCell({ y: t, x: e }) {
+    var i;
+    const s = (i = this.idMatrix[t]) == null ? void 0 : i[e];
+    if (s != null)
+      return this.registry.data[s];
+  }
+  isRowFiltered(t) {
+    var e;
+    return !!((e = this._pointToRawCell({ y: t, x: 0 })) != null && e.filtered);
+  }
+  hasActiveFilters() {
+    const t = this.numCols;
+    for (let e = 1; e <= t; e++) {
+      const s = this._pointToRawCell({ y: 0, x: e });
+      if (s != null && s.filter && s.filter.conditions.length > 0)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Returns true if any data cell in this sheet currently holds a Pending value
+   * (i.e. an async formula that hasn't resolved yet).
+   */
+  hasPendingCells() {
+    const t = this.numRows, e = this.numCols;
+    for (let s = 1; s <= t; s++)
+      for (let i = 1; i <= e; i++) {
+        const r = this.getCell({ y: s, x: i }, { resolution: "RESOLVED" });
+        if (Mt.is(r == null ? void 0 : r.value))
+          return !0;
+      }
+    return !1;
+  }
+  /**
+   * Returns a Promise that resolves when all in-flight async formula computations
+   * have completed and no data cells hold Pending values.
+   * If nothing is pending, resolves immediately.
+   * Useful for waiting before sort/filter so that cell values are fully resolved.
+   */
+  waitForPending() {
+    const t = this.registry.asyncPending;
+    if (t.size > 0) {
+      const e = Array.from(t.values()).map((s) => s.promise);
+      return Promise.all(e).then(() => this.waitForPending());
+    }
+    return this.hasPendingCells() ? new Promise((e) => {
+      const s = () => {
+        if (this.registry.asyncPending.size > 0) {
+          const i = Array.from(this.registry.asyncPending.values()).map((r) => r.promise);
+          Promise.all(i).then(s);
+        } else this.hasPendingCells() ? setTimeout(s, 50) : e();
+      };
+      s();
+    }) : Promise.resolve();
+  }
+  /**
+   * Returns the addresses that were changed in the most recent `_update()` call.
+   * Useful inside `onChange` to know which cells were modified.
+   */
+  getLastChangedAddresses() {
+    return this.lastChangedAddresses;
+  }
+  /**
+   * Capture the full cell state of all filter-related header cells as a CellsByIdType snapshot.
+   * @internal
+   */
+  _captureFilterCellStates() {
+    var i, r, o, l;
+    const t = {}, e = this.numCols, s = this.numRows;
+    for (let a = 1; a <= e; a++) {
+      const h = (i = this.idMatrix[0]) == null ? void 0 : i[a];
+      h != null && (t[h] = { filter: ((r = this.registry.data[h]) == null ? void 0 : r.filter) ?? null });
+    }
+    for (let a = 1; a <= s; a++) {
+      const h = (o = this.idMatrix[a]) == null ? void 0 : o[0];
+      h != null && (t[h] = { filtered: ((l = this.registry.data[h]) == null ? void 0 : l.filtered) ?? !1 });
+    }
+    return t;
+  }
+  filterRows({
+    x: t,
+    filter: e
+  } = {}) {
+    const s = this._captureFilterCellStates();
+    if (t == null) {
+      const o = this.numCols;
+      for (let l = 1; l <= o; l++) {
+        const a = this._pointToRawCell({ y: 0, x: l });
+        a == null || delete a.filter;
+      }
+    } else {
+      const o = this._pointToRawCell({ y: 0, x: t });
+      o && (e ? o.filter = e : delete o.filter);
+    }
+    this._reapplyFilters();
+    const i = this._captureFilterCellStates(), r = Object.keys(s).filter(
+      (o) => JSON.stringify(s[o]) !== JSON.stringify(i[o])
+    );
+    if (r.length > 0) {
+      const o = {}, l = {};
+      for (const a of r)
+        o[a] = s[a], l[a] = i[a];
+      this._pushHistory({
+        applyed: !0,
+        operation: "UPDATE",
+        srcSheetId: this.id,
+        dstSheetId: this.id,
+        diffBefore: o,
+        diffAfter: l,
+        partial: !0
+      });
+    }
+    return this.refresh(!1, !0);
+  }
+  /** @internal */
+  _reapplyFilters() {
+    const t = this.numCols, e = [], s = [];
+    for (let r = 1; r <= t; r++) {
+      const o = this._pointToRawCell({ y: 0, x: r });
+      o != null && o.filter && o.filter.conditions.length > 0 && e.push({ x: r, filter: o.filter }), s.push(_({ y: 0, x: r }));
+    }
+    const i = this.numRows;
+    for (let r = 1; r <= i; r++) {
+      const o = this._pointToRawCell({ y: r, x: 0 });
+      if (!o || o.filterFixed)
+        continue;
+      let l = !1;
+      for (const { x: h, filter: u } of e) {
+        const n = this.getCell({ y: r, x: h }, { resolution: "RESOLVED" });
+        if (!Nt(u, n == null ? void 0 : n.value)) {
+          l = !0;
+          break;
+        }
+      }
+      const a = !!o.filtered;
+      l ? o.filtered = !0 : delete o.filtered, a !== l && s.push(_({ y: r, x: 0 }));
+    }
+    this.lastChangedAddresses = s;
+  }
+  sortRows({ x: t, direction: e }) {
+    const s = this.numRows;
+    if (s <= 1)
+      return this;
+    const i = /* @__PURE__ */ new Set(), r = [];
+    for (let n = 1; n <= s; n++) {
+      const f = this._pointToRawCell({ y: n, x: 0 });
+      f != null && f.sortFixed ? i.add(n) : r.push(n);
+    }
+    r.sort((n, f) => {
+      const d = this.getCell({ y: n, x: t }, { resolution: "RESOLVED" }), p = this.getCell({ y: f, x: t }, { resolution: "RESOLVED" }), y = d == null ? void 0 : d.value, c = p == null ? void 0 : p.value;
+      if (y == null && c == null)
+        return 0;
+      if (y == null)
+        return 1;
+      if (c == null)
+        return -1;
+      let g = 0;
+      return typeof y == "number" && typeof c == "number" ? g = y - c : y instanceof Date && c instanceof Date ? g = y.getTime() - c.getTime() : g = String(y).localeCompare(String(c)), e === "asc" ? g : -g;
+    });
+    const o = [];
+    for (let n = 1; n <= s; n++)
+      i.has(n) || o.push(n);
+    let l = !1;
+    for (let n = 0; n < r.length; n++)
+      if (r[n] !== o[n]) {
+        l = !0;
+        break;
+      }
+    if (!l)
+      return this;
+    const a = {};
+    for (const n of i)
+      a[n] = n;
+    for (let n = 0; n < r.length; n++)
+      a[r[n]] = o[n];
+    const h = this.idMatrix.slice();
+    for (const [n, f] of Object.entries(a))
+      this.idMatrix[Number(f)] = h[Number(n)];
+    this.addressCaches.clear();
+    const u = new L(this);
+    return u.buildMap(h.flat(), this.idMatrix.flat()), u.resolveDependents(), this._pushHistory({
+      applyed: !0,
+      operation: "SORT_ROWS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      sortedRowMapping: a
+    }), this.refresh(!0, !0);
+  }
+  /** @internal */
+  _sortRowMapping(t, e = !1) {
+    const s = this.numRows, i = new Array(s);
+    if (e)
+      for (const [o, l] of Object.entries(t)) {
+        const a = Number(o);
+        i[a - 1] = l;
+      }
+    else
+      for (const [o, l] of Object.entries(t)) {
+        const a = Number(o);
+        i[l - 1] = a;
+      }
+    const r = [];
+    for (let o = 0; o < i.length; o++)
+      r.push(this.idMatrix[i[o]]);
+    for (let o = 0; o < i.length; o++)
+      this.idMatrix[o + 1] = r[o];
+    this.addressCaches.clear();
+  }
+  get isInitialized() {
+    return this.status === 2;
+  }
+  get policies() {
+    return this.registry.policies;
+  }
+  /** @internal */
+  getSystem(t) {
+    const e = this.getId(t);
+    if (e != null)
+      return this.registry.systems[e];
+  }
+  /** @internal */
+  processFormula(t, { idMap: e, ...s }) {
+    if ((typeof t == "string" || t instanceof String) && t.charAt(0) === "=") {
+      const i = new Q(t.substring(1));
+      return i.tokenize(e), i.identify({ ...s, sheet: this }), i.dependencyIds.forEach((r) => this.addDependency(r, s.dependency)), "=" + i.identifiedFormula;
+    }
+    return t;
+  }
+  /** @internal */
+  resolveFormulas() {
+    this.idsToBeIdentified.forEach((t) => {
+      var s;
+      const e = this.registry.data[t];
+      ((s = this.registry.systems[t]) == null ? void 0 : s.sheetId) != null && e != null && (this.clearDependencies(t), e.value = this.processFormula(e == null ? void 0 : e.value, { dependency: t }));
+    }), this.idsToBeIdentified = [], this.status = 2;
+  }
+  /** @internal */
+  getSheetBySheetName(t) {
+    const e = this.registry.sheetIdsByName[t];
+    return this.getSheetBySheetId(e);
+  }
+  /** @internal */
+  getSheetBySheetId(t) {
+    var e, s, i;
+    return (i = (s = (e = this.registry.contextsBySheetId[t]) == null ? void 0 : e.store) == null ? void 0 : s.sheetReactive) == null ? void 0 : i.current;
+  }
+  /** @internal */
+  static _stack(...t) {
+    const e = {};
+    return t.forEach((s) => {
+      s != null && s.style && (e.style = { ...e.style, ...s.style }), s != null && s.prevention && (e.prevention = (e.prevention || 0) | s.prevention);
+    }), e;
+  }
+  /** @internal */
+  initialize(t) {
+    var l, a;
+    if (this.status > 1)
+      return;
+    t[0] == null && (t[0] = { width: it, height: st });
+    const e = wt(t), s = Date.now();
+    this.area = {
+      top: 1,
+      left: 1,
+      bottom: e.numRows,
+      right: e.numCols
+    };
+    for (let h = 0; h < e.numRows + 1; h++) {
+      const u = [];
+      this.idMatrix.push(u);
+      for (let n = 0; n < e.numCols + 1; n++) {
+        const f = this._generateId();
+        u.push(f);
+        const d = _({ y: h, x: n });
+        this.addressCaches.set(f, d);
+      }
+    }
+    Object.keys(t).forEach((h) => {
+      if (h === rt || h === ot || h === nt)
+        return;
+      const u = xt(h), n = t[h];
+      u.forEach((f) => {
+        const d = t[f];
+        t[f] = {
+          ...d,
+          ...n,
+          ...V._stack(d, n)
+        };
+      });
+    });
+    const i = t == null ? void 0 : t[rt], r = t == null ? void 0 : t[ot], o = t == null ? void 0 : t[nt];
+    (r == null ? void 0 : r.width) != null && (this.defaultColWidth = r.width), (o == null ? void 0 : o.height) != null && (this.defaultRowHeight = o.height);
+    for (let h = 0; h < e.numRows + 1; h++) {
+      const u = It(h);
+      for (let n = 0; n < e.numCols + 1; n++) {
+        const f = this.getId({ y: h, x: n }), d = Z(n);
+        let p;
+        if (h === 0 && n > 0) {
+          const c = t == null ? void 0 : t[d], { style: g, ...R } = c ?? {}, S = t == null ? void 0 : t[d + "0"];
+          p = {
+            ...r,
+            ...R,
+            ...S,
+            ...V._stack(r, S)
+          };
+        } else if (n === 0 && h > 0) {
+          const c = t == null ? void 0 : t[u], { style: g, ...R } = c ?? {}, S = t == null ? void 0 : t["0" + u];
+          p = {
+            ...o,
+            ...R,
+            ...S,
+            ...V._stack(o, S)
+          };
+        } else if (h === 0 && n === 0) {
+          const c = t == null ? void 0 : t["0"];
+          p = { ...c, ...V._stack(c) };
+        } else {
+          const c = _({ y: h, x: n }), g = t == null ? void 0 : t[u], R = t == null ? void 0 : t[d], S = t == null ? void 0 : t[c];
+          p = {
+            ...i,
+            ...g,
+            ...R,
+            ...S,
+            ...V._stack(i, g, R, S)
+          };
+        }
+        (a = (l = p == null ? void 0 : p.value) == null ? void 0 : l.startsWith) != null && a.call(l, "=") && ((p == null ? void 0 : p.formulaEnabled) ?? !0) && this.idsToBeIdentified.push(f), h === 0 ? p.width == null && (p.width = $) : n === 0 ? p.height == null && (p.height = U) : (delete p.height, delete p.width, delete p.label), p = (this.policies[p.policy ?? ""] ?? this.defaultPolicy).deserializeValue(p.value, p) ?? {}, this.registry.systems[f] = { id: f, changedTime: s, sheetId: this.id }, this.registry.data[f] = p;
+      }
+    }
+    this.status = 1, this.registry.sheetIdsByName[this.name] = this.id;
+  }
+  /** @internal */
+  _incrementVersion() {
+    this.version++, this.version >= Number.MAX_SAFE_INTEGER && (this.version = 1);
+  }
+  /** @internal */
+  _xsheetDispatch(t) {
+    if (t === this)
+      return;
+    t.refresh(!0);
+    const e = this.registry.contextsBySheetId[t.id];
+    if (e !== null) {
+      const { dispatch: s } = e;
+      requestAnimationFrame(() => {
+        s(this.registry.updateSheet(t));
+      });
+    }
+  }
+  /** @internal */
+  _generateId() {
+    return (this.registry.cellHead++).toString();
+  }
+  getRectSize({ top: t, left: e, bottom: s, right: i }) {
+    var d, p, y, c;
+    const r = e || 1, o = t || 1, l = ((d = this.registry.systems[this.getId({ y: 0, x: i })]) == null ? void 0 : d.offsetLeft) ?? 0, a = ((p = this.registry.systems[this.getId({ y: 0, x: r })]) == null ? void 0 : p.offsetLeft) ?? 0, h = ((y = this.registry.systems[this.getId({ y: s, x: 0 })]) == null ? void 0 : y.offsetTop) ?? 0, u = ((c = this.registry.systems[this.getId({ y: o, x: 0 })]) == null ? void 0 : c.offsetTop) ?? 0, n = Math.max(0, l - a), f = Math.max(0, h - u);
+    return { y: o, x: r, height: f, width: n };
+  }
+  /** @internal */
+  setTotalSize() {
+    const t = this.numCols, e = this.numRows, s = this.headerWidth, i = this.headerHeight;
+    let r = 0;
+    for (let a = 1; a <= t; a++) {
+      const h = this.getCell({ y: 0, x: a }, { resolution: "SYSTEM" }), u = (h == null ? void 0 : h.width) || this.defaultColWidth || $, n = this.registry.systems[this.getId({ y: 0, x: a })];
+      n != null && (n.offsetLeft = s + r), r += u;
+    }
+    this.totalWidth = s + r;
+    let o = 0, l = 0;
+    for (let a = 1; a <= e; a++) {
+      const h = this.getCell({ y: a, x: 0 }, { resolution: "SYSTEM" }), u = (h == null ? void 0 : h.height) || this.defaultRowHeight || U, n = this.registry.systems[this.getId({ y: a, x: 0 })];
+      n != null && (n.offsetTop = i + o), h != null && h.filtered || (o += u), l += u;
+    }
+    this.totalHeight = i + o, this.fullHeight = i + l;
+  }
+  /** @internal */
+  refresh(t = !1, e = !1) {
+    return this._incrementVersion(), this.lastChangedTime = this.changedTime, this.changedTime = Date.now(), this.clearSolvedCaches(), t && this.addressCaches.clear(), e && this.setTotalSize(), this;
+  }
+  /** @internal */
+  clone(t = !1) {
+    return Object.assign(Object.create(Object.getPrototypeOf(this)), this).refresh(t);
+  }
+  /** @internal */
+  getPointById(t, e = 0, s = 0) {
+    const i = t.startsWith("$");
+    i && (t = t.slice(1), s = 0);
+    const r = t.endsWith("$");
+    r && (t = t.slice(0, -1), e = 0);
+    const o = this.addressCaches.get(t);
+    if (o) {
+      const l = A(o);
+      return { y: l.y + e, x: l.x + s, absCol: i, absRow: r };
+    }
+    for (let l = 0; l < this.idMatrix.length; l++) {
+      const a = this.idMatrix[l];
+      for (let h = 0; h < a.length; h++) {
+        const u = a[h], n = _({ y: l, x: h });
+        if (this.addressCaches.set(u, n), u === t)
+          return {
+            y: l + e,
+            x: h + s,
+            absCol: i,
+            absRow: r
+          };
+      }
+    }
+    return { y: -1, x: -1, absCol: i, absRow: r };
+  }
+  /** @internal */
+  getAddressById(t, e = 0, s = 0) {
+    const { y: i, x: r, absCol: o, absRow: l } = this.getPointById(t, e, s);
+    return Ct(_({ y: i, x: r }), o, l);
+  }
+  /** @internal */
+  clearAddressCaches() {
+    this.addressCaches.clear();
+  }
+  /** @internal */
+  _warmAddressCaches() {
+    for (let t = 0; t < this.idMatrix.length; t++) {
+      const e = this.idMatrix[t];
+      for (let s = 0; s < e.length; s++)
+        this.addressCaches.set(e[s], _({ y: t, x: s }));
+    }
+  }
+  /** @internal */
+  getId(t) {
+    var i;
+    const { y: e, x: s } = t;
+    return (i = this.idMatrix[e]) == null ? void 0 : i[s];
+  }
+  /** @internal */
+  getCell(t, { resolution: e = "RESOLVED", raise: s = !1 } = {}) {
+    var h;
+    const { y: i, x: r } = t;
+    if (i === -1 || r === -1)
+      return;
+    const o = (h = this.idMatrix[i]) == null ? void 0 : h[r];
+    if (o == null)
+      return;
+    const l = this.registry.data[o];
+    if (l == null)
+      return;
+    let a = l.value;
+    return e !== "SYSTEM" && (l.formulaEnabled ?? !0) && (a = tt({ value: a, sheet: this, point: t, raise: s, resolution: e, at: o })), { ...l, value: a };
+  }
+  /** @internal */
+  get numRows() {
+    const { top: t, bottom: e } = this.area;
+    return 1 + e - t;
+  }
+  get numCols() {
+    const { left: t, right: e } = this.area;
+    return 1 + e - t;
+  }
+  get top() {
+    return this.area.top;
+  }
+  get left() {
+    return this.area.left;
+  }
+  get bottom() {
+    return this.area.bottom;
+  }
+  get right() {
+    return this.area.right;
+  }
+  /** @internal */
+  _toValueMatrix({
+    area: t,
+    at: e,
+    resolution: s = "RESOLVED",
+    raise: i = !1,
+    filter: r = Yt,
+    asScalar: o = !1
+  } = {}) {
+    const { top: l, left: a, bottom: h, right: u } = t ?? this.area, n = St(h - l + 1, u - a + 1);
+    for (let f = l; f <= h; f++)
+      for (let d = a; d <= u; d++) {
+        const p = this.getId({ y: f, x: d });
+        if (e === p)
+          throw new z("#REF!", "References are circulating.");
+        const y = this.getCell({ y: f, x: d }, { resolution: s, raise: i }) ?? {};
+        if (r(y)) {
+          let c = y.value;
+          o && (c = this.getPolicy({ y: f, x: d }).toScalar({ value: y.value, cell: y, sheet: this, point: { y: f, x: d } })), n[f - l][d - a] = c;
+        }
+      }
+    return n;
+  }
+  /** @internal */
+  _pushHistory(t) {
+    const e = this.registry;
+    if (e.histories.splice(e.historyIndex + 1, e.histories.length).forEach(this._cleanStrayed.bind(this)), e.histories.push(t), e.lastHistory = e.currentHistory = t, e.histories.length > e.historyLimit) {
+      const i = e.histories.splice(0, 1)[0];
+      this._cleanObsolete(i);
+    } else
+      e.historyIndex++;
+  }
+  /** @internal */
+  _cleanObsolete(t) {
+    (t.operation === "REMOVE_ROWS" || t.operation === "REMOVE_COLS") && t.deleted.forEach((e) => {
+      e.forEach((s) => {
+        this._deleteOrphanedId(s);
+      });
+    }), t.operation === "MOVE" && t.moveRelations.forEach((e) => {
+      e.new != null && this._deleteOrphanedId(e.new), e.lost != null && this._deleteOrphanedId(e.lost);
+    });
+  }
+  /** @internal */
+  _cleanStrayed(t) {
+    (t.operation === "INSERT_ROWS" || t.operation === "INSERT_COLS") && t.idMatrix.forEach((e) => {
+      e.forEach((s) => {
+        this._deleteOrphanedId(s);
+      });
+    });
+  }
+  /**
+   * Remove an id from registry.data and registry.dependents entirely.
+   * @internal
+   */
+  _deleteOrphanedId(t) {
+    var s;
+    const e = this.registry.systems[t];
+    (s = e == null ? void 0 : e.dependencies) == null || s.forEach((i) => {
+      var r, o;
+      (o = (r = this.registry.systems[i]) == null ? void 0 : r.dependents) == null || o.delete(t);
+    }), delete this.registry.data[t], delete this.registry.systems[t];
+  }
+  /** @internal */
+  _copyCellLayout(t) {
+    if (t == null)
+      return;
+    const e = {};
+    return t.style != null && (e.style = t.style), t.justifyContent != null && (e.justifyContent = t.justifyContent), t.alignItems != null && (e.alignItems = t.alignItems), t.policy != null && (e.policy = t.policy), t.width != null && (e.width = t.width), t.height != null && (e.height = t.height), e;
+  }
+  move({
+    srcSheet: t = this,
+    src: e,
+    dst: s,
+    historicize: i = !0,
+    operator: r = "SYSTEM",
+    undoReflection: o,
+    redoReflection: l
+  }) {
+    const a = t.__raw__, h = this._createMoveRelations(a, e, this, s), { diffBefore: u, diffAfter: n } = this._moveCells(a, this, h, !1, r);
+    return this._xsheetDispatch(a), i && this._pushHistory({
+      applyed: !0,
+      operation: "MOVE",
+      srcSheetId: a.id,
+      dstSheetId: this.id,
+      undoReflection: o,
+      redoReflection: l,
+      diffBefore: u,
+      diffAfter: n,
+      moveRelations: h
+    }), this.refresh(!0);
+  }
+  /**
+   * Build MoveRelations from src area to dst area, skipping filtered rows.
+   *
+   * Layout of the returned array (processed in this order by _moveCells):
+   *   1. Entries where [0] is a newly-generated ID — these fill the vacated src cells (processed last in forward order)
+   *   2. Entries where [0] is a src address and [1] is a dst address — the actual moves (processed first in forward order, descending)
+   *   Entries whose [1] is an existing ID mean the destination cell is displaced/overflowed and
+   *   is no longer addressable; on forward pass they are skipped; on reverse pass the ID is written back.
+   */
+  /** @internal */
+  _createMoveRelations(t, e, s, i) {
+    const { top: r, left: o, bottom: l, right: a } = e, { top: h, left: u } = i, n = s.numRows, f = s.numCols, d = [];
+    for (let m = r; m <= l; m++)
+      t.isRowFiltered(m) || d.push(m);
+    const p = a - o + 1, y = d.length, c = [];
+    {
+      let m = 0, x = h;
+      for (; m < y; )
+        s.isRowFiltered(x) || (c.push(x), m++), x++;
+    }
+    const g = /* @__PURE__ */ new Set();
+    for (let m = 0; m < y; m++)
+      for (let x = 0; x < p; x++)
+        g.add(_({ y: d[m], x: o + x }));
+    const R = /* @__PURE__ */ new Set();
+    for (let m = 0; m < y; m++) {
+      const x = c[m];
+      for (let C = 0; C < p; C++) {
+        const I = u + C;
+        x <= n && I <= f && R.add(_({ y: x, x: I }));
+      }
+    }
+    const S = [];
+    for (let m = 0; m < y; m++) {
+      const x = d[m], C = c[m];
+      for (let I = 0; I < p; I++) {
+        const w = o + I, v = u + I, T = _({ y: x, x: w }), b = C <= n && v <= f, D = b ? _({ y: C, x: v }) : void 0;
+        let O;
+        t === s && R.has(T) || (O = t._generateId());
+        let F;
+        if (b) {
+          if (!(t === s && g.has(D))) {
+            const M = s.getId({ y: C, x: v });
+            M != null && (F = M);
+          }
+        } else {
+          const M = t.getId({ y: x, x: w });
+          M != null && (F = M);
+        }
+        const N = t.getCell({ y: x, x: w }, { resolution: "SYSTEM" }), E = b ? s.getCell({ y: C, x: v }, { resolution: "SYSTEM" }) : void 0;
+        S.push({
+          before: N == null ? void 0 : N.policy,
+          after: E == null ? void 0 : E.policy,
+          src: T,
+          dst: D,
+          new: O,
+          lost: F
+        });
+      }
+    }
+    return S;
+  }
+  get defaultPolicy() {
+    return this.policies[B] ?? Ft;
+  }
+  /**
+   * Apply (or reverse) a MoveRelations list.
+   *
+   * Forward (reverse=false): process descending — actual ID moves happen bottom-up so
+   *   earlier entries don't clobber later ones; vacate entries (at front of array) are
+   *   applied last.
+   * Reverse (reverse=true): process ascending — restores IDs in the natural order.
+   *
+   * On forward pass: applies policy, collects diffBefore, runs ReferencePreserver.
+   * On reverse pass: only moves IDs (caller is responsible for applyDiff(diffBefore)).
+   */
+  /** @internal */
+  _moveCells(t, e, s, i, r = "SYSTEM") {
+    const o = {}, l = new L(e), a = {}, h = [], u = [];
+    if (i)
+      for (const {
+        before: y,
+        after: c,
+        src: g,
+        dst: R,
+        new: S,
+        lost: m
+      } of s) {
+        if (R != null) {
+          const x = A(R), C = e.getId(x);
+          if (C != null) {
+            const I = A(g);
+            h.push({ y: I.y, x: I.x, id: C });
+          }
+        }
+        if (m != null)
+          if (R != null) {
+            const x = A(R);
+            u.push({ y: x.y, x: x.x, id: m });
+          } else {
+            const x = A(g);
+            h.push({ y: x.y, x: x.x, id: m });
+          }
+      }
+    else
+      for (const {
+        before: y,
+        after: c,
+        src: g,
+        dst: R,
+        new: S,
+        lost: m
+      } of s) {
+        const x = A(g), C = t.getId(x), I = R != null ? A(R) : void 0, w = I != null ? e.getId(I) : void 0, v = C != null ? t.registry.data[C] : void 0, T = w != null ? e.registry.data[w] : void 0;
+        if (!(r === "USER" && (Y(v == null ? void 0 : v.prevention, ht) || Y(T == null ? void 0 : T.prevention, lt)))) {
+          if (S != null) {
+            const b = y || B, O = (t.policies[b] ?? t.defaultPolicy).select({
+              sheet: t,
+              point: x,
+              next: { value: null },
+              current: v,
+              operation: ht
+            });
+            a[S] = {
+              ...O,
+              policy: y
+            }, this.registry.systems[S] = { id: S, sheetId: t.id, changedTime: Date.now() }, h.push({ y: x.y, x: x.x, id: S });
+          }
+          if (w != null && I != null && R != null) {
+            const b = c || B, D = y || B, O = e.policies[b] ?? e.defaultPolicy, F = t.policies[D] ?? t.defaultPolicy, N = F.priority > O.priority, M = (N ? F : O).select({
+              sheet: e,
+              point: I,
+              next: v,
+              current: T,
+              operation: lt
+            });
+            if (M && (o[C] = v ?? {}, a[C] = {
+              ...v,
+              ...M,
+              policy: N ? y : c
+            }), v != null) {
+              const H = this.registry.systems[C];
+              H && (H.changedTime = Date.now());
+            }
+            u.push({ y: I.y, x: I.x, id: C });
+          }
+        }
+      }
+    const n = i ? null : t.idMatrix.flat(), f = !i && t !== e ? e.idMatrix.flat() : null;
+    Object.assign(this.registry.data, a);
+    for (const { y, x: c, id: g } of h)
+      t.idMatrix[y][c] = g;
+    for (const { y, x: c, id: g } of u)
+      e.idMatrix[y][c] = g;
+    const d = s.filter((y) => y.dst != null).map((y) => y.dst), p = s.map((y) => y.src);
+    if (t === e ? e.lastChangedAddresses = [.../* @__PURE__ */ new Set([...p, ...d])] : (e.lastChangedAddresses = d, t.lastChangedAddresses = p), !i) {
+      l.buildMap(n.flat(), t.idMatrix.flat()), t !== e && l.buildMap(f.flat(), e.idMatrix.flat());
+      const y = l.resolveDependents("move");
+      Object.assign(o, y);
+    }
+    return { diffBefore: o, diffAfter: {} };
+  }
+  copy({
+    srcSheet: t = this,
+    src: e,
+    dst: s,
+    onlyValue: i = !1,
+    operator: r = "SYSTEM",
+    undoReflection: o,
+    redoReflection: l
+  }) {
+    const a = t !== this, { top: h, left: u, bottom: n, right: f } = e, { top: d, left: p, bottom: y, right: c } = s, g = {}, R = Date.now(), S = [];
+    for (let w = h; w <= n; w++)
+      t.isRowFiltered(w) || S.push(w);
+    const m = [];
+    for (let w = d; w <= y; w++)
+      w > this.numRows || this.isRowFiltered(w) || m.push(w);
+    const x = S.length, C = f - u + 1, I = c - p + 1;
+    for (let w = 0; w < m.length; w++) {
+      const v = m[w], T = S[w % x];
+      for (let b = 0; b <= I - 1; b++) {
+        const D = p + b;
+        if (D > this.numCols)
+          continue;
+        const O = u + b % C, F = a ? 0 : v - T, N = a ? 0 : D - O, E = {
+          ...t.getCell({ y: T, x: O }, { resolution: "SYSTEM" })
+        }, M = { y: v, x: D }, H = this.getCell(M, { resolution: "SYSTEM" }), ft = this.getPolicy(M), G = { y: T, x: O }, ut = t.getPolicy(G), j = t.getCell(G, { resolution: "SYSTEM" }), yt = ut.priority > ft.priority;
+        E.policy = yt ? j == null ? void 0 : j.policy : H == null ? void 0 : H.policy;
+        const q = this.getId(M);
+        this.clearDependencies(q);
+        const pt = (E == null ? void 0 : E.formulaEnabled) ?? !0 ? this.processFormula(E == null ? void 0 : E.value, {
+          dependency: q,
+          slideY: F,
+          slideX: N
+        }) : E == null ? void 0 : E.value, gt = this.getId(M), J = this.registry.systems[gt];
+        J != null && (J.changedTime = R);
+        const mt = _(M);
+        if (i) {
+          const P = this.getCell(M, { resolution: "SYSTEM" });
+          E.style = P == null ? void 0 : P.style, E.justifyContent = P == null ? void 0 : P.justifyContent, E.alignItems = P == null ? void 0 : P.alignItems;
+        }
+        g[mt] = { ...E, value: pt };
+      }
+    }
+    return this.update({
+      diff: g,
+      partial: !1,
+      operator: r,
+      operation: bt,
+      undoReflection: o,
+      redoReflection: l
+    });
+  }
+  getPolicy(t) {
+    const e = this.getCell(t, { resolution: "SYSTEM" });
+    return (e == null ? void 0 : e.policy) == null ? this.defaultPolicy : this.policies[e.policy] ?? this.defaultPolicy;
+  }
+  /** @internal */
+  _update({
+    diff: t,
+    partial: e = !0,
+    updateChangedTime: s = !0,
+    ignoreFields: i = ["label"],
+    operator: r = "SYSTEM",
+    operation: o = X,
+    formulaIdentify: l = !0
+  }) {
+    const a = {}, h = {}, u = [], n = Date.now();
+    let f = !1;
+    return Object.keys(t).forEach((d) => {
+      var m, x, C, I;
+      const p = A(d), y = this.getId(p), c = this.registry.data[y];
+      if (r === "USER" && Y(c == null ? void 0 : c.prevention, X))
+        return;
+      let g = { ...t[d] };
+      if (l && (g.formulaEnabled ?? (c == null ? void 0 : c.formulaEnabled) ?? !0) && (this.clearDependencies(y), g.value = this.processFormula(g.value, { dependency: y })), i.forEach((w) => {
+        g[w] = c == null ? void 0 : c[w];
+      }), r === "USER" && Y(c == null ? void 0 : c.prevention, K) && delete g.value, r === "USER" && Y(c == null ? void 0 : c.prevention, Tt) && ((m = g == null ? void 0 : g.style) == null || delete m.justifyContent, (x = g == null ? void 0 : g.style) == null || delete x.alignItems), r === "USER" && Y(c == null ? void 0 : c.prevention, Ot) && ((C = g == null ? void 0 : g.style) == null || delete C.width, (I = g == null ? void 0 : g.style) == null || delete I.height), (g.width != null || g.height != null) && (f = !0), a[y] = c ?? {}, g = { ...(this.policies[(c == null ? void 0 : c.policy) || B] ?? this.defaultPolicy).select({
+        sheet: this,
+        point: p,
+        next: g,
+        current: c,
+        operation: o
+      }) }, s) {
+        const w = this.registry.systems[y];
+        w != null && (w.changedTime = n);
+      }
+      if (e) {
+        const w = { ...c, ...g };
+        this.registry.data[y] = w, h[y] = w;
+      } else
+        this.registry.data[y] = g, h[y] = g;
+      u.push(d);
+    }), this.lastChangedAddresses = u, {
+      diffBefore: a,
+      diffAfter: h,
+      resized: f
+    };
+  }
+  update({
+    diff: t,
+    partial: e = !0,
+    updateChangedTime: s = !0,
+    historicize: i = !0,
+    operator: r = "SYSTEM",
+    operation: o = X,
+    ignoreFields: l,
+    undoReflection: a,
+    redoReflection: h
+  }) {
+    const { diffBefore: u, diffAfter: n, resized: f } = this._update({
+      diff: t,
+      partial: e,
+      operator: r,
+      operation: o,
+      updateChangedTime: s,
+      ...l != null ? { ignoreFields: l } : {}
+    });
+    return i && this._pushHistory({
+      applyed: !0,
+      operation: "UPDATE",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: a,
+      redoReflection: h,
+      diffBefore: u,
+      diffAfter: n,
+      partial: e
+    }), this.refresh(!1, f);
+  }
+  /** @internal */
+  writeRawCellMatrix({
+    point: t,
+    matrix: e,
+    updateChangedTime: s = !0,
+    historicize: i = !0,
+    onlyValue: r = !1,
+    operator: o = "SYSTEM",
+    undoReflection: l,
+    redoReflection: a
+  }) {
+    const { y: h, x: u } = t, n = {};
+    let f = 0, d = h;
+    for (; f < e.length && !(d > this.bottom); ) {
+      if (this.isRowFiltered(d)) {
+        d++;
+        continue;
+      }
+      e[f].forEach((y, c) => {
+        const g = u + c;
+        if (g > this.right)
+          return;
+        const R = { y: d, x: g }, S = this.parse(R, y.value ?? "");
+        if (S.style = { ...y.style, ...S.style }, r) {
+          const m = this.getCell(R, { resolution: "SYSTEM" });
+          S.style = m == null ? void 0 : m.style, S.justifyContent = m == null ? void 0 : m.justifyContent, S.alignItems = m == null ? void 0 : m.alignItems;
+        }
+        n[_(R)] = S;
+      }), f++, d++;
+    }
+    return this.update({
+      diff: n,
+      partial: !0,
+      updateChangedTime: s,
+      historicize: i,
+      operator: o,
+      operation: K,
+      undoReflection: l,
+      redoReflection: a
+    });
+  }
+  writeMatrix(t) {
+    const e = t.matrix.map((s) => s.map((i) => ({ value: i })));
+    return this.writeRawCellMatrix({ ...t, matrix: e });
+  }
+  write(t) {
+    const { point: e, value: s } = t, i = this.parse(e, s ?? ""), r = this.getCell(e, { resolution: "RAW" });
+    if (((r == null ? void 0 : r.value) ?? null) === i.value)
+      return this;
+    const o = { [_(e)]: i };
+    return this.update({
+      ...t,
+      diff: o,
+      partial: !0,
+      operation: K
+    });
+  }
+  insertRows({
+    y: t,
+    numRows: e,
+    baseY: s,
+    diff: i,
+    partial: r,
+    updateChangedTime: o,
+    operator: l = "SYSTEM",
+    undoReflection: a,
+    redoReflection: h
+  }) {
+    if (this.maxNumRows !== -1 && this.numRows + e > this.maxNumRows)
+      return console.error(`Rows are limited to ${this.maxNumRows}.`), this;
+    const u = this.numCols, n = [], f = Date.now();
+    for (let d = 0; d < e; d++) {
+      const p = [];
+      for (let y = 0; y <= u; y++) {
+        const c = this._generateId();
+        p.push(c);
+        const g = this.getCell({ y: s, x: y }, { resolution: "SYSTEM" }), R = this._copyCellLayout(g);
+        this.registry.data[c] = { ...R }, this.registry.systems[c] = { id: c, sheetId: this.id, changedTime: f };
+      }
+      n.push(p);
+    }
+    if (this.idMatrix.splice(t, 0, ...n), this.area.bottom += e, this._pushHistory({
+      applyed: !0,
+      operation: "INSERT_ROWS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: a,
+      redoReflection: h,
+      y: t,
+      numRows: e,
+      idMatrix: n
+    }), i && Object.assign(this.registry.lastHistory, this._update({ diff: i, partial: r, updateChangedTime: o, operator: l }), {
+      partial: r
+    }), this.registry.onInsertRows) {
+      const d = this.clone();
+      d.area = {
+        top: t,
+        bottom: t + e - 1,
+        left: this.area.left,
+        right: this.area.right
+      }, d.addressCaches = /* @__PURE__ */ new Map(), this.registry.onInsertRows({ sheet: d, y: t, numRows: e });
+    }
+    return this.refresh(!0, !0);
+  }
+  removeRows({
+    y: t,
+    numRows: e,
+    operator: s = "SYSTEM",
+    undoReflection: i,
+    redoReflection: r
+  }) {
+    if (this.minNumRows !== -1 && this.numRows - e < this.minNumRows)
+      return console.error(`At least ${this.minNumRows} row(s) are required.`), this;
+    const o = new L(this), l = [], a = this.idMatrix.map((n) => [...n]);
+    for (let n = t; n < t + e; n++) {
+      const f = this.getCell({ y: n, x: 0 }, { resolution: "SYSTEM" });
+      if (s === "USER" && Y(f == null ? void 0 : f.prevention, At))
+        return console.warn(`Cannot delete row ${n}.`), this;
+      for (let d = 1; d <= this.numCols; d++) {
+        const p = this.getId({ y: n, x: d });
+        p != null && (o.collectDependents(p), o.map[p] = this.getId({ y: n + e, x: d }));
+      }
+      l.unshift(n);
+    }
+    const h = [];
+    l.forEach((n) => {
+      const f = this.idMatrix.splice(n, 1);
+      h.unshift(f[0]);
+    }), this.area.bottom -= l.length;
+    const u = o.resolveDependents("removeRows");
+    if (this._pushHistory({
+      applyed: !0,
+      operation: "REMOVE_ROWS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: i,
+      redoReflection: r,
+      ys: l.reverse(),
+      diffBefore: u,
+      deleted: h
+    }), this.registry.onRemoveRows) {
+      const n = this.clone();
+      n.idMatrix = a, n.area = {
+        top: t,
+        bottom: t + e - 1,
+        left: this.area.left,
+        right: this.area.right
+      }, n.addressCaches = /* @__PURE__ */ new Map(), this.registry.onRemoveRows({ sheet: n, ys: l.reverse() });
+    }
+    return this.refresh(!0, !0);
+  }
+  insertCols({
+    x: t,
+    numCols: e,
+    baseX: s,
+    diff: i,
+    partial: r,
+    updateChangedTime: o,
+    operator: l = "SYSTEM",
+    undoReflection: a,
+    redoReflection: h
+  }) {
+    if (this.maxNumCols !== -1 && this.numCols + e > this.maxNumCols)
+      return console.error(`Columns are limited to ${this.maxNumCols}.`), this;
+    const u = this.numRows, n = [], f = Date.now();
+    for (let d = 0; d <= u; d++) {
+      const p = [];
+      for (let y = 0; y < e; y++) {
+        const c = this._generateId();
+        p.push(c);
+        const g = this.getCell({ y: d, x: s }, { resolution: "SYSTEM" }), R = this._copyCellLayout(g);
+        this.idMatrix[d].splice(t, 0, c), this.registry.data[c] = { ...R }, this.registry.systems[c] = { id: c, sheetId: this.id, changedTime: f };
+      }
+      n.push(p);
+    }
+    if (this.area.right += e, this._pushHistory({
+      applyed: !0,
+      operation: "INSERT_COLS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: a,
+      redoReflection: h,
+      x: t,
+      numCols: e,
+      idMatrix: n
+    }), i && Object.assign(this.registry.lastHistory, this._update({ diff: i, partial: r, updateChangedTime: o, operator: l }), {
+      partial: r
+    }), this.registry.onInsertCols) {
+      const d = this.clone();
+      d.area = {
+        top: this.area.top,
+        bottom: this.area.bottom,
+        left: t,
+        right: t + e - 1
+      }, d.addressCaches = /* @__PURE__ */ new Map(), this.registry.onInsertCols({ sheet: d, x: t, numCols: e });
+    }
+    return this.refresh(!0, !0);
+  }
+  removeCols({
+    x: t,
+    numCols: e,
+    operator: s = "SYSTEM",
+    undoReflection: i,
+    redoReflection: r
+  }) {
+    if (this.minNumCols !== -1 && this.numCols - e < this.minNumCols)
+      return console.error(`At least ${this.minNumCols} column(s) are required.`), this;
+    const o = new L(this), l = [], a = this.idMatrix.map((n) => [...n]);
+    for (let n = t; n < t + e; n++) {
+      const f = this.getCell({ y: 0, x: n }, { resolution: "SYSTEM" });
+      if (s === "USER" && Y(f == null ? void 0 : f.prevention, Dt)) {
+        console.warn(`Cannot delete col ${n}.`);
+        continue;
+      }
+      for (let d = 1; d <= this.numRows; d++) {
+        const p = this.getId({ y: d, x: n });
+        p != null && (o.collectDependents(p), o.map[p] = this.getId({ y: d, x: n + e }));
+      }
+      l.unshift(n);
+    }
+    const h = [];
+    this.idMatrix.forEach((n) => {
+      const f = [];
+      h.push(f), l.forEach((d) => {
+        f.unshift(...n.splice(d, 1));
+      });
+    }), this.area.right -= l.length;
+    const u = o.resolveDependents("removeCols");
+    if (this._pushHistory({
+      applyed: !0,
+      operation: "REMOVE_COLS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: i,
+      redoReflection: r,
+      xs: l.reverse(),
+      diffBefore: u,
+      deleted: h
+    }), this.registry.onRemoveCols) {
+      const n = this.clone();
+      n.idMatrix = a, n.area = {
+        top: this.area.top,
+        bottom: this.area.bottom,
+        left: t,
+        right: t + e - 1
+      }, n.addressCaches = /* @__PURE__ */ new Map(), this.registry.onRemoveCols({ sheet: n, xs: l.reverse() });
+    }
+    return this.refresh(!0, !0);
+  }
+  /** @internal */
+  histories() {
+    return [...this.registry.histories];
+  }
+  /** @internal */
+  historyIndex() {
+    return this.registry.historyIndex;
+  }
+  /** @internal */
+  historySize() {
+    return this.registry.histories.length;
+  }
+  /** @internal */
+  getHistoryLimit() {
+    return this.registry.historyLimit;
+  }
+  /** @internal */
+  parse(t, e) {
+    const s = this.getCell(t, { resolution: "SYSTEM" }) ?? {};
+    return this.getPolicy(t).deserializeValue(e, s);
+  }
+  /** @internal */
+  render(t) {
+    const { point: e, apply: s } = t;
+    return this.getId(e), this.getPolicy(e).render({ sheet: this, point: e, apply: s, value: void 0 });
+  }
+  getSerializedValue({
+    point: t,
+    cell: e,
+    resolution: s = "RESOLVED"
+  }) {
+    var o, l;
+    if (e == null) {
+      const a = (o = this.idMatrix[t.y]) == null ? void 0 : o[t.x];
+      e = a != null ? this.registry.data[a] : void 0;
+    }
+    if (e == null)
+      return "";
+    const i = this.getPolicy(t), r = e.value;
+    if (typeof r == "string" && r[0] === "=") {
+      if (s === "SYSTEM")
+        return r;
+      if (s === "RAW") {
+        const a = new Q(r.substring(1));
+        return a.tokenize(), "=" + a.display({ sheet: this });
+      }
+      try {
+        const a = (l = this.idMatrix[t.y]) == null ? void 0 : l[t.x], h = tt({ value: r, sheet: this, point: t, raise: !0, resolution: s, at: a }), u = et({ value: h, raise: !1 });
+        return i.serialize({ value: u, cell: e, sheet: this, point: t });
+      } catch (a) {
+        return i.serialize({ value: a, cell: e, sheet: this, point: t });
+      }
+    }
+    return i.serialize({ value: r, cell: e, sheet: this, point: t });
+  }
+  /** @internal */
+  trim(t) {
+    const e = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    return e.area = t, e;
+  }
+  /**
+   * Solve all formulas in this sheet and return a 2D matrix of resolved values.
+   * @internal
+   */
+  solve({ raise: t = !1, at: e }) {
+    return Et({ sheet: this, raise: t, at: e });
+  }
+  /**
+   * Collapse this sheet to a scalar (top-left cell value).
+   * @internal
+   */
+  strip({ raise: t = !1, at: e }) {
+    return et({ value: this, raise: t, at: e });
+  }
+  /** @internal */
+  _applyDiff(t = {}, e = !0) {
+    const s = Object.keys(t);
+    s.forEach((r) => {
+      const o = t[r] ?? {};
+      let l;
+      e ? (l = { ...this.registry.data[r] }, Object.keys(o).forEach((h) => {
+        o[h] === void 0 ? delete l[h] : l[h] = o[h];
+      })) : l = { ...o };
+      const a = this.registry.systems[r];
+      a != null && (a.changedTime = Date.now()), this.registry.data[r] = l, this.clearDependencies(r), this.processFormula(l.value, { dependency: r });
+    }), this._warmAddressCaches();
+    const i = [];
+    for (const r of s) {
+      const o = this.getAddressById(r);
+      o && i.push(o);
+    }
+    this.lastChangedAddresses = i;
+  }
+  undo() {
+    if (this.registry.historyIndex < 0)
+      return { history: null, newSheet: this.__raw__ };
+    const t = this.registry.histories[this.registry.historyIndex--];
+    t.applyed = !1, this.registry.currentHistory = this.registry.histories[this.registry.historyIndex];
+    const e = this.getSheetBySheetId(t.srcSheetId), s = this.getSheetBySheetId(t.dstSheetId);
+    if (!s)
+      return { history: null, newSheet: this.__raw__ };
+    switch (t.operation) {
+      case "UPDATE":
+        s._applyDiff(t.diffBefore, t.partial ?? !1);
+        break;
+      case "INSERT_ROWS": {
+        t.diffBefore && s._applyDiff(t.diffBefore, !1);
+        const { rows: i } = W({ matrix: t.idMatrix });
+        s.idMatrix.splice(t.y, i), s.area.bottom -= i;
+        break;
+      }
+      case "INSERT_COLS": {
+        t.diffBefore && s._applyDiff(t.diffBefore, !1);
+        const { cols: i } = W({ matrix: t.idMatrix });
+        s.idMatrix.forEach((r) => {
+          r.splice(t.x, i);
+        }), s.area.right -= i;
+        break;
+      }
+      case "REMOVE_ROWS": {
+        const { ys: i, deleted: r } = t;
+        i.forEach((o, l) => {
+          s.idMatrix.splice(o, 0, r[l]);
+        }), s.area.bottom += i.length, this._applyDiff(t.diffBefore, !1);
+        break;
+      }
+      case "REMOVE_COLS": {
+        const { xs: i, deleted: r } = t;
+        s.idMatrix.forEach((o, l) => {
+          for (let a = 0; a < i.length; a++)
+            o.splice(i[a], 0, r[l][a]);
+        }), s.area.right += i.length, this._applyDiff(t.diffBefore, !1);
+        break;
+      }
+      case "MOVE": {
+        e && this._moveCells(e, s, t.moveRelations, !0);
+        const i = s.lastChangedAddresses;
+        s._applyDiff(t.diffBefore, !1), s.lastChangedAddresses = [.../* @__PURE__ */ new Set([...i, ...s.lastChangedAddresses])];
+        break;
+      }
+      case "SORT_ROWS": {
+        const i = s.idMatrix.flat();
+        s._sortRowMapping(t.sortedRowMapping, !0);
+        const r = new L(s);
+        r.buildMap(i, s.idMatrix.flat()), r.resolveDependents(), s._reapplyFilters();
+        break;
+      }
+    }
+    return this.refresh(dt(t.operation), !0), s !== this && (s.addressCaches.clear(), s.setTotalSize()), t.operation === "MOVE" && e && e !== s && this._xsheetDispatch(e), {
+      history: t,
+      callback: ({ sheetReactive: i }) => {
+        var r, o;
+        (o = i.current) == null || o.registry.transmit((r = t.undoReflection) == null ? void 0 : r.transmit);
+      }
+    };
+  }
+  redo() {
+    if (this.registry.historyIndex + 1 >= this.registry.histories.length)
+      return { history: null, newSheet: this.__raw__ };
+    const t = this.registry.histories[++this.registry.historyIndex];
+    t.applyed = !0, this.registry.currentHistory = t;
+    const e = this.getSheetBySheetId(t.srcSheetId), s = this.getSheetBySheetId(t.dstSheetId);
+    if (!s)
+      return { history: null, newSheet: this.__raw__ };
+    switch (t.operation) {
+      case "UPDATE":
+        s._applyDiff(t.diffAfter, t.partial ?? !1);
+        break;
+      case "INSERT_ROWS": {
+        t.diffAfter && s._applyDiff(t.diffAfter, !1);
+        const { rows: i } = W({ matrix: t.idMatrix });
+        s.idMatrix.splice(t.y, 0, ...t.idMatrix), s.area.bottom += i;
+        break;
+      }
+      case "INSERT_COLS": {
+        t.diffAfter && s._applyDiff(t.diffAfter, !1);
+        const { cols: i } = W({ matrix: t.idMatrix });
+        s.idMatrix.map((r, o) => {
+          r.splice(t.x, 0, ...t.idMatrix[o]);
+        }), s.area.right += i;
+        break;
+      }
+      case "REMOVE_ROWS": {
+        s.removeRows({
+          y: t.ys[0],
+          numRows: t.ys.length,
+          operator: "SYSTEM",
+          undoReflection: t.undoReflection,
+          redoReflection: t.redoReflection
+        });
+        break;
+      }
+      case "REMOVE_COLS": {
+        s.removeCols({
+          x: t.xs[0],
+          numCols: t.xs.length,
+          operator: "SYSTEM",
+          undoReflection: t.undoReflection,
+          redoReflection: t.redoReflection
+        });
+        break;
+      }
+      case "MOVE": {
+        e && this._moveCells(e, s, t.moveRelations, !1);
+        break;
+      }
+      case "SORT_ROWS": {
+        const i = s.idMatrix.flat();
+        s._sortRowMapping(t.sortedRowMapping, !1);
+        const r = new L(s);
+        r.buildMap(i, s.idMatrix.flat()), r.resolveDependents(), s._reapplyFilters();
+        break;
+      }
+    }
+    return this.refresh(dt(t.operation), !0), s !== this && (s.addressCaches.clear(), s.setTotalSize()), t.operation === "MOVE" && e && e !== s && this._xsheetDispatch(e), {
+      history: t,
+      callback: ({ sheetReactive: i }) => {
+        var r, o;
+        (o = i.current) == null || o.registry.transmit((r = t.redoReflection) == null ? void 0 : r.transmit);
+      }
+    };
+  }
+  /** @internal */
+  getFunctionByName(t) {
+    return this.registry.functions[t];
+  }
+  /** @internal */
+  clearDependencies(t) {
+    var s;
+    const e = this.registry.systems[t];
+    (s = e == null ? void 0 : e.dependencies) == null || s.forEach((i) => {
+      var r, o;
+      (o = (r = this.registry.systems[i]) == null ? void 0 : r.dependents) == null || o.delete(t);
+    }), e != null && (e.dependencies = /* @__PURE__ */ new Set());
+  }
+  /** @internal */
+  addDependency(t, e) {
+    const s = k(this.registry, t);
+    s.dependents == null && (s.dependents = /* @__PURE__ */ new Set()), s.dependents.add(e);
+    const i = k(this.registry, e);
+    i.dependencies == null && (i.dependencies = /* @__PURE__ */ new Set()), i.dependencies.add(t);
+  }
+  /** @internal */
+  getSolvedCache(t) {
+    const e = this.getId(t);
+    return [this.registry.solvedCaches.has(e), this.registry.solvedCaches.get(e)];
+  }
+  /** @internal */
+  setSolvingCache(t) {
+    const e = this.getId(t);
+    this.registry.solvedCaches.set(e, at), k(this.registry, e, { tmpAsyncCaches: {} });
+  }
+  /** @internal */
+  finishSolvedCache(t, e) {
+    if (at.is(e))
+      return;
+    const s = this.getId(t);
+    this.registry.solvedCaches.set(s, e);
+    const i = this.registry.data[s];
+    if (i == null)
+      return;
+    const r = this.registry.systems[s], o = r == null ? void 0 : r.tmpAsyncCaches;
+    o != null && (Object.keys(o).length > 0 ? i.asyncCaches = o : delete i.asyncCaches, delete r.tmpAsyncCaches);
+  }
+  /** @internal */
+  clearSolvedCaches() {
+    this.registry.solvedCaches.clear();
+    for (const t of this.registry.lastSpilledTargetIds) {
+      const e = this.registry.systems[t];
+      (e == null ? void 0 : e.spilledFrom) != null && delete e.spilledFrom;
+    }
+    this.registry.lastSpilledTargetIds.clear();
+  }
+  /**
+   * Spill a 2D matrix of values starting from the origin cell.
+   * The origin cell receives matrix[0][0] and adjacent cells receive spill values in solvedCaches.
+   * For a 1×1 matrix, no spill occurs — the single value is cached directly.
+   * Throws FormulaError('#REF!') if the spill range is obstructed.
+   *
+   * @param origin  The anchor cell that produced the spill.
+   * @param matrix  The 2D array of resolved scalar values.
+   * @returns The top-left value (matrix[0][0]).
+   * @internal
+   */
+  spill(t, e) {
+    var l;
+    const s = e.length, i = s > 0 ? e[0].length : 0;
+    if (s <= 1 && i <= 1)
+      return (l = e[0]) == null ? void 0 : l[0];
+    for (let a = 0; a < s; a++)
+      for (let h = 0; h < i; h++) {
+        if (a === 0 && h === 0)
+          continue;
+        const u = { y: t.y + a, x: t.x + h }, n = this.getId(u), f = _(u);
+        if (n == null) {
+          console.warn(`Spill target ${f} is out of bounds.`);
+          continue;
+        }
+        const d = this.registry.data[n];
+        if ((d == null ? void 0 : d.value) != null && d.value !== "")
+          throw new z(
+            "#REF!",
+            `Array result was not expanded because it would overwrite data in ${f}.`
+          );
+        if (this.registry.solvedCaches.has(n))
+          throw new z(
+            "#REF!",
+            `Array result was not expanded because ${f} is already occupied by another formula.`
+          );
+      }
+    const r = this.getId(t), o = [];
+    for (let a = 0; a < s; a++)
+      for (let h = 0; h < i; h++) {
+        const u = { y: t.y + a, x: t.x + h }, n = this.getId(u);
+        if (n != null && (this.finishSolvedCache(u, e[a][h]), (a !== 0 || h !== 0) && (o.push(_(u)), r != null && this.registry.data[n] != null))) {
+          const d = k(this.registry, n, {});
+          d.spilledFrom = _(t), this.registry.lastSpilledTargetIds.add(n);
+        }
+      }
+    return e[0][0];
+  }
+  /** @internal */
+  sheetPrefix(t = !1) {
+    return t ? "" : vt(this.name);
+  }
+  /** @internal */
+  rangeToArea(t) {
+    const e = t.split(":");
+    let [s, i] = e;
+    s.match(/[a-zA-Z]$/) && (s += "1"), s.match(/^[1-9]/) && (s = `A${s}`), i != null && i.match(/[a-zA-Z]$/) && (i += this.bottom), i != null && i.match(/^[1-9]/) && (i = `${Z(this.right)}${i}`);
+    const { y: r, x: o } = A(s), { y: l, x: a } = A(i || s);
+    return {
+      top: Math.abs(r),
+      left: Math.abs(o),
+      bottom: Math.abs(l),
+      right: Math.abs(a)
+    };
+  }
+  get __raw__() {
+    return this;
+  }
+  get shape() {
+    return Rt(this.area);
+  }
+  get hasSingleCell() {
+    const t = this.shape;
+    return t.rows === 1 && t.cols === 1;
+  }
+  get currentVersion() {
+    return this.version;
+  }
+}
+export {
+  V as Sheet
+};
+//# sourceMappingURL=sheet.js.map