@gridsheet/engine 3.3.0

package/dist/index.js

@@ -0,0 +1,4888 @@
+import H from "dayjs";
+import ds from "dayjs/plugin/utc.js";
+import fs from "dayjs/plugin/timezone.js";
+const ps = 20, J = 24, jt = 90, Dr = 500, vr = 1e3, Re = 24, _e = 50, kr = 5, Pr = 5, $r = 5, Lr = 10, $e = 1e3, Zt = 86400, ms = "YYYY-MM-DDTHH:mm:ss.SSSZ", gs = {
+  startY: -1,
+  startX: -1,
+  endY: -1,
+  endX: -1
+}, ys = new Date(1900, 0, 1), Ft = "default", Dt = "defaultCol", vt = "defaultRow", qt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ", gt = /* @__PURE__ */ new Map(), yt = /* @__PURE__ */ new Map(), ws = (r, t = $e) => {
+  const e = gt.get(--r);
+  if (e != null)
+    return e;
+  if (r === 0)
+    return "";
+  let s = r, i = "";
+  do
+    i = qt[--s % 26] + i, s = Math.floor(s / 26);
+  while (s > 0);
+  gt.set(r, i);
+  const n = gt.keys();
+  for (let o = n.next(); gt.size > t; o = n.next())
+    gt.delete(o.value);
+  return i;
+}, xs = (r, t = $e) => {
+  const e = yt.get(r);
+  if (e != null)
+    return e;
+  if (r === "")
+    return 0;
+  const s = r;
+  let i = 0;
+  for (let o = 0; o < s.length; o++) {
+    const a = s[s.length - o - 1], l = qt.indexOf(a) + 1;
+    i += qt.length ** o * l;
+  }
+  yt.set(r, i);
+  const n = yt.keys();
+  for (let o = n.next(); yt.size > t; o = n.next())
+    yt.delete(o.value);
+  return i;
+}, W = (r) => {
+  if (r === 0)
+    return "";
+  const t = ws(r + 1);
+  return r < 0 ? `$${t}` : t;
+}, _t = (r, t = !1) => {
+  const e = xs(r.toUpperCase());
+  return t ? -e : e;
+}, Et = (r) => r === 0 ? "" : r < 0 ? `$${r}` : String(r), bs = (r, t = !1) => (typeof r == "string" && (r = parseInt(r, 10)), t ? -r : r), D = ({ y: r, x: t, absX: e, absY: s }) => {
+  if (t === -1 && r === -1)
+    return "?";
+  const i = t === void 0 ? "" : t === 0 ? "0" : `${e ? "$" : ""}${W(t)}`, n = r === void 0 ? "" : r === 0 ? "0" : `${s ? "$" : ""}${Et(r)}`;
+  return `${i}${n}`;
+}, N = (r) => {
+  const t = r.match(/(\$)?([a-zA-Z]*)(\$)?([0-9]*)/);
+  if (t == null)
+    return { y: -1, x: -1 };
+  const [, e, s, i, n] = t.slice(), [o, a] = [e != null, i != null];
+  return s === "" && n === "" ? { y: -1, x: -1, absX: !1, absY: !1 } : { y: bs(n) || 0, x: _t(s) || 0, absX: o, absY: a };
+}, Le = (r, t, e) => {
+  const s = r.match(/([A-Z]*)([0-9]*)/);
+  if (s == null)
+    return r;
+  const [, i, n] = s.slice();
+  return `${t ? "$" : ""}${i.toUpperCase()}${e ? "$" : ""}${n}`;
+}, Hr = (r) => `0${r}`, Yr = (r) => typeof r == "number" ? `${W(r)}0` : `${r.toUpperCase()}0`, Br = (r) => r.replace(/\$/g, ""), He = (r, t = !1, e = !1) => `${t ? "$" : ""}#${r}${e ? "$" : ""}`, Ur = (r, t) => {
+  const { rows: e, cols: s } = Ae(r), { rows: i, cols: n } = Ae(t);
+  return {
+    rows: e > i ? e : i,
+    cols: s > n ? s : n
+  };
+}, Ss = (r, t) => {
+  const e = { ...r };
+  return t.left < r.left && (e.left = t.left), t.right > r.right && (e.right = t.right), t.top < r.top && (e.top = t.top), t.bottom > r.bottom && (e.bottom = t.bottom), e;
+}, Rs = (r) => {
+  if (r.endY === -1 || r.endX === -1)
+    return { top: -1, left: -1, bottom: -1, right: -1 };
+  const [t, e] = r.startY < r.endY ? [r.startY, r.endY] : [r.endY, r.startY], [s, i] = r.startX < r.endX ? [r.startX, r.endX] : [r.endX, r.startX];
+  return { top: t, left: s, bottom: e, right: i };
+}, Ee = (r) => ({
+  startY: r.top,
+  startX: r.left,
+  endY: r.bottom,
+  endX: r.right
+}), zr = (r) => {
+  const { top: t, left: e, bottom: s, right: i } = r;
+  if (t === s && e === i)
+    return D({ y: t, x: e });
+  const n = D({ y: t, x: e }), o = D({ y: s, x: i });
+  return `${n}:${o}`;
+}, Vr = (r, t) => r.start === -1 || r.end === -1 ? !1 : r.start <= t && t <= r.end || r.end <= t && t <= r.start, Wr = (r, t) => {
+  if (r.top === -1 || r.left === -1 || r.bottom === -1 || r.right === -1)
+    return !1;
+  const { y: e, x: s } = t, { top: i, left: n, bottom: o, right: a } = r;
+  return i <= e && e <= o && n <= s && s <= a;
+}, _s = (r) => r.endY === -1 || r.endX === -1 ? { rows: 0, cols: 0 } : {
+  rows: Math.abs(r.startY - r.endY),
+  cols: Math.abs(r.startX - r.endX)
+}, Xr = (r) => r.endY === -1 || r.endX === -1 ? { rows: 1, cols: 1 } : {
+  rows: 1 + Math.abs(r.startY - r.endY),
+  cols: 1 + Math.abs(r.startX - r.endX)
+}, Ae = (r) => ({
+  rows: Math.abs(r.top - r.bottom),
+  cols: Math.abs(r.left - r.right)
+}), Kt = (r) => ({
+  rows: 1 + Math.abs(r.top - r.bottom),
+  cols: 1 + Math.abs(r.left - r.right)
+}), Nt = ({ base: r = 0, matrix: t }) => {
+  const e = t.length;
+  return e === 0 ? { rows: 0, cols: 0 } : { rows: r + e, cols: r + t[0].length };
+}, jr = (r, t, e = 1) => Array.from({ length: (t - r - 1) / e + 1 }, (s, i) => r + i * e), Gr = (r, t) => {
+  const e = [];
+  return r.forEach((s) => {
+    const i = [];
+    t.forEach((n) => {
+      i.push(s[n]);
+    }), e.push(i);
+  }), e;
+}, Zr = (r, t) => {
+  const e = [];
+  return r.forEach((s) => {
+    const i = {};
+    s.forEach((n, o) => {
+      if (o >= t.length)
+        return;
+      const a = t[o];
+      i[a] = n;
+    }), e.push(i);
+  }), e;
+}, se = (r, t, e) => [...Array(r)].map(() => Array(t).fill(e)), qr = ({
+  cells: r = {},
+  ensured: t = {},
+  matrix: e = [],
+  flattenAs: s = "value",
+  origin: i = "A1"
+}) => Es({
+  cells: r,
+  ensured: t,
+  matrices: { [i]: e },
+  flattenAs: s
+}), Es = ({
+  cells: r = {},
+  ensured: t = {},
+  matrices: e = {},
+  flattenAs: s = "value"
+} = {}) => {
+  const i = Object.keys(r), a = Object.values(e).reduce((c, f) => {
+    var d;
+    return c + f.length * (((d = f[0]) == null ? void 0 : d.length) ?? 0);
+  }, 0) > 1e5;
+  a ? (Object.defineProperty(r, "__matrices", { value: e, configurable: !0 }), Object.defineProperty(r, "__flattenAs", { value: s, configurable: !0 })) : As({ cells: r, flattenAs: s, matrices: e });
+  const { numRows: l, numCols: u } = Object.assign({ numRows: 1, numCols: 1 }, t), h = D({ y: l, x: u });
+  return r[h] == null && (r[h] = {}), a && (i.push(h), Object.defineProperty(r, "__userKeys", { value: i, configurable: !0 })), r;
+}, As = ({
+  cells: r = {},
+  matrices: t = {},
+  flattenAs: e
+}) => (Object.keys(t).forEach((s) => {
+  const i = t[s], { y: n, x: o } = N(s), a = [];
+  for (let l = 0; l < i.length; l++) {
+    const u = i[l], h = String(n + l);
+    for (let c = 0; c < u.length; c++) {
+      a[c] == null && (a[c] = W(o + c));
+      const f = a[c] + h;
+      if (e) {
+        const d = r[f];
+        d ? e in d || (d[e] = u[c]) : r[f] = { [e]: u[c] };
+      } else
+        r[f] = u[c];
+    }
+  }
+}), r), Cs = (r = {}, t) => {
+  let [e, s] = [0, 0];
+  return (t ?? Object.keys(r)).forEach((i) => {
+    if (i === Ft || i === Dt || i === vt)
+      return;
+    const { y: n, x: o } = N(i);
+    e < n && (e = n), s < o && (s = o);
+  }), { numRows: e, numCols: s };
+}, Kr = (r, t) => {
+  const e = [];
+  for (let s = r; s <= t; s++)
+    e.push(s);
+  return e;
+}, Is = (r, t) => (r.left === -1 && (r = {
+  left: t.x,
+  top: t.y,
+  right: t.x,
+  bottom: t.y
+}), r), Ts = (r) => {
+  if (r.indexOf(":") === -1)
+    return [r];
+  const t = [];
+  if (/^\d+\:\d+$/.test(r)) {
+    const [h, c] = r.split(":").map(Number);
+    for (let f = h; f <= c; f++)
+      t.push(`${f}`);
+    return t;
+  }
+  const s = r.match(/^([A-Z]*)(\d+)?\:([A-Z]*)(\d+)?$/);
+  if (!s)
+    return console.error("Invalid range format", r), [r];
+  const [, i, n, o, a] = s, l = i ? _t(i) : 1, u = o ? _t(o) : 1;
+  for (let h = l; h <= u; h++) {
+    const c = i || o ? W(h) : "";
+    if (n && a)
+      for (let f = Number(n); f <= Number(a); f++)
+        t.push(`${c}${f}`);
+    else !n && !a && t.push(c);
+  }
+  return t;
+}, Jr = (r) => {
+  const t = _s(r);
+  return t.rows + t.cols === 0 ? { startY: -1, startX: -1, endY: -1, endX: -1 } : { ...r };
+}, Qr = (r, t, e, s) => {
+  for (; r <= t; ) {
+    const i = Math.floor((r + t) / 2);
+    e(i) ? s ? t = i - 1 : r = i + 1 : s ? r = i + 1 : t = i - 1;
+  }
+  return s ? r : t;
+}, tn = (r) => {
+  if (r.length === 0)
+    return [];
+  const t = r.map((o) => {
+    const { y: a, x: l } = N(o);
+    return { y: a, x: l };
+  }), e = (o, a) => `${o},${a}`, s = new Set(t.map((o) => e(o.y, o.x))), i = /* @__PURE__ */ new Set(), n = [];
+  for (const o of t) {
+    const a = e(o.y, o.x);
+    if (i.has(a))
+      continue;
+    let l = o.y, u = o.x, h = o.y, c = o.x;
+    const f = [o];
+    for (i.add(a); f.length > 0; ) {
+      const { y: d, x: p } = f.shift();
+      d < l && (l = d), d > h && (h = d), p < u && (u = p), p > c && (c = p);
+      for (const [m, g] of [
+        [0, 1],
+        [0, -1],
+        [1, 0],
+        [-1, 0]
+      ]) {
+        const y = e(d + m, p + g);
+        s.has(y) && !i.has(y) && (i.add(y), f.push({ y: d + m, x: p + g }));
+      }
+    }
+    n.push({ top: l, left: u, bottom: h, right: c });
+  }
+  return n;
+}, en = (r, t = !0) => {
+  const e = /* @__PURE__ */ new Set(), s = [];
+  for (const i of r) {
+    const { x: n } = N(i);
+    e.has(n) || (e.add(n), s.push(n));
+  }
+  return t === !0 ? s.sort((i, n) => i - n) : t === !1 && s.sort((i, n) => n - i), s;
+}, sn = (r, t = !0) => {
+  const e = /* @__PURE__ */ new Set(), s = [];
+  for (const i of r) {
+    const { y: n } = N(i);
+    e.has(n) || (e.add(n), s.push(n));
+  }
+  return t === !0 ? s.sort((i, n) => i - n) : t === !1 && s.sort((i, n) => n - i), s;
+}, rn = (r) => r.startY === -1 || r.startX === -1 || r.endY === -1 || r.endX === -1, et = 864e5;
+class b {
+  constructor(t, e = "HH:mm:ss") {
+    this.__gsType = "Time", this.days = t, this.format = e;
+  }
+  add(t) {
+    return new Date(t.getTime() + this.days * et);
+  }
+  sub(t) {
+    return new Date(t.getTime() - this.days * et);
+  }
+  stringify(t) {
+    const e = this.toMilliseconds(), s = Math.abs(e), i = e < 0 ? "-" : "", n = s % 1e3;
+    let o = Math.floor(s / 1e3);
+    const a = o % 60;
+    o = Math.floor(o / 60);
+    const l = o % 60, u = Math.floor(o / 60);
+    let c = t ?? (n === 0 ? "HH:mm:ss" : "HH:mm:ss.SSS");
+    return c = c.replace("HH", i + String(u).padStart(2, "0")), c = c.replace("H", i + String(u)), c = c.replace("mm", String(l).padStart(2, "0")), c = c.replace("ss", String(a).padStart(2, "0")), c = c.replace("SSS", String(n).padStart(3, "0")), c = c.replace("SS", String(n).padStart(3, "0").substring(0, 2)), c = c.replace("S", String(n).padStart(3, "0").substring(0, 1)), c;
+  }
+  toMilliseconds() {
+    return this.days * et;
+  }
+  toDate() {
+    return new Date(ys.getTime() + this.days * et);
+  }
+  toJSON() {
+    return { __gsType: "Time", days: this.days, format: this.format };
+  }
+  toString() {
+    return this.stringify();
+  }
+  static create(t = 0, e = 0, s = 0, i = 0) {
+    const n = t * 36e5 + e * 6e4 + s * 1e3 + i;
+    return new b(n / et);
+  }
+  static fromDate(t) {
+    const e = t.getHours() * 36e5 + t.getMinutes() * 6e4 + t.getSeconds() * 1e3 + t.getMilliseconds();
+    return new b(e / et);
+  }
+  static fromDates(t, e) {
+    return new b((t.getTime() - e.getTime()) / et);
+  }
+  static fromObject(t) {
+    return new b(t.days, t.format);
+  }
+  static is(t) {
+    return t instanceof b || (t == null ? void 0 : t.__gsType) === "Time";
+  }
+  static ensure(t) {
+    return t instanceof b ? t : (t == null ? void 0 : t.__gsType) === "Time" ? b.fromObject(t) : b.create();
+  }
+  static parse(t, e, s = !1) {
+    if (e != null) {
+      const i = Ms(e), n = t.match(i);
+      if (n != null && n.groups)
+        return b.create(
+          Number(n.groups.HH || n.groups.H || 0),
+          Number(n.groups.mm || n.groups.m || 0),
+          Number(n.groups.ss || n.groups.s || 0),
+          Number(n.groups.SSS || n.groups.SS || n.groups.S || 0)
+        );
+    }
+    if (!s) {
+      {
+        const i = t.match(/^([+-]?)(\d+):(\d{2})$/);
+        if (i) {
+          const [, n, o, a] = i, l = n === "-" ? -1 : 1;
+          return b.create(l * Number(o), l * Number(a));
+        }
+      }
+      {
+        const i = t.match(/^([+-]?)(\d+):(\d{2}):(\d{2})$/);
+        if (i) {
+          const [, n, o, a, l] = i, u = n === "-" ? -1 : 1;
+          return b.create(u * Number(o), u * Number(a), u * Number(l));
+        }
+      }
+      {
+        const i = t.match(/^([+-]?)(\d+):(\d{2}):(\d{2})\.(\d+)$/);
+        if (i) {
+          const [, n, o, a, l, u] = i, h = n === "-" ? -1 : 1;
+          return b.create(h * Number(o), h * Number(a), h * Number(l), h * Number(u));
+        }
+      }
+    }
+  }
+}
+const Ce = {
+  HH: { group: "HH", pattern: "(?<HH>\\d+)" },
+  H: { group: "H", pattern: "(?<HH>\\d+)" },
+  mm: { group: "mm", pattern: "(?<mm>[0-5]\\d)" },
+  m: { group: "m", pattern: "(?<m>\\d|[1-5]\\d)" },
+  ss: { group: "ss", pattern: "(?<ss>[0-5]\\d)" },
+  s: { group: "s", pattern: "(?<s>\\d|[1-5]\\d)" },
+  SSS: { group: "SSS", pattern: "(?<SSS>\\d{3})" },
+  SS: { group: "SS", pattern: "(?<SS>\\d{2})" },
+  S: { group: "S", pattern: "(?<S>\\d)" }
+};
+function Ms(r) {
+  const t = Object.keys(Ce).sort((n, o) => o.length - n.length), e = new RegExp(t.join("|"), "g"), i = r.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&").replace(e, (n) => {
+    var o;
+    return ((o = Ce[n]) == null ? void 0 : o.pattern) ?? n;
+  });
+  return new RegExp(`^${i}$`);
+}
+class x {
+  constructor(t, e, s) {
+    this.__gsType = "FormulaError", this.code = t, this.message = e, this.error = s;
+  }
+  static is(t) {
+    return t instanceof x || (t == null ? void 0 : t.__gsType) === "FormulaError";
+  }
+  toString() {
+    return this.code;
+  }
+}
+class ut {
+  constructor(t) {
+    this.code = t, this.__gsType = "Sentinel";
+  }
+  is(t) {
+    return ut.is(t, this.code);
+  }
+  static is(t, e) {
+    return t instanceof ut || (t == null ? void 0 : t.__gsType) === "Sentinel" ? e == null || t.code === e : !1;
+  }
+}
+const At = new ut("solving"), wt = new ut("none");
+class k {
+  constructor(t) {
+    this.__gsType = "Pending", this.promise = t, this.timestamp = Date.now();
+  }
+  static is(t) {
+    return t instanceof k || (t == null ? void 0 : t.__gsType) === "Pending";
+  }
+  toString() {
+    return `<Pending #${this.timestamp}>`;
+  }
+}
+class B {
+  constructor(t) {
+    this.__gsType = "Spilling", this.matrix = this.ensure2D(t);
+  }
+  ensure2D(t) {
+    return t.length === 0 ? [] : Array.isArray(t[0]) ? t : [t];
+  }
+  static is(t) {
+    return t instanceof B || (t == null ? void 0 : t.__gsType) === "Spilling";
+  }
+}
+const Pt = (r, t = !0) => {
+  let e = r;
+  return t && e.startsWith("$") && (e = e.slice(1)), t && e.endsWith("$") && (e = e.slice(0, -1)), e.replace("#", "");
+};
+class rt {
+  constructor(t) {
+    this.ids = [], this.value = t;
+  }
+}
+class ie extends rt {
+  evaluate() {
+    return this.value;
+  }
+}
+class Os extends rt {
+  evaluate() {
+    throw new x("#REF!", "Reference does not exist.");
+  }
+}
+class Ns extends rt {
+  evaluate() {
+    throw new x("#NAME?", `Invalid ref: ${this.value}`);
+  }
+}
+class Ye extends rt {
+  constructor(t) {
+    super(t);
+  }
+  stringify() {
+    return this.value.toUpperCase();
+  }
+  evaluate({ sheet: t }) {
+    const e = dt(this.value, { sheet: t, dependency: "" });
+    if (e.sheet == null)
+      throw new x("#REF!", `Unknown sheet: ${e.sheetName}`);
+    if (e.addresses.length === 0)
+      throw new x("#REF!", `Invalid address: ${this.value}`);
+    const { y: s, x: i } = N(e.addresses[0]);
+    return e.sheet.trim({ top: s, left: i, bottom: s, right: i });
+  }
+  identify(t) {
+    const { slideY: e = 0, slideX: s = 0 } = t, i = dt(this.value, t);
+    if (i.sheet == null)
+      return this.value;
+    const n = i.addresses[0], { y: o, x: a, absX: l, absY: u } = N(n), h = {
+      y: o + e,
+      x: a + s,
+      absX: l,
+      absY: u
+    }, c = i.sheet.getId(h);
+    return c == null ? this.value : (this.ids = [c], `#${i.sheet.id}!${He(c, l, u)}`);
+  }
+}
+class Be extends rt {
+  stringify() {
+    return this.value.toUpperCase();
+  }
+  evaluate({ sheet: t }) {
+    const e = dt(this.value, { sheet: t, dependency: "" });
+    if (e.sheet == null)
+      throw new x("#REF!", `Unknown sheet: ${e.sheetName}`);
+    if (e.addresses.length === 0)
+      throw new x("#REF!", `Invalid address: ${this.value}`);
+    const s = e.sheet.rangeToArea(e.addresses.join(":"));
+    return e.sheet.trim(s);
+  }
+  identify(t) {
+    const { slideY: e = 0, slideX: s = 0 } = t, i = dt(this.value, t);
+    if (i.sheet == null)
+      return this.value;
+    const n = [];
+    for (let o = 0; o < i.addresses.length; o++) {
+      const a = i.addresses[o], { y: l, x: u, absX: h, absY: c } = N(a), f = {
+        y: l + e,
+        x: u + s,
+        absX: h,
+        absY: c
+      }, d = i.sheet.getId(f);
+      if (d == null)
+        return this.value;
+      this.ids.push(d), n.push(He(d, h, c));
+    }
+    return `#${i.sheet.id}!${n.join(":")}`;
+  }
+}
+class Jt extends rt {
+  parse(t) {
+    if (this.value.indexOf("!") !== -1) {
+      const [e, s] = this.value.split("!"), i = Number(e.slice(1));
+      return { sheet: t.getSheetBySheetId(i), id: Pt(s, !1) };
+    }
+    return { sheet: t, id: Pt(this.value, !1) };
+  }
+  evaluate({ sheet: t }) {
+    const e = this.parse(t);
+    if (e.id === "?")
+      throw new x("#REF!", "Reference does not exist");
+    const { y: s, x: i } = e.sheet.getPointById(e.id), [n, o] = [Math.abs(s), Math.abs(i)];
+    return e.sheet.trim({
+      top: n,
+      left: o,
+      bottom: n,
+      right: o
+    });
+  }
+  display({ sheet: t, slideY: e = 0, slideX: s = 0 }) {
+    const i = this.parse(t), n = i.sheet.getAddressById(i.id, e, s);
+    return n ? i.sheet.id === t.id ? n : `${i.sheet.sheetPrefix()}${n}` : "#REF!";
+  }
+  identify(t) {
+    const { sheet: e, slideY: s = 0, slideX: i = 0 } = t, n = this.display({ sheet: e, slideY: s, slideX: i });
+    if (n == null || n.length < 2)
+      return "#?";
+    const { formula: o, ids: a } = dt(n, t);
+    return this.ids = a, o || "#?";
+  }
+}
+class Qt extends rt {
+  parse(t) {
+    const e = this.value;
+    if (e.indexOf("!") !== -1) {
+      const [s, i] = e.split("!"), n = Number(s.slice(1));
+      return { sheet: t.getSheetBySheetId(n), ids: i.split(":") };
+    }
+    return { sheet: t, ids: e.split(":") };
+  }
+  evaluate({ sheet: t }) {
+    const e = this.parse(t), s = e.ids.map((c) => Pt(c)), i = [];
+    for (let c = 0; c < s.length; c++) {
+      const f = s[c];
+      if (f === "?")
+        throw new x("#REF!", "Reference does not exist");
+      const d = e.sheet.getPointById(f);
+      i.push(d);
+    }
+    const [n, o] = i, [a, l, u, h] = [n.y, n.x, o.y || e.sheet.numRows, o.x || e.sheet.numCols];
+    return e.sheet.trim({ top: a, left: l, bottom: u, right: h });
+  }
+  display({ sheet: t, slideY: e = 0, slideX: s = 0 }) {
+    const i = this.parse(t), n = i.ids.map((o) => Pt(o, !1)).map((o) => i.sheet.getAddressById(o, e, s) || "#REF!").join(":");
+    return i.sheet.id === t.id ? n : `${i.sheet.sheetPrefix()}${n}`;
+  }
+  identify(t) {
+    const { sheet: e, slideY: s = 0, slideX: i = 0 } = t, n = this.display({ sheet: e, slideY: s, slideX: i }), { formula: o, ids: a } = dt(n, t);
+    return this.ids = a, o ?? "";
+  }
+}
+class kt {
+  constructor(t, e = 0, s = [], i) {
+    this.name = t, this.precedence = e, this.args = s, this.at = i;
+  }
+  evaluate({ sheet: t }) {
+    const e = this.name.toLowerCase(), s = t.getFunctionByName(e);
+    if (s == null)
+      throw new x("#NAME?", `Unknown function: ${e}`);
+    return new s({ args: this.args, sheet: t, at: this.at }).call();
+  }
+}
+const Fs = new ie(0), Ds = {
+  "+": "add",
+  "-": "minus",
+  "/": "divide",
+  "*": "multiply",
+  "^": "power",
+  "&": "concat",
+  "=": "eq",
+  "<>": "ne",
+  ">": "gt",
+  ">=": "gte",
+  "<": "lt",
+  "<=": "lte"
+}, vs = {
+  "-": "uminus"
+}, Ue = /* @__PURE__ */ new Set([" ", `
+`, "\r", "	", "\f"]), ks = /* @__PURE__ */ new Set([...Ue, "+", "-", "/", "*", "^", "&", "=", "<", ">", ")", ",", "%"]);
+class I {
+  constructor(t, e, s = 0, i, n = !0) {
+    this.type = t, this.entity = e, this.precedence = s, this.at = i, this.closed = n;
+  }
+  length() {
+    return this.type === "VALUE" && typeof this.entity == "string" ? this.entity.length + (this.closed ? 2 : 1) : new String(this.entity).length;
+  }
+  stringify() {
+    if (this.type === "VALUE") {
+      if (typeof this.entity == "string")
+        return this.closed ? `"${this.entity}"` : `"${this.entity}`;
+      if (typeof this.entity == "boolean")
+        return this.entity ? "TRUE" : "FALSE";
+      if (this.raw != null)
+        return this.raw;
+    }
+    return this.entity;
+  }
+  convert() {
+    switch (this.type) {
+      case "VALUE":
+        return new ie(this.entity);
+      case "ID":
+        return new Jt(this.entity);
+      case "ID_RANGE":
+        return new Qt(this.entity);
+      case "REF":
+        return new Ye(this.entity);
+      case "RANGE":
+        return new Be(this.entity);
+      case "INFIX_OPERATOR": {
+        const t = Ds[this.entity];
+        return new kt(t, this.precedence, void 0, this.at);
+      }
+      case "PREFIX_OPERATOR": {
+        const t = vs[this.entity];
+        return new kt(t, this.precedence, void 0, this.at);
+      }
+      case "FUNCTION":
+        return new kt(this.entity, 0, [], this.at);
+      case "UNREFERENCED":
+        return new Os(this.entity);
+      case "INVALID_REF":
+        return new Ns(this.entity);
+    }
+  }
+}
+const Ps = (r) => Ue.has(r), $s = { true: !0, false: !1 }, Ie = new I("OPEN", "("), Ls = new I("CLOSE", ")"), Hs = new I("COMMA", ","), L = "INFIX_OPERATOR", Ys = "PREFIX_OPERATOR", Bs = "POSTFIX_OPERATOR";
+class $t {
+  constructor(t, e) {
+    this.tokens = [], this.foreign = !1, this.identifiedFormula = "", this.dependencyIds = [], this.formula = t, this.index = 0, this.tokens = [], this.at = e == null ? void 0 : e.at;
+  }
+  isWhiteSpace() {
+    return Ps(this.formula[this.index]);
+  }
+  next(t = 1) {
+    this.index += t;
+  }
+  get(t = 0) {
+    return this.formula[this.index + t];
+  }
+  getToken(t = 0) {
+    return this.tokens[this.tokens.length + t];
+  }
+  getTokenIndexByCharPosition(t) {
+    let e = 0, s = 0;
+    for (let i = 0; i < this.tokens.length; i++) {
+      const n = this.tokens[i];
+      if (s = e + n.length(), e <= t && t <= s)
+        return [i, t === e || t === s];
+      e = s;
+    }
+    return [-1, !1];
+  }
+  getTokenPositionRange(t, e = 1) {
+    let s = 0, i = 0;
+    for (let n = 0; n < t; n++)
+      s = i, i += this.tokens[n].length();
+    return [s + e, i + e];
+  }
+  stringify() {
+    return this.tokens.map((t) => t.stringify()).join("");
+  }
+  identify(t) {
+    const e = [], s = [];
+    for (const i of this.tokens)
+      switch (i.type) {
+        case "VALUE":
+          typeof i.entity == "number" || typeof i.entity == "boolean" ? e.push(String(i.entity)) : e.push(i.closed ? `"${i.entity}"` : `"${i.entity}`);
+          break;
+        case "ID": {
+          const n = new Jt(i.entity);
+          e.push(n.identify(t)), s.push(...n.ids);
+          break;
+        }
+        case "ID_RANGE": {
+          const n = new Qt(i.entity);
+          e.push(n.identify(t)), s.push(...n.ids);
+          break;
+        }
+        case "REF": {
+          const n = new Ye(i.entity);
+          e.push(n.identify(t)), s.push(...n.ids);
+          break;
+        }
+        case "RANGE": {
+          const n = new Be(i.entity);
+          e.push(n.identify(t)), s.push(...n.ids);
+          break;
+        }
+        default:
+          e.push(i.entity);
+          break;
+      }
+    this.identifiedFormula = e.join(""), this.dependencyIds = s;
+  }
+  display({ sheet: t }) {
+    return this.tokens.map((e) => {
+      switch (e.type) {
+        case "VALUE":
+          return typeof e.entity == "number" || typeof e.entity == "boolean" ? e.raw ?? e.entity : e.closed ? `"${e.entity}"` : `"${e.entity}`;
+        case "ID":
+          return new Jt(e.entity).display({ sheet: t });
+        case "ID_RANGE":
+          return new Qt(e.entity).display({ sheet: t });
+      }
+      return e.entity;
+    }).join("");
+  }
+  tokenize(t = {}) {
+    var e, s;
+    for (; this.index <= this.formula.length; ) {
+      this.skipSpaces();
+      let i = this.get();
+      switch (this.next(), i) {
+        case void 0:
+          return;
+        case "(":
+          this.tokens.push(Ie);
+          continue;
+        case ")":
+          this.tokens.push(Ls);
+          continue;
+        case ",":
+          this.tokens.push(Hs);
+          continue;
+        case "+":
+          this.tokens.push(new I(L, "+", 3, this.at));
+          continue;
+        case "-": {
+          const o = (e = this.getToken(-1)) == null ? void 0 : e.type, a = (s = this.getToken(-2)) == null ? void 0 : s.type;
+          o === L || o === "SPACE" && a === L ? this.tokens.push(new I(Ys, "-", 6, this.at)) : this.tokens.push(new I(L, "-", 3, this.at));
+          continue;
+        }
+        case "/":
+          this.tokens.push(new I(L, "/", 4, this.at));
+          continue;
+        case "*":
+          this.tokens.push(new I(L, "*", 4, this.at));
+          continue;
+        case "^":
+          this.tokens.push(new I(L, "^", 5, this.at));
+          continue;
+        case "&":
+          this.tokens.push(new I(L, "&", 4, this.at));
+          continue;
+        case "=":
+          this.tokens.push(new I(L, "=", 1, this.at));
+          continue;
+        case ">":
+          if (this.get() === "=") {
+            this.next(), this.tokens.push(new I(L, ">=", 2, this.at));
+            continue;
+          }
+          this.tokens.push(new I(L, ">", 2, this.at));
+          continue;
+        case "<":
+          if (this.get() === "=") {
+            this.next(), this.tokens.push(new I(L, "<=", 2, this.at));
+            continue;
+          }
+          if (this.get() === ">") {
+            this.next(), this.tokens.push(new I(L, "<>", 1, this.at));
+            continue;
+          }
+          this.tokens.push(new I(L, "<", 2, this.at));
+          continue;
+        case '"': {
+          const { buf: o, closed: a } = this.getString('"');
+          this.tokens.push(new I("VALUE", o, 0, this.at, a));
+          continue;
+        }
+        case "'": {
+          const { buf: o } = this.getString("'");
+          i = `'${o}'`;
+          break;
+        }
+        case "!": {
+          this.foreign = !0;
+          break;
+        }
+        case "%": {
+          this.tokens.push(new I(Bs, "%", 4, this.at));
+          continue;
+        }
+      }
+      let n = i;
+      for (; ; ) {
+        const o = this.get();
+        if (o === "(") {
+          this.tokens.push(new I("FUNCTION", n, 0, this.at), Ie), this.next();
+          break;
+        }
+        if (o == null || ks.has(o)) {
+          if (n.length === 0)
+            break;
+          if (n.match(/^[+-]?(\d*[.])?\d+$/)) {
+            const a = new I("VALUE", parseFloat(n), 0, this.at);
+            a.raw = n, this.tokens.push(a);
+          } else {
+            const a = $s[n.toLowerCase()];
+            a != null ? this.tokens.push(new I("VALUE", a, 0, this.at)) : n.startsWith("#") ? n.indexOf("#REF!") !== -1 ? this.tokens.push(new I("UNREFERENCED", n, 0, this.at)) : n.indexOf(":") !== -1 ? this.tokens.push(new I("ID_RANGE", Us(n, t), 0, this.at)) : this.tokens.push(new I("ID", n, 0, this.at)) : n.indexOf(":") !== -1 ? this.tokens.push(new I("RANGE", n, 0, this.at)) : !n.startsWith("'") && n.indexOf("!") === -1 && n.includes(".") && /[a-zA-Z]/.test(n) || isNaN(n[n.length - 1]) ? this.tokens.push(new I("INVALID_REF", n, 0, this.at)) : this.tokens.push(new I("REF", n, 0, this.at));
+          }
+          break;
+        }
+        n += o, this.next();
+      }
+    }
+  }
+  skipSpaces() {
+    let t = "";
+    for (; this.isWhiteSpace(); )
+      t += this.formula[this.index++];
+    t !== "" && this.tokens.push(new I("SPACE", t, 0, this.at));
+  }
+  getString(t = '"') {
+    let e = "";
+    for (; ; ) {
+      const s = this.get();
+      if (this.next(), s == null)
+        return { buf: e, closed: !1 };
+      if (s === t)
+        if (t === '"' && this.get() === t) {
+          e += t, this.next();
+          continue;
+        } else if (t === "'" && this.get() === t) {
+          e += s;
+          continue;
+        } else
+          return { buf: e, closed: !0 };
+      else
+        e += s;
+    }
+  }
+}
+const Us = (r, t) => {
+  const [e, s] = r.split("!"), i = s.split(":"), n = /* @__PURE__ */ new Set();
+  return Object.keys(t).forEach((o) => {
+    const a = t[o], l = new RegExp(`(\\$)?#${o}\\b(\\$)?`);
+    for (let u = 0; u < i.length; u++) {
+      if (n.has(u))
+        continue;
+      const h = i[u], c = h.replace(l, (f, d, p) => `${d || ""}#${a}${p || ""}`);
+      c !== h && (i[u] = c, n.add(u));
+    }
+  }), `${e}!${i.join(":")}`;
+};
+class ze {
+  constructor(t) {
+    this.index = 0, this.depth = 0, this.tokens = t;
+  }
+  build() {
+    const { expr: t } = this.parse(!1);
+    return t;
+  }
+  parse(t) {
+    const e = [];
+    let s;
+    const i = (n = !1) => {
+      if (s) {
+        const o = e.pop();
+        s.args.push(o);
+      }
+      return { hasNext: n, expr: e.shift() };
+    };
+    for (; this.tokens.length > this.index; ) {
+      const n = this.tokens[this.index++];
+      if (n.type !== "SPACE") {
+        if (n.type === "COMMA") {
+          if (!t)
+            throw new x("#ERROR!", "Invalid comma");
+          return i(!0);
+        } else if (n.type === "VALUE" || n.type === "ID" || n.type === "ID_RANGE" || n.type === "REF" || n.type === "RANGE" || n.type === "UNREFERENCED" || n.type === "INVALID_REF") {
+          const o = n.convert();
+          e.push(o);
+        } else if (n.type === "POSTFIX_OPERATOR" && n.entity === "%") {
+          const o = e.pop();
+          if (!o)
+            throw new x("#ERROR!", "Missing expression before %");
+          const a = new kt("divide", 4, [o, new ie(100)]);
+          e.push(a);
+        } else if (n.type === "FUNCTION") {
+          this.index++, this.depth++;
+          const o = n.convert();
+          for (e.push(o); ; ) {
+            const { expr: a, hasNext: l } = this.parse(!0);
+            if (a && o.args.push(a), !l)
+              break;
+          }
+        } else if (n.type === "OPEN") {
+          this.depth++;
+          const { expr: o } = this.parse(!1);
+          e.push(o);
+        } else if (n.type === "CLOSE") {
+          if (this.depth-- === 0)
+            throw new x("#ERROR!", "Unexpected end paren");
+          return i();
+        } else if (n.type === "INFIX_OPERATOR") {
+          const o = n.convert();
+          let a = e.pop();
+          if (a == null)
+            if (o.name === "minus" || o.name === "add")
+              a = Fs;
+            else
+              throw new x("#ERROR!", "Missing left expression");
+          if (s == null)
+            o.args.push(a), e.unshift(o);
+          else if (o.precedence > s.precedence)
+            o.args.push(a), s.args.push(o), e.unshift(s);
+          else {
+            const l = e.shift();
+            o.args.push(l), s.args.push(a), e.unshift(o);
+          }
+          s = o;
+        } else if (n.type === "PREFIX_OPERATOR") {
+          const o = n.convert();
+          s ? s.args.push(o) : e.unshift(o), s = o;
+        }
+      }
+    }
+    return i();
+  }
+}
+const nn = ze, on = (r) => (r.charAt(0) === "'" && (r = r.slice(1)), r.charAt(r.length - 1) === "'" && (r = r.slice(0, -1)), r);
+function zs(r) {
+  let t, e = [];
+  if (r.startsWith("'")) {
+    let s = 1, i = "";
+    for (; s < r.length; ) {
+      const o = r[s], a = r[s + 1];
+      if (o === "'")
+        if (a === "'")
+          i += "'", s += 2;
+        else if (a === "!") {
+          s += 2;
+          break;
+        } else
+          return { sheetName: void 0, addresses: [] };
+      else
+        i += o, s++;
+    }
+    t = i, e = r.slice(s).trim().split(":");
+  } else {
+    const s = r.indexOf("!");
+    s !== -1 ? (t = r.slice(0, s), e = r.slice(s + 1).trim().split(":")) : e = r.trim().split(":");
+  }
+  return { sheetName: t, addresses: e };
+}
+const dt = (r, { sheet: t, operation: e, dependency: s }) => {
+  const { sheetName: i, addresses: n } = zs(r), o = [];
+  if (i && (t = t.getSheetBySheetName(i), t == null))
+    return { sheet: t, sheetName: i, addresses: n, ids: o };
+  if (n.length === 0)
+    return { sheet: t, sheetName: i, addresses: n, ids: o };
+  const a = [];
+  for (let u = 0; u < n.length; u++) {
+    const h = n[u], { y: c, x: f, absX: d, absY: p } = N(h);
+    let m = t.getId({ y: c, x: f });
+    if (m === s && (e === "removeRows" ? m = t.getId({ y: c - 1, x: f }) : e === "removeCols" && (m = t.getId({ y: c, x: f - 1 }))), m == null) {
+      a.push(Le(h, !!d, !!p) || "?");
+      continue;
+    }
+    o.push(m), a.push(`${d ? "$" : ""}#${m}${p ? "$" : ""}`);
+  }
+  let l = `#${t.id}!${a.join(":")}`;
+  return {
+    sheet: t,
+    sheetName: i,
+    addresses: n,
+    ids: o,
+    formula: l
+  };
+}, Ct = (r, t) => t.length === 0 ? r : Object.fromEntries(
+  Object.entries(r).filter(([e]) => !t.includes(e))
+), bt = (r, t, e = {}) => {
+  r.systems[t] == null && (r.systems[t] = {});
+  const s = r.systems[t];
+  for (const i of Object.keys(e))
+    s[i] ?? (s[i] = e[i]);
+  return s;
+}, Lt = (r, t, e) => {
+  r.asyncCaches || (r.asyncCaches = {}), r.asyncCaches[t] = e;
+}, tt = () => !0, Ve = (r, t, e = {}) => {
+  const s = N(t);
+  return r.getCell(s, e);
+}, Vs = (r, { area: t, resolution: e = "RESOLVED", raise: s = !1, filter: i = tt, asScalar: n = !1 } = {}) => r.__raw__._toValueMatrix({ area: t, resolution: e, raise: s, filter: i, asScalar: n }), an = (r, {
+  resolution: t = "RESOLVED",
+  raise: e = !1,
+  filter: s = tt,
+  addresses: i,
+  area: n,
+  asScalar: o = !1
+} = {}) => {
+  const a = {};
+  if (i) {
+    for (const f of i) {
+      const d = N(f), p = Ve(r, f, { resolution: t, raise: e }) ?? {};
+      if (s(p)) {
+        let m = p.value;
+        o && (m = r.getPolicy(d).toScalar({ value: p.value, cell: p, sheet: r.__raw__, point: d })), a[f] = m;
+      }
+    }
+    return a;
+  }
+  const { top: l, left: u, bottom: h, right: c } = n ?? r.area;
+  for (let f = l; f <= h; f++)
+    for (let d = u; d <= c; d++) {
+      const p = r.getCell({ y: f, x: d }, { resolution: t, raise: e }) ?? {};
+      if (s(p)) {
+        let m = p.value;
+        o && (m = r.getPolicy({ y: f, x: d }).toScalar({ value: p.value, cell: p, sheet: r.__raw__, point: { y: f, x: d } })), a[D({ y: f, x: d })] = m;
+      }
+    }
+  return a;
+}, cn = (r, { resolution: t = "RESOLVED", raise: e = !1, filter: s = tt, rows: i, area: n, asScalar: o = !1 } = {}) => {
+  const a = [], { top: l, left: u, bottom: h, right: c } = n ?? r.area, f = i ?? Array.from({ length: r.numRows }, (d, p) => l + p);
+  for (const d of f) {
+    const p = {};
+    a.push(p);
+    for (let m = u; m <= c; m++) {
+      const g = r.getCell({ y: d, x: m }, { resolution: t, raise: e }) ?? {};
+      if (s(g)) {
+        let y = g.value;
+        o && (y = r.getPolicy({ y: d, x: m }).toScalar({ value: g.value, cell: g, sheet: r.__raw__, point: { y: d, x: m } })), p[W(m)] = y;
+      }
+    }
+  }
+  return a;
+}, ln = (r, { resolution: t = "RESOLVED", raise: e = !1, filter: s = tt, cols: i, area: n, asScalar: o = !1 } = {}) => {
+  const a = [], { top: l, left: u, bottom: h, right: c } = n ?? r.area, f = i ? i.map((d) => typeof d == "string" ? _t(d) : d) : Array.from({ length: r.numCols }, (d, p) => u + p);
+  for (const d of f) {
+    const p = {};
+    a.push(p);
+    for (let m = l; m <= h; m++) {
+      const g = r.getCell({ y: m, x: d }, { resolution: t, raise: e }) ?? {};
+      if (s(g)) {
+        let y = g.value;
+        o && (y = r.getPolicy({ y: m, x: d }).toScalar({ value: g.value, cell: g, sheet: r.__raw__, point: { y: m, x: d } })), p[Et(m)] = y;
+      }
+    }
+  }
+  return a;
+}, hn = (r, { area: t, resolution: e = "RESOLVED", raise: s = !1, filter: i = tt, ignoreFields: n = [] } = {}) => {
+  const { top: o, left: a, bottom: l, right: u } = t ?? r.area, h = se(l - o + 1, u - a + 1);
+  for (let c = o; c <= l; c++)
+    for (let f = a; f <= u; f++) {
+      const d = r.getCell({ y: c, x: f }, { resolution: e, raise: s }) ?? {};
+      if (i(d)) {
+        const p = Ct(d, n);
+        h[c - o][f - a] = p;
+      }
+    }
+  return h;
+}, un = (r, {
+  resolution: t = "RESOLVED",
+  raise: e = !1,
+  filter: s = tt,
+  addresses: i,
+  area: n,
+  ignoreFields: o = []
+} = {}) => {
+  const a = {};
+  if (i) {
+    for (const f of i) {
+      const d = Ve(r, f, { resolution: t, raise: e }) ?? {};
+      s(d) && (a[f] = Ct(d, o));
+    }
+    return a;
+  }
+  const { top: l, left: u, bottom: h, right: c } = n ?? r.area;
+  for (let f = l; f <= h; f++)
+    for (let d = u; d <= c; d++) {
+      const p = r.getCell({ y: f, x: d }, { resolution: t, raise: e }) ?? {};
+      s(p) && (a[D({ y: f, x: d })] = Ct(p, o));
+    }
+  return a;
+}, dn = (r, { resolution: t = "RESOLVED", raise: e = !1, filter: s = tt, rows: i, area: n, ignoreFields: o = [] } = {}) => {
+  const a = [], { top: l, left: u, bottom: h, right: c } = n ?? r.area, f = i ?? Array.from({ length: r.numRows }, (d, p) => l + p);
+  for (const d of f) {
+    const p = {};
+    a.push(p);
+    for (let m = u; m <= c; m++) {
+      const g = r.getCell({ y: d, x: m }, { resolution: t, raise: e }) ?? {};
+      s(g) && (p[W(m)] = Ct(g, o));
+    }
+  }
+  return a;
+}, We = (r) => `'${r.replace(/'/g, "''")}'`, Ws = (r) => r ? `${We(r)}!` : "", fn = (r, { resolution: t = "RESOLVED", raise: e = !1, filter: s = tt, cols: i, area: n, ignoreFields: o = [] } = {}) => {
+  const a = [], { top: l, left: u, bottom: h, right: c } = n ?? r.area, f = i ? i.map((d) => typeof d == "string" ? _t(d) : d) : Array.from({ length: r.numCols }, (d, p) => u + p);
+  for (const d of f) {
+    const p = {};
+    a.push(p);
+    for (let m = l; m <= h; m++) {
+      const g = r.getCell({ y: m, x: d }, { resolution: t, raise: e }) ?? {};
+      s(g) && (p[Et(m)] = Ct(g, o));
+    }
+  }
+  return a;
+}, Bt = 1, Ut = 2, re = 4, ne = 8, oe = 16, ae = 32, It = 64, Tt = 128, ht = 256, zt = 512, ce = 8192, Vt = 1024, le = 16384, he = 32768, ue = 65536, Wt = 131072, Xs = 0, Xe = It | Tt, St = ht | zt | ce | Vt | le | Wt, je = re | ne, Ge = oe | ae, Ze = je | Ge, qe = Bt | Ut, Ke = St | qe | Ze | Xe, Je = ue | he | Wt, js = 524288, Gs = Ke | Je, O = (r, t) => r === void 0 ? !1 : (r & t) === t, Zs = (r) => {
+  const t = [];
+  return O(r, Bt) && t.push("RemoveRow"), O(r, Ut) && t.push("RemoveCol"), O(r, re) && t.push("InsertRowAbove"), O(r, ne) && t.push("InsertRowBelow"), O(r, oe) && t.push("InsertColLeft"), O(r, ae) && t.push("InsertColRight"), O(r, It) && t.push("MoveFrom"), O(r, Tt) && t.push("MoveTo"), O(r, ht) && t.push("Write"), O(r, zt) && t.push("Style"), O(r, Vt) && t.push("Resize"), O(r, le) && t.push("SetPolicy"), O(r, Wt) && t.push("SetLabel"), O(r, he) && t.push("Sort"), O(r, ue) && t.push("Filter"), t;
+}, pn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Add: Ze,
+  ColumnMenu: Je,
+  Copy: ce,
+  Delete: qe,
+  Filter: ue,
+  InsertCols: Ge,
+  InsertColsLeft: oe,
+  InsertColsRight: ae,
+  InsertRows: je,
+  InsertRowsAbove: re,
+  InsertRowsBelow: ne,
+  Move: Xe,
+  MoveFrom: It,
+  MoveTo: Tt,
+  NoOperation: Xs,
+  ReadOnly: Ke,
+  RemoveCols: Ut,
+  RemoveRows: Bt,
+  Resize: Vt,
+  RowMenu: js,
+  SetLabel: Wt,
+  SetPolicy: le,
+  Sort: he,
+  Style: zt,
+  Update: St,
+  ViewOnly: Gs,
+  Write: ht,
+  debugOperations: Zs,
+  hasOperation: O
+}, Symbol.toStringTag, { value: "Module" }));
+H.extend(fs);
+H.extend(ds);
+const Qe = /* @__PURE__ */ new Set(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]), qs = /* @__PURE__ */ new Set([...Qe, "Z", "z"]), Ks = /* @__PURE__ */ new Set(["J", "F", "M", "A", "S", "O", "N", "D", ...Qe]), Js = /* @__PURE__ */ new Set(["N", "B", "R", "Y", "N", "L", "G", "P", "T", "V", "C", ...qs]), Qs = /* @__PURE__ */ new Set([
+  "jan",
+  "feb",
+  "mar",
+  "apr",
+  "may",
+  "jun",
+  "jul",
+  "aug",
+  "sep",
+  "oct",
+  "nov",
+  "dec",
+  "january",
+  "february",
+  "march",
+  "april",
+  "june",
+  "july",
+  "august",
+  "september",
+  "october",
+  "november",
+  "december",
+  "mon",
+  "tue",
+  "wed",
+  "thu",
+  "fri",
+  "sat",
+  "sun",
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday",
+  "am",
+  "pm",
+  "utc",
+  "gmt",
+  "est",
+  "cst",
+  "mst",
+  "pst",
+  "jst",
+  "cet",
+  "eet",
+  "ist",
+  "aest",
+  "edt",
+  "cdt",
+  "mdt",
+  "pdt",
+  "bst",
+  "hst",
+  "akst",
+  "akdt",
+  "nzst",
+  "nzdt",
+  "t",
+  "z"
+]);
+function ts(r) {
+  const t = r[0];
+  if (t == null || !Ks.has(t.toUpperCase()) || !Js.has(r[r.length - 1].toUpperCase()) || r.match(/[=*&#@!?[\]{}"'()|%\\<>~+\r\n]/))
+    return;
+  const e = r.split(/[\s,/\-:.]+/).filter(Boolean);
+  for (const i of e)
+    if (/^[a-zA-Z]+$/.test(i) && !Qs.has(i.toLowerCase()))
+      return;
+  let s = "UTC";
+  try {
+    s = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+  }
+  try {
+    return H.tz(r, s).toDate();
+  } catch {
+  }
+}
+const ti = { true: !0, false: !1 };
+class de {
+  constructor(t) {
+    this.priority = 0, this.datetimeFormat = "YYYY-MM-DD HH:mm:ss", this.dateFormat = "YYYY-MM-DD", this.timeFormat = "HH:mm:ss", this.decimalPrecision = 14, this.deserializeFunctions = [], this.priority = (t == null ? void 0 : t.priority) ?? 1, this.applyMixins(t == null ? void 0 : t.mixins), this.registerDeserializeFunctions();
+  }
+  registerDeserializeFunctions() {
+    this.deserializeFunctions = [
+      ...this.deserializeFirst ? [this.deserializeFirst.bind(this)] : [],
+      this.deserializeNumber.bind(this),
+      this.deserializeTime.bind(this),
+      this.deserializeDate.bind(this),
+      this.deserializeBool.bind(this),
+      this.deserializeAny.bind(this)
+    ];
+  }
+  applyMixins(t) {
+    if (t == null)
+      return;
+    const e = Object.getPrototypeOf(this);
+    for (const s of t)
+      for (const i in s)
+        e !== de.prototype && Object.prototype.hasOwnProperty.call(e, i) || (this[i] = s[i]);
+  }
+  // --- RENDER ---
+  render(t) {
+    let { value: e, cell: s } = t;
+    const { sheet: i, point: n } = t;
+    s == null && (s = i.getCell(n, { resolution: "EVALUATED", raise: !0 }) ?? {}, e = s.value);
+    let o;
+    if (k.is(e))
+      o = "";
+    else if (e == null)
+      o = this.renderNull({ ...t, value: e, cell: s });
+    else
+      switch (typeof e) {
+        case "object":
+          if (e instanceof Date)
+            o = this.renderDate({ ...t, value: e, cell: s });
+          else if (b.is(e))
+            o = this.renderTime({ value: b.ensure(e), cell: s, sheet: i, point: n });
+          else if (Array.isArray(e))
+            o = this.renderArray({ ...t, value: e, cell: s });
+          else {
+            if (x.is(e))
+              throw e;
+            Q(e) ? o = this.renderSheet({ ...t, value: e, cell: s }) : o = this.renderObject({ ...t, value: e, cell: s });
+          }
+          break;
+        case "string":
+          o = this.renderString({ ...t, value: e, cell: s });
+          break;
+        case "number":
+          o = this.renderNumber({ ...t, value: e, cell: s });
+          break;
+        case "boolean":
+          o = this.renderBool({ ...t, value: e, cell: s });
+          break;
+        case "function":
+          o = e();
+          break;
+        default:
+          o = "";
+      }
+    return this.renderCallback ? this.renderCallback(o, { ...t, value: e, cell: s }) : o;
+  }
+  renderString({ value: t }) {
+    return t;
+  }
+  renderBool({ value: t }) {
+    return t ? "TRUE" : "FALSE";
+  }
+  renderNumber({ value: t }) {
+    return isNaN(t) ? "NaN" : parseFloat(t.toPrecision(this.decimalPrecision));
+  }
+  renderDate({ value: t }) {
+    return t.getHours() + t.getMinutes() + t.getSeconds() === 0 ? H(t).format(this.dateFormat) : H(t).format(this.datetimeFormat);
+  }
+  renderTime({ value: t }) {
+    return t.stringify(this.timeFormat);
+  }
+  renderArray(t) {
+    let { value: e, cell: s } = t;
+    return e = e == null ? void 0 : e[0], Array.isArray(e) && (e = e[0]), this.render({ ...t, value: e, cell: s });
+  }
+  renderObject({ value: t }) {
+    return JSON.stringify(t);
+  }
+  renderNull(t) {
+    return "";
+  }
+  renderSheet({ value: t, ...e }) {
+    const s = e.sheet.getId(e.point), i = t.__raw__.strip({ raise: !0, at: s });
+    return this.render({ ...e, value: i });
+  }
+  renderRowHeaderLabel(t) {
+    return null;
+  }
+  renderColHeaderLabel(t) {
+    return null;
+  }
+  // --- TO SCALAR ---
+  toScalar(t) {
+    const { value: e, cell: s, sheet: i, point: n } = t;
+    if (!k.is(e)) {
+      if (e == null)
+        return this.toScalarNull({ value: e, cell: s, sheet: i, point: n });
+      switch (typeof e) {
+        case "string":
+          return this.toScalarString({ value: e, cell: s, sheet: i, point: n });
+        case "number":
+          return this.toScalarNumber({ value: e, cell: s, sheet: i, point: n });
+        case "boolean":
+          return this.toScalarBool({ value: e, cell: s, sheet: i, point: n });
+        case "object":
+          if (e instanceof Date)
+            return this.toScalarDate({ value: e, cell: s, sheet: i, point: n });
+          if (b.is(e))
+            return this.toScalarTime({ value: b.ensure(e), cell: s, sheet: i, point: n });
+          if (Array.isArray(e))
+            return this.toScalarArray({ value: e, cell: s, sheet: i, point: n });
+          if (x.is(e))
+            throw e;
+          return;
+        default:
+          return;
+      }
+    }
+  }
+  toScalarString({ value: t }) {
+    return t;
+  }
+  toScalarNumber({ value: t }) {
+    return t == null ? void 0 : t.toPrecision(this.decimalPrecision);
+  }
+  toScalarBool({ value: t }) {
+    return t;
+  }
+  toScalarDate({ value: t }) {
+    return t.getHours() + t.getMinutes() + t.getSeconds() === 0 ? H(t).format(this.dateFormat) : H(t).format(this.datetimeFormat);
+  }
+  toScalarTime({ value: t }) {
+    return t.stringify(this.timeFormat);
+  }
+  toScalarArray({ value: t, cell: e, sheet: s, point: i }) {
+    let n = t == null ? void 0 : t[0];
+    return Array.isArray(n) && (n = n[0]), this.toScalar({ value: n, cell: e, sheet: s, point: i });
+  }
+  toScalarNull(t) {
+    return null;
+  }
+  // --- SERIALIZE ---
+  serialize({ value: t, cell: e, sheet: s, point: i }) {
+    return t === void 0 && (t = e == null ? void 0 : e.value), k.is(t) ? "" : t instanceof Date ? this.serializeDate({ value: t, cell: e, sheet: s, point: i }) : b.is(t) ? this.serializeTime({ value: b.ensure(t), cell: e, sheet: s, point: i }) : t == null ? this.serializeNull({ cell: e, sheet: s, point: i }) : Array.isArray(t) ? this.serializeArray({ value: t, cell: e, sheet: s, point: i }) : t instanceof x ? this.serializeFormulaError({ value: t, cell: e, sheet: s, point: i }) : t instanceof Error ? this.serializeError({ value: t, cell: e, sheet: s, point: i }) : t.toString();
+  }
+  serializeString({ value: t }) {
+    return t;
+  }
+  serializeBool({ value: t }) {
+    return t ? "true" : "false";
+  }
+  serializeNumber({ value: t }) {
+    return isNaN(t) ? "NaN" : parseFloat(t.toPrecision(this.decimalPrecision)).toString();
+  }
+  serializeDate({ value: t }) {
+    return t.getHours() + t.getMinutes() + t.getSeconds() === 0 ? H(t).format(this.dateFormat) : H(t).format(this.datetimeFormat);
+  }
+  serializeTime({ value: t }) {
+    return t.stringify(this.timeFormat);
+  }
+  serializeArray(t) {
+    let { value: e } = t;
+    return e = e == null ? void 0 : e[0], Array.isArray(e) && (e = e[0]), this.serialize({ ...t, value: e });
+  }
+  serializeNull(t) {
+    return "";
+  }
+  serializeFormulaError({ value: t }) {
+    return t.code;
+  }
+  serializeError(t) {
+    return "";
+  }
+  serializeForClipboard(t) {
+    const { point: e, sheet: s } = t;
+    return s.getSerializedValue({ point: e }) ?? "";
+  }
+  // --- DESERIALIZE ---
+  deserializeValue(t, e) {
+    try {
+      const s = typeof t != "string" ? this.deserializeRaw(t, e) : this.deserialize(t, e);
+      return this.deserializeCallback ? this.deserializeCallback(s, e) : s;
+    } catch (s) {
+      return { ...e, value: String(s) };
+    }
+  }
+  deserializeRaw(t, e) {
+    return b.is(t) && (t = b.ensure(t)), { ...e, value: t };
+  }
+  deserialize(t, e) {
+    if (t[0] === "'")
+      return { ...e, value: t };
+    for (let s = 0; s < this.deserializeFunctions.length; s++) {
+      const i = this.deserializeFunctions[s](t, e);
+      if ((i == null ? void 0 : i.value) !== void 0)
+        return { ...e, ...i };
+    }
+    return t === "" ? { ...e, value: void 0 } : { ...e, value: t };
+  }
+  deserializeAny(t, e) {
+    return t == null || t === "" ? { value: void 0 } : { value: t };
+  }
+  deserializeBool(t, e) {
+    return { value: ti[t.toLowerCase()] };
+  }
+  deserializeNumber(t, e) {
+    return t.match(/^-?[\d.]+$/) != null && t.match(/\.$/) == null && (t.match(/\./g) || []).length <= 1 ? { value: parseFloat(t) } : { value: void 0 };
+  }
+  deserializeTime(t, e) {
+    return t.length < 3 || isNaN(t[t.length - 1]) ? { value: void 0 } : { value: b.parse(t) };
+  }
+  deserializeDate(t, e) {
+    return { value: ts(t) };
+  }
+  // --- SELECT ---
+  getSelectFallback(t) {
+    return { value: null };
+  }
+  getSelectOptions() {
+    return [];
+  }
+  select(t) {
+    const { next: e, sheet: s, point: i } = t, n = this.getSelectOptions();
+    return n.length === 0 || n.some((a) => a.value === (e == null ? void 0 : e.value)) ? e : { ...e, ...this.getSelectFallback({ sheet: s, point: i, value: e == null ? void 0 : e.value }) };
+  }
+}
+const xt = "default", ei = new de({ priority: 0 }), j = (r) => r == null ? "" : String(r);
+function ft(r) {
+  return typeof r == "number" ? "number" : r instanceof Date ? "date" : b.is(r) ? "time" : typeof r == "boolean" ? "boolean" : "string";
+}
+function pt(r, t) {
+  switch (t) {
+    case "number": {
+      let e = r.replace(/[,_]/g, ""), s = 1;
+      e.endsWith("%") && (e = e.slice(0, -1), s = 0.01);
+      const i = Number(e);
+      return { ok: !isNaN(i), num: i * s };
+    }
+    case "date": {
+      const e = ts(r);
+      return e ? { ok: !0, num: e.getTime() } : { ok: !1, num: NaN };
+    }
+    case "time": {
+      const e = b.parse(r);
+      return e ? { ok: !0, num: e.toMilliseconds() } : { ok: !1, num: NaN };
+    }
+    case "boolean": {
+      const e = r.toLowerCase();
+      return e === "true" ? { ok: !0, num: 1 } : e === "false" ? { ok: !0, num: 0 } : { ok: !1, num: NaN };
+    }
+    default:
+      return { ok: !1, num: NaN };
+  }
+}
+function mt(r, t) {
+  switch (t) {
+    case "number":
+      return r;
+    case "date":
+      return r.getTime();
+    case "time":
+      return b.ensure(r).toMilliseconds();
+    case "boolean":
+      return r ? 1 : 0;
+    default:
+      return NaN;
+  }
+}
+const si = (r, t) => {
+  const e = ft(t);
+  if (e === "string") {
+    const i = j(t);
+    return r.value.some((n) => i === n);
+  }
+  const s = mt(t, e);
+  return r.value.some((i) => {
+    const n = pt(i, e);
+    return n.ok && s === n.num;
+  });
+}, ii = (r, t) => {
+  const e = ft(t);
+  if (e === "string") {
+    const i = j(t);
+    return !r.value.some((n) => i === n);
+  }
+  const s = mt(t, e);
+  return !r.value.some((i) => {
+    const n = pt(i, e);
+    return n.ok && s === n.num;
+  });
+}, ri = (r, t) => {
+  const e = ft(t);
+  if (e === "string")
+    return j(t) > r.value[0];
+  const s = mt(t, e), i = pt(r.value[0], e);
+  return i.ok && s > i.num;
+}, ni = (r, t) => {
+  const e = ft(t);
+  if (e === "string")
+    return j(t) >= r.value[0];
+  const s = mt(t, e), i = pt(r.value[0], e);
+  return i.ok && s >= i.num;
+}, oi = (r, t) => {
+  const e = ft(t);
+  if (e === "string")
+    return j(t) < r.value[0];
+  const s = mt(t, e), i = pt(r.value[0], e);
+  return i.ok && s < i.num;
+}, ai = (r, t) => {
+  const e = ft(t);
+  if (e === "string")
+    return j(t) <= r.value[0];
+  const s = mt(t, e), i = pt(r.value[0], e);
+  return i.ok && s <= i.num;
+}, ci = (r, t) => t == null || j(t) === "", li = (r, t) => t != null && j(t) !== "", hi = (r, t) => {
+  const e = j(t).toLowerCase();
+  return r.value.some((s) => e.includes(s.toLowerCase()));
+}, ui = (r, t) => {
+  const e = j(t).toLowerCase();
+  return !r.value.some((s) => e.includes(s.toLowerCase()));
+}, di = {
+  eq: si,
+  ne: ii,
+  gt: ri,
+  gte: ni,
+  lt: oi,
+  lte: ai,
+  blank: ci,
+  nonblank: li,
+  includes: hi,
+  excludes: ui
+};
+function Te(r, t) {
+  const e = di[r.method];
+  return e ? e(r, t) : !0;
+}
+function fi(r, t) {
+  const e = r.mode ?? "or";
+  return r.conditions.length === 0 ? !0 : e === "and" ? r.conditions.every((s) => Te(s, t)) : r.conditions.some((s) => Te(s, t));
+}
+class lt {
+  constructor(t) {
+    this.map = {}, this.dependentIds = /* @__PURE__ */ new Set(), this.sheet = t;
+  }
+  collectDependents(...t) {
+    t.forEach((e) => {
+      var s, i;
+      (i = (s = this.sheet.registry.systems[e]) == null ? void 0 : s.dependents) == null || i.forEach((n) => {
+        this.dependentIds.add(n);
+      });
+    });
+  }
+  /**
+   * Compare two idMatrix snapshots (`before` and `after`) and populate
+   * `this.map` and collect dependents for every position where the occupying
+   * cell ID changed. Works for any rearrangement (sort, move, etc.).
+   */
+  buildMap(t, e) {
+    for (let s = 0; s < t.length; s++) {
+      const i = t[s], n = e[s];
+      i != null && n != null && i !== n && (this.collectDependents(i, n), this.map[i] = n);
+    }
+  }
+  resolveDependents(t) {
+    this.sheet.clearAddressCaches();
+    const e = {};
+    return this.dependentIds.forEach((s) => {
+      const i = this.sheet.registry.data[s];
+      i != null && (e[s] = { ...i }, this.sheet.clearDependencies(s), i.value = this.sheet.processFormula(i.value, {
+        dependency: s,
+        idMap: this.map,
+        operation: t
+      }));
+    }), e;
+  }
+}
+const Me = (r) => {
+  switch (r) {
+    case "INSERT_ROWS":
+    case "INSERT_COLS":
+    case "REMOVE_ROWS":
+    case "REMOVE_COLS":
+    case "MOVE":
+    case "SORT_ROWS":
+      return !0;
+  }
+  return !1;
+}, pi = () => !0;
+class $ {
+  constructor({ limits: t = {}, name: e, registry: s = ye({}), eager: i = !1 }) {
+    this.__gsType = "Sheet", this._stripped = wt, this.area = { top: 0, left: 0, bottom: 0, right: 0 }, this.id = 0, this.name = "", this.eager = !1, this.prevName = "", this.status = 0, this.idsToBeIdentified = [], this.totalWidth = 0, this.totalHeight = 0, this.fullHeight = 0, this.defaultColWidth = jt, this.defaultRowHeight = J, this.version = 0, this.addressCaches = /* @__PURE__ */ new Map(), this.lastChangedAddresses = [], this._initCells = null, this._initMatrices = null, this._matrixBases = [], this._matrixByBase = [], this._colLetters = [], this._rowHeightOverrides = /* @__PURE__ */ new Map(), this._filteredRows = /* @__PURE__ */ new Set(), this.idMatrix = [], this.changedTime = Date.now(), this.eager = i, 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=${We(this.name)}, top=${this.top}, left=${this.left}, bottom=${this.bottom}, right=${this.right})`;
+  }
+  get headerHeight() {
+    var t;
+    return ((t = this.getCell({ y: 0, x: 0 }, { resolution: "SYSTEM" })) == null ? void 0 : t.height) || Re;
+  }
+  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) || _e;
+  }
+  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 }) {
+    const s = this.getId({ y: t, x: e });
+    if (s != null)
+      return this._ensureCellPopulated(t, e, s), 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() {
+    for (const t of Object.keys(this.registry.data)) {
+      const e = this.registry.data[t];
+      if (k.is(e == null ? void 0 : e.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((n) => n.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;
+  }
+  /**
+   * Eagerly fire every async formula cell in this sheet, ignoring the visible
+   * range.
+   *
+   * GridSheet is virtualized: normally only cells the UI renders get solved, so
+   * an off-screen `=…` formula that calls an async function never fires. Only
+   * async cells need this — sync formulas have no side effects and resolve when
+   * read (e.g. by serialization), whereas an async cell must be *fired* and given
+   * time to settle before its value can be read. `resolveAll()` therefore walks
+   * the async-formula index ({@link Registry.asyncFormulaCells}) and solves each
+   * one, which fires it through the usual machinery: it resolves, populates the
+   * per-cell async cache, and triggers a re-render via `transmit()`. Sync cells
+   * that depend on those results resolve normally on the next read.
+   *
+   * Cells already resolved (async-cache hit) or in flight (Pending) are not
+   * re-fired — solving is a cache hit for them — so repeated calls converge and
+   * are cheap. After awaiting {@link waitForPending}, serialization helpers such
+   * as `toValueMatrix` return resolved values for off-screen cells too.
+   *
+   * This is the building block behind the opt-in `eager` sheet option; call it
+   * directly to resolve on demand without enabling eager mode.
+   *
+   * @returns the number of async formula cells visited (for diagnostics/tests).
+   */
+  resolveAll() {
+    var s;
+    const t = this.registry;
+    let e = 0;
+    for (const i of Array.from(t.asyncFormulaCells)) {
+      const n = t.data[i];
+      if (n == null || typeof n.value != "string" || n.value.charAt(0) !== "=") {
+        t.asyncFormulaCells.delete(i);
+        continue;
+      }
+      if (((s = t.systems[i]) == null ? void 0 : s.sheetId) !== this.id)
+        continue;
+      const { y: o, x: a } = this.getPointById(i);
+      if (o < 0 || a < 0) {
+        t.asyncFormulaCells.delete(i);
+        continue;
+      }
+      this.getCell({ y: o, x: a }, { resolution: "RESOLVED", raise: !1 }), e++;
+    }
+    return e;
+  }
+  /**
+   * Capture the full cell state of all filter-related header cells as a CellsByIdType snapshot.
+   * @internal
+   */
+  _captureFilterCellStates() {
+    var i, n;
+    const t = {}, e = this.numCols, s = this.numRows;
+    for (let o = 1; o <= e; o++) {
+      const a = this.getId({ y: 0, x: o });
+      a != null && (t[a] = { filter: ((i = this.registry.data[a]) == null ? void 0 : i.filter) ?? null });
+    }
+    for (let o = 1; o <= s; o++) {
+      const a = this.getId({ y: o, x: 0 });
+      a != null && (t[a] = { filtered: ((n = this.registry.data[a]) == null ? void 0 : n.filtered) ?? !1 });
+    }
+    return t;
+  }
+  filterRows({
+    x: t,
+    filter: e
+  } = {}) {
+    const s = this._captureFilterCellStates();
+    if (t == null) {
+      const o = this.numCols;
+      for (let a = 1; a <= o; a++) {
+        const l = this._pointToRawCell({ y: 0, x: a });
+        l == null || delete l.filter;
+      }
+    } else {
+      const o = this._pointToRawCell({ y: 0, x: t });
+      o && (e ? o.filter = e : delete o.filter);
+    }
+    this._reapplyFilters();
+    const i = this._captureFilterCellStates(), n = Object.keys(s).filter(
+      (o) => JSON.stringify(s[o]) !== JSON.stringify(i[o])
+    );
+    if (n.length > 0) {
+      const o = {}, a = {};
+      for (const l of n)
+        o[l] = s[l], a[l] = i[l];
+      this._pushHistory({
+        applyed: !0,
+        operation: "UPDATE",
+        srcSheetId: this.id,
+        dstSheetId: this.id,
+        diffBefore: o,
+        diffAfter: a,
+        partial: !0
+      });
+    }
+    return this.refresh(!1, !0);
+  }
+  /** @internal */
+  _reapplyFilters() {
+    const t = this.numCols, e = [], s = [];
+    for (let n = 1; n <= t; n++) {
+      const o = this._pointToRawCell({ y: 0, x: n });
+      o != null && o.filter && o.filter.conditions.length > 0 && e.push({ x: n, filter: o.filter }), s.push(D({ y: 0, x: n }));
+    }
+    const i = this.numRows;
+    for (let n = 1; n <= i; n++) {
+      const o = this._pointToRawCell({ y: n, x: 0 });
+      if (!o || o.filterFixed)
+        continue;
+      let a = !1;
+      for (const { x: u, filter: h } of e) {
+        const c = this.getCell({ y: n, x: u }, { resolution: "RESOLVED" });
+        if (!fi(h, c == null ? void 0 : c.value)) {
+          a = !0;
+          break;
+        }
+      }
+      const l = !!o.filtered;
+      a ? (o.filtered = !0, this._filteredRows.add(n)) : (delete o.filtered, this._filteredRows.delete(n)), l !== a && s.push(D({ y: n, x: 0 }));
+    }
+    this.lastChangedAddresses = s;
+  }
+  sortRows({ x: t, direction: e }) {
+    const s = this.numRows;
+    if (s <= 1)
+      return this;
+    const i = /* @__PURE__ */ new Set(), n = [];
+    for (let c = 1; c <= s; c++) {
+      const f = this._pointToRawCell({ y: c, x: 0 });
+      f != null && f.sortFixed ? i.add(c) : n.push(c);
+    }
+    n.sort((c, f) => {
+      const d = this.getCell({ y: c, x: t }, { resolution: "RESOLVED" }), p = this.getCell({ y: f, x: t }, { resolution: "RESOLVED" }), m = d == null ? void 0 : d.value, g = p == null ? void 0 : p.value;
+      if (m == null && g == null)
+        return 0;
+      if (m == null)
+        return 1;
+      if (g == null)
+        return -1;
+      let y = 0;
+      return typeof m == "number" && typeof g == "number" ? y = m - g : m instanceof Date && g instanceof Date ? y = m.getTime() - g.getTime() : y = String(m).localeCompare(String(g)), e === "asc" ? y : -y;
+    });
+    const o = [];
+    for (let c = 1; c <= s; c++)
+      i.has(c) || o.push(c);
+    let a = !1;
+    for (let c = 0; c < n.length; c++)
+      if (n[c] !== o[c]) {
+        a = !0;
+        break;
+      }
+    if (!a)
+      return this;
+    const l = {};
+    for (const c of i)
+      l[c] = c;
+    for (let c = 0; c < n.length; c++)
+      l[n[c]] = o[c];
+    this._materializeIdMatrix();
+    const u = this.idMatrix.slice();
+    for (const [c, f] of Object.entries(l))
+      this.idMatrix[Number(f)] = u[Number(c)];
+    this.addressCaches.clear();
+    const h = new lt(this);
+    return h.buildMap(u.flat(), this.idMatrix.flat()), h.resolveDependents(), this._pushHistory({
+      applyed: !0,
+      operation: "SORT_ROWS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      sortedRowMapping: l
+    }), this.refresh(!0, !0);
+  }
+  /** @internal */
+  _sortRowMapping(t, e = !1) {
+    const s = new Array(this.numRows);
+    if (e)
+      for (const [n, o] of Object.entries(t)) {
+        const a = Number(n);
+        s[a - 1] = o;
+      }
+    else
+      for (const [n, o] of Object.entries(t)) {
+        const a = Number(n);
+        s[o - 1] = a;
+      }
+    this._materializeIdMatrix();
+    const i = [];
+    for (let n = 0; n < s.length; n++)
+      i.push(this.idMatrix[s[n]]);
+    for (let n = 0; n < s.length; n++)
+      this.idMatrix[n + 1] = i[n];
+    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 $t(t.substring(1));
+      return i.tokenize(e), i.identify({ ...s, sheet: this }), i.dependencyIds.forEach((n) => this.addDependency(n, s.dependency)), s.dependency != null && (this._formulaHasAsync(i) ? this.registry.asyncFormulaCells.add(s.dependency) : this.registry.asyncFormulaCells.delete(s.dependency)), "=" + i.identifiedFormula;
+    }
+    return s.dependency != null && this.registry.asyncFormulaCells.delete(s.dependency), t;
+  }
+  /**
+   * Whether a tokenized formula calls at least one async function, decided via
+   * the function class's static `isAsync` flag (no instantiation). Drives the
+   * async-formula index that {@link resolveAll} walks.
+   * @internal
+   */
+  _formulaHasAsync(t) {
+    for (const e of t.tokens)
+      if (e.type === "FUNCTION") {
+        const s = this.registry.functions[String(e.entity).toLowerCase()];
+        if (s != null && s.isAsync)
+          return !0;
+      }
+    return !1;
+  }
+  /** @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 o, a;
+    if (this.status > 1)
+      return;
+    t[0] == null && (t[0] = { width: _e, height: Re });
+    const e = Cs(t, t.__userKeys);
+    this.area = {
+      top: 1,
+      left: 1,
+      bottom: e.numRows,
+      right: e.numCols
+    }, this.idMatrix = new Array(e.numRows + 1), this._colLetters = [];
+    for (let l = 0; l <= e.numCols; l++)
+      this._colLetters[l] = W(l);
+    const s = t.__userKeys ?? Object.keys(t);
+    s.forEach((l) => {
+      if (l === Ft || l === Dt || l === vt)
+        return;
+      const u = Ts(l), h = t[l];
+      u.forEach((c) => {
+        const f = t[c];
+        t[c] = {
+          ...f,
+          ...h,
+          ...$._stack(f, h)
+        };
+      });
+    }), this._common = t == null ? void 0 : t[Ft], this._commonCol = t == null ? void 0 : t[Dt], this._commonRow = t == null ? void 0 : t[vt], this._initCells = t;
+    const i = t.__matrices;
+    if (i) {
+      this._initMatrices = i, this._initFlattenAs = t.__flattenAs, this._matrixByBase = [];
+      for (const l of Object.keys(i)) {
+        const { y: u, x: h } = N(l);
+        this._matrixByBase.push({ baseY: u, baseX: h, matrix: i[l] });
+      }
+    }
+    ((o = this._commonCol) == null ? void 0 : o.width) != null && (this.defaultColWidth = this._commonCol.width), ((a = this._commonRow) == null ? void 0 : a.height) != null && (this.defaultRowHeight = this._commonRow.height), this._ensureIdRow(0);
+    for (let l = 0; l <= e.numCols; l++) {
+      const u = this.idMatrix[0][l];
+      this._ensureCellPopulated(0, l, u);
+    }
+    const n = s;
+    for (const l of n) {
+      if (l === Ft || l === Dt || l === vt)
+        continue;
+      const u = N(l), { y: h, x: c } = u;
+      if (h === 0 && c === 0 || h === 0 || c === 0 || h <= 0 || c <= 0 || h > e.numRows || c > e.numCols)
+        continue;
+      const d = this._ensureIdRow(h)[c];
+      d != null && this._ensureCellPopulated(h, c, d);
+    }
+    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();
+  }
+  /**
+   * Lazily generate the ID row for the given y-coordinate.
+   * If the row already exists, returns it immediately.
+   * @internal
+   */
+  _ensureIdRow(t) {
+    let e = this.idMatrix[t];
+    if (e != null)
+      return e;
+    const s = this.area.right;
+    e = [];
+    for (let i = 0; i <= s; i++) {
+      const n = this._generateId();
+      e.push(n);
+      const o = this._colLetters[i] || W(i);
+      this.addressCaches.set(n, t === 0 ? `${o}0` : i === 0 ? `0${t}` : `${o}${t}`);
+    }
+    return this.idMatrix[t] = e, e;
+  }
+  /**
+   * Ensure that registry.data and registry.systems exist for a given cell.
+   * Performs lazy cell stacking using stored initialization defaults.
+   * @internal
+   */
+  _ensureCellPopulated(t, e, s) {
+    var l, u;
+    if (this.registry.data[s] != null)
+      return;
+    const i = this._initCells, n = Date.now();
+    let o;
+    if (t === 0 && e > 0) {
+      const h = this._colLetters[e] || W(e), c = i == null ? void 0 : i[h], { style: f, ...d } = c ?? {}, p = i == null ? void 0 : i[h + "0"];
+      o = {
+        ...this._commonCol,
+        ...d,
+        ...p,
+        ...$._stack(this._commonCol, p)
+      };
+    } else if (e === 0 && t > 0) {
+      const h = Et(t), c = i == null ? void 0 : i[h], { style: f, ...d } = c ?? {}, p = i == null ? void 0 : i["0" + h];
+      o = {
+        ...this._commonRow,
+        ...d,
+        ...p,
+        ...$._stack(this._commonRow, p)
+      };
+    } else if (t === 0 && e === 0) {
+      const h = i == null ? void 0 : i["0"];
+      o = { ...h, ...$._stack(h) };
+    } else {
+      const h = this._colLetters[e] || W(e), c = Et(t), f = `${h}${c}`, d = i == null ? void 0 : i[c], p = i == null ? void 0 : i[h];
+      let m = i == null ? void 0 : i[f];
+      if ((m == null || !("value" in m)) && this._matrixByBase.length > 0)
+        for (const { baseY: g, baseX: y, matrix: R } of this._matrixByBase) {
+          const A = t - g, w = e - y;
+          if (A >= 0 && A < R.length && w >= 0 && w < R[A].length) {
+            const S = R[A][w];
+            let _;
+            this._initFlattenAs ? _ = { [this._initFlattenAs]: S } : _ = S, m = m ? { ..._, ...m } : _;
+            break;
+          }
+        }
+      o = {
+        ...this._common,
+        ...d,
+        ...p,
+        ...m,
+        ...$._stack(this._common, d, p, m)
+      };
+    }
+    (u = (l = o == null ? void 0 : o.value) == null ? void 0 : l.startsWith) != null && u.call(l, "=") && ((o == null ? void 0 : o.formulaEnabled) ?? !0) && this.idsToBeIdentified.push(s), t === 0 ? o.width == null && (o.width = jt) : e === 0 ? (o.height == null && (o.height = J), o.height !== (this.defaultRowHeight || J) && this._rowHeightOverrides.set(t, o.height), o.filtered && this._filteredRows.add(t)) : (delete o.height, delete o.width, delete o.label), o = (this.policies[o.policy ?? ""] ?? this.defaultPolicy).deserializeValue(o.value, o) ?? {}, this.registry.systems[s] = { ...this.registry.systems[s], id: s, changedTime: n, sheetId: this.id }, this.registry.data[s] = o;
+  }
+  /**
+   * Materialize all lazy ID rows. Call this before operations that need the full
+   * idMatrix (e.g. .flat(), .map(), .slice() for sort/move/undo/redo).
+   * @internal
+   */
+  _materializeIdMatrix() {
+    for (let t = 0; t < this.idMatrix.length; t++)
+      this.idMatrix[t] == null && this._ensureIdRow(t);
+  }
+  /**
+   * Compute the absolute top offset for a given row using arithmetic + overrides.
+   * Avoids iterating all rows — O(overrides) instead of O(numRows).
+   * @internal
+   */
+  getOffsetTop(t) {
+    const e = this.headerHeight, s = this.defaultRowHeight || J;
+    let i = e + (t - 1) * s;
+    for (const [n, o] of this._rowHeightOverrides)
+      n < t && (i += o - s);
+    for (const n of this._filteredRows)
+      if (n < t) {
+        const o = this._rowHeightOverrides.get(n) ?? s;
+        i -= o;
+      }
+    return i;
+  }
+  /**
+   * Re-key the row-metadata caches after rows are removed at [y, y+numRows).
+   * These maps are keyed by absolute row number, so deletions must drop the removed
+   * keys and shift later keys down — otherwise stale entries corrupt getOffsetTop().
+   * @internal
+   */
+  _shiftRowMetaForRemove(t, e) {
+    const s = /* @__PURE__ */ new Map();
+    for (const [n, o] of this._rowHeightOverrides)
+      n < t ? s.set(n, o) : n >= t + e && s.set(n - e, o);
+    this._rowHeightOverrides = s;
+    const i = /* @__PURE__ */ new Set();
+    for (const n of this._filteredRows)
+      n < t ? i.add(n) : n >= t + e && i.add(n - e);
+    this._filteredRows = i;
+  }
+  /**
+   * Re-key the row-metadata caches after numRows are inserted at y, shifting keys >= y up.
+   * @internal
+   */
+  _shiftRowMetaForInsert(t, e) {
+    const s = /* @__PURE__ */ new Map();
+    for (const [n, o] of this._rowHeightOverrides)
+      s.set(n < t ? n : n + e, o);
+    this._rowHeightOverrides = s;
+    const i = /* @__PURE__ */ new Set();
+    for (const n of this._filteredRows)
+      i.add(n < t ? n : n + e);
+    this._filteredRows = i;
+  }
+  /**
+   * (Re)seed row-metadata for the rows at [y, y+numRows) from their current header cells.
+   * Used after rows are added (insert / undo-remove / redo-insert) so non-default heights
+   * and filtered state are reflected immediately rather than only on the next lazy read.
+   * @internal
+   */
+  _seedRowMeta(t, e) {
+    const s = this.defaultRowHeight || J;
+    for (let i = 0; i < e; i++) {
+      const n = t + i, o = this.getId({ y: n, x: 0 }), a = o ? this.registry.data[o] : void 0;
+      (a == null ? void 0 : a.height) != null && a.height !== s ? this._rowHeightOverrides.set(n, a.height) : this._rowHeightOverrides.delete(n), a != null && a.filtered ? this._filteredRows.add(n) : this._filteredRows.delete(n);
+    }
+  }
+  getRectSize({ top: t, left: e, bottom: s, right: i }) {
+    var d, p;
+    const n = e || 1, o = t || 1, a = ((d = this.registry.systems[this.getId({ y: 0, x: i })]) == null ? void 0 : d.offsetLeft) ?? 0, l = ((p = this.registry.systems[this.getId({ y: 0, x: n })]) == null ? void 0 : p.offsetLeft) ?? 0, u = this.getOffsetTop(s), h = this.getOffsetTop(o), c = Math.max(0, a - l), f = Math.max(0, u - h);
+    return { y: o, x: n, height: f, width: c };
+  }
+  /** @internal */
+  setTotalSize() {
+    const t = this.numCols, e = this.numRows, s = this.headerWidth, i = this.headerHeight, n = this.defaultRowHeight || J;
+    let o = 0;
+    for (let h = 1; h <= t; h++) {
+      const c = this.getCell({ y: 0, x: h }, { resolution: "SYSTEM" }), f = (c == null ? void 0 : c.width) || this.defaultColWidth || jt, d = this.registry.systems[this.getId({ y: 0, x: h })];
+      d != null && (d.offsetLeft = s + o), o += f;
+    }
+    this.totalWidth = s + o;
+    let a = 0, l = 0;
+    for (const [h, c] of this._rowHeightOverrides)
+      h >= 1 && h <= e && (a += c - n);
+    for (const h of this._filteredRows)
+      if (h >= 1 && h <= e) {
+        const c = this._rowHeightOverrides.get(h) ?? n;
+        l += c;
+      }
+    const u = e * n + a;
+    this.totalHeight = i + u - l, this.fullHeight = i + u;
+  }
+  /** @internal */
+  refresh(t = !1, e = !1) {
+    return this._incrementVersion(), this.lastChangedTime = this.changedTime, this.changedTime = Date.now(), this.clearSolvedCaches(), this._stripped = wt, t && this.addressCaches.clear(), e && this.setTotalSize(), this;
+  }
+  /** @internal */
+  clone(t = !1) {
+    const e = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    return e._stripped = wt, e.refresh(t);
+  }
+  /** @internal */
+  getPointById(t, e = 0, s = 0) {
+    const i = t.startsWith("$");
+    i && (t = t.slice(1), s = 0);
+    const n = t.endsWith("$");
+    n && (t = t.slice(0, -1), e = 0);
+    const o = this.addressCaches.get(t);
+    if (o) {
+      const a = N(o);
+      return { y: a.y + e, x: a.x + s, absCol: i, absRow: n };
+    }
+    this._materializeIdMatrix();
+    for (let a = 0; a < this.idMatrix.length; a++) {
+      const l = this.idMatrix[a];
+      for (let u = 0; u < l.length; u++) {
+        const h = l[u], c = D({ y: a, x: u });
+        if (this.addressCaches.set(h, c), h === t)
+          return {
+            y: a + e,
+            x: u + s,
+            absCol: i,
+            absRow: n
+          };
+      }
+    }
+    return { y: -1, x: -1, absCol: i, absRow: n };
+  }
+  /** @internal */
+  getAddressById(t, e = 0, s = 0) {
+    const { y: i, x: n, absCol: o, absRow: a } = this.getPointById(t, e, s);
+    return Le(D({ y: i, x: n }), o, a);
+  }
+  /** @internal */
+  clearAddressCaches() {
+    this.addressCaches.clear();
+  }
+  /** @internal */
+  _warmAddressCaches() {
+    this._materializeIdMatrix();
+    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], D({ y: t, x: s }));
+    }
+  }
+  /** @internal */
+  getId(t) {
+    var i;
+    const { y: e, x: s } = t;
+    return e >= 0 && s >= 0 && e <= this.area.bottom && s <= this.area.right ? this._ensureIdRow(e)[s] : (i = this.idMatrix[e]) == null ? void 0 : i[s];
+  }
+  /** @internal */
+  getCell(t, { resolution: e = "RESOLVED", raise: s = !1 } = {}) {
+    const { y: i, x: n } = t;
+    if (i === -1 || n === -1)
+      return;
+    const o = this.getId(t);
+    if (o == null)
+      return;
+    this._ensureCellPopulated(i, n, o);
+    const a = this.registry.data[o];
+    if (a == null)
+      return;
+    let l = a.value;
+    return e !== "SYSTEM" && (a.formulaEnabled ?? !0) && (l = te({ value: l, sheet: this, point: t, raise: s, resolution: e, at: o })), { ...a, value: l };
+  }
+  /** @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: n = pi,
+    asScalar: o = !1
+  } = {}) {
+    const { top: a, left: l, bottom: u, right: h } = t ?? this.area, c = se(u - a + 1, h - l + 1);
+    for (let f = a; f <= u; f++)
+      for (let d = l; d <= h; d++) {
+        const p = this.getId({ y: f, x: d });
+        if (e === p)
+          throw new x("#REF!", "References are circulating.");
+        const m = this.getCell({ y: f, x: d }, { resolution: s, raise: i }) ?? {};
+        if (n(m)) {
+          let g = m.value;
+          o && (g = this.getPolicy({ y: f, x: d }).toScalar({ value: m.value, cell: m, sheet: this, point: { y: f, x: d } })), c[f - a][d - l] = g;
+        }
+      }
+    return c;
+  }
+  /** @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 n, o;
+      (o = (n = this.registry.systems[i]) == null ? void 0 : n.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: n = "SYSTEM",
+    undoReflection: o,
+    redoReflection: a
+  }) {
+    const l = t.__raw__, u = this._createMoveRelations(l, e, this, s), { diffBefore: h, diffAfter: c } = this._moveCells(l, this, u, !1, n);
+    return this._xsheetDispatch(l), i && this._pushHistory({
+      applyed: !0,
+      operation: "MOVE",
+      srcSheetId: l.id,
+      dstSheetId: this.id,
+      undoReflection: o,
+      redoReflection: a,
+      diffBefore: h,
+      diffAfter: c,
+      moveRelations: u
+    }), 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: n, left: o, bottom: a, right: l } = e, { top: u, left: h } = i, c = s.numRows, f = s.numCols, d = [];
+    for (let w = n; w <= a; w++)
+      t.isRowFiltered(w) || d.push(w);
+    const p = l - o + 1, m = d.length, g = [];
+    {
+      let w = 0, S = u;
+      for (; w < m; )
+        s.isRowFiltered(S) || (g.push(S), w++), S++;
+    }
+    const y = /* @__PURE__ */ new Set();
+    for (let w = 0; w < m; w++)
+      for (let S = 0; S < p; S++)
+        y.add(D({ y: d[w], x: o + S }));
+    const R = /* @__PURE__ */ new Set();
+    for (let w = 0; w < m; w++) {
+      const S = g[w];
+      for (let _ = 0; _ < p; _++) {
+        const M = h + _;
+        S <= c && M <= f && R.add(D({ y: S, x: M }));
+      }
+    }
+    const A = [];
+    for (let w = 0; w < m; w++) {
+      const S = d[w], _ = g[w];
+      for (let M = 0; M < p; M++) {
+        const T = o + M, C = h + M, Y = D({ y: S, x: T }), U = _ <= c && C <= f, G = U ? D({ y: _, x: C }) : void 0;
+        let V;
+        t === s && R.has(Y) || (V = t._generateId());
+        let q;
+        if (U) {
+          if (!(t === s && y.has(G))) {
+            const P = s.getId({ y: _, x: C });
+            P != null && (q = P);
+          }
+        } else {
+          const P = t.getId({ y: S, x: T });
+          P != null && (q = P);
+        }
+        const K = t.getCell({ y: S, x: T }, { resolution: "SYSTEM" }), v = U ? s.getCell({ y: _, x: C }, { resolution: "SYSTEM" }) : void 0;
+        A.push({
+          before: K == null ? void 0 : K.policy,
+          after: v == null ? void 0 : v.policy,
+          src: Y,
+          dst: G,
+          new: V,
+          lost: q
+        });
+      }
+    }
+    return A;
+  }
+  get defaultPolicy() {
+    return this.policies[xt] ?? ei;
+  }
+  /**
+   * 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, n = "SYSTEM") {
+    const o = {}, a = new lt(e), l = {}, u = [], h = [];
+    if (i)
+      for (const {
+        before: m,
+        after: g,
+        src: y,
+        dst: R,
+        new: A,
+        lost: w
+      } of s) {
+        if (R != null) {
+          const S = N(R), _ = e.getId(S);
+          if (_ != null) {
+            const M = N(y);
+            u.push({ y: M.y, x: M.x, id: _ });
+          }
+        }
+        if (w != null)
+          if (R != null) {
+            const S = N(R);
+            h.push({ y: S.y, x: S.x, id: w });
+          } else {
+            const S = N(y);
+            u.push({ y: S.y, x: S.x, id: w });
+          }
+      }
+    else
+      for (const {
+        before: m,
+        after: g,
+        src: y,
+        dst: R,
+        new: A,
+        lost: w
+      } of s) {
+        const S = N(y), _ = t.getId(S), M = R != null ? N(R) : void 0, T = M != null ? e.getId(M) : void 0, C = _ != null ? t.registry.data[_] : void 0, Y = T != null ? e.registry.data[T] : void 0;
+        if (!(n === "USER" && (O(C == null ? void 0 : C.prevention, It) || O(Y == null ? void 0 : Y.prevention, Tt)))) {
+          if (A != null) {
+            const U = m || xt, V = (t.policies[U] ?? t.defaultPolicy).select({
+              sheet: t,
+              point: S,
+              next: { value: null },
+              current: C,
+              operation: It
+            });
+            l[A] = {
+              ...V,
+              policy: m
+            }, this.registry.systems[A] = { id: A, sheetId: t.id, changedTime: Date.now() }, u.push({ y: S.y, x: S.x, id: A });
+          }
+          if (T != null && M != null && R != null) {
+            const U = g || xt, G = m || xt, V = e.policies[U] ?? e.defaultPolicy, q = t.policies[G] ?? t.defaultPolicy, K = q.priority > V.priority, P = (K ? q : V).select({
+              sheet: e,
+              point: M,
+              next: C,
+              current: Y,
+              operation: Tt
+            });
+            if (P && (o[_] = C ?? {}, l[_] = {
+              ...C,
+              ...P,
+              policy: K ? m : g
+            }), C != null) {
+              const ct = this.registry.systems[_];
+              ct && (ct.changedTime = Date.now());
+            }
+            h.push({ y: M.y, x: M.x, id: _ });
+          }
+        }
+      }
+    i || (t._materializeIdMatrix(), t !== e && e._materializeIdMatrix());
+    const c = i ? null : t.idMatrix.flat(), f = !i && t !== e ? e.idMatrix.flat() : null;
+    Object.assign(this.registry.data, l);
+    for (const { y: m, x: g, id: y } of u)
+      t._ensureIdRow(m)[g] = y;
+    for (const { y: m, x: g, id: y } of h)
+      e._ensureIdRow(m)[g] = y;
+    const d = s.filter((m) => m.dst != null).map((m) => m.dst), p = s.map((m) => m.src);
+    if (t === e ? e.lastChangedAddresses = [.../* @__PURE__ */ new Set([...p, ...d])] : (e.lastChangedAddresses = d, t.lastChangedAddresses = p), !i) {
+      a.buildMap(c.flat(), t.idMatrix.flat()), t !== e && a.buildMap(f.flat(), e.idMatrix.flat());
+      const m = a.resolveDependents("move");
+      Object.assign(o, m);
+    }
+    return { diffBefore: o, diffAfter: {} };
+  }
+  copy({
+    srcSheet: t = this,
+    src: e,
+    dst: s,
+    onlyValue: i = !1,
+    operator: n = "SYSTEM",
+    undoReflection: o,
+    redoReflection: a
+  }) {
+    const l = t !== this, { top: u, left: h, bottom: c, right: f } = e, { top: d, left: p, bottom: m, right: g } = s, y = {}, R = Date.now(), A = [];
+    for (let T = u; T <= c; T++)
+      t.isRowFiltered(T) || A.push(T);
+    const w = [];
+    for (let T = d; T <= m; T++)
+      T > this.numRows || this.isRowFiltered(T) || w.push(T);
+    const S = A.length, _ = f - h + 1, M = g - p + 1;
+    for (let T = 0; T < w.length; T++) {
+      const C = w[T], Y = A[T % S];
+      for (let U = 0; U <= M - 1; U++) {
+        const G = p + U;
+        if (G > this.numCols)
+          continue;
+        const V = h + U % _, q = l ? 0 : C - Y, K = l ? 0 : G - V, v = {
+          ...t.getCell({ y: Y, x: V }, { resolution: "SYSTEM" })
+        }, P = { y: C, x: G }, ct = this.getCell(P, { resolution: "SYSTEM" }), os = this.getPolicy(P), xe = { y: Y, x: V }, as = t.getPolicy(xe), Xt = t.getCell(xe, { resolution: "SYSTEM" }), cs = as.priority > os.priority;
+        v.policy = cs ? Xt == null ? void 0 : Xt.policy : ct == null ? void 0 : ct.policy;
+        const be = this.getId(P);
+        this.clearDependencies(be);
+        const ls = (v == null ? void 0 : v.formulaEnabled) ?? !0 ? this.processFormula(v == null ? void 0 : v.value, {
+          dependency: be,
+          slideY: q,
+          slideX: K
+        }) : v == null ? void 0 : v.value, hs = this.getId(P), Se = this.registry.systems[hs];
+        Se != null && (Se.changedTime = R);
+        const us = D(P);
+        if (i) {
+          const Z = this.getCell(P, { resolution: "SYSTEM" });
+          v.style = Z == null ? void 0 : Z.style, v.justifyContent = Z == null ? void 0 : Z.justifyContent, v.alignItems = Z == null ? void 0 : Z.alignItems;
+        }
+        y[us] = { ...v, value: ls };
+      }
+    }
+    return this.update({
+      diff: y,
+      partial: !1,
+      operator: n,
+      operation: ce,
+      undoReflection: o,
+      redoReflection: a
+    });
+  }
+  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: n = "SYSTEM",
+    operation: o = St,
+    formulaIdentify: a = !0
+  }) {
+    const l = {}, u = {}, h = [], c = Date.now();
+    let f = !1;
+    return Object.keys(t).forEach((d) => {
+      var w, S, _, M, T;
+      const p = N(d), m = this.getId(p), g = this.registry.data[m];
+      if (n === "USER" && O(g == null ? void 0 : g.prevention, St))
+        return;
+      let y = { ...t[d] };
+      if (a && "value" in y && (y.formulaEnabled ?? (g == null ? void 0 : g.formulaEnabled) ?? !0) && (this.clearDependencies(m), y.value = this.processFormula(y.value, { dependency: m })), i.forEach((C) => {
+        y[C] = g == null ? void 0 : g[C];
+      }), n === "USER" && O(g == null ? void 0 : g.prevention, ht) && delete y.value, n === "USER" && O(g == null ? void 0 : g.prevention, zt) && ((w = y == null ? void 0 : y.style) == null || delete w.justifyContent, (S = y == null ? void 0 : y.style) == null || delete S.alignItems), n === "USER" && O(g == null ? void 0 : g.prevention, Vt) && ((_ = y == null ? void 0 : y.style) == null || delete _.width, (M = y == null ? void 0 : y.style) == null || delete M.height), (y.width != null || y.height != null) && (f = !0), l[m] = g ?? {}, y = { ...(this.policies[(g == null ? void 0 : g.policy) || xt] ?? this.defaultPolicy).select({
+        sheet: this,
+        point: p,
+        next: y,
+        current: g,
+        operation: o
+      }) }, s) {
+        const C = this.registry.systems[m];
+        C != null && (C.changedTime = c);
+      }
+      if (e) {
+        const C = { ...g, ...y };
+        this.registry.data[m] = C, u[m] = C;
+      } else
+        this.registry.data[m] = y, u[m] = y;
+      if (p.x === 0 && p.y >= 1) {
+        const C = (T = this.registry.data[m]) == null ? void 0 : T.height, Y = this.defaultRowHeight || J;
+        C != null && C !== Y ? this._rowHeightOverrides.set(p.y, C) : this._rowHeightOverrides.delete(p.y);
+      }
+      h.push(d);
+    }), this.lastChangedAddresses = h, {
+      diffBefore: l,
+      diffAfter: u,
+      resized: f
+    };
+  }
+  update({
+    diff: t,
+    partial: e = !0,
+    updateChangedTime: s = !0,
+    historicize: i = !0,
+    operator: n = "SYSTEM",
+    operation: o = St,
+    ignoreFields: a,
+    undoReflection: l,
+    redoReflection: u
+  }) {
+    const { diffBefore: h, diffAfter: c, resized: f } = this._update({
+      diff: t,
+      partial: e,
+      operator: n,
+      operation: o,
+      updateChangedTime: s,
+      ...a != null ? { ignoreFields: a } : {}
+    });
+    return i && this._pushHistory({
+      applyed: !0,
+      operation: "UPDATE",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: l,
+      redoReflection: u,
+      diffBefore: h,
+      diffAfter: c,
+      partial: e
+    }), this.refresh(!1, f);
+  }
+  /** @internal */
+  writeRawCellMatrix({
+    point: t,
+    matrix: e,
+    updateChangedTime: s = !0,
+    historicize: i = !0,
+    onlyValue: n = !1,
+    operator: o = "SYSTEM",
+    undoReflection: a,
+    redoReflection: l
+  }) {
+    const { y: u, x: h } = t, c = {};
+    let f = 0, d = u;
+    for (; f < e.length && !(d > this.bottom); ) {
+      if (this.isRowFiltered(d)) {
+        d++;
+        continue;
+      }
+      e[f].forEach((m, g) => {
+        const y = h + g;
+        if (y > this.right)
+          return;
+        const R = { y: d, x: y }, A = this.parse(R, m.value ?? "");
+        if (A.style = { ...m.style, ...A.style }, n) {
+          const w = this.getCell(R, { resolution: "SYSTEM" });
+          A.style = w == null ? void 0 : w.style, A.justifyContent = w == null ? void 0 : w.justifyContent, A.alignItems = w == null ? void 0 : w.alignItems;
+        }
+        c[D(R)] = A;
+      }), f++, d++;
+    }
+    return this.update({
+      diff: c,
+      partial: !0,
+      updateChangedTime: s,
+      historicize: i,
+      operator: o,
+      operation: ht,
+      undoReflection: a,
+      redoReflection: l
+    });
+  }
+  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 ?? ""), n = this.getCell(e, { resolution: "RAW" });
+    if (((n == null ? void 0 : n.value) ?? null) === i.value)
+      return this;
+    const o = { [D(e)]: i };
+    return this.update({
+      ...t,
+      diff: o,
+      partial: !0,
+      operation: ht
+    });
+  }
+  insertRows({
+    y: t,
+    numRows: e,
+    baseY: s,
+    diff: i,
+    partial: n,
+    updateChangedTime: o,
+    operator: a = "SYSTEM",
+    undoReflection: l,
+    redoReflection: u
+  }) {
+    if (this.maxNumRows !== -1 && this.numRows + e > this.maxNumRows)
+      return console.error(`Rows are limited to ${this.maxNumRows}.`), this;
+    const h = this.numCols, c = [], f = Date.now();
+    for (let d = 0; d < e; d++) {
+      const p = [];
+      for (let m = 0; m <= h; m++) {
+        const g = this._generateId();
+        p.push(g);
+        const y = this.getCell({ y: s, x: m }, { resolution: "SYSTEM" }), R = this._copyCellLayout(y);
+        this.registry.data[g] = { ...R }, this.registry.systems[g] = { id: g, sheetId: this.id, changedTime: f };
+      }
+      c.push(p);
+    }
+    if (this.idMatrix.splice(t, 0, ...c), this.area.bottom += e, this._shiftRowMetaForInsert(t, e), this._seedRowMeta(t, e), this._pushHistory({
+      applyed: !0,
+      operation: "INSERT_ROWS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: l,
+      redoReflection: u,
+      y: t,
+      numRows: e,
+      idMatrix: c
+    }), i && Object.assign(this.registry.lastHistory, this._update({ diff: i, partial: n, updateChangedTime: o, operator: a }), {
+      partial: n
+    }), 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: n
+  }) {
+    if (this.minNumRows !== -1 && this.numRows - e < this.minNumRows)
+      return console.error(`At least ${this.minNumRows} row(s) are required.`), this;
+    const o = new lt(this), a = [];
+    this._materializeIdMatrix();
+    const l = this.idMatrix.map((c) => [...c]);
+    for (let c = t; c < t + e; c++) {
+      const f = this.getCell({ y: c, x: 0 }, { resolution: "SYSTEM" });
+      if (s === "USER" && O(f == null ? void 0 : f.prevention, Bt))
+        return console.warn(`Cannot delete row ${c}.`), this;
+      for (let d = 1; d <= this.numCols; d++) {
+        const p = this.getId({ y: c, x: d });
+        p != null && (o.collectDependents(p), o.map[p] = this.getId({ y: c + e, x: d }));
+      }
+      a.unshift(c);
+    }
+    const u = [];
+    a.forEach((c) => {
+      const f = this.idMatrix.splice(c, 1);
+      u.unshift(f[0]);
+    }), this.area.bottom -= a.length, this._shiftRowMetaForRemove(t, e);
+    const h = o.resolveDependents("removeRows");
+    if (this._pushHistory({
+      applyed: !0,
+      operation: "REMOVE_ROWS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: i,
+      redoReflection: n,
+      ys: a.reverse(),
+      diffBefore: h,
+      deleted: u
+    }), this.registry.onRemoveRows) {
+      const c = this.clone();
+      c.idMatrix = l, c.area = {
+        top: t,
+        bottom: t + e - 1,
+        left: this.area.left,
+        right: this.area.right
+      }, c.addressCaches = /* @__PURE__ */ new Map(), this.registry.onRemoveRows({ sheet: c, ys: a.reverse() });
+    }
+    return this.refresh(!0, !0);
+  }
+  insertCols({
+    x: t,
+    numCols: e,
+    baseX: s,
+    diff: i,
+    partial: n,
+    updateChangedTime: o,
+    operator: a = "SYSTEM",
+    undoReflection: l,
+    redoReflection: u
+  }) {
+    if (this.maxNumCols !== -1 && this.numCols + e > this.maxNumCols)
+      return console.error(`Columns are limited to ${this.maxNumCols}.`), this;
+    const h = this.numRows, c = [], f = Date.now();
+    for (let d = 0; d <= h; d++) {
+      const p = [];
+      for (let m = 0; m < e; m++) {
+        const g = this._generateId();
+        p.push(g);
+        const y = this.getCell({ y: d, x: s }, { resolution: "SYSTEM" }), R = this._copyCellLayout(y);
+        this._ensureIdRow(d).splice(t, 0, g), this.registry.data[g] = { ...R }, this.registry.systems[g] = { id: g, sheetId: this.id, changedTime: f };
+      }
+      c.push(p);
+    }
+    if (this.area.right += e, this._pushHistory({
+      applyed: !0,
+      operation: "INSERT_COLS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: l,
+      redoReflection: u,
+      x: t,
+      numCols: e,
+      idMatrix: c
+    }), i && Object.assign(this.registry.lastHistory, this._update({ diff: i, partial: n, updateChangedTime: o, operator: a }), {
+      partial: n
+    }), 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: n
+  }) {
+    if (this.minNumCols !== -1 && this.numCols - e < this.minNumCols)
+      return console.error(`At least ${this.minNumCols} column(s) are required.`), this;
+    const o = new lt(this), a = [];
+    this._materializeIdMatrix();
+    const l = this.idMatrix.map((c) => [...c]);
+    for (let c = t; c < t + e; c++) {
+      const f = this.getCell({ y: 0, x: c }, { resolution: "SYSTEM" });
+      if (s === "USER" && O(f == null ? void 0 : f.prevention, Ut)) {
+        console.warn(`Cannot delete col ${c}.`);
+        continue;
+      }
+      for (let d = 1; d <= this.numRows; d++) {
+        const p = this.getId({ y: d, x: c });
+        p != null && (o.collectDependents(p), o.map[p] = this.getId({ y: d, x: c + e }));
+      }
+      a.unshift(c);
+    }
+    const u = [];
+    this.idMatrix.forEach((c) => {
+      const f = [];
+      u.push(f), a.forEach((d) => {
+        f.unshift(...c.splice(d, 1));
+      });
+    }), this.area.right -= a.length;
+    const h = o.resolveDependents("removeCols");
+    if (this._pushHistory({
+      applyed: !0,
+      operation: "REMOVE_COLS",
+      srcSheetId: this.id,
+      dstSheetId: this.id,
+      undoReflection: i,
+      redoReflection: n,
+      xs: a.reverse(),
+      diffBefore: h,
+      deleted: u
+    }), this.registry.onRemoveCols) {
+      const c = this.clone();
+      c.idMatrix = l, c.area = {
+        top: this.area.top,
+        bottom: this.area.bottom,
+        left: t,
+        right: t + e - 1
+      }, c.addressCaches = /* @__PURE__ */ new Map(), this.registry.onRemoveCols({ sheet: c, xs: a.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"
+  }) {
+    if (e == null) {
+      const o = this.getId(t);
+      e = o != null ? this.registry.data[o] : void 0;
+    }
+    if (e == null)
+      return "";
+    const i = this.getPolicy(t), n = e.value;
+    if (typeof n == "string" && n[0] === "=") {
+      if (s === "SYSTEM")
+        return n;
+      if (s === "RAW" || (e == null ? void 0 : e.formulaEnabled) === !1) {
+        const o = new $t(n.substring(1));
+        return o.tokenize(), "=" + o.display({ sheet: this });
+      }
+      try {
+        const o = this.getId(t), a = te({ value: n, sheet: this, point: t, raise: !0, resolution: s, at: o }), l = nt({ value: a, raise: !1 });
+        return i.serialize({ value: l, cell: e, sheet: this, point: t });
+      } catch (o) {
+        return i.serialize({ value: o, cell: e, sheet: this, point: t });
+      }
+    }
+    return i.serialize({ value: n, cell: e, sheet: this, point: t });
+  }
+  /** @internal */
+  trim(t) {
+    const e = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
+    return e.area = t, e._stripped = wt, e;
+  }
+  /**
+   * Solve all formulas in this sheet and return a 2D matrix of resolved values.
+   * @internal
+   */
+  solve({ raise: t = !1, at: e }) {
+    return Oe({ sheet: this, raise: t, at: e });
+  }
+  /**
+   * Collapse this sheet to a scalar (top-left cell value).
+   * @internal
+   */
+  strip({ raise: t = !1, at: e }) {
+    var i;
+    if (!wt.is(this._stripped))
+      return this._stripped;
+    let s = this;
+    for (; s instanceof $; )
+      s = (i = Oe({ sheet: s, raise: t, at: e })[0]) == null ? void 0 : i[0];
+    return this._stripped = s, this._stripped;
+  }
+  /** @internal */
+  _applyDiff(t = {}, e = !0) {
+    const s = Object.keys(t);
+    s.forEach((n) => {
+      const o = t[n] ?? {};
+      let a;
+      e ? (a = { ...this.registry.data[n] }, Object.keys(o).forEach((h) => {
+        o[h] === void 0 ? delete a[h] : a[h] = o[h];
+      })) : a = { ...o };
+      const l = this.registry.systems[n];
+      l != null && (l.changedTime = Date.now()), this.registry.data[n] = a, this.clearDependencies(n), this.processFormula(a.value, { dependency: n });
+      const u = this.addressCaches.get(n);
+      if (u) {
+        const h = N(u);
+        if (h.x === 0 && h.y > 0) {
+          const c = this.defaultRowHeight || J, f = a.height ?? c;
+          f !== c ? this._rowHeightOverrides.set(h.y, f) : this._rowHeightOverrides.delete(h.y), a.filtered ? this._filteredRows.add(h.y) : this._filteredRows.delete(h.y);
+        }
+      }
+    }), this._warmAddressCaches();
+    const i = [];
+    for (const n of s) {
+      const o = this.getAddressById(n);
+      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 } = Nt({ matrix: t.idMatrix });
+        s._materializeIdMatrix(), s.idMatrix.splice(t.y, i), s.area.bottom -= i, s._shiftRowMetaForRemove(t.y, i);
+        break;
+      }
+      case "INSERT_COLS": {
+        t.diffBefore && s._applyDiff(t.diffBefore, !1);
+        const { cols: i } = Nt({ matrix: t.idMatrix });
+        s._materializeIdMatrix(), s.idMatrix.forEach((n) => {
+          n.splice(t.x, i);
+        }), s.area.right -= i;
+        break;
+      }
+      case "REMOVE_ROWS": {
+        const { ys: i, deleted: n } = t;
+        s._materializeIdMatrix(), i.forEach((a, l) => {
+          s.idMatrix.splice(a, 0, n[l]);
+        }), s.area.bottom += i.length;
+        const o = Math.min(...i);
+        s._shiftRowMetaForInsert(o, i.length), s._seedRowMeta(o, i.length), this._applyDiff(t.diffBefore, !1);
+        break;
+      }
+      case "REMOVE_COLS": {
+        const { xs: i, deleted: n } = t;
+        s._materializeIdMatrix(), s.idMatrix.forEach((o, a) => {
+          for (let l = 0; l < i.length; l++)
+            o.splice(i[l], 0, n[a][l]);
+        }), 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": {
+        s._materializeIdMatrix();
+        const i = s.idMatrix.flat();
+        s._sortRowMapping(t.sortedRowMapping, !0);
+        const n = new lt(s);
+        n.buildMap(i, s.idMatrix.flat()), n.resolveDependents(), s._reapplyFilters();
+        break;
+      }
+    }
+    return this.refresh(Me(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 n, o;
+        (o = i.current) == null || o.registry.transmit((n = t.undoReflection) == null ? void 0 : n.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 } = Nt({ matrix: t.idMatrix });
+        s._materializeIdMatrix(), s.idMatrix.splice(t.y, 0, ...t.idMatrix), s.area.bottom += i, s._shiftRowMetaForInsert(t.y, i), s._seedRowMeta(t.y, i);
+        break;
+      }
+      case "INSERT_COLS": {
+        t.diffAfter && s._applyDiff(t.diffAfter, !1);
+        const { cols: i } = Nt({ matrix: t.idMatrix });
+        s._materializeIdMatrix(), s.idMatrix.map((n, o) => {
+          n.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": {
+        s._materializeIdMatrix();
+        const i = s.idMatrix.flat();
+        s._sortRowMapping(t.sortedRowMapping, !1);
+        const n = new lt(s);
+        n.buildMap(i, s.idMatrix.flat()), n.resolveDependents(), s._reapplyFilters();
+        break;
+      }
+    }
+    return this.refresh(Me(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 n, o;
+        (o = i.current) == null || o.registry.transmit((n = t.redoReflection) == null ? void 0 : n.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 n, o;
+      (o = (n = this.registry.systems[i]) == null ? void 0 : n.dependents) == null || o.delete(t);
+    }), e != null && (e.dependencies = /* @__PURE__ */ new Set());
+  }
+  /** @internal */
+  addDependency(t, e) {
+    const s = bt(this.registry, t);
+    s.dependents == null && (s.dependents = /* @__PURE__ */ new Set()), s.dependents.add(e);
+    const i = bt(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), bt(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 n = this.registry.systems[s], o = n == null ? void 0 : n.tmpAsyncCaches;
+    o != null && (Object.keys(o).length > 0 ? i.asyncCaches = o : delete i.asyncCaches, delete n.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 a;
+    const s = e.length, i = s > 0 ? e[0].length : 0;
+    if (s <= 1 && i <= 1)
+      return (a = e[0]) == null ? void 0 : a[0];
+    for (let l = 0; l < s; l++)
+      for (let u = 0; u < i; u++) {
+        if (l === 0 && u === 0)
+          continue;
+        const h = { y: t.y + l, x: t.x + u }, c = this.getId(h), f = D(h);
+        if (c == null) {
+          console.warn(`Spill target ${f} is out of bounds.`);
+          continue;
+        }
+        const d = this.registry.data[c];
+        if ((d == null ? void 0 : d.value) != null && d.value !== "")
+          throw new x(
+            "#REF!",
+            `Array result was not expanded because it would overwrite data in ${f}.`
+          );
+        if (this.registry.solvedCaches.has(c))
+          throw new x(
+            "#REF!",
+            `Array result was not expanded because ${f} is already occupied by another formula.`
+          );
+      }
+    const n = this.getId(t), o = [];
+    for (let l = 0; l < s; l++)
+      for (let u = 0; u < i; u++) {
+        const h = { y: t.y + l, x: t.x + u }, c = this.getId(h);
+        if (c != null && (this.finishSolvedCache(h, e[l][u]), (l !== 0 || u !== 0) && (o.push(D(h)), n != null))) {
+          const f = bt(this.registry, c, {});
+          f.spilledFrom = D(t), this.registry.lastSpilledTargetIds.add(c);
+        }
+      }
+    return e[0][0];
+  }
+  /** @internal */
+  sheetPrefix(t = !1) {
+    return t ? "" : Ws(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 = `${W(this.right)}${i}`);
+    const { y: n, x: o } = N(s), { y: a, x: l } = N(i || s);
+    return {
+      top: Math.abs(n),
+      left: Math.abs(o),
+      bottom: Math.abs(a),
+      right: Math.abs(l)
+    };
+  }
+  get __raw__() {
+    return this;
+  }
+  get shape() {
+    return Kt(this.area);
+  }
+  get hasSingleCell() {
+    const t = this.shape;
+    return t.rows === 1 && t.cols === 1;
+  }
+  get currentVersion() {
+    return this.version;
+  }
+}
+const te = ({ value: r, sheet: t, point: e, raise: s = !0, resolution: i = "RESOLVED", at: n }) => {
+  var u;
+  const [o, a] = t.getSolvedCache(e);
+  if (o && r == null && !At.is(a))
+    return a;
+  if (typeof r != "string" || i === "SYSTEM")
+    return r;
+  if (r.charAt(0) === "'")
+    return i === "RAW" ? r : r.substring(1);
+  if (r.charAt(0) !== "=")
+    return r;
+  if (i === "RAW") {
+    const h = new $t(r.substring(1), { at: n });
+    return h.tokenize(), "=" + h.display({ sheet: t });
+  }
+  let l = r;
+  if (o && !At.is(a))
+    l = a;
+  else
+    try {
+      const h = new $t(r.substring(1), { at: n });
+      h.tokenize();
+      const f = new ze(h.tokens).build();
+      l = (u = f == null ? void 0 : f.evaluate) == null ? void 0 : u.call(f, { sheet: t });
+    } catch (h) {
+      if (s)
+        throw t.finishSolvedCache(e, h), h;
+      return h;
+    }
+  return B.is(l) ? l = t.spill(e, l.matrix) : t.finishSolvedCache(e, l), i === "RESOLVED" && l instanceof $ && (l = nt({ value: l, raise: s, at: n })), k.is(l) && t.finishSolvedCache(e, l), l;
+}, Oe = ({ sheet: r, raise: t = !0, at: e }) => {
+  const s = r.area;
+  return r._toValueMatrix({ area: s, at: e, resolution: "SYSTEM" }).map((n, o) => {
+    const a = s.top + o;
+    return n.map((l, u) => {
+      const h = s.left + u, c = { y: a, x: h }, [f, d] = r.getSolvedCache(c);
+      try {
+        if (At.is(d))
+          throw new x("#REF!", "References are circulating.", new Error(l));
+        if (k.is(d))
+          return d;
+        if (x.is(d))
+          throw d;
+        if (d != null)
+          return d;
+        r.setSolvingCache(c);
+        const p = te({ value: l, sheet: r, point: c, raise: t, at: e, resolution: "RESOLVED" });
+        return r.finishSolvedCache(c, p), p;
+      } catch (p) {
+        if (r.finishSolvedCache(c, p), t)
+          throw p;
+        return p;
+      }
+    });
+  });
+}, nt = ({ value: r, at: t, raise: e = !0 }) => r instanceof $ ? r.strip({ raise: e, at: t }) : r, ee = new ut("asyncCacheMiss"), mi = (r) => r.some((t) => k.is(t)), es = (r) => (r == null ? void 0 : r.__gsType) === "Sheet", Rt = (r, t) => {
+  for (const e of r)
+    if (k.is(e) || Array.isArray(e) && Rt(e, t) || B.is(e) && Rt(e.matrix, t) || es(e) && Rt(e._toValueMatrix({ at: t }), t))
+      return !0;
+  return !1;
+}, gi = (r, t = 0) => {
+  let e = 3735928559 ^ t, s = 1103547991 ^ t;
+  for (let i = 0; i < r.length; i++) {
+    const n = r.charCodeAt(i);
+    e = Math.imul(e ^ n, 2654435761), s = Math.imul(s ^ n, 1597334677);
+  }
+  return e = Math.imul(e ^ e >>> 16, 2246822507), e ^= Math.imul(s ^ s >>> 13, 3266489909), s = Math.imul(s ^ s >>> 16, 2246822507), s ^= Math.imul(e ^ e >>> 13, 3266489909), 4294967296 * (2097151 & s) + (e >>> 0);
+}, yi = (r, t, e = 1) => {
+  const s = JSON.stringify(t, (n, o) => es(o) ? Vs(o) : k.is(o) ? null : o), i = Array.from({ length: e }, (n, o) => gi(s, o).toString(36));
+  return `${r}:${s.length}:${i.join("-")}`;
+}, wi = (r, t, e, s = !1) => {
+  var l;
+  const i = r.registry, n = i.data[t];
+  if (n == null)
+    return ee;
+  const o = bt(i, t, { tmpAsyncCaches: {} });
+  if (n.asyncCaches != null) {
+    const u = n.asyncCaches[e];
+    if (u != null && (u.expireTime == null || Date.now() < u.expireTime))
+      return o.tmpAsyncCaches[e] = u, u.value;
+  }
+  const a = `${t}:${e}`;
+  if (i.asyncPending.has(a))
+    return i.asyncPending.get(a);
+  if (s && ((l = i.asyncInflight) != null && l.has(e))) {
+    const u = i.asyncInflight.get(e);
+    return i.asyncPending.set(a, u.pending), u.pending.promise.then((h) => {
+      const c = i.data[t];
+      c != null && Lt(c, e, { value: h, expireTime: u.expireTime });
+    }).catch((h) => {
+      x.is(h) || (h = new x("#ASYNC!", (h == null ? void 0 : h.message) ?? String(h), h instanceof Error ? h : void 0));
+      const c = i.data[t];
+      c != null && Lt(c, e, { value: h, expireTime: u.expireTime });
+    }).finally(() => {
+      i.asyncPending.delete(a);
+    }), u.pending;
+  }
+  return ee;
+}, xi = (r, t, e, s, i, n = !1) => {
+  const o = t.registry, a = i != null ? Date.now() + i : void 0, l = `${e}:${s}`, u = new k(r);
+  return o.asyncPending.set(l, u), n && (o.asyncInflight || (o.asyncInflight = /* @__PURE__ */ new Map()), o.asyncInflight.set(s, { pending: u, expireTime: a })), r.then((h) => {
+    const c = o.data[e];
+    c != null && Lt(c, s, { value: h, expireTime: a });
+  }).catch((h) => {
+    x.is(h) || (h = new x("#ASYNC!", (h == null ? void 0 : h.message) ?? String(h), h instanceof Error ? h : void 0));
+    const c = o.data[e];
+    c != null && Lt(c, s, { value: h, expireTime: a });
+  }).finally(() => {
+    o.asyncPending.delete(l), n && o.asyncInflight && o.asyncInflight.delete(s), o.solvedCaches.clear(), o.transmit();
+  }), u;
+}, Gt = () => new k(Promise.resolve()), fe = (r, t) => {
+  if (typeof r == "string" || typeof t == "string")
+    return X(r) > X(t);
+  try {
+    return F(r) > F(t);
+  } catch {
+    return !1;
+  }
+}, pe = (r, t) => {
+  if (typeof r == "string" || typeof t == "string")
+    return X(r) >= X(t);
+  try {
+    return F(r) >= F(t);
+  } catch {
+    return !1;
+  }
+}, ss = (r, t) => !pe(r, t), is = (r, t) => !fe(r, t), me = (r, t) => X(r).toLowerCase() === X(t).toLowerCase(), bi = (r, t) => !me(r, t), ge = (r) => typeof r != "string" || !r.endsWith("%") ? !1 : !isNaN(parseFloat(r.slice(0, -1))), Mt = (r) => typeof r == "number" || ge(r) ? !0 : typeof r == "string" ? !isNaN(parseFloat(r)) && isFinite(Number(r)) : !1, F = (r, t) => {
+  const { alternative: e, ignore: s } = t || {};
+  if (k.is(r))
+    return r;
+  if (typeof r > "u" && typeof e < "u")
+    return e;
+  if (!r)
+    return 0;
+  if (r instanceof $) {
+    const n = nt({ value: r });
+    return F(n, { alternative: e });
+  }
+  if (r instanceof Date)
+    return r.getTime();
+  if (b.is(r))
+    return r.days;
+  if (ge(r))
+    return parseFloat(r.slice(0, -1)) / 100;
+  const i = parseFloat(r);
+  if (isNaN(i)) {
+    if (s)
+      return e ?? 0;
+    throw new x("#VALUE!", `${r} cannot be converted to a number`);
+  }
+  return i;
+}, X = (r) => {
+  if (k.is(r))
+    return r;
+  if (r === 0)
+    return "0";
+  if (!r)
+    return "";
+  if (r instanceof $) {
+    const t = nt({ value: r });
+    return X(t);
+  }
+  switch (r.constructor.name) {
+    case "Date":
+      return H(r).format(ms);
+    default:
+      return String(r);
+  }
+}, Ot = (r, t) => {
+  const { alternative: e, ignore: s } = t ?? {};
+  if (k.is(r))
+    return r;
+  if (typeof r > "u" && typeof e < "u")
+    return e;
+  if (r === null)
+    return !1;
+  if (r instanceof $) {
+    const i = nt({ value: r });
+    return Ot(i, t);
+  }
+  if (typeof r == "string" || r instanceof String) {
+    const i = { true: !0, false: !1 }[r.toLowerCase()];
+    if (i == null) {
+      if (s)
+        return !1;
+      throw new x("#VALUE!", `text '${r}' cannot be converted to a boolean`);
+    }
+    return i;
+  }
+  return !!r;
+};
+function Si(r) {
+  if (k.is(r) || r instanceof Date)
+    return r;
+  if (r instanceof $) {
+    const t = nt({ value: r });
+    return Si(t);
+  }
+  if (typeof r == "number")
+    return new Date(r);
+  if (typeof r == "string") {
+    const t = new Date(r);
+    if (!isNaN(t.getTime()))
+      return t;
+  }
+  throw new x("#VALUE!", `${r} cannot be converted to a date`);
+}
+const Ri = /^(<=|>=|<>|>|<|=)?(.*)$/, _i = (r, t) => {
+  const e = t.match(Ri), [, s = "", i = ""] = e || [];
+  let n = i;
+  if (s === ">" || s === "<" || s === ">=" || s === "<=")
+    switch (typeof r == "number" && (n = parseFloat(i)), s) {
+      case ">":
+        return fe(r, n);
+      case ">=":
+        return pe(r, n);
+      case "<":
+        return ss(r, n);
+      case "<=":
+        return is(r, n);
+    }
+  const o = s === "" || s === "=";
+  if (i === "")
+    return (r == null || r === "") === o;
+  if (typeof r == "string" || r instanceof String) {
+    const a = i.replace(/~\*/g, "(\\*)").replace(/~\?/g, "(\\?)").replace(/\*/g, "(.*)").replace(/\?/g, "(.)");
+    return RegExp(`^${a}$`, "i").test(r) === o;
+  }
+  return me(r, n) === o;
+}, ot = (r, t, e) => {
+  if (r instanceof $) {
+    const s = r.solve({ at: e });
+    for (let i = 0; i < s.length; i++)
+      for (let n = 0; n < s[i].length; n++)
+        t(s[i][n], { y: i, x: n });
+  } else if (B.is(r)) {
+    const s = r.matrix;
+    for (let i = 0; i < s.length; i++)
+      for (let n = 0; n < s[i].length; n++)
+        t(s[i][n], { y: i, x: n });
+  } else if (Array.isArray(r) && Array.isArray(r[0]))
+    for (let s = 0; s < r.length; s++)
+      for (let i = 0; i < r[s].length; i++)
+        t(r[s][i], { y: s, x: i });
+  else
+    t(r, { y: 0, x: 0 });
+}, mn = (r, t, e) => {
+  if (r.length === 0)
+    return [];
+  const s = r[0], i = s.numRows, n = s.numCols, o = Array.from({ length: i }, () => Array(n).fill(!0));
+  for (let a = 0; a < r.length; a++) {
+    const l = r[a], u = t[a];
+    ot(
+      l,
+      (h, c) => {
+        var f, d;
+        (f = o[c.y])[d = c.x] && (f[d] = _i(h, u));
+      },
+      e
+    );
+  }
+  return o;
+}, Q = (r) => (r == null ? void 0 : r.__gsType) === "Sheet", gn = {
+  name: "condition",
+  description: 'The condition to evaluate. Use "=" for equal, "<" for less than, ">" for greater than, "<=" for less than or equal, ">=" for greater than or equal, "<>" for not equal.',
+  acceptedTypes: ["any"]
+}, Ei = (r, { nullable: t = !0, errorTolerant: e = !1, acceptedTypes: s }) => {
+  if (!s || s.length === 0)
+    return !0;
+  if (r == null)
+    return t;
+  if (x.is(r) || r instanceof Error) {
+    if (e)
+      return !0;
+    throw r;
+  }
+  for (const i of s)
+    switch (i) {
+      case "any":
+        return !0;
+      case "number":
+        if (Mt(r))
+          return !0;
+        break;
+      case "string":
+        if (typeof r == "string")
+          return !0;
+        break;
+      case "boolean":
+        if (typeof r == "boolean")
+          return !0;
+        break;
+      case "date":
+        if (r instanceof Date)
+          return !0;
+        break;
+      case "time":
+        if (b.is(r))
+          return !0;
+        break;
+      case "matrix":
+        if (at(r))
+          return !0;
+        break;
+      case "reference":
+        if (Q(r))
+          return !0;
+        break;
+    }
+  return !1;
+}, at = (r) => Q(r) || B.is(r) || Array.isArray(r) && Array.isArray(r[0]), Ai = (r, t) => {
+  var i;
+  if (!at(r))
+    return r;
+  if (Q(r))
+    return nt({ value: r, raise: !1, at: t });
+  const e = B.is(r) ? r.matrix : r;
+  return (i = e == null ? void 0 : e[0]) == null ? void 0 : i[0];
+}, Ne = (r) => {
+  if (Q(r))
+    return !r.hasSingleCell;
+  if (B.is(r)) {
+    const t = r.matrix;
+    return t.length > 1 || t.length === 1 && t[0].length > 1;
+  }
+  return Array.isArray(r) && Array.isArray(r[0]) ? r.length > 1 || r[0].length > 1 : !1;
+}, Fe = (r, t) => {
+  const e = [];
+  let s = -1, i = 0;
+  for (let n = 0; n < r.length; n++)
+    r[n].variadic && (s < 0 && (s = n), i++);
+  for (let n = 0; n < t; n++)
+    if (s >= 0 && n >= s) {
+      const o = (n - s) % i;
+      e.push(s + o);
+    } else n < r.length ? e.push(n) : e.push(r.length - 1);
+  return e;
+}, Yt = class Yt {
+  constructor({ args: t, sheet: e, at: s }) {
+    this.defs = [], this.description = "", this.category = "other", this.isAsync = !1, this.hashPrecision = 1, this.useInflight = !0, this.broadcastDisabled = !1, this.autoSpilling = !1, this.eachMatrix = (i, n) => {
+      if (Q(i)) {
+        const o = i.solve({ at: this.at, raise: !0 });
+        for (let a = 0; a < o.length; a++)
+          for (let l = 0; l < o[a].length; l++)
+            n(o[a][l]);
+      } else if (B.is(i)) {
+        const o = i.matrix;
+        for (let a = 0; a < o.length; a++)
+          for (let l = 0; l < o[a].length; l++)
+            n(o[a][l]);
+      } else if (Array.isArray(i) && Array.isArray(i[0]))
+        for (let o = 0; o < i.length; o++)
+          for (let a = 0; a < i[o].length; a++)
+            n(i[o][a]);
+      else
+        n(i);
+    }, this.args = t.map((i) => {
+      try {
+        return i.evaluate({ sheet: e });
+      } catch (n) {
+        return n;
+      }
+    }), this.sheet = e, this.at = s ?? "?";
+  }
+  _main(...t) {
+    return this.autoSpilling ? new B(this.main(...t)) : this.main(...t);
+  }
+  /**
+   * Validate and normalise arguments before `main()` is called.
+   *
+   * Checks:
+   * 1. Argument count satisfies defs (respecting optional / variadic).
+   * 2. Each argument's runtime type matches the corresponding def's `type` list.
+   *
+   * Subclasses may override for additional coercion / spreading.
+   */
+  validate(t) {
+    const e = [...t], s = this.defs;
+    if (s.length === 0) {
+      if (t.length !== 0)
+        throw new x("#N/A", "Too many arguments: expected 0, got " + t.length + ".");
+      return e;
+    }
+    let i = 0, n = !1;
+    for (const a of s)
+      a.variadic && (n = !0), a.optional || i++;
+    if (t.length < i)
+      throw new x("#N/A", `Too few arguments: expected at least ${i}, got ${t.length}.`);
+    if (!n && t.length > s.length)
+      throw new x("#N/A", `Too many arguments: expected at most ${s.length}, got ${t.length}.`);
+    const o = Fe(s, t.length);
+    for (let a = 0; a < t.length; a++) {
+      const l = s[o[a]];
+      if (!l)
+        continue;
+      let u = t[a];
+      if (!(!l.acceptedTypes || l.acceptedTypes.length === 0)) {
+        if (Ne(u)) {
+          if (!l.takesMatrix)
+            continue;
+        } else at(u) && (l.takesMatrix || (u = Ai(u, this.at)));
+        if (ge(u) && (u = parseFloat(u.slice(0, -1)) / 100), !Ei(u, l))
+          throw new x(
+            "#VALUE!",
+            `Argument "${l.name}" (position ${a + 1}) expected ${l.acceptedTypes.join(" | ")}, got ${typeof u}.`
+          );
+        e[a] = u;
+      }
+    }
+    return e;
+  }
+  /**
+   * Extract a 2D array from a matrix value (Spilling, Sheet, or nested array).
+   * Default behavior for Sheet is value.solve(). Functions like COL can override
+   * this to preserve Sheet metadata per cell.
+   */
+  toMatrix(t) {
+    return B.is(t) ? t.matrix : Q(t) ? t.solve({ at: this.at }) : Array.isArray(t) && Array.isArray(t[0]) ? t : [[t]];
+  }
+  /**
+   * Collapse a 1×1 matrix value (Sheet, Spilling, or 2D array) to a scalar.
+   * Non-matrix values pass through unchanged.
+   *
+   * Override in sub-classes that need the original Sheet / reference
+   * metadata (e.g. COL, ROW) — for instance, to extract position
+   * information before collapsing.
+   */
+  toScalar(t) {
+    var e, s, i;
+    if (Q(t)) {
+      const { rows: n, cols: o } = t.shape;
+      return n === 1 && o === 1 ? t.strip({}) : t;
+    }
+    return B.is(t) ? (s = (e = t.matrix) == null ? void 0 : e[0]) == null ? void 0 : s[0] : Array.isArray(t) ? Array.isArray(t[0]) ? (i = t[0]) == null ? void 0 : i[0] : t[0] : t;
+  }
+  call() {
+    const t = this.broadcast();
+    if (t !== void 0)
+      return t;
+    if (Rt(this.args, this.at))
+      return Gt();
+    if (this.args = this.validate(this.args), this.isAsync) {
+      const e = yi(this.constructor.name, this.args, this.hashPrecision), s = wi(this.sheet, this.at, e, this.useInflight);
+      if (s !== ee)
+        return s;
+      const i = this._main(...this.args);
+      return xi(i, this.sheet, this.at, e, this.ttlMilliseconds, this.useInflight);
+    }
+    return this._main(...this.args);
+  }
+  /**
+   * If any broadcastable argument is a matrix (multi-cell), expand the call
+   * across all element positions and return a Spilling.
+   * Returns `undefined` when no broadcast is necessary.
+   *
+   * Rules:
+   * - broadcastDisabled = true → never broadcast
+   * - An arg is broadcastable when its corresponding args[].takesMatrix is not true
+   * - A Sheet/Spilling/2D-array whose size is (1,1) is treated as a scalar
+   *   (not broadcast); only multi-cell matrices trigger broadcast
+   * - For variadic args, extra args are assigned round-robin
+   *   across the variadic helpArg positions
+   */
+  broadcast() {
+    if (this.broadcastDisabled)
+      return;
+    const t = Fe(this.defs, this.args.length), e = this.args.map((u, h) => {
+      var f;
+      const c = t[h];
+      return !((f = this.defs[c]) != null && f.takesMatrix);
+    }), s = this.args.map((u, h) => e[h] && Ne(u) ? this.toMatrix(u) : null);
+    if (s.every((u) => u === null))
+      return;
+    const i = this.args.map((u, h) => s[h] !== null ? u : this.toScalar(u));
+    let n = 1, o = 1;
+    for (const u of s)
+      u && (n = Math.max(n, u.length), o = Math.max(
+        o,
+        u.reduce((h, c) => Math.max(h, c.length), 0)
+      ));
+    const a = this.args, l = [];
+    for (let u = 0; u < n; u++) {
+      const h = [];
+      for (let c = 0; c < o; c++) {
+        const f = i.map((d, p) => {
+          var g;
+          const m = s[p];
+          return m ? ((g = m == null ? void 0 : m[u]) == null ? void 0 : g[c]) ?? null : d;
+        });
+        try {
+          if (mi(f))
+            h.push(Gt());
+          else {
+            const d = this.validate(f);
+            Rt(d, this.at) ? h.push(Gt()) : h.push(this._main(...d));
+          }
+        } catch (d) {
+          h.push(d);
+        }
+      }
+      l.push(h);
+    }
+    return this.args = a, l;
+  }
+};
+Yt.__name = "", Yt.isAsync = !1;
+let E = Yt;
+const we = class we extends E {
+  constructor() {
+    super(...arguments), this.isAsync = !0;
+  }
+};
+we.isAsync = !0;
+let De = we;
+const Ci = `Returns the sum of two numbers.
+This is the same as the '+' operator.`;
+class Ii extends E {
+  constructor() {
+    super(...arguments), this.example = "ADD(2, 3)", this.description = Ci, this.defs = [
+      { name: "value1", description: "First additive.", acceptedTypes: ["number", "date", "time"] },
+      { name: "value2", description: "Second additive.", acceptedTypes: ["number", "date", "time"] }
+    ], this.category = "math";
+  }
+  main(t, e) {
+    if (typeof t == "number" && typeof e == "number")
+      return t + e;
+    if (t instanceof Date && b.is(e))
+      return b.ensure(e).add(t);
+    if (b.is(t) && e instanceof Date)
+      return b.ensure(t).add(e);
+    if (t instanceof Date && typeof e == "number")
+      return H(t).add(e * Zt, "second").toDate();
+    if (typeof t == "number" && e instanceof Date)
+      return H(e).add(t * Zt, "second").toDate();
+    try {
+      return F(t, { alternative: 0 }) + F(e, { alternative: 0 });
+    } catch {
+      throw new x("#VALUE!", "Mismatched types for augend or addend.");
+    }
+  }
+}
+const Ti = `Returns the difference of two numbers.
+This is the same as the '-' operator.`;
+class Mi extends E {
+  constructor() {
+    super(...arguments), this.example = "MINUS(8, 3)", this.description = Ti, this.defs = [
+      { name: "value1", description: "A number that will be subtracted.", acceptedTypes: ["number", "date", "time"] },
+      {
+        name: "value2",
+        description: "A number that will subtract from value1.",
+        acceptedTypes: ["number", "date", "time"]
+      }
+    ], this.category = "math";
+  }
+  main(t, e) {
+    if (typeof t == "number" && typeof e == "number")
+      return t - e;
+    if (t instanceof Date && e instanceof Date)
+      return b.fromDates(t, e);
+    if (t instanceof Date && b.is(e))
+      return b.ensure(e).sub(t);
+    if (b.is(t) && e instanceof Date)
+      return b.ensure(t).sub(e);
+    if (t instanceof Date && typeof e == "number")
+      return H(t).subtract(e * Zt, "second").toDate();
+    try {
+      return F(t, { alternative: 0 }) - F(e, { alternative: 0 });
+    } catch {
+      throw new x("#VALUE!", "Mismatched types for minuend or subtrahend.");
+    }
+  }
+}
+const Oi = `Returns the product of two numbers.
+This is the same as the '*' operator.`;
+class Ni extends E {
+  constructor() {
+    super(...arguments), this.example = "MULTIPLY(6, 7)", this.description = Oi, this.defs = [
+      { name: "factor1", description: "First factor.", acceptedTypes: ["number"] },
+      { name: "factor2", description: "Second factor.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(t, e) {
+    return F(t) * F(e);
+  }
+}
+const Fi = `Returns the result of dividing one number by another.
+This is the same as the '/' operator.`;
+class Di extends E {
+  constructor() {
+    super(...arguments), this.example = "DIVIDE(4, 2)", this.description = Fi, this.defs = [
+      {
+        name: "dividend",
+        description: "A number that will be divided by divisor.",
+        acceptedTypes: ["number"]
+      },
+      {
+        name: "divisor",
+        description: "A number that will divide a dividend. Must be non-zero.",
+        acceptedTypes: ["number"]
+      }
+    ], this.category = "math";
+  }
+  validate(t) {
+    const e = super.validate(t).map((s) => F(s));
+    if (e[1] === 0)
+      throw new x("#DIV/0!", "The second argument must be non-zero.");
+    return e;
+  }
+  main(t, e) {
+    return t / e;
+  }
+}
+const vi = "Returns the sum of a series of numbers or cells.";
+class ki extends E {
+  constructor() {
+    super(...arguments), this.example = "SUM(A2:A100, 101)", this.description = vi, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to sum.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "math";
+  }
+  main(...t) {
+    if (t.length === 0)
+      return 0;
+    let e = 0;
+    return t.forEach((s) => {
+      ot(
+        s,
+        (i) => {
+          e += F(i, { ignore: !0 });
+        },
+        this.at
+      );
+    }), e;
+  }
+}
+const Pi = `Returns the concatenation of two values.
+This is the same as the '&' operator.`;
+class $i extends E {
+  constructor() {
+    super(...arguments), this.example = 'CONCAT("Hello", "World")', this.description = Pi, this.defs = [
+      {
+        name: "value1",
+        description: "A value to be concatenated with value2.",
+        acceptedTypes: ["string", "number", "boolean"]
+      },
+      {
+        name: "value2",
+        description: "A value to be concatenated with value1",
+        acceptedTypes: ["string", "number", "boolean"]
+      }
+    ], this.category = "text";
+  }
+  main(t, e) {
+    return X(t) + X(e);
+  }
+}
+const Li = `Returns TRUE if the two specified values are equal, FALSE if they are not.
+This is the same as the '=' operator.`;
+class Hi extends E {
+  constructor() {
+    super(...arguments), this.example = "EQ(6, 7)", this.description = Li, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(t, e) {
+    return me(t, e);
+  }
+}
+const Yi = `Returns TRUE if the two specified values are not equal, FALSE if they are.
+This is the same as the '<>' operator.`;
+class Bi extends E {
+  constructor() {
+    super(...arguments), this.example = "NE(6, 7)", this.description = Yi, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(t, e) {
+    return bi(t, e);
+  }
+}
+const Ui = `Returns TRUE if the first argument is truly greater than the second, FALSE otherwise.
+This is the same as the '>' operator.`;
+class zi extends E {
+  constructor() {
+    super(...arguments), this.example = "GT(5, 3)", this.description = Ui, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(t, e) {
+    return fe(t, e);
+  }
+}
+const Vi = `Returns TRUE if the first argument is greater than the second, FALSE otherwise.
+This is the same as the '>=' operator.`;
+class Wi extends E {
+  constructor() {
+    super(...arguments), this.example = "GTE(5, 3)", this.description = Vi, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(t, e) {
+    return pe(t, e);
+  }
+}
+const Xi = `Returns TRUE if the first argument is truely less than the second argument, FALSE otherwise.
+This is the same as the '<' operator.`;
+class ji extends E {
+  constructor() {
+    super(...arguments), this.example = "LT(3, 6)", this.description = Xi, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(t, e) {
+    return ss(t, e);
+  }
+}
+const Gi = `Returns TRUE if the first argument is less than the second argument, FALSE otherwise.
+This is the same as the '<=' operator.`;
+class Zi extends E {
+  constructor() {
+    super(...arguments), this.example = "LTE(3, 6)", this.description = Gi, this.defs = [
+      { name: "value1", description: "First value.", acceptedTypes: ["any"] },
+      { name: "value2", description: "A value to be compared with value1.", acceptedTypes: ["any"] }
+    ], this.category = "logical";
+  }
+  main(t, e) {
+    return is(t, e);
+  }
+}
+const qi = "Returns a serial value corresponding to the current date and time.";
+class Ki extends E {
+  constructor() {
+    super(...arguments), this.example = "NOW()", this.description = qi, this.defs = [], this.category = "time";
+  }
+  main() {
+    return /* @__PURE__ */ new Date();
+  }
+}
+const Ji = `Returns TRUE if all arguments are logically TRUE.
+Returns FALSE if any argument is logically FALSE.`;
+class Qi extends E {
+  constructor() {
+    super(...arguments), this.example = "AND(A1=1, A2=2)", this.description = Ji, this.defs = [
+      {
+        name: "expression",
+        description: "Logical expressions to evaluate.",
+        acceptedTypes: ["boolean", "number"],
+        variadic: !0
+      }
+    ], this.category = "logical";
+  }
+  main(...t) {
+    return t.map((e) => Ot(e)).reduce((e, s) => e && s);
+  }
+}
+const tr = `Returns TRUE if any argument is logically true.
+Returns FALSE if all arguments are logically false.`;
+class er extends E {
+  constructor() {
+    super(...arguments), this.example = "OR(A1=1, A2=2)", this.description = tr, this.defs = [
+      {
+        name: "expression",
+        description: "Logical expressions to evaluate.",
+        acceptedTypes: ["boolean", "number"],
+        variadic: !0
+      }
+    ], this.category = "logical";
+  }
+  main(...t) {
+    return t.map((e) => Ot(e)).reduce((e, s) => e || s);
+  }
+}
+const sr = `If the logical expression is TRUE, the second argument is returned.
+If FALSE, the third argument is returned.`;
+class ir extends E {
+  constructor() {
+    super(...arguments), this.example = 'IF(A2 = "Human", "Hello", "World")', this.description = sr, this.defs = [
+      { name: "condition", description: "An expression as a condition", acceptedTypes: ["any"] },
+      {
+        name: "value1",
+        description: "value to be returned if the condition is true.",
+        acceptedTypes: ["any"]
+      },
+      {
+        name: "value2",
+        description: "value to be returned if the condition is false.",
+        optional: !0,
+        acceptedTypes: ["any"]
+      }
+    ], this.category = "logical";
+  }
+  main(t, e, s = !1) {
+    return Ot(t) ? e : s;
+  }
+}
+const rr = "Returns the first argument if it is not an error value, otherwise returns the second argument if present, or a blank if the second argument is absent.";
+class nr extends E {
+  constructor() {
+    super(...arguments), this.example = 'IFERROR(A1, "Error in cell A1")', this.description = rr, this.defs = [
+      {
+        name: "value",
+        description: "The value to return if value itself is not an error.",
+        acceptedTypes: ["any"],
+        errorTolerant: !0
+      },
+      {
+        name: "value_if_error",
+        description: "The value the function returns if value is an error.",
+        optional: !0,
+        acceptedTypes: ["any"]
+      }
+    ], this.category = "logical", this.broadcastDisabled = !0;
+  }
+  main(t, e) {
+    return x.is(t) || t instanceof Error ? e : t;
+  }
+}
+const or = `Returns the inverse of the Boolean; if TRUE, NOT returns FALSE.
+If FALSE, NOT returns TRUE.`;
+class ar extends E {
+  constructor() {
+    super(...arguments), this.example = "NOT(TRUE)", this.description = or, this.defs = [
+      {
+        name: "logical expression",
+        description: "A logical expression as a boolean.",
+        acceptedTypes: ["boolean", "number"]
+      }
+    ], this.category = "logical";
+  }
+  main(t) {
+    return !Ot(t);
+  }
+}
+const cr = "Returns the count of a series of numbers or cells.";
+class lr extends E {
+  constructor() {
+    super(...arguments), this.example = "COUNT(A2:A100,B2:B100,4,26)", this.description = cr, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to count.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "math";
+  }
+  main(...t) {
+    let e = 0;
+    return t.forEach((s) => {
+      at(s) ? ot(
+        s,
+        (i) => {
+          Mt(i) && e++;
+        },
+        this.at
+      ) : (F(s), e++);
+    }), e;
+  }
+}
+const hr = "Returns the absolute value of a number";
+class ur extends E {
+  constructor() {
+    super(...arguments), this.example = "ABS(-2)", this.description = hr, this.defs = [{ name: "value", description: "target number", acceptedTypes: ["number"] }], this.category = "math";
+  }
+  main(t) {
+    return Math.abs(F(t));
+  }
+}
+const dr = "Returns a number multiplied by an exponent.";
+class ve extends E {
+  constructor() {
+    super(...arguments), this.example = "POWER(4,0.5)", this.description = dr, this.defs = [
+      { name: "base", description: "A number to be multiplied by an exponent.", acceptedTypes: ["number"] },
+      { name: "exponent", description: "An exponent to power the base.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(t, e) {
+    return Math.pow(F(t), F(e));
+  }
+}
+const fr = "Returns the number of values in the data set.";
+class pr extends E {
+  constructor() {
+    super(...arguments), this.example = "COUNTA(A2:A100,B2:B100,4,26)", this.description = fr, this.defs = [
+      {
+        name: "value",
+        description: "Values or ranges to count.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "math";
+  }
+  main(...t) {
+    let e = 0;
+    return t.forEach((s) => {
+      ot(
+        s,
+        (i) => {
+          i != null && i !== "" && e++;
+        },
+        this.at
+      );
+    }), e;
+  }
+}
+const mr = "Returns the average of a series of numbers or cells.";
+class gr extends E {
+  constructor() {
+    super(...arguments), this.example = "AVERAGE(A2:A100, 101)", this.description = mr, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to average.",
+        takesMatrix: !0,
+        acceptedTypes: ["number", "matrix"],
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  main(...t) {
+    let e = 0, s = 0;
+    if (t.forEach((i) => {
+      if (at(i))
+        ot(
+          i,
+          (n) => {
+            Mt(n) && (e += F(n), s++);
+          },
+          this.at
+        );
+      else {
+        const n = F(i);
+        e += n, s++;
+      }
+    }), s === 0)
+      throw new x("#DIV/0!", "Evaluation of function AVERAGE caused a divide by zero error.");
+    return e / s;
+  }
+}
+const yr = "Returns the max in a series of numbers or cells.";
+class wr extends E {
+  constructor() {
+    super(...arguments), this.example = "MAX(A2:A100, 101)", this.description = yr, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to find max from.",
+        acceptedTypes: ["number", "matrix"],
+        takesMatrix: !0,
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  main(...t) {
+    let e = -1 / 0, s = !1;
+    return t.forEach((i) => {
+      if (at(i))
+        ot(
+          i,
+          (n) => {
+            if (Mt(n)) {
+              const o = F(n);
+              o > e && (e = o), s = !0;
+            }
+          },
+          this.at
+        );
+      else {
+        const n = F(i);
+        n > e && (e = n), s = !0;
+      }
+    }), s ? e : 0;
+  }
+}
+const xr = "Returns the min in a series of numbers or cells.";
+class br extends E {
+  constructor() {
+    super(...arguments), this.example = "MIN(A2:A100, 101)", this.description = xr, this.defs = [
+      {
+        name: "value",
+        description: "Numbers or ranges to find min from.",
+        acceptedTypes: ["number", "matrix"],
+        takesMatrix: !0,
+        variadic: !0
+      }
+    ], this.category = "statistics";
+  }
+  main(...t) {
+    let e = 1 / 0, s = !1;
+    return t.forEach((i) => {
+      if (at(i))
+        ot(
+          i,
+          (n) => {
+            if (Mt(n)) {
+              const o = F(n);
+              o < e && (e = o), s = !0;
+            }
+          },
+          this.at
+        );
+      else {
+        const n = F(i);
+        n < e && (e = n), s = !0;
+      }
+    }), s ? e : 0;
+  }
+}
+const Sr = "Returns the length of a string.";
+class Rr extends E {
+  constructor() {
+    super(...arguments), this.example = "LEN(A2)", this.description = Sr, this.defs = [
+      {
+        name: "text",
+        description: "A text to be returned the length.",
+        acceptedTypes: ["string", "number"]
+      }
+    ], this.category = "text";
+  }
+  main(t) {
+    return X(t).length;
+  }
+}
+const _r = "Returns a number with positive and negative values reversed.";
+class Er extends E {
+  constructor() {
+    super(...arguments), this.example = "UMINUS(4)", this.description = _r, this.defs = [
+      { name: "value1", description: "A number that will be subtracted.", acceptedTypes: ["number"] }
+    ], this.category = "math";
+  }
+  main(t) {
+    return -F(t);
+  }
+}
+const Ar = `Enables the display of values returned from an array formula into multiple rows and/or columns.
+If the argument is already a Spilling, it is returned as-is. If it is a Sheet (range reference), the field matrix is extracted and wrapped in a Spilling. Otherwise the value is wrapped as a single-element Spilling.`;
+class Cr extends E {
+  constructor() {
+    super(...arguments), this.autoSpilling = !0, this.example = "ARRAYFORMULA(A1:A10 * B1:B10)", this.description = Ar, this.defs = [
+      {
+        name: "value",
+        description: "The array expression or value to evaluate.",
+        takesMatrix: !0,
+        acceptedTypes: ["matrix", "any"]
+      }
+    ], this.category = "logical", this.broadcastDisabled = !0;
+  }
+  main(t) {
+    return B.is(t) ? t : t instanceof $ ? t._toValueMatrix() : Array.isArray(t) ? t : [[t]];
+  }
+}
+const rs = {
+  // Arithmetic & Comparison
+  add: Ii,
+  minus: Mi,
+  uminus: Er,
+  multiply: Ni,
+  divide: Di,
+  pow: ve,
+  power: ve,
+  concat: $i,
+  eq: Hi,
+  ne: Bi,
+  gt: zi,
+  gte: Wi,
+  lt: ji,
+  lte: Zi,
+  // Logical
+  if: ir,
+  iferror: nr,
+  and: Qi,
+  or: er,
+  not: ar,
+  arrayformula: Cr,
+  // Statistics & Aggregation
+  sum: ki,
+  max: wr,
+  min: br,
+  average: gr,
+  count: lr,
+  counta: pr,
+  // Text
+  len: Rr,
+  // Math
+  abs: ur,
+  // Time
+  now: Ki
+}, ke = /* @__PURE__ */ new Map(), yn = (r = rs) => {
+  let t = ke.get(r);
+  return t || (t = Object.keys(r).map((e) => {
+    const s = r[e], i = new s({ args: [], sheet: {} });
+    return {
+      name: e.toUpperCase(),
+      category: i.category,
+      example: i.example ?? (s == null ? void 0 : s.__name) ?? "Unknown",
+      description: i.description ?? "",
+      defs: i.defs || []
+    };
+  }), ke.set(r, t)), t;
+};
+class Ir {
+  constructor({
+    historyLimit: t,
+    additionalFunctions: e,
+    policies: s = {},
+    onSave: i,
+    onChange: n,
+    onRemoveRows: o,
+    onRemoveCols: a,
+    onInsertRows: l,
+    onInsertCols: u,
+    onSelect: h,
+    onKeyUp: c,
+    onInit: f
+  } = {}) {
+    this.sheetHead = 0, this.cellHead = 0, this.data = {}, this.systems = {}, this.sheetIdsByName = {}, this.contextsBySheetId = {}, this.choosingSheetId = 0, this.choosingAddress = "", this.editingSheetId = 0, this.editingAddress = "", this.paletteBySheetName = {}, this.lastFocused = null, this.solvedCaches = /* @__PURE__ */ new Map(), this.lastSpilledTargetIds = /* @__PURE__ */ new Set(), this.asyncFormulaCells = /* @__PURE__ */ new Set(), this.asyncPending = /* @__PURE__ */ new Map(), this.copyingSheetId = 0, this.copyingZone = gs, this.cutting = !1, this.histories = [], this.historyIndex = -1, this.historyLimit = ps, this._componentSheetIds = /* @__PURE__ */ new Map(), this.ready = !1, this.functions = {}, this.policies = {}, this.transmit = (d) => {
+    }, this.updateSheet = (d) => ({ type: 0, value: d }), t != null && (this.historyLimit = t), this.functions = {
+      ...rs,
+      ...e
+    };
+    for (const d in this.functions) {
+      const p = this.functions[d];
+      p.__name = d;
+    }
+    this.policies = s, this.onSave = i, this.onChange = n, this.onRemoveRows = o, this.onRemoveCols = a, this.onInsertRows = l, this.onInsertCols = u, this.onSelect = h, this.onKeyUp = c, this.onInit = f;
+  }
+  boot() {
+    if (this.ready || Object.keys(this.contextsBySheetId).length === 0)
+      return;
+    const t = Object.keys(this.contextsBySheetId), e = [];
+    for (let s = 0; s < t.length; s++) {
+      const i = t[s], n = this.contextsBySheetId[i], o = n.store.sheetReactive.current;
+      if (!o || o.status === 0)
+        return;
+      e.push(n);
+    }
+    for (let s = 0; s < e.length; s++) {
+      const { store: i, dispatch: n } = e[s], o = i.sheetReactive.current;
+      o && (o.resolveFormulas(), n(this.updateSheet(o)));
+    }
+    this.ready = !0;
+  }
+}
+const ye = (r = {}) => new Ir(r), wn = ye, xn = (r = {}) => ({ registry: ye(r) }), Tr = (r) => ({
+  renderNumber({ value: t }) {
+    if (t == null || isNaN(t))
+      return "NaN";
+    const [e, s] = String(parseFloat(t.toPrecision(this.decimalPrecision))).split("."), i = e.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, `$1${r}`);
+    return s == null ? i : `${i}.${s}`;
+  }
+}), bn = Tr(","), Sn = {
+  renderNumber({ value: r }) {
+    return r == null || isNaN(r) ? "0%" : `${parseFloat((r * 100).toPrecision(this.decimalPrecision))}%`;
+  }
+}, Rn = (r, t, e, s) => {
+  if (t != null)
+    return t;
+  const i = r.getPolicy(e);
+  return (e.x === 0 ? i.renderRowHeaderLabel(s) : i.renderColHeaderLabel(s)) ?? null;
+}, _n = [
+  // orange
+  "#FF6600",
+  // purple
+  "#AA44FF",
+  // emeraldblue
+  "#00CCCC",
+  // peach
+  "#EEAAEE",
+  // yellow
+  "#DDDD00",
+  // winered
+  "#AA4444",
+  // lightgreen
+  "#00FF00",
+  // pink
+  "#FF00FF",
+  // navy
+  "#3366FF",
+  // cyan
+  "#008888"
+], z = "dashed 1px #888888", Pe = {
+  left: ["horizontal", -1],
+  right: ["horizontal", 1],
+  up: ["vertical", -1],
+  down: ["vertical", 1],
+  none: ["none", 0]
+};
+class En {
+  constructor(t, e) {
+    const { sheetReactive: s, choosing: i, selectingZone: n } = t, o = s.current;
+    if (!o)
+      throw new Error("Sheet is not available");
+    this.src = Is(Rs(n), i), this.direction = this.suggestDirection(e), this.dst = this.getDestinationArea(e), this.sheet = o;
+  }
+  get applied() {
+    var f, d;
+    const [t, e] = Pe[this.direction], { top: s, left: i, bottom: n, right: o } = this.src, a = se(n - s + 1, o - i + 1);
+    for (let p = s; p <= n; p++)
+      for (let m = i; m <= o; m++)
+        a[p - s][m - i] = this.sheet.getCell({ y: p, x: m }, { resolution: "SYSTEM" }) ?? null;
+    const l = Kt(this.src), u = Kt(this.dst), h = {};
+    if (t === "horizontal")
+      for (let p = 0; p < u.rows; p++) {
+        const m = this.getChangePatterns(a[p], "");
+        for (let g = 0; g < u.cols; g++) {
+          const y = (f = a[p % l.rows]) == null ? void 0 : f[g % l.cols], R = e > 0 ? this.dst.left + g : this.dst.right - g, A = e > 0 ? g % l.cols : (l.cols - 1 - g % l.cols) % l.cols, w = { y: this.dst.top + p, x: R }, S = this.sheet.getId(w), _ = m[A].next().value, M = (y == null ? void 0 : y.formulaEnabled) ?? !0 ? this.sheet.processFormula(_, {
+            dependency: S
+          }) : _;
+          h[D(w)] = {
+            ...y,
+            value: M
+          };
+        }
+      }
+    else if (t === "vertical")
+      for (let p = 0; p < u.cols; p++) {
+        const m = this.getChangePatterns(
+          a.map((g) => g[p]),
+          ""
+        );
+        for (let g = 0; g < u.rows; g++) {
+          const y = (d = a[g % l.rows]) == null ? void 0 : d[p % l.cols], R = e > 0 ? this.dst.top + g : this.dst.bottom - g, A = e > 0 ? g % l.rows : (l.rows - 1 - g % l.rows) % l.rows, w = m[A].next().value;
+          h[D({ y: R, x: this.dst.left + p })] = { ...y, value: w };
+        }
+      }
+    return this.sheet.update({
+      diff: h,
+      operator: "USER",
+      undoReflection: {
+        sheetId: this.sheet.id,
+        selectingZone: Ee(this.src)
+      },
+      redoReflection: {
+        sheetId: this.sheet.id,
+        selectingZone: Ee(this.dst)
+      }
+    });
+  }
+  get wholeArea() {
+    return Ss(this.src, this.dst);
+  }
+  getCellStyle(t) {
+    const { x: e, y: s } = t, i = {}, { top: n, left: o, bottom: a, right: l } = this.src;
+    switch (this.direction) {
+      case "left": {
+        this.dst.left <= e && e <= this.dst.right && (n === s && (i.borderTop = z), a === s - 1 && (i.borderTop = z)), this.dst.left === e && n <= s && s <= a && (i.borderLeft = z);
+        break;
+      }
+      case "right": {
+        this.dst.left <= e && e <= this.dst.right && (n === s && (i.borderTop = z), a === s - 1 && (i.borderTop = z)), this.dst.right === e - 1 && n <= s && s <= a && (i.borderLeft = z);
+        break;
+      }
+      case "up": {
+        this.dst.top <= s && s <= this.dst.bottom && (o === e && (i.borderLeft = z), l === e - 1 && (i.borderLeft = z)), this.dst.top === s && o <= e && e <= l && (i.borderTop = z);
+        break;
+      }
+      case "down": {
+        this.dst.top <= s && s <= this.dst.bottom && (o === e && (i.borderLeft = z), l === e - 1 && (i.borderLeft = z)), this.dst.bottom === s - 1 && o <= e && e <= l && (i.borderTop = z);
+        break;
+      }
+    }
+    return i;
+  }
+  getDestinationArea(t) {
+    const { x: e, y: s } = t, { top: i, left: n, bottom: o, right: a } = this.src;
+    switch (this.direction) {
+      case "left":
+        return { top: i, bottom: o, left: e, right: n - 1 };
+      case "right":
+        return { top: i, bottom: o, left: a + 1, right: e };
+      case "up":
+        return { left: n, right: a, top: s, bottom: i - 1 };
+      case "down":
+        return { left: n, right: a, top: o + 1, bottom: s };
+    }
+    return this.src;
+  }
+  suggestDirection(t) {
+    const { top: e, left: s, bottom: i, right: n } = this.src;
+    let o = 0, a = 0;
+    return t.x < s ? o = t.x - s : t.x > n && (o = t.x - n), t.y < e ? a = t.y - e : t.y > i && (a = t.y - i), Math.abs(o) > 0 && Math.abs(a) > 0 ? Math.abs(o) > Math.abs(a) ? o < 0 ? "left" : "right" : a < 0 ? "up" : "down" : o !== 0 ? o < 0 ? "left" : "right" : a !== 0 ? a < 0 ? "up" : "down" : "none";
+  }
+  getChangePatterns(t, e) {
+    const s = [], i = Mr(t), [n, o] = Pe[this.direction];
+    return i.forEach((a) => {
+      const l = o > 0 ? a.last : a.first;
+      switch (a.kind) {
+        case "other": {
+          s.push(st(a.first));
+          return;
+        }
+        case "formula": {
+          const u = a.first, h = this.sheet;
+          function* c() {
+            let f = 0;
+            const d = t.length * o;
+            for (; ; )
+              f += d, yield h.processFormula(u, {
+                dependency: e,
+                slideY: n === "vertical" ? f : 0,
+                slideX: n === "horizontal" ? f : 0
+              });
+          }
+          s.push(c());
+          return;
+        }
+        case "number": {
+          if (!a.equidistant) {
+            s.push(st(a.first), ...a.nexts.map((c) => st(c)));
+            return;
+          }
+          function* u() {
+            let c = l;
+            const f = a.numericDelta * o;
+            for (; ; )
+              c += f, yield c;
+          }
+          const h = u();
+          s.push(h, ...a.nexts.map(() => h));
+          return;
+        }
+        case "date": {
+          const u = (f) => o > 0 ? a.time.add(f) : a.time.sub(f);
+          if (!a.equidistant) {
+            s.push(st(a.first), ...a.nexts.map((f) => st(f)));
+            return;
+          }
+          function* h() {
+            let f = l;
+            for (; ; )
+              f = u(f), yield new Date(f);
+          }
+          const c = h();
+          s.push(c, ...a.nexts.map(() => c));
+          return;
+        }
+        case "string+number": {
+          if (!a.equidistant) {
+            s.push(st(a.first), ...a.nexts.map((c) => st(c)));
+            return;
+          }
+          function* u() {
+            const { prefix: c } = it(a.first), { number: f } = it(l);
+            let d = f;
+            const p = a.numericDelta * o;
+            for (; ; )
+              d += p, yield `${c}${Math.abs(d)}`;
+          }
+          const h = u();
+          s.push(h, ...a.nexts.map(() => h));
+          return;
+        }
+      }
+    }), s;
+  }
+}
+function* st(r) {
+  for (; ; )
+    yield r;
+}
+const ns = new RegExp("(.+?)(\\d+)$"), it = (r) => {
+  const t = r.match(ns);
+  if (t) {
+    const [, e, s] = t;
+    return { prefix: e, number: Number(s) };
+  }
+  return { prefix: "", number: 0 };
+};
+class Ht {
+  constructor(t) {
+    this.time = b.create(), this.numericDelta = 0, this.equidistant = !0, this.first = t, this.nexts = [], this.kind = this.discriminate(t);
+  }
+  discriminate(t) {
+    const e = t instanceof Date ? "date" : typeof t;
+    return e === "number" || e === "date" ? e : e === "string" && t[0] === "=" ? "formula" : e === "string" && t.match(ns) ? "string+number" : "other";
+  }
+  get last() {
+    return this.nexts.length === 0 ? this.first : this.nexts[this.nexts.length - 1];
+  }
+  add(t) {
+    const e = this.discriminate(t);
+    if (this.kind !== e || e === "other" || e === "formula")
+      return new Ht(t);
+    if (this.nexts.length === 0)
+      switch (e) {
+        case "date": {
+          this.time = b.fromDates(t, this.first);
+          break;
+        }
+        case "number": {
+          this.numericDelta = t - this.first;
+          break;
+        }
+        case "string+number": {
+          const { prefix: s, number: i } = it(this.first), { prefix: n, number: o } = it(t);
+          s === n && (this.numericDelta = o - i);
+          break;
+        }
+      }
+    this.nexts.push(t);
+  }
+  subdivide() {
+    if (this.nexts.length === 0)
+      return [];
+    const t = [];
+    let e = this;
+    switch (this.kind) {
+      case "date": {
+        const s = this.nexts.every((i, n) => n === 0 || H(i).isSame(this.time.add(this.nexts[n - 1])));
+        return this.equidistant = s, [];
+      }
+      case "number": {
+        const s = this.nexts.every((i, n) => n === 0 || i === this.first + this.numericDelta * (n + 1));
+        return this.equidistant = s, [];
+      }
+      case "string+number": {
+        const { prefix: s } = it(this.first);
+        for (let i = 0; i < e.nexts.length; i++) {
+          const n = e.nexts[i], { prefix: o, number: a } = it(n);
+          if (s !== o) {
+            const l = this.nexts.splice(i, this.nexts.length);
+            e = new Ht(l.splice(0, 1)[0]), l.forEach(e.add.bind(e)), t.push(e, ...e.subdivide());
+            break;
+          } else {
+            const { number: l } = it(e.first);
+            a !== l + (i + 1) * e.numericDelta && (e.equidistant = !1);
+          }
+        }
+        break;
+      }
+    }
+    return t;
+  }
+}
+function Mr(r) {
+  var s, i;
+  let t = new Ht((s = r[0]) == null ? void 0 : s.value);
+  const e = [t];
+  for (let n = 1; n < r.length; n++) {
+    const o = (i = r[n]) == null ? void 0 : i.value, a = t.add(o);
+    a && (e.push(a), t = a);
+  }
+  for (let n = e.length - 1; n >= 0; n--) {
+    const o = e[n];
+    e.splice(n + 1, 0, ...o.subdivide());
+  }
+  return e;
+}
+export {
+  En as Autofill,
+  E as BaseFunction,
+  De as BaseFunctionAsync,
+  _n as COLOR_PALETTE,
+  Dt as DEFAULT_COL_KEY,
+  J as DEFAULT_HEIGHT,
+  ps as DEFAULT_HISTORY_LIMIT,
+  vt as DEFAULT_ROW_KEY,
+  jt as DEFAULT_WIDTH,
+  x as FormulaError,
+  nn as FormulaParser,
+  Re as HEADER_HEIGHT,
+  _e as HEADER_WIDTH,
+  $t as Lexer,
+  Pr as MIN_HEIGHT,
+  kr as MIN_WIDTH,
+  $r as OVERSCAN_X,
+  Lr as OVERSCAN_Y,
+  k as Pending,
+  Sn as PercentagePolicyMixin,
+  de as Policy,
+  Be as RangeEntity,
+  Ye as RefEntity,
+  Ir as Registry,
+  Dr as SHEET_HEIGHT,
+  vr as SHEET_WIDTH,
+  $ as Sheet,
+  B as Spilling,
+  bn as ThousandSeparatorPolicyMixin,
+  b as Time,
+  ie as ValueEntity,
+  N as a2p,
+  Zr as aa2oa,
+  tn as addressesToAreas,
+  en as addressesToCols,
+  sn as addressesToRows,
+  Wr as among,
+  Ae as areaDiff,
+  Kt as areaShape,
+  zr as areaToRange,
+  Ee as areaToZone,
+  Vr as between,
+  Qr as binarySearch,
+  Es as buildInitialCells,
+  qr as buildInitialCellsFromOrigin,
+  _t as c2x,
+  Yr as ch,
+  _i as check,
+  Is as complementSelectingArea,
+  Ss as concatAreas,
+  gn as conditionArg,
+  wn as createBinding,
+  xn as createBook,
+  mn as createBooleanMask,
+  se as createMatrix,
+  ye as createRegistry,
+  ot as eachMatrix,
+  Ot as ensureBoolean,
+  Si as ensureDate,
+  F as ensureNumber,
+  X as ensureString,
+  yn as getFunctionHelps,
+  Rn as getLabel,
+  Cs as getMaxSizesFromCells,
+  Le as grantAddressAbsolute,
+  Mt as isNumeric,
+  ge as isPercentage,
+  rn as isZoneNotSelected,
+  jr as makeSequence,
+  Nt as matrixShape,
+  Gr as oa2aa,
+  pn as operations,
+  D as p2a,
+  bs as r2y,
+  Kr as range,
+  Jr as restrictZone,
+  Hr as rh,
+  zs as splitRef,
+  Br as stripAddressAbsolute,
+  Ai as stripMatrix,
+  on as stripSheetName,
+  Ur as superposeArea,
+  fn as toCellCols,
+  hn as toCellMatrix,
+  un as toCellObject,
+  dn as toCellRows,
+  Ws as toSheetPrefix,
+  ln as toValueCols,
+  Vs as toValueMatrix,
+  an as toValueObject,
+  cn as toValueRows,
+  W as x2c,
+  Et as y2r,
+  Xr as zoneShape,
+  Rs as zoneToArea
+};
+//# sourceMappingURL=index.js.map