@extable/core 0.1.0

package/dist/index.js

@@ -0,0 +1,4445 @@
+function zt(c) {
+  const t = c.payload;
+  if (!t) return null;
+  const e = t.batchId;
+  return typeof e == "string" && e.length ? e : null;
+}
+class Gt {
+  constructor(t = 100) {
+    this.applied = [], this.undone = [], this.cap = t;
+  }
+  enqueue(t) {
+    const e = zt(t), i = this.applied.at(-1);
+    for (e && i && i.batchId === e ? i.commands.push(t) : this.applied.push({ batchId: e, commands: [t] }); this.applied.length > this.cap; ) this.applied.shift();
+    this.undone = [];
+  }
+  canUndo() {
+    return this.applied.length > 0;
+  }
+  canRedo() {
+    return this.undone.length > 0;
+  }
+  listApplied() {
+    const t = [];
+    for (const e of this.applied) t.push(...e.commands);
+    return t;
+  }
+  listUndoGroups() {
+    return this.applied.slice().reverse().map((t) => ({ batchId: t.batchId, commands: t.commands.slice() }));
+  }
+  listRedoGroups() {
+    return this.undone.slice().reverse().map((t) => ({ batchId: t.batchId, commands: t.commands.slice() }));
+  }
+  undo() {
+    const t = this.applied.pop();
+    return t && this.undone.push(t), t?.commands ?? null;
+  }
+  redo() {
+    const t = this.undone.pop();
+    return t && this.applied.push(t), t?.commands ?? null;
+  }
+  clear() {
+    this.applied = [], this.undone = [];
+  }
+}
+function vt() {
+  return typeof crypto < "u" && "randomUUID" in crypto ? crypto.randomUUID() : `row_${Math.random().toString(16).slice(2)}`;
+}
+function Ct(c) {
+  if (c !== void 0)
+    return Array.isArray(c) ? c : [c];
+}
+function _(c) {
+  if (c)
+    try {
+      c.remove();
+    } catch {
+    }
+}
+const j = (c, t = 2) => c.toString().padStart(t, "0"), Et = {
+  yyyy: (c) => j(c.getFullYear(), 4),
+  MM: (c) => j(c.getMonth() + 1),
+  dd: (c) => j(c.getDate()),
+  HH: (c) => j(c.getHours()),
+  hh: (c) => {
+    const t = c.getHours() % 12 || 12;
+    return j(t);
+  },
+  mm: (c) => j(c.getMinutes()),
+  ss: (c) => j(c.getSeconds()),
+  a: (c) => c.getHours() >= 12 ? "PM" : "AM"
+}, Tt = Object.keys(Et).sort((c, t) => t.length - c.length), Dt = /* @__PURE__ */ new Set(["yyyy", "MM", "dd"]), Ht = /* @__PURE__ */ new Set(["HH", "hh", "mm", "ss", "a"]), Qt = /* @__PURE__ */ new Set([...Dt, ...Ht]), tt = {
+  iso: "yyyy-MM-dd",
+  us: "MM/dd/yyyy",
+  eu: "dd.MM.yyyy"
+}, et = {
+  iso: "HH:mm:ss",
+  "24h": "HH:mm",
+  "12h": "hh:mm a"
+}, it = {
+  iso: "yyyy-MM-dd'T'HH:mm:ss'Z'",
+  "iso-24h": "yyyy-MM-dd'T'HH:mm:ss'Z'",
+  "iso-12h": "yyyy-MM-dd hh:mm a",
+  us: "MM/dd/yyyy HH:mm",
+  "us-24h": "MM/dd/yyyy HH:mm",
+  "us-12h": "MM/dd/yyyy hh:mm a",
+  eu: "dd.MM.yyyy HH:mm",
+  "eu-24h": "dd.MM.yyyy HH:mm",
+  "eu-12h": "dd.MM.yyyy hh:mm a"
+};
+function dt(c) {
+  const t = new Date(c);
+  return Number.isNaN(t.getTime()) ? null : t;
+}
+function At(c, t) {
+  let e = "", i = 0, n = !1;
+  for (; i < t.length; ) {
+    const s = t[i];
+    if (s === "'") {
+      n = !n, i += 1;
+      continue;
+    }
+    if (n) {
+      e += s, i += 1;
+      continue;
+    }
+    let o = !1;
+    for (const r of Tt)
+      if (t.startsWith(r, i)) {
+        e += Et[r](c), i += r.length, o = !0;
+        break;
+      }
+    o || (e += s, i += 1);
+  }
+  return e;
+}
+function Zt(c, t) {
+  return t === "date" ? Dt.has(c) : t === "time" ? Ht.has(c) : Qt.has(c);
+}
+function Jt(c, t) {
+  let e = 0, i = !1;
+  for (; e < c.length; ) {
+    if (c[e] === "'") {
+      i = !i, e += 1;
+      continue;
+    }
+    if (i) {
+      e += 1;
+      continue;
+    }
+    let s = !1;
+    for (const o of Tt)
+      if (c.startsWith(o, e)) {
+        if (!Zt(o, t)) return !1;
+        e += o.length, s = !0;
+        break;
+      }
+    s || (e += 1);
+  }
+  return !0;
+}
+function Y(c, t) {
+  if (!c)
+    return t === "date" ? tt.iso : t === "time" ? et.iso : it.iso;
+  if (t === "date" && tt[c]) return tt[c];
+  if (t === "time" && et[c]) return et[c];
+  if (t === "datetime" && it[c]) return it[c];
+  const e = t === "date" ? tt.iso : t === "time" ? et.iso : it.iso;
+  return Jt(c, t) ? c : e;
+}
+const St = (c) => !Number.isNaN(c.getTime()), te = (c) => {
+  if (typeof c == "string") return c;
+  if (c && typeof c == "object") {
+    const t = c;
+    if (t.kind === "enum")
+      return typeof t.value == "string" ? t.value : null;
+  }
+  return null;
+}, ee = (c) => {
+  if (Array.isArray(c) && c.every((t) => typeof t == "string")) return c;
+  if (c && typeof c == "object") {
+    const t = c;
+    if (t.kind === "tags") {
+      const e = t.values;
+      return Array.isArray(e) && e.every((i) => typeof i == "string") ? e : null;
+    }
+  }
+  return null;
+};
+function ie(c, t) {
+  if (c == null) return null;
+  switch (t.type) {
+    case "string": {
+      if (typeof c != "string") return "Expected a string";
+      if (t.string?.maxLength !== void 0 && c.length > t.string.maxLength)
+        return `Too long (max ${t.string.maxLength})`;
+      if (t.string?.regex)
+        try {
+          if (!new RegExp(t.string.regex).test(c)) return "Does not match pattern";
+        } catch {
+        }
+      return null;
+    }
+    case "number":
+      return typeof c != "number" || !Number.isFinite(c) ? "Expected a number" : t.number?.signed === !1 && c < 0 ? "Expected a non-negative number" : null;
+    case "boolean":
+      return typeof c != "boolean" ? "Expected a boolean" : null;
+    case "enum": {
+      const e = te(c);
+      if (!e) return "Expected an enum value";
+      const i = t.enum?.allowCustom ?? !1, n = t.enum?.options ?? [];
+      return !i && n.length && !n.includes(e) ? "Not in allowed options" : null;
+    }
+    case "tags": {
+      const e = ee(c);
+      if (!e) return "Expected a list of tags";
+      const i = t.tags?.allowCustom ?? !1, n = t.tags?.options ?? [];
+      if (!i && n.length) {
+        for (const s of e)
+          if (!n.includes(s)) return "Contains an unknown tag";
+      }
+      return null;
+    }
+    case "date":
+    case "time":
+    case "datetime": {
+      if (t.type === "date" ? Y(t.dateFormat, "date") : t.type === "time" ? Y(t.timeFormat, "time") : Y(t.dateTimeFormat, "datetime"), c instanceof Date) return St(c) ? null : "Invalid date";
+      if (typeof c == "string") {
+        const e = dt(c);
+        return e && St(e) ? null : "Invalid date/time";
+      }
+      return "Expected a date/time string";
+    }
+    default:
+      return null;
+  }
+}
+class ne {
+  constructor(t, e, i) {
+    this.rows = [], this.baseIndexById = /* @__PURE__ */ new Map(), this.dataVersion = 0, this.visibleRowsCache = null, this.distinctValueCache = /* @__PURE__ */ new Map(), this.pending = /* @__PURE__ */ new Map(), this.rowVersion = /* @__PURE__ */ new Map(), this.listeners = /* @__PURE__ */ new Set(), this.cellStyles = /* @__PURE__ */ new Map(), this.cellConditionalStyles = /* @__PURE__ */ new Map(), this.computedCache = /* @__PURE__ */ new Map(), this.conditionalCache = /* @__PURE__ */ new Map(), this.rowConditionalCache = /* @__PURE__ */ new Map(), this.formulaDiagnostics = /* @__PURE__ */ new Map(), this.conditionalDiagnostics = /* @__PURE__ */ new Map(), this.baseValidationErrors = /* @__PURE__ */ new Map(), this.uniqueValidationErrors = /* @__PURE__ */ new Map(), this.notifySuspended = !1, this.notifyDirty = !1, this.schema = e, this.view = i, this.setData(t ?? []);
+  }
+  subscribe(t) {
+    return this.listeners.add(t), () => this.listeners.delete(t);
+  }
+  notify() {
+    if (this.visibleRowsCache = null, this.distinctValueCache.clear(), this.notifySuspended) {
+      this.notifyDirty = !0;
+      return;
+    }
+    for (const t of this.listeners) t();
+  }
+  batchUpdate(t) {
+    this.notifySuspended = !0;
+    try {
+      t();
+    } finally {
+      this.notifySuspended = !1, this.notifyDirty && (this.notifyDirty = !1, this.notify());
+    }
+  }
+  setData(t) {
+    this.dataVersion += 1, this.pending.clear(), this.cellStyles.clear(), this.cellConditionalStyles.clear(), this.computedCache.clear(), this.conditionalCache.clear(), this.rowConditionalCache.clear(), this.formulaDiagnostics.clear(), this.conditionalDiagnostics.clear(), this.baseValidationErrors.clear(), this.uniqueValidationErrors.clear(), this.rows = (t ?? []).map((e, i) => {
+      const n = vt();
+      return this.rowVersion.set(n, 0), {
+        id: n,
+        raw: e,
+        displayIndex: i + 1
+      };
+    }), this.rebuildBaseIndex(), this.recomputeValidationErrors(), this.notify();
+  }
+  setSchema(t) {
+    this.dataVersion += 1, this.schema = t, this.computedCache.clear(), this.conditionalCache.clear(), this.rowConditionalCache.clear(), this.formulaDiagnostics.clear(), this.conditionalDiagnostics.clear(), this.recomputeValidationErrors(), this.notify();
+  }
+  setView(t) {
+    this.dataVersion += 1, Array.isArray(t.sorts) && t.sorts.length > 1 ? this.view = { ...t, sorts: t.sorts.slice(0, 1) } : this.view = t, this.notify();
+  }
+  getSchema() {
+    return { ...this.schema, columns: this.getColumns() };
+  }
+  getColumns() {
+    return this.schema.columns;
+  }
+  getRowConditionalStyleFn() {
+    return this.schema.row?.conditionalStyle ?? null;
+  }
+  getView() {
+    return this.view;
+  }
+  getDataVersion() {
+    return this.dataVersion;
+  }
+  getFullSchema() {
+    return this.schema;
+  }
+  listRows() {
+    return this.computeVisibleRows().rows;
+  }
+  listAllRows() {
+    return this.rows;
+  }
+  getAllRowCount() {
+    return this.rows.length;
+  }
+  findRow(t) {
+    const e = this.baseIndexById.get(t);
+    if (e === void 0) return null;
+    const i = this.rows[e];
+    if (i && i.id === t) return { row: i, index: e };
+    const n = this.rows.findIndex((o) => o.id === t);
+    if (n < 0) return null;
+    const s = this.rows[n];
+    return s ? (this.rebuildBaseIndex(), { row: s, index: n }) : null;
+  }
+  getRowHeight(t) {
+    return this.view.rowHeights?.[t];
+  }
+  setRowHeight(t, e) {
+    this.view.rowHeights || (this.view.rowHeights = {}), this.view.rowHeights[t] !== e && (this.view.rowHeights[t] = e, this.notify());
+  }
+  setRowHeightsBulk(t) {
+    const e = Object.entries(t);
+    if (e.length === 0) return;
+    this.view.rowHeights || (this.view.rowHeights = {});
+    let i = !1;
+    for (const [n, s] of e)
+      this.view.rowHeights[n] !== s && (this.view.rowHeights[n] = s, i = !0);
+    i && this.notify();
+  }
+  getCell(t, e) {
+    const i = this.findRow(t);
+    if (!i) return;
+    const n = i.row, s = this.pending.get(t);
+    return s && e in s ? s[e] : n.raw[e];
+  }
+  getRawCell(t, e) {
+    const i = this.findRow(t);
+    return i ? i.row.raw[e] : void 0;
+  }
+  isRowReadonly(t) {
+    const e = this.findRow(t);
+    return e ? !!e.row.raw._readonly : !1;
+  }
+  isColumnReadonly(t) {
+    const e = this.schema.columns.find((i) => i.key === t);
+    return !!(e?.readonly || e?.formula);
+  }
+  isReadonly(t, e) {
+    return this.isRowReadonly(t) || this.isColumnReadonly(e);
+  }
+  setCell(t, e, i, n) {
+    this.dataVersion += 1;
+    const s = this.findRow(t);
+    if (!s) return;
+    const o = s.row, r = () => {
+      const l = this.rowVersion.get(t) ?? 0;
+      this.rowVersion.set(t, l + 1);
+    };
+    if (n)
+      o.raw[e] = i, this.pending.delete(t), r();
+    else {
+      const l = this.getRawCell(t, e), h = this.pending.get(t) ?? {};
+      this.isEqual(l, i) ? delete h[e] : h[e] = i, Object.keys(h).length > 0 ? this.pending.set(t, h) : this.pending.delete(t), r();
+    }
+    this.updateValidationForCell(t, e, this.getCell(t, e)), this.schema.columns.find((l) => l.key === e)?.unique && this.recomputeUniqueValidationForColumn(e), this.clearDiagnosticsForCell(t, e), this.notify();
+  }
+  applyPending(t) {
+    this.dataVersion += 1;
+    const e = this.pending.get(t);
+    if (!e) return;
+    const i = this.findRow(t);
+    if (!i) return;
+    const n = i.row, s = /* @__PURE__ */ new Set();
+    for (const [o, r] of Object.entries(e)) {
+      n.raw[o] = r, this.updateValidationForCell(t, o, r);
+      const a = this.schema.columns.find((l) => String(l.key) === String(o));
+      a?.unique && s.add(a.key), this.clearDiagnosticsForCell(t, o);
+    }
+    this.pending.delete(t);
+    for (const o of s) this.recomputeUniqueValidationForColumn(o);
+    this.notify();
+  }
+  clearPending(t) {
+    this.dataVersion += 1, this.pending.delete(t), this.notify();
+  }
+  getPending() {
+    return this.pending;
+  }
+  hasPending(t, e) {
+    const i = this.pending.get(t);
+    return i ? e in i : !1;
+  }
+  insertRow(t) {
+    return this.insertRowAt(t, this.rows.length);
+  }
+  insertRowAt(t, e, i) {
+    this.dataVersion += 1;
+    const n = i ?? vt(), s = Math.max(0, Math.min(e, this.rows.length));
+    return this.rows.splice(s, 0, { id: n, raw: t, displayIndex: 0 }), this.reindexRows(), this.rowVersion.set(n, 0), this.rebuildBaseIndex(), this.recomputeValidationErrors(), this.notify(), n;
+  }
+  removeRow(t) {
+    this.dataVersion += 1;
+    const e = this.findRow(t);
+    if (!e) return null;
+    const i = this.rows.splice(e.index, 1)[0];
+    return i ? (this.pending.delete(t), this.rowVersion.delete(t), this.reindexRows(), this.rebuildBaseIndex(), this.recomputeValidationErrors(), this.notify(), { row: i, index: e.index }) : null;
+  }
+  getDisplayIndex(t) {
+    return this.findRow(t)?.row.displayIndex ?? null;
+  }
+  getRowIndex(t) {
+    return this.computeVisibleRows().indexById.get(t) ?? -1;
+  }
+  getBaseRowIndex(t) {
+    return this.baseIndexById.get(t) ?? -1;
+  }
+  getColumnIndex(t) {
+    return this.getColumns().findIndex((e) => e.key === t);
+  }
+  getColumnByIndex(t) {
+    return this.getColumns()[t] ?? null;
+  }
+  getRowByIndex(t) {
+    return this.listRows()[t] ?? null;
+  }
+  rebuildBaseIndex() {
+    this.baseIndexById.clear();
+    for (let t = 0; t < this.rows.length; t += 1) {
+      const e = this.rows[t];
+      e && this.baseIndexById.set(e.id, t);
+    }
+  }
+  getFilterSortKey(t) {
+    const e = t?.excludeColumnKey, i = t?.includeSort ?? !0, n = this.view, s = (n.filters ?? []).filter((a) => {
+      if (e === void 0) return !0;
+      const l = a?.key;
+      return String(l) !== String(e);
+    }).map((a) => {
+      if (a?.kind === "values") {
+        const u = a;
+        return {
+          kind: "values",
+          key: String(u.key),
+          includeBlanks: !!u.includeBlanks,
+          values: (u.values ?? []).map((f) => this.stableValueKey(f))
+        };
+      }
+      const h = a;
+      return {
+        kind: "op",
+        key: String(h.key),
+        op: String(h.op ?? ""),
+        value: this.stableValueKey(h.value)
+      };
+    }).sort((a, l) => a.key === l.key ? a.kind < l.kind ? -1 : 1 : a.key < l.key ? -1 : 1), o = Object.entries(n.columnDiagnostics ?? {}).filter(([a]) => e !== void 0 ? String(a) !== String(e) : !0).map(([a, l]) => ({
+      key: String(a),
+      errors: !!l?.errors,
+      warnings: !!l?.warnings
+    })).filter((a) => a.errors || a.warnings).sort((a, l) => a.key < l.key ? -1 : a.key > l.key ? 1 : 0), r = i ? (n.sorts ?? []).slice(0, 1).map((a) => ({ key: String(a.key), dir: a.dir })) : [];
+    return JSON.stringify({ filters: s, columnDiagnosticsEntries: o, sorts: r });
+  }
+  stableValueKey(t) {
+    if (t === null) return "null";
+    if (t === void 0) return "undefined";
+    if (t instanceof Date) return `date:${t.getTime()}`;
+    if (typeof t == "string") return `s:${t}`;
+    if (typeof t == "number") return `n:${Number.isNaN(t) ? "NaN" : String(t)}`;
+    if (typeof t == "boolean") return `b:${t ? "1" : "0"}`;
+    if (typeof t == "object") {
+      const e = t, i = e.kind;
+      if (i === "enum" && typeof e.value == "string") return `enum:${e.value}`;
+      if (i === "tags" && Array.isArray(e.values))
+        return `tags:${e.values.filter((n) => typeof n == "string").join("|")}`;
+    }
+    try {
+      return `json:${JSON.stringify(t)}`;
+    } catch {
+      return `str:${String(t)}`;
+    }
+  }
+  isBlankValue(t) {
+    return t == null || t === "";
+  }
+  resolveFilterColumnKey(t) {
+    return this.getColumns().find((n) => String(n.key) === String(t))?.key ?? t;
+  }
+  getFilterCellValue(t, e) {
+    const i = this.getColumns().find((n) => String(n.key) === String(e));
+    return i ? this.resolveCellValue(t, i).value : this.getCell(t, e);
+  }
+  valuesFilterMatches(t, e) {
+    const i = this.resolveFilterColumnKey(e.key), n = this.getFilterCellValue(t, i);
+    if (this.isBlankValue(n)) return !!e.includeBlanks;
+    if (!e.values || e.values.length === 0) return !1;
+    const s = this.stableValueKey(n);
+    for (const o of e.values)
+      if (this.stableValueKey(o) === s) return !0;
+    return !1;
+  }
+  rowPassesColumnDiagnostics(t, e, i) {
+    const n = !!i.errors, s = !!i.warnings;
+    if (!n && !s) return !0;
+    const o = this.resolveFilterColumnKey(e), r = this.getColumns().find((l) => String(l.key) === String(o));
+    r && (this.resolveCellValue(t, r), this.resolveConditionalStyle(t, r));
+    const a = this.getCellMarker(t, o);
+    return a ? a.level === "error" ? n : s : !1;
+  }
+  computeRowsAfterFilter(t) {
+    const e = t?.excludeColumnKey, i = t?.includeSort ?? !0, n = this.view, s = this.getSchema(), o = (n.filters ?? []).filter((d) => {
+      if (e === void 0) return !0;
+      const m = d?.key;
+      return String(m) !== String(e);
+    }), r = Object.entries(n.columnDiagnostics ?? {}).filter(
+      ([d]) => e !== void 0 ? String(d) !== String(e) : !0
+    ), a = [];
+    for (const d of this.rows) {
+      let m = !0;
+      for (const g of o)
+        if (g?.kind === "values" && !this.valuesFilterMatches(d.id, g)) {
+          m = !1;
+          break;
+        }
+      if (m) {
+        for (const [g, y] of r)
+          if (!this.rowPassesColumnDiagnostics(d.id, g, y)) {
+            m = !1;
+            break;
+          }
+        m && a.push(d);
+      }
+    }
+    if (!i) return a;
+    const l = (n.sorts ?? []).slice(0, 1)[0];
+    if (!l) return a;
+    const h = s.columns.find((d) => String(d.key) === String(l.key));
+    if (!h) return a;
+    const u = l.dir === "desc" ? -1 : 1, f = a.map((d) => {
+      const m = this.getFilterCellValue(d.id, h.key), g = this.isBlankValue(m), y = this.baseIndexById.get(d.id) ?? 0;
+      return { row: d, v: m, blank: g, baseIndex: y };
+    }), p = (d, m) => {
+      if (d === m) return 0;
+      if (d instanceof Date && m instanceof Date) return d.getTime() - m.getTime();
+      if (typeof d == "number" && typeof m == "number") return d - m;
+      if (typeof d == "boolean" && typeof m == "boolean") return d === m ? 0 : d ? 1 : -1;
+      const g = d instanceof Date ? d.toISOString() : typeof d == "string" ? d : String(d), y = m instanceof Date ? m.toISOString() : typeof m == "string" ? m : String(m);
+      return g === y ? 0 : g < y ? -1 : 1;
+    };
+    return f.sort((d, m) => {
+      if (d.blank && m.blank) return d.baseIndex - m.baseIndex;
+      if (d.blank) return 1;
+      if (m.blank) return -1;
+      const g = p(d.v, m.v);
+      return g !== 0 ? g * u : d.baseIndex - m.baseIndex;
+    }), f.map((d) => d.row);
+  }
+  computeVisibleRows() {
+    const t = this.getFilterSortKey(), e = this.visibleRowsCache;
+    if (e && e.version === this.dataVersion && e.key === t) return e;
+    const n = this.computeRowsAfterFilter({ includeSort: !0 }), s = /* @__PURE__ */ new Map();
+    for (let r = 0; r < n.length; r += 1) {
+      const a = n[r];
+      a && s.set(a.id, r);
+    }
+    const o = { version: this.dataVersion, key: t, rows: n, indexById: s };
+    return this.visibleRowsCache = o, o;
+  }
+  getDistinctValuesForColumn(t) {
+    const e = `${String(t)}|${this.getFilterSortKey({ excludeColumnKey: t, includeSort: !1 })}`, i = this.distinctValueCache.get(e);
+    if (i && i.version === this.dataVersion) return i;
+    const n = this.computeRowsAfterFilter({ excludeColumnKey: t, includeSort: !1 }), s = this.getSchema().columns.find((h) => String(h.key) === String(t));
+    if (!s) {
+      const h = { version: this.dataVersion, values: [], hasBlanks: !1, total: 0 };
+      return this.distinctValueCache.set(e, h), h;
+    }
+    const o = /* @__PURE__ */ new Map();
+    let r = !1;
+    for (const h of n) {
+      const u = this.getFilterCellValue(h.id, s.key);
+      if (this.isBlankValue(u)) {
+        r = !0;
+        continue;
+      }
+      const f = this.stableValueKey(u);
+      if (o.has(f)) continue;
+      const p = (() => {
+        if (u instanceof Date) return u.toISOString();
+        if (typeof u == "string") return u;
+        if (typeof u == "number" || typeof u == "boolean") return String(u);
+        if (typeof u == "object" && u) {
+          const d = u, m = d.kind;
+          if (m === "enum" && typeof d.value == "string") return d.value;
+          if (m === "tags" && Array.isArray(d.values))
+            return d.values.filter((g) => typeof g == "string").join(", ");
+        }
+        return String(u);
+      })();
+      o.set(f, { value: u, label: p });
+    }
+    const a = [...o.values()].sort(
+      (h, u) => h.label < u.label ? -1 : h.label > u.label ? 1 : 0
+    ), l = {
+      version: this.dataVersion,
+      values: a,
+      hasBlanks: r,
+      total: a.length + (r ? 1 : 0)
+    };
+    return this.distinctValueCache.set(e, l), l;
+  }
+  cellStyleKey(t, e) {
+    return `${t}::${String(e)}`;
+  }
+  clearDiagnosticsForCell(t, e) {
+    const i = this.cellStyleKey(t, e);
+    this.formulaDiagnostics.delete(i), this.conditionalDiagnostics.delete(i);
+  }
+  getCellDiagnostic(t, e) {
+    const i = this.cellStyleKey(t, e), n = this.formulaDiagnostics.get(i) ?? null, s = this.conditionalDiagnostics.get(i) ?? null;
+    return n ? !s || n.level === "error" ? n : s.level === "error" ? s : n : s;
+  }
+  getDiagnostics() {
+    const t = /* @__PURE__ */ new Set();
+    for (const e of this.formulaDiagnostics.keys()) t.add(e);
+    for (const e of this.conditionalDiagnostics.keys()) t.add(e);
+    return [...t].map((e) => {
+      const i = e.indexOf("::"), n = i >= 0 ? e.slice(0, i) : e, s = i >= 0 ? e.slice(i + 2) : "";
+      return { rowId: n, colKey: s, diag: this.getCellDiagnostic(n, s) };
+    });
+  }
+  getRowObjectEffective(t) {
+    const e = this.findRow(t);
+    if (!e) return null;
+    const i = e.row, n = this.pending.get(t);
+    if (!n || Object.keys(n).length === 0)
+      return i.raw;
+    const s = { ...i.raw };
+    for (const [o, r] of Object.entries(n))
+      s[o] = r;
+    return s;
+  }
+  resolveCellValue(t, e) {
+    if (!e.formula)
+      return { value: this.getCell(t, e.key), diagnostic: null };
+    const i = this.getRowVersion(t), n = this.cellStyleKey(t, e.key), s = this.computedCache.get(n);
+    if (s && s.version === i && s.formulaRef === e.formula)
+      return s.diagnostic && this.formulaDiagnostics.set(n, s.diagnostic), {
+        value: s.value,
+        textOverride: s.textOverride,
+        diagnostic: s.diagnostic
+      };
+    const o = this.getRowObjectEffective(t);
+    if (!o) {
+      const r = this.getCell(t, e.key), a = {
+        version: i,
+        formulaRef: e.formula,
+        value: r,
+        diagnostic: null
+      };
+      return this.computedCache.set(n, a), { value: r, diagnostic: null };
+    }
+    try {
+      const r = e.formula(o);
+      if (Array.isArray(r) && r.length >= 2 && r[1] instanceof Error) {
+        const l = {
+          level: "warning",
+          message: r[1].message,
+          source: "formula"
+        }, h = r[0];
+        return this.computedCache.set(n, { version: i, formulaRef: e.formula, value: h, diagnostic: l }), this.formulaDiagnostics.set(n, l), { value: h, diagnostic: l };
+      }
+      const a = r;
+      return this.computedCache.set(n, { version: i, formulaRef: e.formula, value: a, diagnostic: null }), this.formulaDiagnostics.delete(n), { value: a, diagnostic: null };
+    } catch (r) {
+      const l = { level: "error", message: r instanceof Error ? r.message : String(r), source: "formula" };
+      return this.computedCache.set(n, {
+        version: i,
+        formulaRef: e.formula,
+        value: null,
+        textOverride: "#ERROR",
+        diagnostic: l
+      }), this.formulaDiagnostics.set(n, l), { value: null, textOverride: "#ERROR", diagnostic: l };
+    }
+  }
+  setCellConditionalStyle(t, e, i) {
+    const n = this.cellStyleKey(t, e);
+    i ? this.cellConditionalStyles.set(n, i) : this.cellConditionalStyles.delete(n), this.conditionalCache.delete(n), this.clearDiagnosticsForCell(t, e), this.notify();
+  }
+  evalConditionalStyleFn(t, e) {
+    try {
+      const i = t(e);
+      return i instanceof Error ? {
+        delta: null,
+        diagnostic: { level: "warning", message: i.message, source: "conditionalStyle" },
+        forceErrorText: !1
+      } : { delta: i ?? null, diagnostic: null, forceErrorText: !1 };
+    } catch (i) {
+      return {
+        delta: null,
+        diagnostic: { level: "error", message: i instanceof Error ? i.message : String(i), source: "conditionalStyle" },
+        forceErrorText: !0
+      };
+    }
+  }
+  resolveRowConditionalStyle(t) {
+    const e = this.getRowConditionalStyleFn();
+    if (!e) return { delta: null, diagnostic: null, forceErrorText: !1 };
+    const i = this.getRowVersion(t), n = this.rowConditionalCache.get(t);
+    if (n && n.version === i && n.fnRef === e)
+      return {
+        delta: n.delta,
+        diagnostic: n.diagnostic,
+        forceErrorText: n.forceErrorText
+      };
+    const s = this.getRowObjectEffective(t);
+    if (!s) {
+      const r = { version: i, fnRef: e, delta: null, diagnostic: null, forceErrorText: !1 };
+      return this.rowConditionalCache.set(t, r), { delta: null, diagnostic: null, forceErrorText: !1 };
+    }
+    const o = this.evalConditionalStyleFn(e, s);
+    return this.rowConditionalCache.set(t, { version: i, fnRef: e, ...o }), o;
+  }
+  resolveConditionalStyle(t, e) {
+    const i = this.getRowVersion(t), n = this.cellStyleKey(t, e.key), s = this.getRowObjectEffective(t), o = this.resolveRowConditionalStyle(t), r = (f, p) => p ? f ? { ...f, ...p } : { ...p } : f;
+    let a = null, l = null, h = !1;
+    if (a = r(a, o.delta), o.diagnostic && (l = o.diagnostic), h = h || o.forceErrorText, e.conditionalStyle && s) {
+      const f = `${t}::${String(e.key)}::col`, p = this.conditionalCache.get(f);
+      if (p && p.version === i && p.fnRef === e.conditionalStyle)
+        a = r(a, p.delta), p.diagnostic && (l === null || l.level !== "error") && (l = p.diagnostic), h = h || p.forceErrorText;
+      else {
+        const d = this.evalConditionalStyleFn(e.conditionalStyle, s);
+        this.conditionalCache.set(f, { version: i, fnRef: e.conditionalStyle, ...d }), a = r(a, d.delta), d.diagnostic && (l === null || l.level !== "error") && (l = d.diagnostic), h = h || d.forceErrorText;
+      }
+    }
+    const u = this.cellConditionalStyles.get(n);
+    if (u && s) {
+      const f = this.conditionalCache.get(n);
+      if (f && f.version === i && f.fnRef === u)
+        a = r(a, f.delta), f.diagnostic && (l === null || l.level !== "error") && (l = f.diagnostic), h = h || f.forceErrorText;
+      else {
+        const p = this.evalConditionalStyleFn(u, s);
+        this.conditionalCache.set(n, { version: i, fnRef: u, ...p }), a = r(a, p.delta), p.diagnostic && (l === null || l.level !== "error") && (l = p.diagnostic), h = h || p.forceErrorText;
+      }
+    }
+    return l ? this.conditionalDiagnostics.set(n, l) : this.conditionalDiagnostics.delete(n), { delta: a, diagnostic: l, forceErrorText: h };
+  }
+  getValidationErrors() {
+    const t = /* @__PURE__ */ new Map();
+    for (const [i, n] of this.baseValidationErrors.entries()) t.set(i, { ...n });
+    for (const [i, n] of this.uniqueValidationErrors.entries()) {
+      const s = t.get(i);
+      s ? t.set(i, { ...s, message: `${s.message}
+${n.message}` }) : t.set(i, { ...n });
+    }
+    const e = [...t.values()];
+    return e.sort((i, n) => {
+      const s = this.getRowIndex(i.rowId), o = this.getRowIndex(n.rowId);
+      if (s !== o) return s - o;
+      const r = this.getColumnIndex(i.colKey), a = this.getColumnIndex(n.colKey);
+      return r - a;
+    }), e;
+  }
+  getCellValidationMessage(t, e) {
+    const i = this.cellStyleKey(t, e), n = this.baseValidationErrors.get(i)?.message ?? null, s = this.uniqueValidationErrors.get(i)?.message ?? null;
+    return n ? s ? `${n}
+${s}` : n : s;
+  }
+  getCellMarker(t, e) {
+    const i = this.getCellDiagnostic(t, e), n = this.getCellValidationMessage(t, e);
+    if (!i && !n) return null;
+    const s = n ? "error" : i?.level ?? "warning", o = [i?.message ?? null, n].filter(Boolean).join(`
+`);
+    return { level: s, message: o };
+  }
+  updateValidationForCell(t, e, i) {
+    const n = this.schema.columns.find((r) => String(r.key) === String(e));
+    if (!n) return;
+    const s = ie(i, n), o = this.cellStyleKey(t, e);
+    s ? this.baseValidationErrors.set(o, { rowId: t, colKey: e, message: s }) : this.baseValidationErrors.delete(o);
+  }
+  recomputeValidationErrors() {
+    this.baseValidationErrors.clear(), this.uniqueValidationErrors.clear();
+    for (const t of this.rows)
+      for (const e of this.schema.columns) {
+        const i = this.getCell(t.id, e.key);
+        this.updateValidationForCell(t.id, e.key, i);
+      }
+    for (const t of this.getColumns())
+      t.unique && this.recomputeUniqueValidationForColumn(t.key);
+  }
+  normalizeUniqueValue(t) {
+    if (t == null) return null;
+    if (typeof t == "string") return t === "" ? null : t;
+    if (typeof t == "number" || typeof t == "boolean") return String(t);
+    if (t instanceof Date) return String(t.getTime());
+    if (typeof t == "object") {
+      const e = t, i = e.kind;
+      if (i === "enum" && typeof e.value == "string")
+        return e.value === "" ? null : e.value;
+      if (i === "tags" && Array.isArray(e.values)) {
+        const n = e.values.filter((s) => typeof s == "string").join(",");
+        return n === "" ? null : n;
+      }
+    }
+    return String(t);
+  }
+  recomputeUniqueValidationForColumn(t) {
+    const e = String(t);
+    for (const n of Array.from(this.uniqueValidationErrors.keys())) {
+      const s = n.indexOf("::");
+      (s >= 0 ? n.slice(s + 2) : "") === e && this.uniqueValidationErrors.delete(n);
+    }
+    const i = /* @__PURE__ */ new Map();
+    for (const n of this.rows) {
+      const s = this.getCell(n.id, t), o = this.normalizeUniqueValue(s);
+      if (!o) continue;
+      const r = i.get(o) ?? [];
+      r.push(n.id), i.set(o, r);
+    }
+    for (const n of i.values()) {
+      if (n.length < 2) continue;
+      const s = n.map((r) => this.getDisplayIndex(r)).filter((r) => typeof r == "number" && Number.isFinite(r)).sort((r, a) => r - a), o = s.length ? s.join(", ") : n.join(", ");
+      for (const r of n) {
+        const a = this.cellStyleKey(r, t);
+        this.uniqueValidationErrors.set(a, {
+          rowId: r,
+          colKey: t,
+          message: `Duplicate value
+Rows: ${o}`
+        });
+      }
+    }
+  }
+  getCellStyle(t, e) {
+    return this.cellStyles.get(this.cellStyleKey(t, e)) ?? null;
+  }
+  setCellStyle(t, e, i) {
+    const n = this.cellStyleKey(t, e);
+    !i || Object.keys(i).length === 0 ? this.cellStyles.delete(n) : this.cellStyles.set(n, i), this.notify();
+  }
+  updateColumnStyle(t, e) {
+    const i = this.schema.columns.find((s) => String(s.key) === String(t));
+    if (!i) return;
+    const n = typeof e == "function" ? e(i.style) : e;
+    i.style = n, this.notify();
+  }
+  isEqual(t, e) {
+    return t instanceof Date && e instanceof Date ? t.getTime() === e.getTime() : Object.is(t, e);
+  }
+  getRowVersion(t) {
+    return this.rowVersion.get(t) ?? 0;
+  }
+  reindexRows() {
+    let t = 1;
+    for (const e of this.rows)
+      e.displayIndex = t, t += 1;
+  }
+}
+function se(c, t) {
+  const e = c.getSchema(), i = c.listRows(), n = (o, r) => {
+    if (!Number.isInteger(o) || !Number.isInteger(r) || o < 0 || o >= i.length || r < 0 || r >= e.columns.length) return null;
+    const a = i[o], l = e.columns[r];
+    return { rowId: a.id, colKey: l.key, rowIndex: o, colIndex: r };
+  }, s = (o, r) => {
+    const a = c.getRowIndex(o);
+    if (a < 0) return null;
+    const l = e.columns.findIndex((h) => h.key === r);
+    return l < 0 ? null : { rowId: o, colKey: r, rowIndex: a, colIndex: l };
+  };
+  if ("rowId" in t && "colKey" in t)
+    return s(t.rowId, t.colKey);
+  if ("rowIndex" in t && "colIndex" in t)
+    return n(t.rowIndex, t.colIndex);
+  if ("rowId" in t && "colIndex" in t) {
+    const o = c.getRowIndex(t.rowId);
+    return o < 0 ? null : n(o, t.colIndex);
+  }
+  if ("rowIndex" in t && "colKey" in t) {
+    const o = e.columns.findIndex((r) => r.key === t.colKey);
+    return o < 0 ? null : n(t.rowIndex, o);
+  }
+  return null;
+}
+function oe() {
+  return { caseInsensitive: !1, regex: !1 };
+}
+function at(c, t) {
+  if (c == null) return "";
+  if (c instanceof Date) return c.toISOString();
+  if (typeof c == "string") return c;
+  if (typeof c == "number" || typeof c == "boolean") return String(c);
+  if (typeof c == "object") {
+    const e = c, i = e.kind;
+    if (i === "enum" && typeof e.value == "string") return e.value;
+    if (i === "tags" && Array.isArray(e.values))
+      return e.values.filter((n) => typeof n == "string").join(", ");
+  }
+  return t.type === "boolean" ? String(c).toLowerCase() === "true" ? "TRUE" : "FALSE" : String(c);
+}
+function re(c) {
+  return c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function xt(c, t) {
+  return t <= 0 ? -1 : Math.max(0, Math.min(t - 1, c));
+}
+class le {
+  constructor(t, e, i, n) {
+    this.dataModel = t, this.navigateToCell = e, this.applyEdit = i, this.canEdit = n, this.state = {
+      query: "",
+      replace: "",
+      mode: "find",
+      options: oe(),
+      matches: [],
+      activeIndex: -1,
+      error: null
+    }, this.listeners = /* @__PURE__ */ new Set(), this.debounceId = null, this.unsubscribeData = null, this.unsubscribeData = this.dataModel.subscribe(() => {
+      this.state.query && this.scheduleRecompute();
+    });
+  }
+  destroy() {
+    this.debounceId !== null && window.clearTimeout(this.debounceId), this.debounceId = null, this.unsubscribeData?.(), this.unsubscribeData = null, this.listeners.clear();
+  }
+  getState() {
+    return this.state;
+  }
+  subscribe(t) {
+    return this.listeners.add(t), t(this.state), () => this.listeners.delete(t);
+  }
+  setMode(t) {
+    this.setState({ ...this.state, mode: t });
+  }
+  setQuery(t) {
+    this.setState({ ...this.state, query: t }), this.scheduleRecompute();
+  }
+  setReplace(t) {
+    this.setState({ ...this.state, replace: t });
+  }
+  setOptions(t) {
+    this.setState({ ...this.state, options: { ...this.state.options, ...t } }), this.scheduleRecompute();
+  }
+  next() {
+    if (!this.state.matches.length) return;
+    const t = (this.state.activeIndex + 1) % this.state.matches.length;
+    this.activateIndex(t);
+  }
+  prev() {
+    if (!this.state.matches.length) return;
+    const t = (this.state.activeIndex - 1 + this.state.matches.length) % this.state.matches.length;
+    this.activateIndex(t);
+  }
+  activateIndex(t) {
+    const e = xt(t, this.state.matches.length);
+    if (e < 0) return;
+    const i = this.state.matches[e];
+    i && (this.setState({ ...this.state, activeIndex: e }), this.navigateToCell(i.rowId, i.colKey));
+  }
+  replaceCurrent() {
+    const t = this.state.activeIndex;
+    if (t < 0) return;
+    const e = this.state.matches[t];
+    if (!e || !this.canEdit(e.rowId, e.colKey)) return;
+    const n = this.dataModel.getSchema().columns[e.colIndex];
+    if (!n) return;
+    const s = this.dataModel.getCell(e.rowId, e.colKey), o = at(s, n), r = this.applyReplacement(o, e);
+    this.applyEdit(e.rowId, e.colKey, r), this.recompute();
+  }
+  replaceAll() {
+    if (!this.state.matches.length) return;
+    const t = this.dataModel.getSchema(), e = /* @__PURE__ */ new Map();
+    for (const i of this.state.matches)
+      this.canEdit(i.rowId, i.colKey) && e.set(`${i.rowId}|${i.colKey}`, [...e.get(`${i.rowId}|${i.colKey}`) ?? [], i]);
+    for (const [i, n] of e.entries()) {
+      const [s, o] = i.split("|"), r = n[0];
+      if (!r) continue;
+      const a = r.colIndex, l = t.columns[a];
+      if (!l || !s || !o) continue;
+      const h = o, u = this.dataModel.getCell(s, h), f = at(u, l), p = this.applyReplacementAllInCell(f, n);
+      this.applyEdit(s, h, p);
+    }
+    this.recompute();
+  }
+  applyReplacement(t, e) {
+    const { query: i, replace: n, options: s } = this.state;
+    if (!i) return t;
+    if (s.regex)
+      try {
+        const o = `g${s.caseInsensitive ? "i" : ""}`, r = new RegExp(i, o);
+        let a = -1;
+        return t.replace(r, (l, ...h) => {
+          const u = h[h.length - 2];
+          return typeof u != "number" || u !== e.start || a === u ? l : (a = u, n);
+        });
+      } catch {
+        return t;
+      }
+    return t.slice(0, e.start) + n + t.slice(e.end);
+  }
+  applyReplacementAllInCell(t, e) {
+    if (!e.length) return t;
+    const { query: i, replace: n, options: s } = this.state;
+    if (!i) return t;
+    if (s.regex)
+      try {
+        const a = `g${s.caseInsensitive ? "i" : ""}`, l = new RegExp(i, a);
+        return t.replace(l, n);
+      } catch {
+        return t;
+      }
+    const o = [...e].sort((a, l) => l.start - a.start);
+    let r = t;
+    for (const a of o)
+      r = r.slice(0, a.start) + n + r.slice(a.end);
+    return r;
+  }
+  scheduleRecompute() {
+    this.debounceId !== null && window.clearTimeout(this.debounceId), this.debounceId = window.setTimeout(() => {
+      this.debounceId = null, this.recompute();
+    }, 180);
+  }
+  recompute() {
+    const { query: t, options: e } = this.state;
+    if (!t) {
+      this.setState({ ...this.state, matches: [], activeIndex: -1, error: null });
+      return;
+    }
+    const i = this.dataModel.getSchema(), n = this.dataModel.getView(), s = this.dataModel.listRows(), o = [];
+    let r = null, a = null;
+    if (e.regex)
+      try {
+        const h = `g${e.caseInsensitive ? "i" : ""}`;
+        a = new RegExp(t, h);
+      } catch (h) {
+        r = h instanceof Error ? h.message : "Invalid pattern";
+      }
+    else {
+      const h = e.caseInsensitive ? "gi" : "g";
+      a = new RegExp(re(t), h);
+    }
+    if (!a || r) {
+      this.setState({
+        ...this.state,
+        matches: [],
+        activeIndex: -1,
+        error: r ?? "Invalid pattern"
+      });
+      return;
+    }
+    for (let h = 0; h < s.length; h += 1) {
+      const u = s[h];
+      if (u)
+        for (let f = 0; f < i.columns.length; f += 1) {
+          const p = i.columns[f];
+          if (!p || n.hiddenColumns?.some((y) => String(y) === String(p.key))) continue;
+          const d = this.dataModel.getCell(u.id, p.key), m = at(d, p);
+          if (!m) continue;
+          a.lastIndex = 0;
+          let g = a.exec(m);
+          for (; g; ) {
+            const y = g.index, w = y + (g[0]?.length ?? 0);
+            if (o.push({
+              rowId: u.id,
+              colKey: p.key,
+              rowIndex: h,
+              colIndex: f,
+              start: y,
+              end: w,
+              text: m
+            }), g[0] === "") break;
+            g = a.exec(m);
+          }
+        }
+    }
+    const l = o.length ? xt(this.state.activeIndex, o.length) : -1;
+    this.setState({ ...this.state, matches: o, activeIndex: l, error: null });
+  }
+  setState(t) {
+    this.state = t;
+    for (const e of this.listeners) e(this.state);
+  }
+}
+class ae {
+  constructor(t, e, i) {
+    this.lockedRows = /* @__PURE__ */ new Set(), this.mode = "none", this.mode = t, this.server = e, this.user = i;
+  }
+  setMode(t) {
+    this.mode = t;
+  }
+  setUser(t) {
+    this.user = t;
+  }
+  async selectRow(t) {
+    if (this.mode === "row" && !this.lockedRows.has(t) && (this.lockedRows.add(t), this.server && this.user))
+      try {
+        await this.server.lockRow(t, this.user);
+      } catch (e) {
+        console.warn("lockRow failed", e);
+      }
+  }
+  async unlockOnMove(t) {
+    this.mode === "row" && t && await this.unlockRows([t]);
+  }
+  async unlockOnCommit(t) {
+    if (this.mode !== "row") return;
+    const e = [];
+    for (const i of this.lockedRows)
+      i !== t && e.push(i);
+    e.length && await this.unlockRows(e);
+  }
+  async unlockRows(t) {
+    for (const e of t) this.lockedRows.delete(e);
+    if (this.server && this.user)
+      try {
+        await this.server.unlockRows(t, this.user);
+      } catch (e) {
+        console.warn("unlockRows failed", e);
+      }
+  }
+  getLockedRows() {
+    return new Set(this.lockedRows);
+  }
+}
+const ct = 864e5;
+function Rt(c) {
+  const t = dt(c);
+  return t ? Number.isNaN(t.getTime()) ? null : t : null;
+}
+function ce(c) {
+  const t = /* @__PURE__ */ new Date(`1970-01-01T${c}`);
+  return Number.isNaN(t.getTime()) ? null : t;
+}
+function de(c, t, e) {
+  if (t == null || e.type === "string") return null;
+  if (e.type === "boolean") return String(!!t);
+  if (e.type === "number" && typeof t == "number") return String(t);
+  if (e.type === "datetime") {
+    const i = t instanceof Date ? t : Rt(String(t));
+    return i ? String(i.getTime()) : null;
+  }
+  if (e.type === "date") {
+    const i = t instanceof Date ? t : Rt(String(t));
+    if (!i) return null;
+    const n = Math.floor(i.getTime() / ct) * ct;
+    return String(n);
+  }
+  if (e.type === "time") {
+    const i = t instanceof Date ? t : ce(String(t));
+    return i ? String(i.getTime() % ct) : null;
+  }
+  return null;
+}
+const Ft = 24, ht = 48, ut = 24;
+function W(c, t, e = 100) {
+  const i = {
+    // Reserve extra space for browser UI affordances (e.g. date picker icon) and formatting.
+    date: 8
+  };
+  return c.columns.map((n) => {
+    const s = t.columnWidths?.[String(n.key)] ?? n.width ?? e, o = i[n.type] ?? 0;
+    return s + o;
+  });
+}
+function he(c) {
+  return {
+    ...c,
+    startRow: Math.min(c.startRow, c.endRow),
+    endRow: Math.max(c.startRow, c.endRow),
+    startCol: Math.min(c.startCol, c.endCol),
+    endCol: Math.max(c.startCol, c.endCol)
+  };
+}
+function st(c) {
+  const t = /^(.*?)(\d+)$/.exec(c);
+  if (!t) return null;
+  const e = t[1] ?? "", i = t[2] ?? "", n = Number(i);
+  return Number.isFinite(n) ? { prefix: e, num: n, width: i.length } : null;
+}
+function Mt(c) {
+  if (c instanceof Date) return c;
+  if (typeof c == "number" && Number.isFinite(c)) return new Date(c);
+  if (typeof c == "string") {
+    const t = c.trim();
+    if (/^\d{1,2}:\d{2}(:\d{2}(\.\d{1,3})?)?$/.test(t)) {
+      const i = /* @__PURE__ */ new Date(`1970-01-01T${t}`);
+      return Number.isNaN(i.getTime()) ? null : i;
+    }
+    const e = new Date(t);
+    return Number.isNaN(e.getTime()) ? null : e;
+  }
+  return null;
+}
+function kt(c) {
+  if (c instanceof Date) return c;
+  if (typeof c == "number" && Number.isFinite(c)) return new Date(c);
+  if (typeof c == "string") {
+    const t = new Date(c);
+    return Number.isNaN(t.getTime()) ? null : t;
+  }
+  return null;
+}
+function ue(c, t) {
+  return new Date(Date.UTC(c, t + 1, 0)).getUTCDate();
+}
+function Kt(c, t) {
+  const e = c.getUTCFullYear(), i = c.getUTCMonth(), n = c.getUTCDate(), s = c.getUTCHours(), o = c.getUTCMinutes(), r = c.getUTCSeconds(), a = c.getUTCMilliseconds(), l = e * 12 + i + t, h = Math.floor(l / 12), u = (l % 12 + 12) % 12, f = ue(h, u), p = Math.min(n, f);
+  return new Date(Date.UTC(h, u, p, s, o, r, a));
+}
+function fe(c, t) {
+  return Kt(c, t * 12);
+}
+function Lt(c, t) {
+  const e = c.getFullYear(), i = c.getMonth(), n = c.getDate(), s = c.getHours(), o = c.getMinutes(), r = c.getSeconds(), a = c.getMilliseconds(), l = e * 12 + i + t, h = Math.floor(l / 12), u = (l % 12 + 12) % 12, f = new Date(h, u + 1, 0).getDate(), p = Math.min(n, f);
+  return new Date(h, u, p, s, o, r, a);
+}
+function pe(c, t) {
+  return Lt(c, t * 12);
+}
+function Vt(c, t) {
+  if (t.length !== 1) return null;
+  const e = he(t[0]);
+  if (e.kind !== "cells") return null;
+  const i = e.endCol - e.startCol + 1, n = e.endRow - e.startRow + 1;
+  if (i !== 1 || n !== 1 && n !== 2) return null;
+  const o = c.getSchema().columns[e.startCol];
+  if (!o) return null;
+  if (o.type === "boolean")
+    return n !== 1 ? null : {
+      colKey: o.key,
+      colIndex: e.startCol,
+      startRowIndex: e.startRow,
+      endRowIndex: e.endRow,
+      mode: "copy"
+    };
+  if (n === 1)
+    return {
+      colKey: o.key,
+      colIndex: e.startCol,
+      startRowIndex: e.startRow,
+      endRowIndex: e.endRow,
+      mode: "copy"
+    };
+  if (o.type === "string") {
+    const r = c.listRows(), a = r[e.startRow], l = r[e.endRow];
+    if (!a || !l) return null;
+    const h = String(c.getCell(a.id, o.key) ?? ""), u = String(c.getCell(l.id, o.key) ?? ""), f = st(h), p = st(u);
+    return !f || !p || f.prefix !== p.prefix || f.width !== p.width ? null : {
+      colKey: o.key,
+      colIndex: e.startCol,
+      startRowIndex: e.startRow,
+      endRowIndex: e.endRow,
+      mode: "sequence"
+    };
+  }
+  return o.type === "number" || o.type === "date" || o.type === "time" || o.type === "datetime" ? {
+    colKey: o.key,
+    colIndex: e.startCol,
+    startRowIndex: e.startRow,
+    endRowIndex: e.endRow,
+    mode: "sequence"
+  } : null;
+}
+function ge(c, t) {
+  const e = c.getSchema(), i = c.listRows(), n = e.columns[t.colIndex];
+  if (!n) return null;
+  const s = i[t.startRowIndex], o = i[t.endRowIndex];
+  if (!s || !o) return null;
+  const r = c.getCell(s.id, n.key), a = c.getCell(o.id, n.key);
+  if (t.mode === "copy")
+    return () => a;
+  if (n.type === "number") {
+    const l = typeof r == "number" ? r : Number(r), h = typeof a == "number" ? a : Number(a);
+    if (!Number.isFinite(l) || !Number.isFinite(h)) return null;
+    const u = h - l;
+    return (f) => h + u * f;
+  }
+  if (n.type === "date" || n.type === "time" || n.type === "datetime") {
+    const l = n.type === "time" ? Mt(r) : kt(r), h = n.type === "time" ? Mt(a) : kt(a);
+    if (!l || !h) return null;
+    const u = l.getTime(), f = h.getTime(), p = f - u;
+    if (n.type === "time")
+      return (d) => new Date(f + p * d);
+    if (n.type === "date") {
+      const d = l.getUTCDate() === h.getUTCDate();
+      if (d && l.getUTCMonth() === h.getUTCMonth()) {
+        const g = h.getUTCFullYear() - l.getUTCFullYear();
+        if (g !== 0) {
+          const y = new Date(Date.UTC(h.getUTCFullYear(), h.getUTCMonth(), h.getUTCDate()));
+          return (w) => fe(y, g * w);
+        }
+      } else if (d) {
+        const g = (h.getUTCFullYear() - l.getUTCFullYear()) * 12 + (h.getUTCMonth() - l.getUTCMonth());
+        if (g !== 0) {
+          const y = new Date(Date.UTC(h.getUTCFullYear(), h.getUTCMonth(), h.getUTCDate()));
+          return (w) => Kt(y, g * w);
+        }
+      }
+    } else {
+      const d = l.getDate() === h.getDate();
+      if (d && l.getMonth() === h.getMonth()) {
+        const g = h.getFullYear() - l.getFullYear();
+        if (g !== 0)
+          return (y) => pe(h, g * y);
+      } else if (d) {
+        const g = (h.getFullYear() - l.getFullYear()) * 12 + (h.getMonth() - l.getMonth());
+        if (g !== 0)
+          return (y) => Lt(h, g * y);
+      }
+    }
+    return (d) => new Date(f + p * d);
+  }
+  if (n.type === "string") {
+    const l = String(r ?? ""), h = String(a ?? ""), u = st(l), f = st(h);
+    if (!u || !f || u.prefix !== f.prefix || u.width !== f.width) return null;
+    const p = f.num - u.num;
+    return (d) => {
+      const m = f.num + p * d, g = m < 0 ? "-" : "", y = Math.abs(m), w = String(y).padStart(f.width, "0");
+      return `${f.prefix}${g}${w}`;
+    };
+  }
+  return null;
+}
+const _t = 12, Pt = 14;
+function Bt(c, t = _t) {
+  return new DOMRect(c.right - t - 1, c.bottom - t - 1, t, t);
+}
+function $t(c, t, e) {
+  return c >= e.left && c <= e.right && t >= e.top && t <= e.bottom;
+}
+function ot(c, t, e, i, n) {
+  if (n === "readonly") return !1;
+  const s = Vt(c, t);
+  return !(!s || !e || e === "__all__" || i === null || i === "__all__" || i === null || i !== s.colKey || c.isReadonly(e, i));
+}
+function ft(c) {
+  const t = c.style, e = t?.decorations;
+  return {
+    backgroundColor: t?.backgroundColor,
+    textColor: t?.textColor,
+    bold: e?.bold,
+    italic: e?.italic,
+    underline: e?.underline,
+    strike: e?.strike
+  };
+}
+function X(c, t) {
+  return t ? {
+    backgroundColor: t.backgroundColor ?? c.backgroundColor,
+    textColor: t.textColor ?? c.textColor,
+    bold: t.bold ?? c.bold,
+    italic: t.italic ?? c.italic,
+    underline: t.underline ?? c.underline,
+    strike: t.strike ?? c.strike
+  } : c;
+}
+function me(c, t, e) {
+  const i = ft(e), n = c.resolveConditionalStyle(t, e).delta ?? {}, s = c.getCellStyle(t, e.key) ?? {}, o = X(X(i, n), s);
+  return { columnStyle: i, cellStyle: s, resolved: o };
+}
+function It(c) {
+  let t = "";
+  c.backgroundColor && (t += `background-color:${c.backgroundColor};`), c.textColor && (t += `color:${c.textColor};`), c.bold && (t += "font-weight:600;"), c.italic && (t += "font-style:italic;");
+  const e = [];
+  return c.underline && e.push("underline"), c.strike && e.push("line-through"), e.length && (t += `text-decoration-line:${e.join(" ")};`), t;
+}
+function Nt(c, t) {
+  const e = c.sorts?.[0];
+  return e && e.key === t ? e.dir : null;
+}
+function Ot(c, t) {
+  if ((c.filters ?? []).some((n) => {
+    const s = n;
+    return s?.kind === "values" && s.key === t;
+  })) return !0;
+  const i = c.columnDiagnostics?.[t];
+  return !!(i?.errors || i?.warnings);
+}
+function ye() {
+  return `
+    <svg viewBox="0 0 24 24" width="16" height="16" aria-hidden="true" focusable="false">
+      <path d="M3 5h18l-7 8v6l-4 2v-8L3 5z" fill="none" stroke="currentColor" stroke-width="2" stroke-linejoin="round"/>
+    </svg>
+  `.trim();
+}
+function we(c) {
+  return `
+    <svg viewBox="0 0 24 24" width="16" height="16" aria-hidden="true" focusable="false">
+      <path d="${c === "asc" ? "M12 6l6 8H6l6-8z" : "M12 18l-6-8h12l-6 8z"}" fill="currentColor"/>
+    </svg>
+  `.trim();
+}
+function be(c, t, e, i, n, s) {
+  const o = Math.min(10, Math.floor(Math.min(i, n) / 2));
+  if (o <= 0) return;
+  const r = s === "error" ? "#ef4444" : "#f59e0b";
+  c.save(), c.fillStyle = r, c.beginPath(), c.moveTo(t + i, e), c.lineTo(t + i - o, e), c.lineTo(t + i, e + o), c.closePath(), c.fill(), c.restore();
+}
+class qt {
+  constructor() {
+    this.numberFormatCache = /* @__PURE__ */ new Map(), this.dateParseCache = /* @__PURE__ */ new Map();
+  }
+  getNumberFormatter(t) {
+    const e = JSON.stringify(t);
+    let i = this.numberFormatCache.get(e);
+    return i || (i = new Intl.NumberFormat("en-US", t), this.numberFormatCache.set(e, i)), i;
+  }
+  parseIsoDate(t) {
+    const e = this.dateParseCache.get(t);
+    if (e) return e;
+    const i = dt(t);
+    return !i || Number.isNaN(i.getTime()) ? null : (this.dateParseCache.set(t, i), i);
+  }
+}
+function ve(c, t, e, i, n) {
+  c.save(), c.globalAlpha = n, c.strokeStyle = "rgba(15,23,42,1)", c.lineWidth = 2, c.lineJoin = "round", c.beginPath(), c.moveTo(t, e), c.lineTo(t + i, e), c.lineTo(t + Math.round(i * 0.62), e + Math.round(i * 0.46)), c.lineTo(t + Math.round(i * 0.38), e + Math.round(i * 0.46)), c.closePath(), c.stroke(), c.beginPath(), c.moveTo(t + Math.round(i * 0.46), e + Math.round(i * 0.46)), c.lineTo(t + Math.round(i * 0.46), e + i), c.lineTo(t + Math.round(i * 0.54), e + i - 2), c.lineTo(t + Math.round(i * 0.54), e + Math.round(i * 0.46)), c.stroke(), c.restore();
+}
+function Ce(c, t, e, i, n, s) {
+  c.save(), c.globalAlpha = n, c.fillStyle = "rgba(15,23,42,1)", c.beginPath(), s === "asc" ? (c.moveTo(t + i / 2, e), c.lineTo(t + i, e + i), c.lineTo(t, e + i)) : (c.moveTo(t, e), c.lineTo(t + i, e), c.lineTo(t + i / 2, e + i)), c.closePath(), c.fill(), c.restore();
+}
+class pt {
+  constructor(t) {
+    this.n = t, this.tree = new Array(t + 1).fill(0);
+  }
+  static from(t) {
+    const e = new pt(t.length);
+    for (let i = 0; i < t.length; i += 1) e.add(i, t[i] ?? 0);
+    return e;
+  }
+  sum(t) {
+    let e = Math.max(0, Math.min(this.n, t)), i = 0;
+    for (; e > 0; )
+      i += this.tree[e] ?? 0, e -= e & -e;
+    return i;
+  }
+  total() {
+    return this.sum(this.n);
+  }
+  add(t, e) {
+    let i = t + 1;
+    if (!(i <= 0 || i > this.n))
+      for (; i <= this.n; )
+        this.tree[i] = (this.tree[i] ?? 0) + e, i += i & -i;
+  }
+  /**
+   * Returns the smallest index `i` (0-based) such that `sum(i + 1) >= target`.
+   * If `target <= 0`, returns 0. If `target > total`, returns `n - 1`.
+   */
+  lowerBound(t) {
+    if (this.n <= 0 || t <= 0) return 0;
+    const e = this.total();
+    if (t > e) return this.n - 1;
+    let i = 0, n = 1;
+    for (; n <= this.n; ) n <<= 1;
+    let s = 0;
+    for (let o = n; o !== 0; o >>= 1) {
+      const r = i + o;
+      if (r <= this.n) {
+        const a = s + (this.tree[r] ?? 0);
+        a < t && (i = r, s = a);
+      }
+    }
+    return Math.min(this.n - 1, i);
+  }
+}
+class nt {
+  constructor(t) {
+    this.dataModel = t, this.tableEl = null, this.defaultRowHeight = ut, this.rowHeaderWidth = ht, this.activeRowId = null, this.activeColKey = null, this.selection = [], this.valueFormatCache = new qt(), this.measureCache = /* @__PURE__ */ new Map(), this.frame = 0;
+  }
+  mount(t) {
+    this.tableEl = document.createElement("table"), this.tableEl.dataset.extableRenderer = "html", t.innerHTML = "", t.appendChild(this.tableEl), this.render();
+  }
+  setActiveCell(t, e) {
+    this.activeRowId = t, this.activeColKey = e, this.updateActiveClasses();
+  }
+  setSelection(t) {
+    this.selection = t, this.applySelectionClasses();
+  }
+  render(t) {
+    if (this.frame += 1, !this.tableEl) return;
+    const e = this.tableEl.parentElement, i = e?.scrollTop ?? 0, n = e?.scrollLeft ?? 0, s = this.dataModel.getSchema(), o = this.dataModel.getView(), r = this.dataModel.listRows();
+    this.tableEl.innerHTML = "";
+    const a = W(s, o), l = s.columns.map((m) => ft(m)), h = l.map((m) => It(m)), u = this.rowHeaderWidth + a.reduce((m, g) => m + (g ?? 0), 0), f = document.createElement("colgroup"), p = document.createElement("col");
+    p.style.width = `${this.rowHeaderWidth}px`, f.appendChild(p);
+    for (const m of a) {
+      const g = document.createElement("col");
+      m && (g.style.width = `${m}px`), f.appendChild(g);
+    }
+    this.tableEl.appendChild(f), this.tableEl.style.width = `${u}px`, this.tableEl.appendChild(this.renderHeader(s, a));
+    const d = document.createElement("tbody");
+    for (const m of r)
+      d.appendChild(this.renderRow(m, s, a, l, h));
+    this.tableEl.appendChild(d), this.updateActiveClasses(), this.applySelectionClasses(), e && (e.scrollTop = i, e.scrollLeft = n);
+    for (const [m, g] of Array.from(this.measureCache.entries()))
+      g.frame !== this.frame && this.measureCache.delete(m);
+  }
+  destroy() {
+    _(this.tableEl), this.tableEl = null;
+  }
+  getCellElements() {
+    return this.tableEl?.querySelectorAll("tr[data-row-id] td[data-col-key]") ?? null;
+  }
+  hitTest(t) {
+    const e = t.target;
+    if (!e) return null;
+    const i = e.closest("th.extable-corner");
+    if (i)
+      return {
+        rowId: "__all__",
+        colKey: "__all__",
+        element: i,
+        rect: i.getBoundingClientRect()
+      };
+    const n = e.closest("th.extable-row-header:not(.extable-corner)");
+    if (n) {
+      const r = n.closest("tr[data-row-id]");
+      if (r)
+        return {
+          rowId: r.dataset.rowId ?? "",
+          colKey: null,
+          element: n,
+          rect: n.getBoundingClientRect()
+        };
+    }
+    const s = e.closest("td[data-col-key]"), o = s?.closest("tr[data-row-id]");
+    return !s || !o ? null : {
+      rowId: o.dataset.rowId ?? "",
+      colKey: s.dataset.colKey ?? "",
+      element: s,
+      rect: s.getBoundingClientRect()
+    };
+  }
+  renderHeader(t, e) {
+    const i = document.createElement("thead"), n = document.createElement("tr"), s = document.createElement("th");
+    s.classList.add("extable-row-header", "extable-corner"), s.textContent = "", s.style.width = `${this.rowHeaderWidth}px`, this.activeRowId && s.classList.toggle("extable-active-row-header", !0), s.dataset.colKey = "", n.appendChild(s);
+    const o = this.dataModel.getView();
+    for (let r = 0; r < t.columns.length; r += 1) {
+      const a = t.columns[r];
+      if (!a) continue;
+      const l = document.createElement("th");
+      l.dataset.colKey = a.key;
+      const h = Nt(o, a.key), u = Ot(o, a.key);
+      h ? l.dataset.extableSortDir = h : l.removeAttribute("data-extable-sort-dir"), u ? l.dataset.extableFsActive = "1" : l.removeAttribute("data-extable-fs-active");
+      const f = document.createElement("div");
+      f.className = "extable-col-header";
+      const p = document.createElement("span");
+      p.className = "extable-col-header-text", p.textContent = a.header ?? a.key;
+      const d = document.createElement("button");
+      d.type = "button", d.className = "extable-filter-sort-trigger", d.dataset.extableFsOpen = "1", d.dataset.extableColKey = a.key, d.title = "Filter / Sort", d.innerHTML = h ? we(h) : ye(), f.appendChild(p), f.appendChild(d), l.appendChild(f);
+      const m = e[r] ?? a.width;
+      m && (l.style.width = `${m}px`), l.dataset.colKey = a.key, this.activeColKey !== null && this.activeColKey === a.key && l.classList.add("extable-active-col-header"), n.appendChild(l);
+    }
+    return i.appendChild(n), i;
+  }
+  renderRow(t, e, i, n, s) {
+    const o = document.createElement("tr");
+    o.dataset.rowId = t.id;
+    const r = this.dataModel.getView(), a = document.createElement("th");
+    a.scope = "row", a.classList.add("extable-row-header");
+    const l = this.dataModel.getDisplayIndex(t.id) ?? "";
+    a.textContent = String(l), a.style.width = `${this.rowHeaderWidth}px`, this.activeRowId === t.id && a.classList.add("extable-active-row-header"), o.appendChild(a);
+    for (let u = 0; u < e.columns.length; u += 1) {
+      const f = e.columns[u];
+      if (!f) continue;
+      const p = document.createElement("td");
+      p.classList.add("extable-cell"), p.dataset.colKey = f.key, f.type === "boolean" && p.classList.add("extable-boolean");
+      const d = this.dataModel.hasPending(t.id, f.key), m = this.dataModel.resolveConditionalStyle(t.id, f), g = this.dataModel.getCellStyle(t.id, f.key);
+      if (!g && !m.delta && !d) {
+        const M = s[u] ?? "";
+        M && (p.style.cssText = M);
+      } else {
+        const M = n[u] ?? {}, A = m.delta ? X(M, m.delta) : M, K = g ? X(A, g) : A, H = d ? { ...K, textColor: void 0 } : K, P = It(H);
+        P && (p.style.cssText = P);
+      }
+      const y = i[u] ?? r.columnWidths?.[f.key] ?? f.width;
+      y && (p.style.width = `${y}px`);
+      const w = r.wrapText?.[f.key] ?? f.wrapText;
+      p.classList.add(w ? "cell-wrap" : "cell-nowrap");
+      const S = this.dataModel.getRawCell(t.id, f.key), b = this.dataModel.resolveCellValue(t.id, f), C = b.textOverride ?? (m.forceErrorText ? "#ERROR" : void 0), v = C ? { text: C } : this.formatValue(b.value, f);
+      p.textContent = v.text, v.color && (p.style.color = v.color);
+      const R = this.dataModel.getCellMarker(t.id, f.key);
+      R ? (p.classList.toggle("extable-diag-warning", R.level === "warning"), p.classList.toggle("extable-diag-error", R.level === "error"), p.dataset.extableDiagMessage = R.message) : (p.classList.remove("extable-diag-warning", "extable-diag-error"), p.removeAttribute("data-extable-diag-message"));
+      const I = f.style?.align ?? (f.type === "number" ? "right" : "left");
+      p.classList.add(I === "right" ? "align-right" : "align-left");
+      const x = de(S, b.value, f);
+      if (x !== null)
+        p.dataset.raw = x;
+      else {
+        const M = S == null ? "" : String(S);
+        p.dataset.raw = M;
+      }
+      d && p.classList.add("pending"), this.dataModel.isReadonly(t.id, f.key) ? p.classList.add("extable-readonly", "extable-readonly-muted") : p.classList.add("extable-editable"), this.activeRowId === t.id && this.activeColKey !== null && this.activeColKey === f.key && p.classList.add("extable-active-cell"), o.appendChild(p);
+    }
+    if (e.columns.some((u) => r.wrapText?.[u.key] ?? u.wrapText)) {
+      let u = this.defaultRowHeight;
+      for (let f = 0; f < e.columns.length; f += 1) {
+        const p = e.columns[f];
+        if (!p || !p.wrapText) continue;
+        const d = i[f] ?? r.columnWidths?.[p.key] ?? p.width ?? 100, m = this.dataModel.resolveCellValue(t.id, p), g = this.dataModel.resolveConditionalStyle(t.id, p), w = m.textOverride ?? (g.forceErrorText ? "#ERROR" : void 0) ? "#ERROR" : m.value === null || m.value === void 0 ? "" : String(m.value), S = this.dataModel.getRowVersion(t.id), b = `${t.id}|${p.key}|${S}|${d}|${w}`, C = this.measureCache.get(b);
+        if (C) {
+          C.frame = this.frame, this.measureCache.set(b, C), u = Math.max(u, C.height);
+          continue;
+        }
+        const v = document.createElement("span");
+        v.style.visibility = "hidden", v.style.position = "absolute", v.style.left = "-10000px", v.style.top = "0", v.style.whiteSpace = "pre-wrap", v.style.overflowWrap = "anywhere", v.style.display = "inline-block", v.style.width = `${d}px`, v.textContent = w;
+        const R = this.tableEl?.parentElement;
+        if (!R) continue;
+        R.appendChild(v);
+        const I = v.clientHeight + 10;
+        v.remove(), this.measureCache.set(b, { height: I, frame: this.frame }), u = Math.max(u, I);
+      }
+      o.style.height = `${u}px`, this.dataModel.setRowHeight(t.id, u);
+    } else
+      o.style.height = `${this.defaultRowHeight}px`, this.dataModel.setRowHeight(t.id, this.defaultRowHeight);
+    return o;
+  }
+  updateActiveClasses() {
+    if (!this.tableEl) return;
+    const t = this.activeRowId === "__all__" && this.activeColKey === "__all__";
+    this.tableEl.classList.toggle("extable-all-selected", t);
+    for (const e of Array.from(this.tableEl.querySelectorAll(".extable-active-row-header")))
+      e.classList.remove("extable-active-row-header");
+    for (const e of Array.from(this.tableEl.querySelectorAll(".extable-active-col-header")))
+      e.classList.remove("extable-active-col-header");
+    for (const e of Array.from(this.tableEl.querySelectorAll(".extable-active-cell")))
+      e.classList.remove("extable-active-cell");
+    if (this.activeRowId)
+      for (const e of Array.from(
+        this.tableEl.querySelectorAll(
+          `tr[data-row-id="${this.activeRowId}"] .extable-row-header`
+        )
+      ))
+        e.classList.add("extable-active-row-header");
+    if (this.activeColKey !== null) {
+      for (const e of Array.from(
+        this.tableEl.querySelectorAll(`th[data-col-key="${this.activeColKey}"]`)
+      ))
+        e.classList.add("extable-active-col-header");
+      if (this.activeRowId)
+        for (const e of Array.from(
+          this.tableEl.querySelectorAll(
+            `tr[data-row-id="${this.activeRowId}"] td[data-col-key="${this.activeColKey}"]`
+          )
+        ))
+          e.classList.add("extable-active-cell");
+    }
+  }
+  applySelectionClasses() {
+    if (!this.tableEl) return;
+    for (const i of Array.from(this.tableEl.querySelectorAll(".extable-selected")))
+      i.classList.remove("extable-selected");
+    if (!this.selection.length) return;
+    const t = Array.from(this.tableEl.querySelectorAll("tbody tr")), e = this.dataModel.getSchema();
+    for (const i of this.selection) {
+      const n = Math.max(0, Math.min(i.startRow, i.endRow)), s = Math.min(t.length - 1, Math.max(i.startRow, i.endRow)), o = Math.max(0, Math.min(i.startCol, i.endCol)), r = Math.min(e.columns.length - 1, Math.max(i.startCol, i.endCol));
+      for (let a = n; a <= s; a += 1) {
+        const l = t[a];
+        if (!l) continue;
+        const h = l.querySelector("th.extable-row-header");
+        h && h.classList.add("extable-selected");
+        const u = Array.from(l.querySelectorAll("td"));
+        for (let f = o; f <= r; f += 1) {
+          const p = u[f];
+          p && p.classList.add("extable-selected");
+        }
+      }
+    }
+  }
+  formatValue(t, e) {
+    if (t == null) return { text: "" };
+    if (e.type === "boolean")
+      return e.booleanDisplay === "checkbox" || !e.booleanDisplay ? { text: t ? "☑" : "☐" } : Array.isArray(e.booleanDisplay) && e.booleanDisplay.length >= 2 ? { text: String(t ? e.booleanDisplay[0] : e.booleanDisplay[1]) } : { text: t ? String(e.booleanDisplay) : "" };
+    if (e.type === "number" && typeof t == "number") {
+      const i = t, n = {};
+      e.number?.scale !== void 0 && (n.minimumFractionDigits = e.number.scale, n.maximumFractionDigits = e.number.scale), n.useGrouping = !!e.number?.thousandSeparator;
+      const s = this.valueFormatCache.getNumberFormatter(n).format(i), o = e.number?.negativeRed && i < 0 ? "#b91c1c" : void 0;
+      return { text: s, color: o };
+    }
+    if ((e.type === "date" || e.type === "time" || e.type === "datetime") && (t instanceof Date || typeof t == "string")) {
+      const i = e.type === "date" ? Y(e.dateFormat, "date") : e.type === "time" ? Y(e.timeFormat, "time") : Y(e.dateTimeFormat, "datetime");
+      let n = null;
+      return t instanceof Date ? n = t : n = this.valueFormatCache.parseIsoDate(t), n ? { text: At(n, i) } : { text: String(t) };
+    }
+    return { text: String(t) };
+  }
+}
+const O = class O {
+  constructor(t, e = () => "direct") {
+    this.getEditMode = e, this.root = null, this.canvas = null, this.spacer = null, this.overlayLayer = null, this.tooltip = null, this.tooltipTarget = null, this.tooltipMessage = null, this.rowHeight = ut, this.headerHeight = Ft, this.lineHeight = 16, this.padding = 12, this.rowHeaderWidth = ht, this.activeRowId = null, this.activeColKey = null, this.selection = [], this.valueFormatCache = new qt(), this.textMeasureCache = /* @__PURE__ */ new Map(), this.frame = 0, this.cursorTimer = null, this.pendingCursorPoint = null, this.hoverHeaderColKey = null, this.hoverHeaderIcon = !1, this.rowHeightCacheKey = null, this.rowHeightMeasuredVersion = /* @__PURE__ */ new Map(), this.rowHeightMeasureRaf = null, this.rowHeightMeasureTask = null, this.heightIndex = null, this.handleClick = (i) => {
+      if (!this.root || !this.canvas) return;
+      const n = this.canvas.getBoundingClientRect(), s = i.clientX - n.left, o = i.clientY - n.top, r = s + this.root.scrollLeft, a = o;
+      if (a >= this.headerHeight || r < this.rowHeaderWidth) return;
+      const l = this.dataModel.getSchema(), h = this.dataModel.getView(), u = W(l, h);
+      let f = this.rowHeaderWidth, p = -1;
+      for (let C = 0; C < u.length; C += 1) {
+        const v = u[C] ?? 100;
+        if (r >= f && r <= f + v) {
+          p = C;
+          break;
+        }
+        f += v;
+      }
+      if (p < 0) return;
+      const d = l.columns[p];
+      if (!d) return;
+      const m = u[p] ?? 100, g = 18, w = f + m - g - 4, S = Math.floor((this.headerHeight - g) / 2);
+      r >= w && r <= w + g && a >= S && a <= S + g && this.root.dispatchEvent(
+        new CustomEvent("extable:filter-sort-open", { bubbles: !0, detail: { colKey: d.key } })
+      );
+    }, this.handlePointerMove = (i) => {
+      this.pendingCursorPoint = { x: i.clientX, y: i.clientY }, !this.cursorTimer && (this.cursorTimer = window.setTimeout(() => {
+        this.cursorTimer = null;
+        const n = this.pendingCursorPoint;
+        n && this.updateCanvasCursor(n.x, n.y);
+      }, 50));
+    }, this.handlePointerLeave = () => {
+      this.canvas && (this.canvas.style.cursor = "cell", this.tooltip && (this.tooltip.dataset.visible = "0"), this.tooltipTarget = null, this.tooltipMessage = null);
+    }, this.dataModel = t;
+  }
+  mount(t) {
+    this.root = t, this.canvas = document.createElement("canvas");
+    const e = O.MAX_CANVAS_DIM_PX;
+    this.canvas.width = Math.max(1, Math.min(e, Math.floor(t.clientWidth || 600))), this.canvas.height = Math.max(1, Math.min(e, Math.floor(t.clientHeight || 400))), this.canvas.style.width = `${this.canvas.width}px`, this.canvas.style.height = `${this.canvas.height}px`, this.canvas.dataset.extableRenderer = "canvas", this.canvas.style.position = "sticky", this.canvas.style.top = "0", this.canvas.style.left = "0", this.canvas.style.zIndex = "1", this.canvas.style.cursor = "cell", this.canvas.addEventListener("pointermove", this.handlePointerMove), this.canvas.addEventListener("pointerleave", this.handlePointerLeave), this.canvas.addEventListener("click", this.handleClick), this.spacer = document.createElement("div"), this.spacer.style.width = "1px", this.tooltip && this.tooltip.remove(), this.overlayLayer && this.overlayLayer.remove(), this.overlayLayer = document.createElement("div"), this.overlayLayer.className = "extable-overlay-layer", this.tooltip = document.createElement("div"), this.tooltip.className = "extable-tooltip", this.tooltip.dataset.visible = "0", this.overlayLayer.appendChild(this.tooltip), t.innerHTML = "", t.style.position = "relative", t.appendChild(this.overlayLayer), t.appendChild(this.canvas), t.appendChild(this.spacer), this.render();
+  }
+  setActiveCell(t, e) {
+    this.activeRowId = t, this.activeColKey = e, this.render();
+  }
+  setSelection(t) {
+    this.selection = t, this.render();
+  }
+  render(t) {
+    try {
+      if (this.frame += 1, !this.canvas || !this.root) return;
+      const e = this.canvas.getContext("2d");
+      if (!e) return;
+      e.font = "14px sans-serif";
+      let i = e.font;
+      const n = this.activeRowId === "__all__" && this.activeColKey === "__all__", s = this.dataModel.getSchema(), o = this.dataModel.getView(), r = this.dataModel.listRows(), a = W(s, o), l = s.columns.map((k) => ft(k)), h = /* @__PURE__ */ new Map(), u = s.columns.some((k) => o.wrapText?.[k.key] ?? k.wrapText), f = u ? this.getRowHeightCacheKey(s, o, a) : null;
+      f !== this.rowHeightCacheKey && (this.rowHeightCacheKey = f, this.rowHeightMeasuredVersion.clear(), this.rowHeightMeasureTask = null), u || this.cancelRowHeightMeasurement(), this.ensureHeightIndex(r, u ? f : null, u);
+      const p = this.heightIndex;
+      if (!p) return;
+      const d = this.rowHeaderWidth + a.reduce((k, D) => k + (D ?? 0), 0), m = t?.clientWidth ?? (this.root.clientWidth || 600), g = t?.clientHeight ?? (this.root.clientHeight || this.canvas.height || 400), y = O.MAX_CANVAS_DIM_PX, w = Math.max(1, Math.min(y, Math.floor(m))), S = Math.max(1, Math.min(y, Math.floor(g)));
+      this.canvas.width !== w && (this.canvas.width = w), this.canvas.height !== S && (this.canvas.height = S), this.canvas.style.width = `${w}px`, this.canvas.style.height = `${S}px`, e.font = "14px sans-serif", i = e.font, this.refreshTooltipPosition();
+      const b = t?.scrollTop ?? this.root.scrollTop, C = t?.scrollLeft ?? this.root.scrollLeft, v = (k) => {
+        const D = k + 1, E = Math.max(
+          0,
+          Math.min(r.length - 1, p.fenwick.lowerBound(D))
+        ), q = p.fenwick.sum(E);
+        let F = E, $ = 0;
+        const B = (this.canvas?.height ?? 0) + this.rowHeight * 2;
+        for (let T = E; T < r.length && $ < B; T += 1)
+          $ += p.heights[T] ?? this.rowHeight, F = T + 1;
+        return { accum: q, visibleStart: E, visibleEnd: F };
+      };
+      let R = p.fenwick.total(), I = Math.max(
+        0,
+        Math.min(b, Math.max(0, R - this.rowHeight))
+      ), { accum: x, visibleStart: M, visibleEnd: A } = v(I);
+      if (u && f) {
+        const k = {};
+        for (let D = M; D < A; D += 1) {
+          const E = r[D];
+          if (!E) continue;
+          const q = this.dataModel.getRowVersion(E.id);
+          if (this.rowHeightMeasuredVersion.get(E.id) === q) continue;
+          const F = this.measureRowHeight(e, E, s, a);
+          k[E.id] = F, this.rowHeightMeasuredVersion.set(E.id, q);
+        }
+        this.applyRowHeightUpdates(k), R = p.fenwick.total(), this.dataModel.setRowHeightsBulk(k), I = Math.max(
+          0,
+          Math.min(b, Math.max(0, R - this.rowHeight))
+        ), { accum: x, visibleStart: M, visibleEnd: A } = v(I), (this.rowHeightMeasureTask || Object.keys(k).length > 0) && this.scheduleRowHeightMeasurement();
+      }
+      this.spacer && (this.spacer.style.height = `${R + this.headerHeight}px`, this.spacer.style.width = `${d}px`);
+      const K = this.rowHeaderWidth - C;
+      e.clearRect(0, 0, this.canvas.width, this.canvas.height), e.fillStyle = "#e5e7eb", e.fillRect(0, 0, this.rowHeaderWidth, this.canvas.height);
+      let H = this.headerHeight + x - I;
+      for (let k = M; k < A; k += 1) {
+        const D = r[k], E = p.heights[k] ?? this.rowHeight;
+        e.strokeStyle = "#d0d7de", e.fillStyle = "#e5e7eb", e.fillRect(0, H, this.rowHeaderWidth, E), e.strokeRect(0, H, this.rowHeaderWidth, E);
+        const q = this.dataModel.getDisplayIndex(D.id) ?? "";
+        this.activeRowId === D.id && (e.fillStyle = "rgba(59,130,246,0.16)", e.fillRect(0, H, this.rowHeaderWidth, E)), e.fillStyle = "#0f172a", e.font = "bold 14px sans-serif", e.textAlign = "center", e.textBaseline = "middle", e.fillText(String(q), this.rowHeaderWidth / 2, H + E / 2), e.font = i, e.textAlign = "left", e.textBaseline = "alphabetic", e.save(), e.beginPath(), e.rect(
+          this.rowHeaderWidth,
+          this.headerHeight,
+          this.canvas.width - this.rowHeaderWidth,
+          this.canvas.height - this.headerHeight
+        ), e.clip(), e.translate(K, 0);
+        let F = 0, $ = "";
+        for (let B = 0; B < s.columns.length; B += 1) {
+          const T = s.columns[B], L = a[B] ?? 100;
+          if (!T) {
+            F += L;
+            continue;
+          }
+          const V = this.dataModel.isReadonly(D.id, T.key);
+          e.strokeStyle = "#d0d7de";
+          const Z = this.dataModel.resolveConditionalStyle(D.id, T), z = this.dataModel.getCellStyle(D.id, T.key), G = l[B] ?? {}, gt = Z.delta ? X(G, Z.delta) : G, U = z ? X(gt, z) : gt, Ut = V ? "#f3f4f6" : U.backgroundColor ?? "#ffffff";
+          e.fillStyle = Ut, e.fillRect(F, H, L, E), e.strokeRect(F, H, L, E);
+          const mt = this.dataModel.resolveCellValue(D.id, T), lt = mt.textOverride ?? (Z.forceErrorText ? "#ERROR" : void 0) ? { text: "#ERROR" } : this.formatValue(mt.value, T), Wt = lt.text, jt = T.style?.align ?? (T.type === "number" ? "right" : "left");
+          if (this.activeRowId === D.id && this.activeColKey !== null && this.activeColKey === T.key && (e.strokeStyle = "#3b82f6", e.lineWidth = 2, e.strokeRect(F + 1, H + 1, L - 2, E - 2), e.lineWidth = 1, ot(
+            this.dataModel,
+            this.selection,
+            this.activeRowId,
+            this.activeColKey,
+            this.getEditMode()
+          ))) {
+            const N = _t, Q = F + L - N - 1, J = H + E - N - 1;
+            e.fillStyle = "#3b82f6", e.fillRect(Q, J, N, N), e.strokeStyle = "#ffffff", e.strokeRect(Q + 0.5, J + 0.5, N - 1, N - 1);
+          }
+          e.fillStyle = this.dataModel.hasPending(D.id, T.key) ? "#b91c1c" : lt.color ? lt.color : V ? "#94a3b8" : U.textColor ?? "#0f172a";
+          const Yt = o.wrapText?.[T.key] ?? T.wrapText ?? !1, yt = T.type === "boolean" && (!T.booleanDisplay || T.booleanDisplay === "checkbox"), Xt = T.type === "boolean" && !!(T.booleanDisplay && T.booleanDisplay !== "checkbox");
+          if (yt)
+            e.font = i, $ = "";
+          else {
+            const N = `${U.italic ? "i" : ""}${U.bold ? "b" : ""}`;
+            if (N !== $) {
+              const Q = h.get(N);
+              if (Q) e.font = Q;
+              else {
+                const J = U.bold ? "600 " : "", bt = `${U.italic ? "italic " : ""}${J}14px sans-serif`.trim();
+                h.set(N, bt), e.font = bt;
+              }
+              $ = N;
+            }
+          }
+          this.drawCellText(
+            e,
+            Wt,
+            F + 8,
+            H + 6,
+            L - 12,
+            E - 12,
+            Yt,
+            jt,
+            yt,
+            Xt,
+            { underline: !!U.underline, strike: !!U.strike }
+          );
+          const wt = this.dataModel.getCellMarker(D.id, T.key);
+          wt && be(e, F, H, L, E, wt.level), F += L;
+        }
+        e.restore(), H += E;
+      }
+      e.fillStyle = "#e5e7eb", e.fillRect(0, 0, this.canvas.width, this.headerHeight), e.strokeStyle = "#d0d7de", e.strokeRect(0, 0, this.rowHeaderWidth, this.headerHeight), e.fillStyle = "#9ca3af", e.beginPath(), e.moveTo(4, 4), e.lineTo(16, 4), e.lineTo(4, 16), e.closePath(), e.fill(), this.activeRowId && (e.fillStyle = "rgba(59,130,246,0.16)", e.fillRect(0, 0, this.rowHeaderWidth, this.headerHeight)), e.save(), e.beginPath(), e.rect(this.rowHeaderWidth, 0, this.canvas.width - this.rowHeaderWidth, this.headerHeight), e.clip(), e.translate(K, 0);
+      let P = 0;
+      for (let k = 0; k < s.columns.length; k += 1) {
+        const D = s.columns[k], E = a[k] ?? 100;
+        if (!D) {
+          P += E;
+          continue;
+        }
+        this.activeColKey !== null && this.activeColKey === D.key && (e.fillStyle = "rgba(59,130,246,0.16)", e.fillRect(P, 0, E, this.headerHeight)), e.strokeStyle = "#d0d7de", e.strokeRect(P, 0, E, this.headerHeight), e.fillStyle = "#0f172a", e.font = "bold 14px sans-serif", e.fillText(D.header ?? D.key, P + 8, this.headerHeight - 8), e.font = i;
+        const F = Nt(o, D.key), $ = Ot(o, D.key), B = this.hoverHeaderColKey !== null && this.hoverHeaderColKey === D.key;
+        if (!!F || $ || B) {
+          const L = B ? 0.9 : $ || F ? 0.75 : 0.45, V = 16, z = P + E - V - 6, G = Math.floor((this.headerHeight - V) / 2);
+          F ? Ce(e, z + 3, G + 3, V - 6, L, F) : ve(e, z + 2, G + 2, V - 4, L);
+        }
+        P += E;
+      }
+      if (e.restore(), this.selection.length) {
+        e.save(), e.strokeStyle = "#3b82f6", e.fillStyle = "rgba(59,130,246,0.12)";
+        for (const k of this.selection) {
+          const D = Math.max(0, Math.min(k.startRow, k.endRow)), E = Math.min(r.length - 1, Math.max(k.startRow, k.endRow)), q = Math.max(0, Math.min(k.startCol, k.endCol)), F = Math.min(
+            s.columns.length - 1,
+            Math.max(k.startCol, k.endCol)
+          ), $ = this.headerHeight + p.fenwick.sum(D) - I, B = p.fenwick.sum(E + 1) - p.fenwick.sum(D);
+          let T = this.rowHeaderWidth;
+          for (let V = 0; V < q; V += 1)
+            T += a[V] ?? 100;
+          let L = 0;
+          for (let V = q; V <= F; V += 1)
+            L += a[V] ?? 100;
+          T -= C, e.fillRect(T, $, L, B), e.strokeRect(T + 0.5, $ + 0.5, L - 1, B - 1);
+        }
+        e.restore();
+      }
+      n && (e.save(), e.fillStyle = "rgba(59,130,246,0.08)", e.fillRect(0, 0, this.canvas.width, this.canvas.height), e.restore());
+    } catch {
+      return;
+    }
+  }
+  destroy() {
+    this.cancelRowHeightMeasurement(), this.heightIndex = null, this.canvas && (this.canvas.removeEventListener("pointermove", this.handlePointerMove), this.canvas.removeEventListener("pointerleave", this.handlePointerLeave), this.canvas.removeEventListener("click", this.handleClick)), this.cursorTimer && (window.clearTimeout(this.cursorTimer), this.cursorTimer = null), this.pendingCursorPoint = null, _(this.canvas), _(this.spacer), _(this.overlayLayer), _(this.tooltip), this.canvas = null, this.spacer = null, this.overlayLayer = null, this.tooltip = null, this.tooltipTarget = null, this.tooltipMessage = null, this.root = null;
+  }
+  ensureHeightIndex(t, e, i) {
+    const n = this.heightIndex;
+    if (n && n.rowsRef === t && n.key === e) return;
+    const s = new Array(t.length), o = /* @__PURE__ */ new Map();
+    for (let r = 0; r < t.length; r += 1) {
+      const a = t[r];
+      if (!a) continue;
+      o.set(a.id, r);
+      let l = this.rowHeight;
+      if (i && e) {
+        const h = this.dataModel.getRowVersion(a.id), u = this.rowHeightMeasuredVersion.get(a.id), f = this.dataModel.getRowHeight(a.id);
+        u === h && typeof f == "number" && (l = f);
+      }
+      s[r] = l;
+    }
+    this.heightIndex = {
+      key: e,
+      rowsRef: t,
+      idToIndex: o,
+      heights: s,
+      fenwick: pt.from(s)
+    };
+  }
+  applyRowHeightUpdates(t) {
+    const e = this.heightIndex;
+    if (e)
+      for (const [i, n] of Object.entries(t)) {
+        const s = e.idToIndex.get(i);
+        if (s === void 0) continue;
+        const o = e.heights[s] ?? this.rowHeight;
+        o !== n && (e.heights[s] = n, e.fenwick.add(s, n - o));
+      }
+  }
+  getRowHeightCacheKey(t, e, i) {
+    const n = t.columns.map((o) => e.wrapText?.[o.key] ?? o.wrapText ? "1" : "0").join(""), s = i.map((o) => String(o ?? 0)).join(",");
+    return `${n}|${s}`;
+  }
+  cancelRowHeightMeasurement() {
+    this.rowHeightMeasureRaf !== null && (cancelAnimationFrame(this.rowHeightMeasureRaf), this.rowHeightMeasureRaf = null), this.rowHeightMeasureTask = null;
+  }
+  scheduleRowHeightMeasurement() {
+    this.rowHeightMeasureRaf === null && (this.rowHeightMeasureRaf = requestAnimationFrame(() => {
+      this.rowHeightMeasureRaf = null, this.runRowHeightMeasurement();
+    }));
+  }
+  runRowHeightMeasurement() {
+    if (!this.canvas) return;
+    const t = this.canvas.getContext("2d");
+    if (!t) return;
+    t.font = "14px sans-serif";
+    const e = this.dataModel.getSchema(), i = this.dataModel.getView(), n = W(e, i);
+    if (!e.columns.some((f) => i.wrapText?.[f.key] ?? f.wrapText)) return;
+    const o = this.getRowHeightCacheKey(e, i, n);
+    this.rowHeightCacheKey !== o && (this.rowHeightCacheKey = o, this.rowHeightMeasuredVersion.clear(), this.rowHeightMeasureTask = null);
+    const r = this.rowHeightMeasureTask ?? { key: o, nextIndex: 0 };
+    if (r.key !== o) return;
+    const a = this.dataModel.listRows(), l = {};
+    let h = 0;
+    const u = performance.now();
+    for (; r.nextIndex < a.length && h < O.ROW_HEIGHT_MEASURE_CHUNK && !(performance.now() - u > O.ROW_HEIGHT_MEASURE_TIME_BUDGET_MS); ) {
+      const f = a[r.nextIndex];
+      if (r.nextIndex += 1, !f) continue;
+      const p = this.dataModel.getRowVersion(f.id);
+      if (this.rowHeightMeasuredVersion.get(f.id) === p) continue;
+      const d = this.measureRowHeight(t, f, e, n);
+      l[f.id] = d, this.rowHeightMeasuredVersion.set(f.id, p), h += 1;
+    }
+    this.rowHeightMeasureTask = r.nextIndex < a.length ? r : null, this.ensureHeightIndex(a, this.rowHeightCacheKey, !0), this.applyRowHeightUpdates(l), this.dataModel.setRowHeightsBulk(l), this.rowHeightMeasureTask && this.scheduleRowHeightMeasurement();
+  }
+  getCellElements() {
+    return null;
+  }
+  hitTest(t) {
+    if (!this.root || !this.canvas) return null;
+    const e = this.canvas.getBoundingClientRect(), i = t.clientX - e.left, n = t.clientY - e.top, s = i + this.root.scrollLeft, o = this.dataModel.getSchema(), r = this.dataModel.getView(), a = this.dataModel.listRows(), l = this.headerHeight, h = W(o, r), u = o.columns.some((x) => r.wrapText?.[x.key] ?? x.wrapText), f = u ? this.getRowHeightCacheKey(o, r, h) : null;
+    this.ensureHeightIndex(a, f, u);
+    const p = this.heightIndex;
+    if (!p) return null;
+    const d = p.fenwick.total(), m = Math.max(
+      0,
+      Math.min(
+        this.root.scrollTop - this.headerHeight,
+        Math.max(0, d - this.rowHeight)
+      )
+    );
+    if (n < l && i < this.rowHeaderWidth)
+      return {
+        rowId: "__all__",
+        colKey: "__all__",
+        rect: new DOMRect(e.left, e.top, this.rowHeaderWidth, l)
+      };
+    if (n < l) {
+      let x = this.rowHeaderWidth, M = -1;
+      for (let A = 0; A < h.length; A += 1) {
+        const K = h[A] ?? 100;
+        if (s >= x && s <= x + K) {
+          M = A;
+          break;
+        }
+        x += K;
+      }
+      if (M >= 0) {
+        const A = o.columns[M], K = new DOMRect(
+          e.left + x - this.root.scrollLeft,
+          e.top,
+          h[M] ?? 100,
+          l
+        );
+        return { rowId: "__header__", colKey: A.key, rect: K };
+      }
+      return null;
+    }
+    if (i < this.rowHeaderWidth) {
+      const x = n - l + m, M = Math.max(
+        0,
+        Math.min(a.length - 1, p.fenwick.lowerBound(x + 1))
+      ), A = p.fenwick.sum(M);
+      if (M < 0 || M >= a.length) return null;
+      const K = a[M], H = e.top + l + A - m, P = new DOMRect(
+        e.left,
+        H,
+        this.rowHeaderWidth,
+        p.heights[M] ?? this.rowHeight
+      );
+      return { rowId: K.id, colKey: null, rect: P };
+    }
+    const g = n - l + m, y = Math.max(0, Math.min(a.length - 1, p.fenwick.lowerBound(g + 1))), w = p.fenwick.sum(y);
+    if (y < 0 || y >= a.length) return null;
+    let S = this.rowHeaderWidth, b = -1;
+    for (let x = 0; x < h.length; x += 1) {
+      const M = h[x] ?? 100;
+      if (s >= S && s <= S + M) {
+        b = x;
+        break;
+      }
+      S += M;
+    }
+    if (b === -1) return null;
+    const C = a[y], v = o.columns[b], R = w, I = new DOMRect(
+      e.left + S - this.root.scrollLeft,
+      e.top + l + R - this.root.scrollTop,
+      h[b] ?? 100,
+      p.heights[y] ?? this.rowHeight
+    );
+    return { rowId: C.id, colKey: v.key, rect: I };
+  }
+  isPointInSelection(t, e) {
+    if (!this.selection.length) return !1;
+    const i = this.dataModel.getSchema(), n = this.dataModel.getRowIndex(t), s = i.columns.findIndex((o) => o.key === e);
+    if (n < 0 || s < 0) return !1;
+    for (const o of this.selection) {
+      if (o.kind !== "cells") continue;
+      const r = Math.min(o.startRow, o.endRow), a = Math.max(o.startRow, o.endRow), l = Math.min(o.startCol, o.endCol), h = Math.max(o.startCol, o.endCol);
+      if (n >= r && n <= a && s >= l && s <= h)
+        return !0;
+    }
+    return !1;
+  }
+  positionTooltipAtRect(t) {
+    if (!this.tooltip || !this.root) return;
+    const e = 8, i = this.root.getBoundingClientRect(), n = this.root.clientWidth, s = this.root.clientHeight;
+    let o = t.right - i.left + e, r = t.top - i.top + e, a = "right";
+    const l = this.tooltip.getBoundingClientRect();
+    o + l.width > n && (o = Math.max(0, t.left - i.left - l.width - e), a = "left"), r + l.height > s && (r = Math.max(0, s - l.height - e)), this.tooltip.style.left = `${o}px`, this.tooltip.style.top = `${r}px`, this.tooltip.dataset.side = a;
+  }
+  refreshTooltipPosition() {
+    if (!this.tooltip || this.tooltip.dataset.visible !== "1" || !this.tooltipTarget || !this.tooltipMessage) return;
+    const t = this.getCellRect(this.tooltipTarget.rowId, this.tooltipTarget.colKey);
+    if (!t) {
+      this.tooltip.dataset.visible = "0", this.tooltipTarget = null, this.tooltipMessage = null;
+      return;
+    }
+    this.tooltip.textContent = this.tooltipMessage, this.positionTooltipAtRect(t);
+  }
+  getCellRect(t, e) {
+    if (!this.root || !this.canvas) return null;
+    const i = this.canvas.getBoundingClientRect(), n = this.dataModel.getSchema(), s = this.dataModel.getView(), o = this.dataModel.listRows(), r = this.dataModel.getRowIndex(t), a = n.columns.findIndex((m) => m.key === e);
+    if (r < 0 || a < 0) return null;
+    const l = W(n, s), h = n.columns.some((m) => s.wrapText?.[m.key] ?? m.wrapText), u = h ? this.getRowHeightCacheKey(n, s, l) : null;
+    this.ensureHeightIndex(o, u, h);
+    const f = this.heightIndex;
+    if (!f) return null;
+    const p = f.fenwick.sum(r);
+    let d = this.rowHeaderWidth;
+    for (let m = 0; m < a; m += 1)
+      d += l[m] ?? 100;
+    return new DOMRect(
+      i.left + d - this.root.scrollLeft,
+      i.top + this.headerHeight + p - this.root.scrollTop,
+      l[a] ?? 100,
+      f.heights[r] ?? this.rowHeight
+    );
+  }
+  updateCanvasCursor(t, e) {
+    if (!this.root || !this.canvas) return;
+    if (this.root.dataset.extableFillDragging === "1") {
+      this.canvas.style.cursor = "crosshair";
+      return;
+    }
+    {
+      const l = this.canvas.getBoundingClientRect(), h = t - l.left, u = e - l.top, f = h + this.root.scrollLeft, p = u, d = this.hoverHeaderColKey, m = this.hoverHeaderIcon;
+      let g = null, y = !1;
+      if (p >= 0 && p < this.headerHeight && f >= this.rowHeaderWidth) {
+        const S = this.dataModel.getSchema(), b = this.dataModel.getView(), C = W(S, b);
+        let v = this.rowHeaderWidth, R = -1;
+        for (let x = 0; x < C.length; x += 1) {
+          const M = C[x] ?? 100;
+          if (f >= v && f <= v + M) {
+            R = x;
+            break;
+          }
+          v += M;
+        }
+        const I = R >= 0 ? S.columns[R] : null;
+        if (I) {
+          g = I.key;
+          const x = C[R] ?? 100, M = 18, K = v + x - M - 4, H = Math.floor((this.headerHeight - M) / 2);
+          y = f >= K && f <= K + M && p >= H && p <= H + M;
+        }
+      }
+      const w = String(d ?? "") !== String(g ?? "") || !!m != !!y;
+      if (this.hoverHeaderColKey = g, this.hoverHeaderIcon = y, g !== null) {
+        this.canvas.style.cursor = y ? "pointer" : "default", this.tooltip && (this.tooltip.dataset.visible = "0"), this.tooltipTarget = null, this.tooltipMessage = null, w && this.render();
+        return;
+      }
+      w && this.render();
+    }
+    let i = "cell";
+    const n = this.hitTest(new MouseEvent("mousemove", { clientX: t, clientY: e }));
+    if (!n) {
+      this.canvas.style.cursor = i, this.tooltip && (this.tooltip.dataset.visible = "0"), this.tooltipTarget = null, this.tooltipMessage = null;
+      return;
+    }
+    if (n.colKey === "__all__" || n.colKey === null) {
+      this.canvas.style.cursor = "default", this.tooltip && (this.tooltip.dataset.visible = "0"), this.tooltipTarget = null, this.tooltipMessage = null;
+      return;
+    }
+    if (this.getEditMode() === "readonly") {
+      this.canvas.style.cursor = "cell";
+      return;
+    }
+    const s = this.dataModel.getCellMarker(n.rowId, n.colKey);
+    if (this.tooltip && s) {
+      const l = this.tooltipTarget && this.tooltipTarget.rowId === n.rowId && this.tooltipTarget.colKey === n.colKey, h = this.tooltipMessage === s.message;
+      if (!l || !h || this.tooltip.dataset.visible !== "1") {
+        this.tooltipTarget = { rowId: n.rowId, colKey: n.colKey }, this.tooltipMessage = s.message, this.tooltip.textContent = s.message;
+        const u = this.getCellRect(n.rowId, n.colKey);
+        u ? (this.positionTooltipAtRect(u), this.tooltip.dataset.visible = "1") : this.tooltip.dataset.visible = "0";
+      }
+    } else this.tooltip && (this.tooltip.dataset.visible = "0", this.tooltipTarget = null, this.tooltipMessage = null);
+    if (!this.isPointInSelection(n.rowId, n.colKey)) {
+      this.canvas.style.cursor = "cell";
+      return;
+    }
+    if (!(this.activeRowId === n.rowId && this.activeColKey !== null && this.activeColKey === n.colKey)) {
+      this.canvas.style.cursor = "cell";
+      return;
+    }
+    if (this.activeRowId && this.activeColKey !== null && this.activeRowId !== "__all__" && this.activeColKey !== "__all__" && ot(
+      this.dataModel,
+      this.selection,
+      this.activeRowId,
+      this.activeColKey,
+      this.getEditMode()
+    )) {
+      const l = this.getCellRect(this.activeRowId, this.activeColKey);
+      if (l) {
+        const h = Bt(l, Pt);
+        if ($t(t, e, h)) {
+          this.canvas.style.cursor = "crosshair";
+          return;
+        }
+      }
+    }
+    const r = this.dataModel.getSchema().columns.find((l) => l.key === n.colKey);
+    this.dataModel.isReadonly(n.rowId, n.colKey) || r?.type === "boolean" ? i = "default" : i = "text", this.canvas.style.cursor = i;
+  }
+  measureRowHeight(t, e, i, n) {
+    let s = this.rowHeight;
+    const o = this.dataModel.getView();
+    for (let r = 0; r < i.columns.length; r += 1) {
+      const a = i.columns[r];
+      if (!a || !(o.wrapText?.[a.key] ?? a.wrapText)) continue;
+      const h = (n[r] ?? 100) - this.padding, u = this.dataModel.resolveCellValue(e.id, a), f = this.dataModel.resolveConditionalStyle(e.id, a), d = u.textOverride ?? (f.forceErrorText ? "#ERROR" : void 0) ? "#ERROR" : this.formatValue(u.value, a).text, g = this.wrapLines(t, d, h).length * this.lineHeight + this.padding;
+      s = Math.max(s, g);
+    }
+    return s;
+  }
+  wrapLines(t, e, i) {
+    const n = `${t.font}|${i}|${e}`, s = this.textMeasureCache.get(n);
+    if (s)
+      return this.textMeasureCache.delete(n), this.textMeasureCache.set(n, s), s.lines;
+    const o = e.split(`
+`), r = [];
+    for (const a of o) {
+      let l = a;
+      for (; t.measureText(l).width > i && l.length > 1; ) {
+        let h = l.length;
+        for (; h > 1 && t.measureText(l.slice(0, h)).width > i; )
+          h -= 1;
+        r.push(l.slice(0, h)), l = l.slice(h);
+      }
+      r.push(l);
+    }
+    for (this.textMeasureCache.set(n, { lines: r }); this.textMeasureCache.size > O.TEXT_MEASURE_CACHE_MAX; ) {
+      const a = this.textMeasureCache.keys().next().value;
+      if (!a) break;
+      this.textMeasureCache.delete(a);
+    }
+    return r;
+  }
+  drawCellText(t, e, i, n, s, o, r, a = "left", l = !1, h = !1, u) {
+    t.save(), t.beginPath(), t.rect(i - 4, n - 4, s + 8, o + 8), t.clip();
+    const f = t.font;
+    l ? t.font = "28px sans-serif" : h && (t.font = "14px sans-serif");
+    const p = (d, m) => {
+      const g = n + this.lineHeight * m;
+      let y = i, w = i;
+      if (a === "right")
+        t.textAlign = "right", w = i + s, y = w - t.measureText(d).width, t.fillText(d, w, g);
+      else if (a === "center") {
+        t.textAlign = "center";
+        const S = i + s / 2, b = t.measureText(d).width;
+        y = S - b / 2, w = S + b / 2, t.fillText(d, S, g);
+      } else
+        t.textAlign = "left", y = i, w = i + t.measureText(d).width, t.fillText(d, i, g);
+      if (u?.underline || u?.strike) {
+        const S = t.strokeStyle, b = t.lineWidth;
+        if (t.strokeStyle = t.fillStyle, t.lineWidth = 1, t.beginPath(), u.underline) {
+          const C = g + 2;
+          t.moveTo(y, C), t.lineTo(w, C);
+        }
+        if (u.strike) {
+          const C = g - Math.floor(this.lineHeight / 2) + 2;
+          t.moveTo(y, C), t.lineTo(w, C);
+        }
+        t.stroke(), t.strokeStyle = S, t.lineWidth = b;
+      }
+    };
+    if (r) {
+      const d = this.wrapLines(t, e, s);
+      for (let m = 0; m < d.length; m += 1)
+        p(d[m], m + 1);
+    } else {
+      let d = e;
+      for (; t.measureText(d).width > s && d.length > 1; )
+        d = `${d.slice(0, -2)}…`;
+      p(d, 1);
+    }
+    t.textAlign = "left", t.font = f, t.restore();
+  }
+  formatValue(t, e) {
+    if (t == null) return { text: "" };
+    if (e.type === "boolean")
+      return e.booleanDisplay === "checkbox" || !e.booleanDisplay ? { text: t ? "☑" : "☐" } : Array.isArray(e.booleanDisplay) && e.booleanDisplay.length >= 2 ? { text: String(t ? e.booleanDisplay[0] : e.booleanDisplay[1]) } : { text: t ? String(e.booleanDisplay) : "" };
+    if (e.type === "number" && typeof t == "number") {
+      const i = t, n = {};
+      e.number?.scale !== void 0 && (n.minimumFractionDigits = e.number.scale, n.maximumFractionDigits = e.number.scale), n.useGrouping = !!e.number?.thousandSeparator;
+      const s = this.valueFormatCache.getNumberFormatter(n).format(i), o = e.number?.negativeRed && i < 0 ? "#b91c1c" : void 0;
+      return { text: s, color: o };
+    }
+    if ((e.type === "date" || e.type === "time" || e.type === "datetime") && (t instanceof Date || typeof t == "string")) {
+      const i = e.type === "date" ? e.dateFormat ?? "yyyy-MM-dd" : e.type === "time" ? e.timeFormat ?? "HH:mm" : e.dateTimeFormat ?? "yyyy-MM-dd'T'HH:mm:ss'Z'";
+      let n = null;
+      return t instanceof Date ? n = t : n = this.valueFormatCache.parseIsoDate(t), n ? { text: At(n, i) } : { text: String(t) };
+    }
+    return { text: String(t) };
+  }
+};
+O.MAX_CANVAS_DIM_PX = 8192, O.ROW_HEIGHT_MEASURE_CHUNK = 500, O.ROW_HEIGHT_MEASURE_TIME_BUDGET_MS = 8, O.TEXT_MEASURE_CACHE_MAX = 2e3;
+let rt = O;
+class Se {
+  constructor(t, e, i, n, s, o, r, a, l, h, u, f, p) {
+    this.dataModel = r, this.onActiveChange = l, this.onSelectionChange = u, this.onUndo = f, this.onRedo = p, this.handleDocumentContextMenu = null, this.selectionRanges = [], this.inputEl = null, this.floatingInputWrapper = null, this.selectionInput = null, this.copyToastEl = null, this.copyToastTimer = null, this.selectionMode = !0, this.lastBooleanCell = null, this.selectionAnchor = null, this.dragging = !1, this.dragStart = null, this.pointerDownClient = null, this.dragMoved = !1, this.dragSelectionChanged = !1, this.suppressNextClick = !1, this.fillDragging = !1, this.fillSource = null, this.fillEndRowIndex = null, this.rootCursorBackup = null, this.lastPointerClient = null, this.autoScrollRaf = null, this.autoScrollActive = !1, this.activeCell = null, this.activeHost = null, this.activeHostOriginalText = null, this.composing = !1, this.lastCompositionEnd = 0, this.handleSelectionBlur = () => this.teardownSelectionInput(), this.handlePointerDown = (d) => {
+      if (d.button !== 0) return;
+      const m = d.target;
+      if (m?.closest('button[data-extable-fs-open="1"]') || m?.closest(".extable-filter-sort-trigger") || this.inputEl && d.target && this.inputEl.contains(d.target)) return;
+      if (this.inputEl && this.activeCell && this.activeCell.colKey !== null) {
+        const { rowId: R, colKey: I } = this.activeCell, x = this.readActiveValue();
+        this.commitEdit(R, I, x), this.onMove(R), this.teardownInput(!1);
+      }
+      if (this.fillDragging) return;
+      const g = this.hitTest(d);
+      if (!g || g.rowId === "__all__" && g.colKey === "__all__" || g.colKey === "__all__") return;
+      const y = Vt(this.dataModel, this.selectionRanges);
+      if (y && this.activeCell) {
+        const R = this.dataModel.getSchema(), I = this.dataModel.listRows(), x = y.endRowIndex, M = y.colIndex, A = I[x], K = R.columns[M];
+        if (A && K) {
+          const H = this.findHtmlCellElement(A.id, K.key)?.getBoundingClientRect() ?? this.computeCanvasCellRect(A.id, K.key);
+          if (H && ot(
+            this.dataModel,
+            this.selectionRanges,
+            this.activeCell.rowId,
+            this.activeCell.colKey,
+            this.editMode
+          )) {
+            const P = Bt(H, Pt);
+            if ($t(d.clientX, d.clientY, P)) {
+              d.preventDefault(), this.fillDragging = !0, this.fillSource = y, this.fillEndRowIndex = y.endRowIndex, this.root.dataset.extableFillDragging = "1", this.rootCursorBackup === null && (this.rootCursorBackup = this.root.style.cursor || ""), this.root.style.cursor = "crosshair", this.lastPointerClient = { x: d.clientX, y: d.clientY }, this.dragging = !1, this.dragStart = null, this.suppressNextClick = !0;
+              try {
+                d.target?.setPointerCapture?.(d.pointerId);
+              } catch {
+              }
+              this.selectionRanges = [
+                {
+                  kind: "cells",
+                  startRow: y.startRowIndex,
+                  endRow: y.endRowIndex,
+                  startCol: y.colIndex,
+                  endCol: y.colIndex
+                }
+              ], this.onSelectionChange(this.selectionRanges), this.startAutoScroll();
+              return;
+            }
+          }
+        }
+      }
+      const w = this.dataModel.getSchema(), S = this.dataModel.listRows(), b = g.rowId === "__header__" ? 0 : this.dataModel.getRowIndex(g.rowId), C = w.columns.findIndex((R) => String(R.key) === String(g.colKey));
+      if (C < 0) return;
+      if (g.rowId === "__header__") {
+        if (!S.length) return;
+        const R = {
+          kind: "cells",
+          startRow: 0,
+          endRow: S.length - 1,
+          startCol: C,
+          endCol: C
+        };
+        this.selectionRanges = [R], this.onSelectionChange(this.selectionRanges), this.dragging = !1, this.selectionMode = !1, this.dragStart = null, this.selectionAnchor = null, this.suppressNextClick = !0;
+        const I = S[0], x = w.columns[C];
+        I && x && (this.activeCell = { rowId: I.id, colKey: x.key }, this.onActiveChange(I.id, x.key));
+        return;
+      }
+      if (b < 0) return;
+      const v = g.colKey === null ? "rows" : "cells";
+      this.dragging = !0, this.pointerDownClient = { x: d.clientX, y: d.clientY }, this.dragMoved = !1, this.dragSelectionChanged = !1, this.dragStart = { rowIndex: b, colIndex: C, kind: v }, this.suppressNextClick = !1, this.selectionMode = !0, this.selectionAnchor = null, this.lastPointerClient = { x: d.clientX, y: d.clientY };
+      try {
+        d.target?.setPointerCapture?.(d.pointerId);
+      } catch {
+      }
+      this.startAutoScroll();
+    }, this.handlePointerMove = (d) => {
+      if (this.lastPointerClient = { x: d.clientX, y: d.clientY }, this.fillDragging && this.fillSource) {
+        this.updateFillDragFromClientPoint(d.clientX, d.clientY);
+        return;
+      }
+      if (!(!this.dragging || !this.dragStart)) {
+        if (!this.dragMoved && this.pointerDownClient) {
+          const m = d.clientX - this.pointerDownClient.x, g = d.clientY - this.pointerDownClient.y;
+          if (m * m + g * g < 9) return;
+          this.dragMoved = !0;
+        }
+        this.updateDragFromClientPoint(d.clientX, d.clientY);
+      }
+    }, this.handlePointerUp = (d) => {
+      if (this.fillDragging && this.fillSource) {
+        const g = this.fillSource, y = this.fillEndRowIndex ?? g.endRowIndex;
+        this.fillDragging = !1, this.fillSource = null, this.fillEndRowIndex = null, this.root.dataset.extableFillDragging = "", this.rootCursorBackup !== null && (this.root.style.cursor = this.rootCursorBackup, this.rootCursorBackup = null), this.stopAutoScroll();
+        try {
+          d.target?.releasePointerCapture?.(d.pointerId);
+        } catch {
+        }
+        this.commitFill(g, y), this.suppressNextClick = !0;
+        return;
+      }
+      if (!this.dragging) return;
+      this.dragging = !1, this.dragStart = null;
+      const m = this.dragSelectionChanged;
+      this.pointerDownClient = null, this.dragMoved = !1, this.dragSelectionChanged = !1, this.stopAutoScroll();
+      try {
+        d.target?.releasePointerCapture?.(d.pointerId);
+      } catch {
+      }
+      if (m && (this.suppressNextClick = !0), this.suppressNextClick && this.activeCell && this.activeCell.colKey !== null) {
+        const g = this.dataModel.getCell(this.activeCell.rowId, this.activeCell.colKey);
+        this.focusSelectionInput(this.cellToClipboardString(g));
+      }
+    }, this.handleSelectionCopy = (d) => {
+      if (!this.selectionMode) return;
+      const m = this.buildSelectionClipboardPayload();
+      m && (d.preventDefault(), d.clipboardData?.setData("text/plain", m.text), d.clipboardData?.setData("text/tab-separated-values", m.text), d.clipboardData?.setData("text/html", m.html), this.showCopyToast(`Copied ${m.cellCount} cells`, "info"));
+    }, this.handleSelectionCut = (d) => {
+      if (!this.selectionMode) return;
+      const m = this.buildSelectionClipboardPayload();
+      m && (d.preventDefault(), d.clipboardData?.setData("text/plain", m.text), d.clipboardData?.setData("text/tab-separated-values", m.text), d.clipboardData?.setData("text/html", m.html), this.clearSelectionValues());
+    }, this.handleSelectionPaste = (d) => {
+      if (!this.selectionMode) return;
+      d.preventDefault();
+      const m = d.clipboardData?.getData("text/html") ?? "", g = d.clipboardData?.getData("text/tab-separated-values") ?? "", y = d.clipboardData?.getData("text/plain") ?? "", w = this.parseClipboardGrid({ html: m, tsv: g, text: y });
+      w && this.applyClipboardGrid(w);
+    }, this.handleSelectionCompositionStart = () => {
+      this.selectionMode && (this.selectionMode = !1, this.teardownSelectionInput(), this.openEditorAtActiveCell());
+    }, this.handleSelectionKeydown = (d) => {
+      if (!this.selectionMode || !this.activeCell || d.isComposing || this.composing || d.key === "Shift" || d.key === "Control" || d.key === "Alt" || d.key === "Meta" || d.key === "CapsLock" || d.key === "NumLock" || d.key === "ScrollLock")
+        return;
+      const m = typeof navigator < "u" && /mac/i.test(navigator.platform);
+      if (m ? d.metaKey : d.ctrlKey) {
+        const b = d.key.toLowerCase();
+        if (b === "z") {
+          d.preventDefault(), m && d.shiftKey ? this.onRedo() : this.onUndo(), this.selectionAnchor = null;
+          return;
+        }
+        if (b === "y") {
+          d.preventDefault(), this.onRedo(), this.selectionAnchor = null;
+          return;
+        }
+        if (b === "c") {
+          d.preventDefault(), document.execCommand("copy"), this.selectionAnchor = null;
+          return;
+        }
+        if (b === "x") {
+          d.preventDefault(), document.execCommand("cut"), this.selectionAnchor = null;
+          return;
+        }
+        if (b === "v") {
+          this.selectionAnchor = null;
+          return;
+        }
+      }
+      if (d.key === " " && this.activeCell.colKey !== null) {
+        this.findColumn(this.activeCell.colKey)?.type === "boolean" && (d.preventDefault(), this.toggleBoolean(this.activeCell.rowId, this.activeCell.colKey)), this.selectionAnchor = null;
+        return;
+      }
+      const y = d.key === "Tab", w = d.key === "Enter", S = d.key === "ArrowLeft" || d.key === "ArrowRight" || d.key === "ArrowUp" || d.key === "ArrowDown";
+      if (y || w || S) {
+        if (d.preventDefault(), this.teardownSelectionInput(), y) {
+          this.moveActiveCell(0, d.shiftKey ? -1 : 1, !1);
+          return;
+        }
+        if (w) {
+          this.moveActiveCell(d.shiftKey ? -1 : 1, 0, !1);
+          return;
+        }
+        const b = d.shiftKey;
+        d.key === "ArrowLeft" ? this.moveActiveCell(0, -1, b) : d.key === "ArrowRight" ? this.moveActiveCell(0, 1, b) : d.key === "ArrowUp" ? this.moveActiveCell(-1, 0, b) : d.key === "ArrowDown" && this.moveActiveCell(1, 0, b);
+        return;
+      }
+      this.selectionMode = !1, this.selectionAnchor = null, this.teardownSelectionInput(), this.openEditorAtActiveCell();
+    }, this.handleClick = (d) => {
+      if (d.button !== 0 || d.target?.closest('button[data-extable-fs-open="1"]'))
+        return;
+      if (this.suppressNextClick) {
+        this.suppressNextClick = !1;
+        return;
+      }
+      if (this.inputEl && d.target && this.inputEl.contains(d.target))
+        return;
+      if (this.inputEl && this.activeCell && this.activeCell.colKey !== null) {
+        const { rowId: v, colKey: R } = this.activeCell, I = this.readActiveValue();
+        this.commitEdit(v, R, I), this.onMove(v), this.teardownInput(!1);
+      }
+      const g = typeof document.elementFromPoint == "function" ? this.getHitAtClientPoint(d.clientX, d.clientY) : this.hitTest(d);
+      if (!g) return;
+      const y = this.selectionMode && !d.shiftKey && !d.metaKey && !d.ctrlKey && this.activeCell?.rowId === g.rowId && String(this.activeCell?.colKey) === String(g.colKey);
+      if (g.rowId === "__all__" && g.colKey === "__all__") {
+        this.teardownInput(!1), this.activeCell = null, this.onActiveChange("__all__", "__all__"), this.selectionAnchor = null;
+        return;
+      }
+      if (this.onRowSelect(g.rowId), this.applySelectionFromHit(d, g), g.colKey === null || g.colKey === "__all__")
+        return;
+      if (this.isCellReadonly(g.rowId, g.colKey)) {
+        this.selectionMode = !0, this.selectionAnchor = null, this.teardownInput(!1), this.teardownSelectionInput();
+        return;
+      }
+      if (this.findColumn(g.colKey)?.type === "boolean") {
+        const v = this.lastBooleanCell?.rowId === g.rowId && String(this.lastBooleanCell?.colKey) === String(g.colKey);
+        if (this.lastBooleanCell = { rowId: g.rowId, colKey: g.colKey }, this.selectionMode = !0, this.selectionAnchor = null, this.teardownInput(!1), this.teardownSelectionInput(), v) {
+          this.toggleBoolean(g.rowId, g.colKey), this.focusSelectionInput("");
+          return;
+        }
+        this.focusSelectionInput("");
+        return;
+      }
+      this.lastBooleanCell = null, this.selectionAnchor = null, this.teardownInput(!1);
+      const b = this.dataModel.getCell(g.rowId, g.colKey), C = this.cellToClipboardString(b);
+      this.focusSelectionInput(C), y && (this.selectionMode = !1, this.teardownSelectionInput(), this.openEditorAtActiveCell());
+    }, this.handleContextMenu = (d) => {
+      const m = d.target;
+      if (d.ctrlKey) {
+        d.preventDefault();
+        return;
+      }
+      if (!m || !this.root.contains(m)) return;
+      d.preventDefault(), d.stopPropagation();
+      const g = this.hitTest(d), y = g?.rowId ?? null, w = g?.colKey ?? null;
+      this.onContextMenu(y, w, d.clientX, d.clientY);
+    }, this.root = t, this.editMode = e, this.onEdit = i, this.onRowSelect = n, this.onMove = s, this.hitTest = o, this.isCellReadonly = a, this.onContextMenu = h, this.bind();
+  }
+  setEditMode(t) {
+    this.editMode = t;
+  }
+  syncAfterRowsChanged() {
+    const t = this.dataModel.getSchema(), e = this.dataModel.listRows();
+    if (!e.length || !t.columns.length) {
+      this.selectionRanges = [], this.activeCell = null, this.selectionAnchor = null, this.lastBooleanCell = null, this.teardownInput(!0), this.onActiveChange(null, null), this.onSelectionChange(this.selectionRanges), this.updateFillHandleFlag();
+      return;
+    }
+    const i = e.length - 1, n = t.columns.length - 1, s = this.activeCell?.rowId ?? null, o = this.activeCell?.colKey ?? null, r = s ? this.dataModel.getRowIndex(s) : -1, a = o !== null ? t.columns.findIndex((w) => String(w.key) === String(o)) : -1;
+    if (r >= 0 && a >= 0) {
+      let w = !1;
+      if (!this.selectionRanges.length)
+        this.selectionRanges = [
+          {
+            kind: "cells",
+            startRow: r,
+            endRow: r,
+            startCol: a,
+            endCol: a
+          }
+        ], w = !0;
+      else {
+        const S = this.selectionRanges.map((b) => {
+          const C = (R, I) => Math.max(0, Math.min(I, R)), v = {
+            ...b,
+            startRow: C(b.startRow, i),
+            endRow: C(b.endRow, i),
+            startCol: C(b.startCol, n),
+            endCol: C(b.endCol, n)
+          };
+          return (v.startRow !== b.startRow || v.endRow !== b.endRow || v.startCol !== b.startCol || v.endCol !== b.endCol) && (w = !0), v;
+        });
+        this.selectionRanges = S;
+      }
+      w && this.onSelectionChange(this.selectionRanges), this.updateFillHandleFlag();
+      return;
+    }
+    const l = o ?? t.columns[0]?.key ?? "";
+    let h = t.columns.findIndex((w) => String(w.key) === String(l));
+    h < 0 && (h = 0);
+    const u = t.columns[h]?.key ?? "", f = s ? this.dataModel.getBaseRowIndex(s) : 0, p = e[e.length - 1] ?? e[0] ?? null, d = e.find((w) => this.dataModel.getBaseRowIndex(w.id) >= f) ?? p;
+    if (!d) return;
+    const m = d.id, g = this.dataModel.getRowIndex(m);
+    this.selectionAnchor = null, this.lastBooleanCell = null, this.teardownInput(!1), this.selectionRanges = [
+      {
+        kind: "cells",
+        startRow: g,
+        endRow: g,
+        startCol: h,
+        endCol: h
+      }
+    ], this.activeCell = { rowId: m, colKey: u }, this.onActiveChange(m, u), this.onSelectionChange(this.selectionRanges), this.ensureVisibleCell(m, u);
+    const y = this.dataModel.getCell(m, u);
+    this.focusSelectionInput(this.cellToClipboardString(y)), this.updateFillHandleFlag();
+  }
+  navigateToCell(t, e) {
+    const i = this.dataModel.getSchema(), n = this.dataModel.getRowIndex(t), s = i.columns.findIndex((a) => String(a.key) === String(e));
+    if (n < 0 || s < 0) return;
+    this.selectionAnchor = null, this.lastBooleanCell = null, this.teardownInput(!1);
+    const o = {
+      kind: "cells",
+      startRow: n,
+      endRow: n,
+      startCol: s,
+      endCol: s
+    };
+    this.selectionRanges = [o], this.activeCell = { rowId: t, colKey: e }, this.onActiveChange(t, e), this.onSelectionChange(this.selectionRanges), this.ensureVisibleCell(t, e);
+    const r = this.dataModel.getCell(t, e);
+    this.focusSelectionInput(this.cellToClipboardString(r)), this.updateFillHandleFlag();
+  }
+  cancelEditing() {
+    this.teardownInput(!0);
+  }
+  destroy() {
+    this.root.removeEventListener("click", this.handleClick), this.root.removeEventListener("pointerdown", this.handlePointerDown), this.root.removeEventListener("pointermove", this.handlePointerMove), this.root.removeEventListener("pointerup", this.handlePointerUp), this.root.removeEventListener("pointercancel", this.handlePointerUp), this.handleDocumentContextMenu && document.removeEventListener("contextmenu", this.handleDocumentContextMenu, !0), this.teardownInput(!0), this.teardownSelectionInput(), this.teardownCopyToast(), this.stopAutoScroll();
+  }
+  onScroll(t, e) {
+    this.positionCopyToast();
+  }
+  bind() {
+    this.root.addEventListener("click", this.handleClick), this.root.addEventListener("pointerdown", this.handlePointerDown), this.root.addEventListener("pointermove", this.handlePointerMove), this.root.addEventListener("pointerup", this.handlePointerUp), this.root.addEventListener("pointercancel", this.handlePointerUp), this.handleDocumentContextMenu = (t) => this.handleContextMenu(t), document.addEventListener("contextmenu", this.handleDocumentContextMenu, { capture: !0 });
+  }
+  updateFillHandleFlag() {
+    const t = this.activeCell?.colKey ?? null, e = this.activeCell?.rowId ?? null;
+    this.root.dataset.extableFillHandle = ot(
+      this.dataModel,
+      this.selectionRanges,
+      e,
+      t,
+      this.editMode
+    ) ? "1" : "";
+  }
+  findColumn(t) {
+    return this.dataModel.getSchema().columns.find((i) => i.key === t);
+  }
+  pad2(t) {
+    return String(t).padStart(2, "0");
+  }
+  formatLocalDateForInput(t) {
+    return `${t.getFullYear()}-${this.pad2(t.getMonth() + 1)}-${this.pad2(t.getDate())}`;
+  }
+  formatLocalTimeForInput(t) {
+    return `${this.pad2(t.getHours())}:${this.pad2(t.getMinutes())}`;
+  }
+  formatLocalDateTimeForInput(t) {
+    return `${this.formatLocalDateForInput(t)}T${this.formatLocalTimeForInput(t)}`;
+  }
+  normalizeTemporalInitialValue(t, e) {
+    const i = e.trim();
+    if (!i) return "";
+    if (t === "date") {
+      const s = i.match(/^(\d{4}-\d{2}-\d{2})/);
+      if (s) return s[1] ?? "";
+      const o = new Date(i);
+      return Number.isNaN(o.getTime()) ? "" : this.formatLocalDateForInput(o);
+    }
+    if (t === "time") {
+      const s = i.match(/(\d{2}:\d{2})(?::\d{2})?/);
+      if (s) return s[1] ?? "";
+      const o = new Date(i);
+      return Number.isNaN(o.getTime()) ? "" : this.formatLocalTimeForInput(o);
+    }
+    if (/Z$/.test(i) && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(i))
+      return i.replace(/Z$/, "").slice(0, 16);
+    if (/^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}/.test(i) && !/[+-]\d{2}:\d{2}$/.test(i))
+      return i.slice(0, 16);
+    const n = new Date(i);
+    return Number.isNaN(n.getTime()) ? "" : this.formatLocalDateTimeForInput(n);
+  }
+  ensureCopyToast() {
+    if (this.copyToastEl) return this.copyToastEl;
+    window.getComputedStyle(this.root).position === "static" && (this.root.style.position = "relative");
+    const e = document.createElement("div");
+    return e.className = "extable-toast", e.dataset.extableCopyToast = "1", e.setAttribute("popover", "manual"), e.style.position = "absolute", e.style.left = "0", e.style.top = "0", e.style.pointerEvents = "none", e.style.zIndex = "1000", e.style.margin = "0", this.root.appendChild(e), this.copyToastEl = e, e;
+  }
+  teardownCopyToast() {
+    this.copyToastTimer && (window.clearTimeout(this.copyToastTimer), this.copyToastTimer = null), this.copyToastEl && (this.copyToastEl.hidePopover?.(), _(this.copyToastEl), this.copyToastEl = null);
+  }
+  positionCopyToast() {
+    if (!this.copyToastEl) return;
+    const t = this.copyToastEl.offsetWidth || 0, e = this.copyToastEl.offsetHeight || 0, i = 16, n = Math.max(0, this.root.scrollLeft + this.root.clientWidth - t - i), s = Math.max(0, this.root.scrollTop + this.root.clientHeight - e - i);
+    this.copyToastEl.style.left = `${n}px`, this.copyToastEl.style.top = `${s}px`;
+  }
+  showCopyToast(t, e = "info", i = 1200) {
+    const n = this.ensureCopyToast();
+    n.textContent = t, n.dataset.variant = e, n.hidePopover?.(), n.showPopover?.(), this.positionCopyToast(), this.copyToastTimer && (window.clearTimeout(this.copyToastTimer), this.copyToastTimer = null), this.copyToastTimer = window.setTimeout(() => {
+      n.hidePopover?.();
+    }, i);
+  }
+  ensureSelectionInput() {
+    if (this.selectionInput) return this.selectionInput;
+    const t = document.createElement("input");
+    return t.type = "text", t.autocomplete = "off", t.spellcheck = !1, t.style.position = "absolute", t.style.left = "0", t.style.top = "0", t.style.transform = "translate(-10000px, 0)", t.style.width = "1px", t.style.height = "1px", t.style.opacity = "0", t.style.pointerEvents = "none", t.addEventListener("keydown", this.handleSelectionKeydown), t.addEventListener("compositionstart", this.handleSelectionCompositionStart), t.addEventListener("copy", this.handleSelectionCopy), t.addEventListener("cut", this.handleSelectionCut), t.addEventListener("paste", this.handleSelectionPaste), t.addEventListener("blur", this.handleSelectionBlur), this.root.appendChild(t), this.selectionInput = t, t;
+  }
+  focusSelectionInput(t) {
+    const e = this.ensureSelectionInput();
+    e.value = t, this.selectionMode = !0, e.focus({ preventScroll: !0 }), e.select();
+  }
+  openEditorAtActiveCell(t) {
+    if (!this.activeCell) return;
+    const { rowId: e, colKey: i } = this.activeCell;
+    if (i === null) return;
+    const n = this.findHtmlCellElement(e, i);
+    if (n) {
+      this.activateCellElement(n, e, i, t);
+      return;
+    }
+    const s = this.computeCanvasCellRect(e, i);
+    s && this.activateFloating(s, e, i, t);
+  }
+  escapeCssAttrValue(t) {
+    const i = globalThis.CSS?.escape;
+    return typeof i == "function" ? i(t) : t.replace(/["\\]/g, "\\$&");
+  }
+  findHtmlCellElement(t, e) {
+    if (e === null) return null;
+    const i = String(e), n = this.escapeCssAttrValue(t), s = this.escapeCssAttrValue(i);
+    return this.root.querySelector(
+      `tr[data-row-id="${n}"] td[data-col-key="${s}"]`
+    ) ?? null;
+  }
+  computeCanvasCellRect(t, e) {
+    if (e === null) return null;
+    const i = this.computeCanvasCellBoxContent(t, e);
+    if (!i) return null;
+    const n = this.root.getBoundingClientRect();
+    return new DOMRect(
+      n.left + i.left - this.root.scrollLeft,
+      n.top + i.top - this.root.scrollTop,
+      i.width,
+      i.height
+    );
+  }
+  computeCanvasCellBoxContent(t, e) {
+    return this.root.querySelector(
+      'canvas[data-extable-renderer="canvas"]'
+    ) ? this.getCanvasCellMetrics(t, e) : null;
+  }
+  getCanvasCellMetrics(t, e) {
+    const i = this.dataModel.getSchema(), n = this.dataModel.getView(), s = this.dataModel.listRows(), o = s.findIndex((g) => g.id === t), r = i.columns.findIndex((g) => String(g.key) === String(e));
+    if (o < 0 || r < 0) return null;
+    const a = Ft, l = ht, h = ut, u = W(i, n);
+    let f = l;
+    for (let g = 0; g < r; g += 1) f += u[g] ?? 100;
+    let p = a;
+    for (let g = 0; g < o; g += 1) {
+      const y = s[g];
+      if (!y) return null;
+      const w = this.dataModel.getRowHeight(y.id) ?? h;
+      p += w;
+    }
+    const d = this.dataModel.getRowHeight(t) ?? h, m = u[r] ?? 100;
+    return { left: f, top: p, width: m, height: d, rowIndex: o, colIndex: r };
+  }
+  ensureVisibleCell(t, e) {
+    const i = this.findHtmlCellElement(t, e);
+    if (i) {
+      typeof i.scrollIntoView == "function" && i.scrollIntoView({ block: "nearest", inline: "nearest" });
+      return;
+    }
+    const n = this.getCanvasCellMetrics(t, e);
+    if (!n) return;
+    const s = n.left, o = n.left + n.width, r = n.top, a = n.top + n.height, l = this.root.scrollLeft, h = this.root.scrollLeft + this.root.clientWidth, u = this.root.scrollTop, f = this.root.scrollTop + this.root.clientHeight;
+    s < l ? this.root.scrollLeft = Math.max(0, s) : o > h && (this.root.scrollLeft = Math.max(0, o - this.root.clientWidth)), r < u ? this.root.scrollTop = Math.max(0, r) : a > f && (this.root.scrollTop = Math.max(0, a - this.root.clientHeight));
+  }
+  moveActiveCell(t, e, i = !1) {
+    const n = this.dataModel.getSchema(), s = this.dataModel.listRows();
+    if (!s.length || !n.columns.length) return;
+    const { rowIndex: o, colIndex: r } = this.getActiveIndices();
+    i || (this.selectionAnchor = null);
+    const a = i && this.selectionAnchor ? this.selectionAnchor : i ? { rowIndex: o, colIndex: r } : null;
+    i && !this.selectionAnchor && (this.selectionAnchor = { rowIndex: o, colIndex: r });
+    const l = Math.max(0, Math.min(s.length - 1, o + t)), h = Math.max(0, Math.min(n.columns.length - 1, r + e));
+    {
+      const u = s[l];
+      if (!u) return;
+      const f = n.columns[h];
+      if (!f) return;
+      const p = u.id, d = f.key, m = a ? {
+        kind: "cells",
+        startRow: a.rowIndex,
+        endRow: l,
+        startCol: a.colIndex,
+        endCol: h
+      } : {
+        kind: "cells",
+        startRow: l,
+        endRow: l,
+        startCol: h,
+        endCol: h
+      };
+      this.selectionRanges = [m], this.activeCell = { rowId: p, colKey: d }, this.onActiveChange(p, d), this.onSelectionChange(this.selectionRanges), this.ensureVisibleCell(p, d);
+      const g = this.dataModel.getCell(p, d), y = this.cellToClipboardString(g);
+      this.focusSelectionInput(y), this.updateFillHandleFlag();
+      return;
+    }
+  }
+  getHitAtClientPoint(t, e) {
+    if (typeof document.elementFromPoint != "function") return null;
+    const i = document.elementFromPoint(t, e);
+    if (i && this.root.contains(i)) {
+      const n = i.closest("th.extable-corner");
+      if (n)
+        return {
+          rowId: "__all__",
+          colKey: "__all__",
+          element: n,
+          rect: n.getBoundingClientRect()
+        };
+      const s = i.closest("th.extable-row-header:not(.extable-corner)");
+      if (s) {
+        const l = s.closest("tr[data-row-id]");
+        if (l)
+          return {
+            rowId: l.dataset.rowId ?? "",
+            colKey: null,
+            element: s,
+            rect: s.getBoundingClientRect()
+          };
+      }
+      const o = i.closest("th[data-col-key]");
+      if (o)
+        return {
+          rowId: "__header__",
+          colKey: o.dataset.colKey ?? "",
+          element: o,
+          rect: o.getBoundingClientRect()
+        };
+      const r = i.closest("td[data-col-key]"), a = r?.closest("tr[data-row-id]");
+      if (r && a)
+        return {
+          rowId: a.dataset.rowId ?? "",
+          colKey: r.dataset.colKey ?? "",
+          element: r,
+          rect: r.getBoundingClientRect()
+        };
+    }
+    return this.hitTest({ clientX: t, clientY: e });
+  }
+  updateDragFromClientPoint(t, e) {
+    if (!this.dragging || !this.dragStart) return;
+    const i = this.getHitAtClientPoint(t, e);
+    if (!i || i.colKey === "__all__" || this.dragStart.kind === "cells" && i.colKey === null)
+      return;
+    const n = this.dataModel.getSchema(), s = this.dataModel.listRows(), o = this.dataModel.getRowIndex(i.rowId);
+    if (o < 0) return;
+    const r = this.dragStart.kind === "rows" ? n.columns.length - 1 : n.columns.findIndex((d) => String(d.key) === String(i.colKey));
+    if (r < 0) return;
+    const a = this.dragStart.rowIndex, l = this.dragStart.kind === "rows" ? 0 : this.dragStart.colIndex, h = this.dragStart.kind === "rows" ? n.columns.length - 1 : r;
+    (o !== a || h !== l) && (this.dragSelectionChanged = !0);
+    const u = {
+      kind: this.dragStart.kind,
+      startRow: a,
+      endRow: o,
+      startCol: l,
+      endCol: h
+    };
+    this.selectionRanges = [u];
+    const f = s[o]?.id ?? i.rowId, p = this.dragStart.kind === "rows" ? n.columns[0]?.key ?? i.colKey : n.columns[r]?.key ?? i.colKey;
+    this.activeCell = { rowId: f, colKey: p }, this.onActiveChange(f, p), this.onSelectionChange(this.selectionRanges), this.updateFillHandleFlag();
+  }
+  updateFillDragFromClientPoint(t, e) {
+    if (!this.fillDragging || !this.fillSource) return;
+    const i = this.getHitAtClientPoint(t, e);
+    if (!i || i.colKey === "__all__" || i.colKey === null) return;
+    const n = this.dataModel.getSchema(), s = this.dataModel.listRows(), o = this.dataModel.getRowIndex(i.rowId);
+    if (o < 0 || n.columns.findIndex((l) => String(l.key) === String(i.colKey)) !== this.fillSource.colIndex) return;
+    const a = Math.max(this.fillSource.endRowIndex, o);
+    if (this.fillEndRowIndex !== a) {
+      this.fillEndRowIndex = a;
+      const l = s[a]?.id ?? i.rowId, h = n.columns[this.fillSource.colIndex];
+      if (!h) return;
+      const u = h.key;
+      this.activeCell = { rowId: l, colKey: u }, this.onActiveChange(l, u), this.selectionRanges = [
+        {
+          kind: "cells",
+          startRow: this.fillSource.startRowIndex,
+          endRow: a,
+          startCol: this.fillSource.colIndex,
+          endCol: this.fillSource.colIndex
+        }
+      ], this.onSelectionChange(this.selectionRanges);
+    }
+    this.suppressNextClick = !0;
+  }
+  computeAutoScrollDelta(t, e) {
+    const i = this.root.getBoundingClientRect(), n = 24, s = 18;
+    let o = 0, r = 0;
+    return t < i.left + n ? o = -Math.ceil((i.left + n - t) / n * s) : t > i.right - n && (o = Math.ceil((t - (i.right - n)) / n * s)), e < i.top + n ? r = -Math.ceil((i.top + n - e) / n * s) : e > i.bottom - n && (r = Math.ceil((e - (i.bottom - n)) / n * s)), { dx: o, dy: r };
+  }
+  startAutoScroll() {
+    if (this.autoScrollActive) return;
+    this.autoScrollActive = !0;
+    const t = () => {
+      if (!this.autoScrollActive) return;
+      const i = this.lastPointerClient;
+      if (!i || !this.dragging && !this.fillDragging) {
+        this.stopAutoScroll();
+        return;
+      }
+      const { dx: n, dy: s } = this.computeAutoScrollDelta(i.x, i.y);
+      if (n !== 0 || s !== 0) {
+        const r = this.root.scrollTop, a = this.root.scrollLeft;
+        this.root.scrollTop = Math.max(0, r + s), this.root.scrollLeft = Math.max(0, a + n), this.fillDragging ? this.updateFillDragFromClientPoint(i.x, i.y) : this.updateDragFromClientPoint(i.x, i.y);
+      }
+      const o = window.requestAnimationFrame ?? ((r) => window.setTimeout(() => r(performance.now()), 16));
+      this.autoScrollRaf = o(t);
+    }, e = window.requestAnimationFrame ?? ((i) => window.setTimeout(() => i(performance.now()), 16));
+    this.autoScrollRaf = e(t);
+  }
+  stopAutoScroll() {
+    this.autoScrollActive = !1, this.autoScrollRaf !== null && ((window.cancelAnimationFrame ?? ((e) => window.clearTimeout(e)))(this.autoScrollRaf), this.autoScrollRaf = null);
+  }
+  commitFill(t, e) {
+    const i = this.dataModel.getSchema(), n = this.dataModel.listRows(), s = i.columns[t.colIndex];
+    if (!s || e <= t.endRowIndex) return;
+    const o = ge(this.dataModel, t);
+    if (!o) return;
+    const r = this.editMode === "direct", a = `fill:${Date.now()}:${Math.random().toString(16).slice(2)}`;
+    for (let u = t.endRowIndex + 1; u <= e; u += 1) {
+      const f = n[u];
+      if (!f) break;
+      if (this.isCellReadonly(f.id, s.key)) continue;
+      const p = u - t.endRowIndex, d = o(p), m = {
+        kind: "edit",
+        rowId: f.id,
+        colKey: s.key,
+        next: d,
+        payload: { batchId: a }
+      };
+      this.onEdit(m, r);
+    }
+    const l = n[e];
+    if (!l) return;
+    this.selectionRanges = [
+      {
+        kind: "cells",
+        startRow: t.startRowIndex,
+        endRow: e,
+        startCol: t.colIndex,
+        endCol: t.colIndex
+      }
+    ], this.activeCell = { rowId: l.id, colKey: s.key }, this.onActiveChange(l.id, s.key), this.onSelectionChange(this.selectionRanges), this.updateFillHandleFlag(), this.ensureVisibleCell(l.id, s.key);
+    const h = this.dataModel.getCell(l.id, s.key);
+    this.focusSelectionInput(this.cellToClipboardString(h));
+  }
+  teardownSelectionInput() {
+    const t = this.selectionInput;
+    t && (this.selectionInput = null, t.removeEventListener("keydown", this.handleSelectionKeydown), t.removeEventListener("compositionstart", this.handleSelectionCompositionStart), t.removeEventListener("copy", this.handleSelectionCopy), t.removeEventListener("cut", this.handleSelectionCut), t.removeEventListener("paste", this.handleSelectionPaste), t.removeEventListener("blur", this.handleSelectionBlur), _(t));
+  }
+  async copySelection() {
+    const t = this.buildSelectionClipboardPayload();
+    if (!t) return;
+    const { text: e, html: i, cellCount: n } = t, s = async () => {
+      if (typeof navigator > "u" || !navigator.clipboard) return !1;
+      if (typeof ClipboardItem < "u" && navigator.clipboard.write)
+        try {
+          const a = new ClipboardItem({
+            "text/plain": new Blob([e], { type: "text/plain" }),
+            "text/html": new Blob([i], { type: "text/html" })
+          });
+          return await navigator.clipboard.write([a]), !0;
+        } catch {
+        }
+      if (navigator.clipboard.writeText)
+        try {
+          return await navigator.clipboard.writeText(e), !0;
+        } catch {
+        }
+      return !1;
+    }, o = () => {
+      const a = this.ensureSelectionInput(), l = a.value;
+      a.value = e, a.select(), document.execCommand?.("copy"), a.value = l;
+    };
+    await s() || o(), this.showCopyToast(`Copied ${n} cells`, "info");
+  }
+  async pasteFromClipboard() {
+    if (this.editMode !== "readonly" && this.selectionMode && !(typeof navigator > "u" || !navigator.clipboard?.readText))
+      try {
+        const t = await navigator.clipboard.readText();
+        if (!t) return;
+        const e = this.parseClipboardGrid({ html: "", tsv: t, text: t });
+        if (!e) return;
+        this.applyClipboardGrid(e);
+      } catch {
+      }
+  }
+  getActiveIndices() {
+    const t = this.dataModel.getSchema(), e = this.dataModel.listRows(), i = { rowIndex: 0, colIndex: 0 }, n = this.activeCell;
+    if (!n) return i;
+    const s = e.findIndex((r) => r.id === n.rowId), o = t.columns.findIndex((r) => String(r.key) === String(n.colKey));
+    return { rowIndex: s >= 0 ? s : 0, colIndex: o >= 0 ? o : 0 };
+  }
+  normalizeRange(t) {
+    return {
+      ...t,
+      startRow: Math.min(t.startRow, t.endRow),
+      endRow: Math.max(t.startRow, t.endRow),
+      startCol: Math.min(t.startCol, t.endCol),
+      endCol: Math.max(t.startCol, t.endCol)
+    };
+  }
+  getCopyRange() {
+    const t = this.dataModel.getSchema();
+    if (this.selectionRanges.length > 0) {
+      const s = this.selectionRanges[0];
+      return s ? this.normalizeRange(s) : null;
+    }
+    if (!this.activeCell) return null;
+    const e = this.activeCell;
+    if (!e) return null;
+    const i = this.dataModel.getRowIndex(e.rowId), n = t.columns.findIndex((s) => String(s.key) === String(e.colKey));
+    return i < 0 || n < 0 ? null : { kind: "cells", startRow: i, endRow: i, startCol: n, endCol: n };
+  }
+  cellToClipboardString(t) {
+    if (t == null) return "";
+    if (t instanceof Date) return t.toISOString();
+    if (typeof t == "boolean") return t ? "TRUE" : "FALSE";
+    if (typeof t == "number") return String(t);
+    if (typeof t == "object") {
+      const e = t, i = e.kind;
+      if (i === "enum" && typeof e.value == "string") return e.value;
+      if (i === "tags" && Array.isArray(e.values))
+        return e.values.filter((n) => typeof n == "string").join(", ");
+    }
+    return String(t);
+  }
+  escapeHtml(t) {
+    return t.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+  }
+  buildSelectionClipboardPayload() {
+    const t = this.dataModel.getSchema(), e = this.dataModel.listRows(), i = this.getCopyRange();
+    if (!i || i.kind !== "cells") return null;
+    const n = [], s = [], o = "border-collapse:collapse;border-spacing:0;", r = "border:1px solid #d0d7de;padding:4px 6px;vertical-align:top;";
+    let a = 0;
+    for (let u = i.startRow; u <= i.endRow; u += 1) {
+      const f = e[u];
+      if (!f) continue;
+      const p = [], d = [];
+      for (let m = i.startCol; m <= i.endCol; m += 1) {
+        const g = t.columns[m];
+        if (!g) continue;
+        const y = this.dataModel.getCell(f.id, g.key), w = this.cellToClipboardString(y);
+        p.push(w), d.push(`<td style="${r}">${this.escapeHtml(w)}</td>`), a += 1;
+      }
+      n.push(p.join("	")), s.push(`<tr>${d.join("")}</tr>`);
+    }
+    const l = n.join(`\r
+`), h = `<table style="${o}"><tbody>${s.join("")}</tbody></table>`;
+    return { text: l, html: h, cellCount: a };
+  }
+  clearSelectionValues() {
+    const t = this.dataModel.getSchema(), e = this.dataModel.listRows(), i = this.getCopyRange();
+    if (!i || i.kind !== "cells") return;
+    const n = this.editMode === "direct", s = `cut:${Date.now()}:${Math.random().toString(16).slice(2)}`;
+    for (let o = i.startRow; o <= i.endRow; o += 1) {
+      const r = e[o];
+      if (r)
+        for (let a = i.startCol; a <= i.endCol; a += 1) {
+          const l = t.columns[a];
+          if (!l || this.isCellReadonly(r.id, l.key)) continue;
+          const h = l.type === "boolean" ? !1 : "", u = {
+            kind: "edit",
+            rowId: r.id,
+            colKey: l.key,
+            next: h,
+            payload: { batchId: s }
+          };
+          this.onEdit(u, n);
+        }
+    }
+  }
+  parseClipboardGrid(t) {
+    const e = this.parseHtmlTable(t.html);
+    if (e) return e;
+    const i = t.tsv || t.text;
+    return this.parseTsv(i);
+  }
+  parseTsv(t) {
+    const e = t.replace(/\r\n$/, "").replace(/\n$/, "");
+    return e ? e.split(/\r\n|\n/).map((n) => n.split("	")) : null;
+  }
+  parseHtmlTable(t) {
+    if (!t) return null;
+    try {
+      const n = new DOMParser().parseFromString(t, "text/html").querySelector("table");
+      if (!n) return null;
+      const s = Array.from(n.querySelectorAll("tr"));
+      if (s.length === 0) return null;
+      const o = [];
+      for (const r of s) {
+        const a = Array.from(r.querySelectorAll("th,td"));
+        if (a.some(
+          (l) => l.rowSpan > 1 || l.colSpan > 1
+        ))
+          return null;
+        o.push(a.map((l) => (l.textContent ?? "").trim()));
+      }
+      return o.length ? o : null;
+    } catch {
+      return null;
+    }
+  }
+  coerceCellValue(t, e) {
+    const i = this.findColumn(e);
+    if (!i) return t;
+    if (t === "") return "";
+    if (i.type === "number") {
+      const n = Number(t);
+      return Number.isFinite(n) ? n : t;
+    }
+    if (i.type === "boolean") {
+      const n = t.trim().toLowerCase();
+      return n === "true" || n === "1" || n === "yes" ? !0 : n === "false" || n === "0" || n === "no" ? !1 : t;
+    }
+    return t;
+  }
+  applyClipboardGrid(t) {
+    const e = this.dataModel.getSchema(), i = this.dataModel.listRows(), { rowIndex: n, colIndex: s } = this.getActiveIndices(), o = this.editMode === "direct", r = `paste:${Date.now()}:${Math.random().toString(16).slice(2)}`;
+    for (let a = 0; a < t.length; a += 1) {
+      const l = i[n + a];
+      if (!l) break;
+      const h = t[a] ?? [];
+      for (let u = 0; u < h.length; u += 1) {
+        const f = e.columns[s + u];
+        if (!f) break;
+        if (this.isCellReadonly(l.id, f.key)) continue;
+        const p = this.coerceCellValue(h[u] ?? "", f.key), d = {
+          kind: "edit",
+          rowId: l.id,
+          colKey: f.key,
+          next: p,
+          payload: { batchId: r }
+        };
+        this.onEdit(d, o);
+      }
+    }
+  }
+  createEditor(t, e) {
+    const i = this.findColumn(t);
+    if (i?.wrapText || e.includes(`
+`)) {
+      const o = document.createElement("textarea");
+      return o.value = e, o.style.resize = "none", o.style.whiteSpace = "pre-wrap", o.style.overflowWrap = "anywhere", o.style.overflow = "hidden", this.autosize(o), o.addEventListener("input", () => this.autosize(o)), { control: o, value: e };
+    }
+    if (i?.type === "boolean") {
+      const o = document.createElement("input");
+      return o.type = "checkbox", o.checked = e === "true" || e === "1" || e === "on", { control: o, value: e };
+    }
+    if (i?.type === "number") {
+      const o = document.createElement("input");
+      return o.type = "number", o.value = e, { control: o, value: e };
+    }
+    if (i?.type === "date" || i?.type === "time" || i?.type === "datetime") {
+      const o = document.createElement("input");
+      o.type = i.type === "date" ? "date" : i.type === "time" ? "time" : "datetime-local";
+      const r = this.normalizeTemporalInitialValue(i.type, e);
+      return o.value = r, { control: o, value: r };
+    }
+    if (i?.type === "enum" || i?.type === "tags") {
+      const o = i.enum?.allowCustom ?? i.tags?.allowCustom, r = i.enum?.options ?? i.tags?.options ?? [];
+      if (o === !1) {
+        const u = document.createElement("select"), f = document.createElement("option");
+        f.value = "", f.textContent = "", u.appendChild(f);
+        for (const p of r) {
+          const d = document.createElement("option");
+          d.value = p, d.textContent = p, e === p && (d.selected = !0), u.appendChild(d);
+        }
+        return { control: u, value: e };
+      }
+      const a = document.createElement("input");
+      a.type = "text";
+      const l = `extable-datalist-${String(t)}`;
+      a.setAttribute("list", l), a.value = e;
+      let h = document.getElementById(l);
+      if (!h) {
+        h = document.createElement("datalist"), h.id = l;
+        for (const u of r) {
+          const f = document.createElement("option");
+          f.value = u, h.appendChild(f);
+        }
+        this.root.appendChild(h);
+      }
+      return { control: a, value: e, datalistId: l };
+    }
+    const s = document.createElement("input");
+    return s.type = "text", s.value = e, { control: s, value: e };
+  }
+  autosize(t) {
+    const e = window.getComputedStyle(t);
+    let i = Number.parseFloat(e.lineHeight);
+    (!Number.isFinite(i) || i <= 0) && (i = 16), t.rows = 1;
+    const n = Math.ceil(t.scrollHeight / i);
+    t.rows = Math.max(1, n), t.style.minHeight = `${i}px`;
+  }
+  positionFloatingContentBox(t, e) {
+    e.style.left = `${t.left + 2}px`, e.style.top = `${t.top + 2}px`, e.style.width = `${Math.max(8, t.width - 4)}px`, e.style.height = `${Math.max(8, t.height - 4)}px`;
+  }
+  toggleBoolean(t, e) {
+    const i = this.dataModel.getCell(t, e), o = { kind: "edit", rowId: t, colKey: e, next: !(i === !0 || i === "true" || i === "1" || i === 1) }, r = this.editMode === "direct";
+    this.onEdit(o, r), this.onMove(t);
+  }
+  applySelectionFromHit(t, e) {
+    const i = this.dataModel.getSchema(), n = this.dataModel.getRowIndex(e.rowId), s = e.colKey === null, o = s ? i.columns.length > 0 ? 0 : -1 : i.columns.findIndex((h) => String(h.key) === String(e.colKey));
+    if (o < 0) return;
+    const r = s ? {
+      kind: "rows",
+      startRow: n,
+      endRow: n,
+      startCol: 0,
+      endCol: i.columns.length - 1
+    } : {
+      kind: "cells",
+      startRow: n,
+      endRow: n,
+      startCol: Math.max(0, o),
+      endCol: Math.max(0, o)
+    };
+    let a = [];
+    if (t.shiftKey && this.activeCell) {
+      const h = this.activeCell, u = this.dataModel.getRowIndex(h.rowId), f = i.columns.findIndex((d) => String(d.key) === String(h.colKey));
+      a = [s ? {
+        kind: "rows",
+        startRow: u,
+        endRow: n,
+        startCol: 0,
+        endCol: i.columns.length - 1
+      } : {
+        kind: "cells",
+        startRow: u,
+        endRow: n,
+        startCol: Math.max(0, f),
+        endCol: Math.max(0, o)
+      }];
+    } else t.metaKey || t.ctrlKey ? a = [...this.selectionRanges, r] : a = [r];
+    this.selectionRanges = this.mergeRanges(a);
+    const l = r.kind === "rows" ? { rowId: e.rowId, colKey: i.columns[o]?.key ?? null } : { rowId: e.rowId, colKey: e.colKey };
+    this.activeCell = l, this.onActiveChange(l.rowId, l.colKey), this.onSelectionChange(this.selectionRanges), this.updateFillHandleFlag();
+  }
+  mergeRanges(t) {
+    const e = [], i = [...t].sort((n, s) => n.kind !== s.kind ? n.kind === "rows" ? -1 : 1 : n.startRow !== s.startRow ? n.startRow - s.startRow : n.startCol !== s.startCol ? n.startCol - s.startCol : n.endRow !== s.endRow ? n.endRow - s.endRow : n.endCol - s.endCol);
+    for (const n of i) {
+      const s = e.at(-1);
+      if (!s) {
+        e.push({ ...n });
+        continue;
+      }
+      if (s.kind !== n.kind) {
+        e.push({ ...n });
+        continue;
+      }
+      if (n.kind === "rows") {
+        if (s.startCol === n.startCol && s.endCol === n.endCol && s.startRow <= n.endRow + 1 && n.startRow <= s.endRow + 1) {
+          s.startRow = Math.min(s.startRow, n.startRow), s.endRow = Math.max(s.endRow, n.endRow);
+          continue;
+        }
+      } else {
+        const o = s.startCol === n.startCol && s.endCol === n.endCol, r = s.startRow === n.startRow && s.endRow === n.endRow, a = s.startRow <= n.endRow + 1 && n.startRow <= s.endRow + 1, l = s.startCol <= n.endCol + 1 && n.startCol <= s.endCol + 1;
+        if (o && a) {
+          s.startRow = Math.min(s.startRow, n.startRow), s.endRow = Math.max(s.endRow, n.endRow);
+          continue;
+        }
+        if (r && l) {
+          s.startCol = Math.min(s.startCol, n.startCol), s.endCol = Math.max(s.endCol, n.endCol);
+          continue;
+        }
+      }
+      e.push({ ...n });
+    }
+    return e;
+  }
+  activateCellElement(t, e, i, n) {
+    this.teardownInput(), this.activeCell = { rowId: e, colKey: i }, this.activeHost = t, this.activeHostOriginalText = t.textContent ?? "";
+    const s = this.dataModel.getCell(e, i), o = n?.initialValueOverride ?? (s == null ? "" : String(s)), { control: r, value: a } = this.createEditor(i, o), l = r;
+    l.value = a, l.style.width = "calc(100% - 4px)", l.style.boxSizing = "border-box", l.style.margin = "2px", l.style.padding = "4px 6px", l.style.border = "none", l.style.borderRadius = "0", l.style.boxShadow = "none", l.style.background = "#fff", l.style.outline = "none", l.style.fontSize = "14px", l.style.fontFamily = "inherit", l.style.lineHeight = "1.2", l.style.fontWeight = "inherit";
+    const h = this.findColumn(i);
+    if (l.style.textAlign = h?.style?.align ?? (h?.type === "number" ? "right" : "left"), l.addEventListener("keydown", (u) => this.handleKey(u, t)), l.addEventListener("focus", () => {
+      (l instanceof HTMLInputElement || l instanceof HTMLTextAreaElement) && l.select();
+    }), this.bindImmediateCommit(l), t.textContent = "", t.appendChild(l), l.tagName.toLowerCase() === "textarea" && requestAnimationFrame(() => {
+      l instanceof HTMLTextAreaElement && this.autosize(l);
+    }), l.focus({ preventScroll: !0 }), n?.placeCursorAtEnd && (l instanceof HTMLInputElement || l instanceof HTMLTextAreaElement)) {
+      const u = l.value.length;
+      l.setSelectionRange(u, u);
+    }
+    this.inputEl = l;
+  }
+  activateFloating(t, e, i, n) {
+    this.teardownInput(), this.activeCell = { rowId: e, colKey: i };
+    const s = this.computeCanvasCellBoxContent(e, i);
+    if (!s) return;
+    const o = document.createElement("div");
+    this.activeHost = o, this.activeHostOriginalText = null, o.style.position = "absolute", o.dataset.extableFloating = "fixed", o.style.pointerEvents = "auto", o.style.padding = "0", o.style.zIndex = "10";
+    const r = this.dataModel.getCell(e, i), a = n?.initialValueOverride ?? (r == null ? "" : String(r)), { control: l, value: h } = this.createEditor(i, a), u = l;
+    u.value = h, u.style.width = "calc(100% - 4px)", u.style.height = "calc(100% - 4px)", u.style.boxSizing = "border-box", u.style.margin = "2px", u.style.padding = "4px 6px", u.style.border = "none", u.style.borderRadius = "0", u.style.boxShadow = "none", u.style.background = "#fff", u.style.outline = "none", u.style.fontSize = "14px", u.style.fontFamily = "inherit", u.style.lineHeight = "1.2", u.style.fontWeight = "inherit";
+    const f = this.findColumn(i);
+    if (u.style.textAlign = f?.style?.align ?? (f?.type === "number" ? "right" : "left"), u.style.pointerEvents = "auto", u.addEventListener("keydown", (p) => this.handleKey(p, o)), u.addEventListener("focus", () => {
+      (u instanceof HTMLInputElement || u instanceof HTMLTextAreaElement) && u.select();
+    }), this.bindImmediateCommit(u), o.appendChild(u), u.tagName.toLowerCase() === "textarea" && requestAnimationFrame(() => {
+      u instanceof HTMLTextAreaElement && this.autosize(u);
+    }), this.root.appendChild(o), this.positionFloatingContentBox(s, o), u.focus({ preventScroll: !0 }), n?.placeCursorAtEnd && (u instanceof HTMLInputElement || u instanceof HTMLTextAreaElement)) {
+      const p = u.value.length;
+      u.setSelectionRange(p, p);
+    }
+    this.inputEl = u, this.floatingInputWrapper = o;
+  }
+  handleKey(t, e) {
+    if (!this.activeCell || !this.inputEl) return;
+    const i = Date.now();
+    if (t.isComposing || this.composing || i - this.lastCompositionEnd < 24) return;
+    const { rowId: n, colKey: s } = this.activeCell;
+    if (s === null) return;
+    const o = this.inputEl.tagName.toLowerCase() === "textarea", r = t.key === "Enter" && t.altKey, a = (l, h) => {
+      const u = this.readActiveValue();
+      this.commitEdit(n, s, u), this.onMove(n), this.teardownInput(!1), this.moveActiveCell(l, h);
+    };
+    if (t.key === "Tab") {
+      t.preventDefault(), a(0, t.shiftKey ? -1 : 1);
+      return;
+    }
+    if (t.key === "Enter") {
+      if (o && r)
+        return;
+      t.preventDefault(), a(t.shiftKey ? -1 : 1, 0);
+      return;
+    }
+    if (t.key === "Escape") {
+      if (t.preventDefault(), this.cancelEdit(e), this.onMove(), this.activeCell && this.activeCell.colKey !== null) {
+        const l = this.dataModel.getCell(this.activeCell.rowId, this.activeCell.colKey), h = this.cellToClipboardString(l);
+        this.focusSelectionInput(h);
+      }
+    } else t.key === "Backspace" && this.inputEl.value === "" && (t.preventDefault(), this.commitEdit(n, s, ""), this.onMove(n), this.teardownInput(!1), this.moveActiveCell(0, 0));
+  }
+  commitEdit(t, e, i) {
+    if (e === null) return;
+    const n = {
+      kind: "edit",
+      rowId: t,
+      colKey: e,
+      next: i
+    }, s = this.editMode === "direct";
+    this.onEdit(n, s);
+  }
+  readActiveValue() {
+    if (!this.inputEl || !this.activeCell) return this.inputEl?.value ?? "";
+    if (this.inputEl instanceof HTMLInputElement) {
+      if (this.inputEl.type === "checkbox")
+        return this.inputEl.checked;
+      if (this.inputEl.type === "number") {
+        if (this.inputEl.value === "") return "";
+        const t = Number(this.inputEl.value);
+        return Number.isNaN(t) ? "" : t;
+      }
+      return this.inputEl.value;
+    }
+    return this.inputEl instanceof HTMLSelectElement ? this.inputEl.value : this.inputEl.value;
+  }
+  bindImmediateCommit(t) {
+    !this.activeCell || !(t instanceof HTMLInputElement ? t.type === "checkbox" || t.type === "number" || t.type === "date" || t.type === "time" || t.type === "datetime-local" : t instanceof HTMLSelectElement) || t.addEventListener("change", () => {
+      const i = this.activeCell;
+      if (!i) return;
+      const { rowId: n, colKey: s } = i;
+      if (s === null) return;
+      const o = this.readActiveValue();
+      this.commitEdit(n, s, o), this.onMove(n), this.teardownInput(!1);
+    });
+  }
+  cancelEdit(t) {
+    if (this.activeCell) {
+      const { rowId: e, colKey: i } = this.activeCell;
+      if (i === null) return;
+      const n = t.dataset?.original ?? t.dataset?.value ?? (() => {
+        const o = this.dataModel.getCell(e, i);
+        return o == null ? "" : String(o);
+      })(), s = {
+        kind: "edit",
+        rowId: e,
+        colKey: i,
+        next: n,
+        prev: n
+      };
+      this.onEdit(s, !0);
+    }
+    this.teardownInput(!1), (t.dataset?.original !== void 0 || t.dataset?.value !== void 0) && (t.textContent = t.dataset.original ?? t.dataset.value ?? ""), t.blur();
+  }
+  teardownInput(t = !1) {
+    _(this.inputEl), _(this.floatingInputWrapper), this.activeHost && this.activeHostOriginalText !== null && (this.activeHost.textContent = this.activeHostOriginalText), this.inputEl = null, this.floatingInputWrapper = null, this.activeHost = null, this.activeHostOriginalText = null, t && (this.activeCell = null, this.onActiveChange(null, null));
+  }
+}
+const Ie = (c) => c;
+class xe {
+  constructor(t) {
+    this.shell = null, this.viewportEl = null, this.viewportResizeObserver = null, this.selectionManager = null, this.resizeHandler = null, this.scrollHandler = null, this.viewportState = null, this.rafId = null, this.contextMenu = null, this.contextMenuRowId = null, this.handleGlobalPointer = null, this.toast = null, this.toastTimer = null, this.findReplace = null, this.findReplaceSidebar = null, this.findReplaceSidebarUnsub = null, this.findReplaceEnabled = !0, this.findReplaceUiEnabled = !0, this.findReplaceEnableSearch = !1, this.mounted = !1, this.filterSortSidebar = null, this.filterSortSidebarUnsub = null, this.filterSortKeydown = null, this.filterSortClickCapture = null, this.filterSortOpenEvent = null, this.filterSortActiveColumnKey = null, this.filterSortDraft = null, this.tableStateListeners = /* @__PURE__ */ new Set(), this.selectionListeners = /* @__PURE__ */ new Set(), this.lastTableState = null, this.lastSelectionSnapshot = null, this.selectionRanges = [], this.activeCell = null, this.activeErrors = [], this.rowStateListeners = /* @__PURE__ */ new Set(), this.lastRowStates = /* @__PURE__ */ new Map(), this.root = t.root, this.root.classList.add("extable-root"), this.renderMode = t.options?.renderMode ?? "auto", this.editMode = t.options?.editMode ?? "direct", this.lockMode = t.options?.lockMode ?? "none", this.loadingEnabled = t.options?.loading?.enabled ?? !0, this.findReplaceEnabled = t.options?.findReplace?.enabled ?? !0, this.findReplaceUiEnabled = t.options?.findReplace?.sidebar ?? t.options?.findReplace?.dialog ?? !0, this.findReplaceEnableSearch = t.options?.findReplace?.enableSearch ?? !0, this.server = t.options?.server, this.user = t.options?.user;
+    const e = t.defaultData ?? null, i = e ?? [];
+    this.dataLoaded = e != null, this.dataModel = new ne(
+      i,
+      t.schema,
+      t.defaultView
+    ), this.commandQueue = new Gt(), this.lockManager = new ae(this.lockMode, this.server, this.user), this.renderer = this.chooseRenderer(this.renderMode), this.applyRootDecor(t.options), this.applyReadonlyClass(), this.loadInitial();
+  }
+  isCellReadonly(t, e) {
+    return this.editMode === "readonly" || this.dataModel.isReadonly(t, e);
+  }
+  resolveRowId(t) {
+    return typeof t == "string" ? this.findRowById(t)?.id ?? null : (this.dataModel.listAllRows()[t] ?? null)?.id ?? null;
+  }
+  isSearchPanelVisible() {
+    return this.root.classList.contains("extable-search-open");
+  }
+  isFilterSortPanelVisible() {
+    return this.root.classList.contains("extable-filter-sort-open");
+  }
+  safeRender(t) {
+    try {
+      this.renderer.render(t), this.activeErrors.some((i) => i.scope === "render") && (this.activeErrors = this.activeErrors.filter((i) => i.scope !== "render"), this.emitTableState());
+    } catch (e) {
+      const i = e instanceof Error ? e.message : String(e);
+      this.activeErrors = [
+        ...this.activeErrors.filter((n) => n.scope !== "render"),
+        { scope: "render", message: i }
+      ], this.emitTableState();
+    }
+  }
+  async loadInitial() {
+    if (this.server?.fetchInitial)
+      try {
+        const t = await this.server.fetchInitial();
+        this.dataModel.setData(t.data), t.schema && this.dataModel.setSchema(t.schema), t.view && this.dataModel.setView(t.view), this.user = t.user ?? this.user, this.lockManager.setUser(this.user);
+      } catch (t) {
+        console.warn("fetchInitial failed", t);
+      }
+    this.mount();
+  }
+  applyRootDecor(t) {
+    const e = Ct(t?.defaultClass);
+    if (e?.length && this.root.classList.add(...e), t?.defaultStyle)
+      for (const [i, n] of Object.entries(t.defaultStyle))
+        this.root.style[i] = n ?? "";
+  }
+  applyReadonlyClass() {
+    this.root.classList.toggle("extable-readonly-all", this.editMode === "readonly");
+  }
+  chooseRenderer(t) {
+    if (t === "auto") {
+      const e = typeof navigator < "u" ? navigator.userAgent : "";
+      return /bot|crawl|spider/i.test(e) || typeof navigator < "u" && "userAgentData" in navigator && navigator.userAgentData?.brands?.some(
+        (n) => /bot/i.test(n.brand ?? "")
+      ) ? new nt(this.dataModel) : new rt(this.dataModel, () => this.editMode);
+    }
+    return t === "html" ? new nt(this.dataModel) : new rt(this.dataModel, () => this.editMode);
+  }
+  ensureShell() {
+    if (this.shell && this.viewportEl && this.shell.parentElement === this.root) return;
+    this.root.innerHTML = "";
+    const t = document.createElement("div");
+    t.className = "extable-shell";
+    const e = document.createElement("div");
+    e.className = "extable-viewport", t.appendChild(e), this.root.appendChild(t), this.shell = t, this.viewportEl = e, this.viewportResizeObserver?.disconnect();
+    const i = globalThis.ResizeObserver;
+    typeof i == "function" ? (this.viewportResizeObserver = new i(() => {
+      this.updateViewportFromRoot();
+    }), this.viewportResizeObserver.observe(e)) : this.viewportResizeObserver = null;
+  }
+  getScrollHost() {
+    return this.viewportEl ?? this.root;
+  }
+  mount(t = !1) {
+    if (this.mounted && !t) return;
+    this.ensureShell();
+    const e = this.viewportEl ?? this.root;
+    if (this.renderer.mount(e), this.ensureContextMenu(), this.ensureToast(), this.initViewportState(), this.root.classList.toggle("extable-loading", !this.dataLoaded && this.loadingEnabled), !this.dataLoaded && this.loadingEnabled) {
+      this.root.dataset.extable = "loading", this.bindViewport(), this.ensureFindReplace(), this.ensureFilterSort(), this.emitTableState(), this.emitSelection("data");
+      return;
+    }
+    this.selectionManager = new Se(
+      e,
+      this.editMode,
+      (i, n) => this.handleEdit(i, n),
+      (i) => {
+        this.lockManager.selectRow(i);
+      },
+      (i) => {
+        this.lockManager.unlockOnMove(i);
+      },
+      (i) => this.renderer.hitTest(i),
+      this.dataModel,
+      (i, n) => this.isCellReadonly(i, n),
+      (i, n) => {
+        const s = i && n !== null ? { rowId: i, colKey: n } : null;
+        s && this.renderer.setActiveCell(s.rowId, s.colKey), this.activeCell = s, this.emitSelection("selection");
+      },
+      (i, n, s, o) => this.showContextMenu(i, s, o),
+      (i) => {
+        this.selectionRanges = i, this.renderer.setSelection(i), this.emitSelection("selection");
+      },
+      () => this.undo(),
+      () => this.redo()
+    ), this.root.dataset.extable = "ready", this.bindViewport(), this.ensureFindReplace(), this.ensureFilterSort(), this.server && (this.unsubscribe = this.server.subscribe((i) => this.handleServerEvent(i))), this.emitTableState(), this.emitSelection("selection"), this.mounted = !0;
+  }
+  destroy() {
+    this.teardownFilterSort(), this.teardownFindReplace(), this.selectionManager?.destroy(), this.renderer.destroy(), this.unsubscribe?.(), this.unbindViewport(), this.viewportResizeObserver?.disconnect(), this.viewportResizeObserver = null, this.mounted = !1;
+  }
+  // editMode/lockMode are configured only at construction time for consistency.
+  setRootClass(t) {
+    this.root.className = "", this.root.classList.add(...Ct(t) ?? []);
+  }
+  setRootStyle(t) {
+    for (const [e, i] of Object.entries(t))
+      this.root.style[e] = i ?? "";
+  }
+  setData(t) {
+    if (t == null) {
+      if (this.dataLoaded) return;
+      this.dataLoaded = !1, this.safeRender(this.viewportState ?? void 0), this.emitSelection("data"), this.emitTableState();
+      return;
+    }
+    const e = this.dataLoaded;
+    this.dataLoaded = !0, this.dataModel.setData(t), this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitSelection("data"), this.emitTableState(), !e && this.loadingEnabled && (this.root.classList.remove("extable-loading"), this.selectionManager?.destroy(), this.selectionManager = null, this.mount());
+  }
+  setView(t) {
+    this.dataModel.setView(t), this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitSelection("view"), this.emitTableState();
+  }
+  // Public API: configuration getters (mirror setters)
+  getSchema() {
+    return this.dataModel.getSchema();
+  }
+  getView() {
+    return this.dataModel.getView();
+  }
+  /**
+   * Returns the current table data (includes pending edits in commit mode and formula results).
+   * Note: This is the full dataset (not affected by view filters/sorts). Use `listRows()` for the visible rows.
+   */
+  getData() {
+    return this.getTableData();
+  }
+  /**
+   * Returns the raw dataset without pending edits and without formula results.
+   * Note: This is the full dataset (not affected by view filters/sorts). Use `listRows()` for the visible rows.
+   */
+  getRawData() {
+    return this.dataModel.listAllRows().map((t) => ({ ...t.raw }));
+  }
+  // Public API: cell-level access
+  getCell(t, e) {
+    return this.dataModel.getCell(t, e);
+  }
+  // Public API: row/column index utilities
+  getRowIndex(t) {
+    return this.dataModel.getRowIndex(t);
+  }
+  getColumnIndex(t) {
+    return this.dataModel.getColumnIndex(t);
+  }
+  // Public API: row-level access
+  findRowById(t) {
+    const e = this.dataModel.getBaseRowIndex(t);
+    return e < 0 ? null : this.dataModel.listAllRows()[e] ?? null;
+  }
+  listRows() {
+    return this.dataModel.listRows();
+  }
+  getAllRows() {
+    return this.dataModel.listAllRows();
+  }
+  /**
+   * Returns a single row as an object (includes pending edits in commit mode and formula results).
+   * When a number is passed, it is interpreted as the base row index (not affected by view filters/sorts).
+   */
+  getRow(t) {
+    const e = this.resolveRowId(t);
+    return e ? this.buildRow(e) : null;
+  }
+  buildRow(t) {
+    const e = this.findRowById(t);
+    if (!e) return null;
+    const i = this.dataModel.getSchema(), n = { ...e.raw };
+    for (const s of i.columns)
+      n[s.key] = this.dataModel.resolveCellValue(t, s).value;
+    return n;
+  }
+  // Public API: bulk data access
+  getTableData() {
+    return this.dataModel.listAllRows().map((e) => this.buildRow(e.id)).filter(Boolean);
+  }
+  getColumnData(t) {
+    const i = this.dataModel.getSchema().columns.find((s) => s.key === t);
+    return i ? this.dataModel.listAllRows().map((s) => this.dataModel.resolveCellValue(s.id, i).value) : [];
+  }
+  // Public API: commit-mode pending helpers
+  getPending() {
+    return this.editMode !== "commit" ? /* @__PURE__ */ new Map() : new Map(this.dataModel.getPending());
+  }
+  getPendingRowIds() {
+    return [...this.getPending().keys()];
+  }
+  hasPendingChanges() {
+    return this.getPending().size > 0;
+  }
+  getPendingCellCount() {
+    const t = this.getPending();
+    let e = 0;
+    for (const i of t.values()) e += Object.keys(i).length;
+    return e;
+  }
+  getCellPending(t, e) {
+    if (this.editMode !== "commit") return !1;
+    const i = this.resolveRowId(t);
+    return i ? this.dataModel.hasPending(i, e) : !1;
+  }
+  getDisplayValue(t, e) {
+    const i = this.resolveRowId(t);
+    if (!i) return "";
+    const s = this.dataModel.getSchema().columns.find((a) => String(a.key) === String(e));
+    if (!s) return "";
+    const o = this.dataModel.resolveCellValue(i, s);
+    if (o.textOverride) return o.textOverride;
+    const r = o.value;
+    if (r == null) return "";
+    if (r instanceof Date) return r.toISOString();
+    if (typeof r == "string") return r;
+    if (typeof r == "number" || typeof r == "boolean") return String(r);
+    if (typeof r == "object") {
+      const a = r;
+      if (a.kind === "enum" && typeof a.value == "string") return a.value;
+      if (a.kind === "tags" && Array.isArray(a.values))
+        return a.values.filter((h) => typeof h == "string").join(", ");
+    }
+    return String(r);
+  }
+  insertRow(t, e) {
+    let i = null;
+    if (typeof e == "number" && Number.isFinite(e))
+      i = Math.max(0, Math.min(Math.floor(e), this.dataModel.getAllRowCount()));
+    else if (typeof e == "string") {
+      const o = this.dataModel.getBaseRowIndex(e);
+      o >= 0 && (i = o);
+    }
+    i === null && (i = this.dataModel.getAllRowCount());
+    const n = this.dataModel.insertRowAt(t, i), s = {
+      kind: "insertRow",
+      rowId: n,
+      rowData: t,
+      payload: { index: i }
+    };
+    return this.commandQueue.enqueue(s), this.emitRowState(n, "new"), this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitSelection("data"), this.emitTableState(), this.editMode === "direct" && this.sendCommit([s]), n;
+  }
+  deleteRow(t) {
+    const e = this.resolveRowId(t);
+    if (!e) return !1;
+    const i = this.dataModel.removeRow(e);
+    if (!i) return !1;
+    const n = {
+      kind: "deleteRow",
+      rowId: i.row.id,
+      rowData: i.row.raw,
+      payload: { index: i.index }
+    };
+    return this.commandQueue.enqueue(n), this.emitRowState(e, "delete"), this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitSelection("data"), this.emitTableState(), this.editMode === "direct" && this.sendCommit([n]), !0;
+  }
+  handleEdit(t, e) {
+    if (this.editMode === "readonly" || !t.rowId || t.colKey === void 0) return;
+    const i = this.dataModel.getCell(t.rowId, t.colKey);
+    this.commandQueue.enqueue({ ...t, prev: i }), this.dataModel.setCell(t.rowId, t.colKey, t.next, e), this.emitRowState(t.rowId, "edit"), this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitTableState(), this.emitSelection("edit"), e && this.sendCommit([t]);
+  }
+  undo() {
+    this.selectionManager?.cancelEditing();
+    const t = this.commandQueue.undo();
+    if (!(!t || !t.length)) {
+      for (let e = t.length - 1; e >= 0; e -= 1) {
+        const i = t[e];
+        i && this.applyInverse(i);
+      }
+      this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitTableState(), this.emitSelection("edit");
+    }
+  }
+  redo() {
+    this.selectionManager?.cancelEditing();
+    const t = this.commandQueue.redo();
+    if (!(!t || !t.length)) {
+      for (const e of t)
+        this.applyForward(e);
+      this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitTableState(), this.emitSelection("edit");
+    }
+  }
+  getUndoRedoHistory() {
+    const t = (n) => {
+      const s = /* @__PURE__ */ new Set(), o = [];
+      for (const r of n)
+        s.has(r.kind) || (s.add(r.kind), o.push(r.kind));
+      return o;
+    }, e = (n, s) => n.length === 1 && n[0] === "edit" ? `Edit ${s} cell(s)` : n.length === 1 && n[0] === "insertRow" ? s === 1 ? "Insert row" : `Insert row (${s})` : n.length === 1 && n[0] === "deleteRow" ? s === 1 ? "Delete row" : `Delete row (${s})` : n.length === 1 && n[0] === "updateView" ? "Update view" : `Command: ${n.join(", ")} (${s})`, i = (n) => n.map((s) => {
+      const o = t(s.commands), r = s.commands.length;
+      return {
+        batchId: s.batchId,
+        kinds: o,
+        commandCount: r,
+        label: e(o, r)
+      };
+    });
+    return {
+      undo: i(this.commandQueue.listUndoGroups()),
+      redo: i(this.commandQueue.listRedoGroups())
+    };
+  }
+  applyInverse(t) {
+    switch (t.kind) {
+      case "edit":
+        t.rowId && t.colKey !== void 0 && (this.dataModel.setCell(t.rowId, t.colKey, t.prev, this.editMode === "direct"), this.emitRowState(t.rowId, "edit"));
+        return;
+      case "insertRow":
+        t.rowId && this.dataModel.removeRow(t.rowId), t.rowId && this.emitRowState(t.rowId, "delete");
+        return;
+      case "deleteRow":
+        if (t.rowId && t.rowData) {
+          const e = t.payload?.index, i = typeof e == "number" ? e : this.dataModel.getAllRowCount();
+          this.dataModel.insertRowAt(t.rowData, i, t.rowId), this.emitRowState(t.rowId, "new");
+        }
+        return;
+      default:
+        return;
+    }
+  }
+  applyForward(t) {
+    switch (t.kind) {
+      case "edit":
+        t.rowId && t.colKey !== void 0 && (this.dataModel.setCell(t.rowId, t.colKey, t.next, this.editMode === "direct"), this.emitRowState(t.rowId, "edit"));
+        return;
+      case "insertRow":
+        if (t.rowData) {
+          const e = t.payload?.index, i = typeof e == "number" ? e : this.dataModel.getAllRowCount(), n = typeof t.rowId == "string" ? t.rowId : void 0;
+          this.dataModel.insertRowAt(t.rowData, i, n), n && this.emitRowState(n, "new");
+        }
+        return;
+      case "deleteRow":
+        t.rowId && (this.dataModel.removeRow(t.rowId), this.emitRowState(t.rowId, "delete"));
+        return;
+      default:
+        return;
+    }
+  }
+  async commit() {
+    const t = this.commandQueue.listApplied();
+    if (!t.length) return [];
+    const e = /* @__PURE__ */ new Set();
+    for (const n of t)
+      n.rowId && (this.dataModel.applyPending(n.rowId), e.add(n.rowId));
+    await this.sendCommit(t), await this.lockManager.unlockOnCommit(this.commandQueue.listApplied().at(-1)?.rowId), this.commandQueue.clear();
+    const i = [];
+    for (const n of e) {
+      this.emitRowState(n, "edit");
+      const s = this.getRowStateSnapshot(n);
+      s && i.push(s);
+    }
+    return this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitTableState(), this.emitSelection("edit"), i;
+  }
+  async sendCommit(t) {
+    if (this.server && this.user)
+      try {
+        await this.server.commit(t, this.user), this.activeErrors = this.activeErrors.filter((e) => e.scope !== "commit"), this.emitTableState();
+      } catch (e) {
+        console.warn("commit failed", e);
+        const i = e instanceof Error ? e.message : String(e);
+        this.activeErrors = [
+          ...this.activeErrors.filter((n) => n.scope !== "commit"),
+          { scope: "commit", message: i }
+        ], this.emitTableState();
+      }
+  }
+  handleServerEvent(t) {
+    for (const e of t.commands)
+      this.applyCommand(e);
+    this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.emitSelection("data"), this.emitTableState();
+  }
+  applyCommand(t) {
+    switch (t.kind) {
+      case "edit":
+        t.rowId && t.colKey !== void 0 && (this.dataModel.setCell(t.rowId, t.colKey, t.next, !0), this.emitRowState(t.rowId, "edit"));
+        break;
+      case "insertRow":
+        if (t.rowData) {
+          const e = this.dataModel.insertRow(t.rowData);
+          e && this.emitRowState(e, "new");
+        }
+        break;
+      case "deleteRow":
+        t.rowId && (this.dataModel.removeRow(t.rowId), this.emitRowState(t.rowId, "delete"));
+        break;
+      case "updateView":
+        t.next && typeof t.next == "object" && this.dataModel.setView(t.next);
+        break;
+    }
+  }
+  ensureContextMenu() {
+    if (this.contextMenu?.isConnected) return;
+    this.contextMenu = null;
+    const t = document.createElement("div");
+    t.className = "extable-context-menu", t.setAttribute("popover", "manual"), t.addEventListener("contextmenu", (s) => s.preventDefault());
+    const i = this.editMode === "readonly" ? [{ key: "copy", label: "Copy" }] : [
+      { key: "copy", label: "Copy" },
+      { key: "paste", label: "Paste" },
+      { key: "sep-top", kind: "sep" },
+      { key: "undo", label: "Undo" },
+      { key: "redo", label: "Redo" },
+      { key: "sep-mid", kind: "sep" },
+      { key: "insert-above", label: "Insert row above" },
+      { key: "insert-below", label: "Insert row below" },
+      { key: "delete-row", label: "Delete row" }
+    ], n = document.createElement("div");
+    for (const s of i) {
+      if (s.kind === "sep") {
+        const r = document.createElement("hr");
+        r.className = "extable-context-sep", n.appendChild(r);
+        continue;
+      }
+      const o = document.createElement("button");
+      o.type = "button", o.dataset.action = s.key, o.textContent = s.label ?? "", o.addEventListener("click", () => {
+        this.handleContextAction(s.key), this.closeContextMenu();
+      }), n.appendChild(o);
+    }
+    t.appendChild(n), (this.viewportEl ?? this.root).appendChild(t), this.contextMenu = t;
+  }
+  showContextMenu(t, e, i) {
+    if (this.ensureContextMenu(), !this.contextMenu || !this.contextMenu.isConnected && (this.contextMenu = null, this.ensureContextMenu(), !this.contextMenu))
+      return;
+    this.contextMenuRowId = t;
+    for (const l of Array.from(
+      this.contextMenu.querySelectorAll("button[data-action]")
+    )) {
+      const h = l.dataset.action;
+      h === "undo" ? l.disabled = !this.commandQueue.canUndo() : h === "redo" && (l.disabled = !this.commandQueue.canRedo());
+    }
+    const n = window.innerWidth, s = window.innerHeight, o = { width: 220, height: 160 };
+    let r = e, a = i;
+    r + o.width > n && (r = Math.max(0, n - o.width - 8)), a + o.height > s && (a = Math.max(0, s - o.height - 8)), this.contextMenu.style.left = `${r}px`, this.contextMenu.style.top = `${a}px`, this.contextMenu.hidePopover?.(), this.contextMenu.showPopover?.();
+  }
+  handleContextAction(t) {
+    if (t === "copy") {
+      this.selectionManager?.copySelection();
+      return;
+    }
+    if (t === "paste") {
+      this.selectionManager?.pasteFromClipboard();
+      return;
+    }
+    if (t === "undo") {
+      this.undo();
+      return;
+    }
+    if (t === "redo") {
+      this.redo();
+      return;
+    }
+    if (!this.contextMenuRowId) return;
+    const e = this.dataModel.getBaseRowIndex(this.contextMenuRowId), i = e >= 0 ? e : this.dataModel.getAllRowCount();
+    if (t === "insert-above" || t === "insert-below") {
+      const n = t === "insert-above" ? i : i + 1, s = this.createBlankRow(), o = this.dataModel.insertRowAt(s, n);
+      this.commandQueue.enqueue({
+        kind: "insertRow",
+        rowId: o,
+        rowData: s,
+        payload: { index: n }
+      }), this.emitRowState(o, "new"), this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.showToast("Row inserted", "info");
+      return;
+    }
+    if (t === "delete-row") {
+      const n = this.dataModel.removeRow(this.contextMenuRowId);
+      if (!n) return;
+      this.commandQueue.enqueue({
+        kind: "deleteRow",
+        rowId: n.row.id,
+        rowData: n.row.raw,
+        payload: { index: n.index }
+      }), this.emitRowState(n.row.id, "delete"), this.safeRender(this.viewportState ?? void 0), this.selectionManager?.syncAfterRowsChanged(), this.showToast("Row deleted", "info");
+      return;
+    }
+  }
+  createBlankRow() {
+    const t = this.dataModel.getSchema(), e = {};
+    for (const i of t.columns)
+      e[String(i.key)] = null;
+    return e;
+  }
+  closeContextMenu() {
+    this.contextMenu?.hidePopover?.();
+  }
+  ensureToast() {
+    if (this.toast?.isConnected) return;
+    this.toast = null;
+    const t = document.createElement("div");
+    t.className = "extable-toast", t.setAttribute("popover", "manual"), t.style.right = "16px", t.style.bottom = "16px", t.style.position = "fixed", (this.viewportEl ?? this.root).appendChild(t), this.toast = t;
+  }
+  showToast(t, e = "info", i = 2500) {
+    this.ensureToast(), this.toast && (this.toast.textContent = t, this.toast.dataset.variant = e, this.toast.hidePopover?.(), this.toast.showPopover?.(), this.toastTimer && (window.clearTimeout(this.toastTimer), this.toastTimer = null), this.toastTimer = window.setTimeout(() => {
+      this.toast?.hidePopover?.();
+    }, i));
+  }
+  bindViewport() {
+    this.resizeHandler = () => this.updateViewportFromRoot(), this.scrollHandler = () => this.updateViewportFromRoot(), this.getScrollHost().addEventListener("scroll", this.scrollHandler, { passive: !0 }), window.addEventListener("resize", this.resizeHandler), this.handleGlobalPointer = (t) => {
+      this.contextMenu && !this.contextMenu.contains(t.target) && this.contextMenu.hidePopover?.();
+    }, document.addEventListener("pointerdown", this.handleGlobalPointer, !0);
+  }
+  unbindViewport() {
+    this.resizeHandler && window.removeEventListener("resize", this.resizeHandler), this.scrollHandler && this.getScrollHost().removeEventListener("scroll", this.scrollHandler), this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null), this.handleGlobalPointer && (document.removeEventListener("pointerdown", this.handleGlobalPointer, !0), this.handleGlobalPointer = null), this.contextMenu && (this.contextMenu.hidePopover?.(), this.contextMenu.parentElement && _(this.contextMenu), this.contextMenu = null), this.toast && (this.toast.hidePopover?.(), this.toast.parentElement && _(this.toast), this.toast = null);
+  }
+  remount(t) {
+    this.unbindViewport(), this.teardownFilterSort(), this.teardownFindReplace(), this.selectionManager?.destroy(), this.renderer.destroy(), this.root = t, this.applyReadonlyClass(), this.shell = null, this.viewportEl = null, this.viewportResizeObserver?.disconnect(), this.viewportResizeObserver = null, this.renderer = this.chooseRenderer(this.renderMode), this.mounted = !1, this.mount(!0);
+  }
+  showSearchPanel(t = "find") {
+    if (!this.findReplaceEnabled || !this.findReplaceUiEnabled || (this.ensureFindReplace(), !this.findReplace || !this.findReplaceSidebar)) return;
+    this.hideFilterSortPanel(), this.findReplace.setMode(t), this.root.classList.toggle("extable-search-open", !0), this.updateViewportFromRoot(), this.safeRender(this.viewportState ?? void 0), this.emitTableState();
+    const e = this.findReplaceSidebar.querySelector(
+      'input[data-extable-fr="query"]'
+    );
+    e?.focus({ preventScroll: !0 }), e?.select();
+  }
+  hideSearchPanel() {
+    this.findReplaceSidebar && (this.root.classList.toggle("extable-search-open", !1), this.updateViewportFromRoot(), this.safeRender(this.viewportState ?? void 0), this.emitTableState(), this.getScrollHost().querySelector(
+      'input[data-extable-selection="1"]'
+    )?.focus?.({
+      preventScroll: !0
+    }));
+  }
+  // External toggle for host apps.
+  toggleSearchPanel(t = "find") {
+    this.isSearchPanelVisible() ? this.hideSearchPanel() : this.showSearchPanel(t);
+  }
+  updateFindReplaceReadonlyUI() {
+    if (!this.findReplaceSidebar) return;
+    const t = this.findReplaceSidebar, e = t.querySelector('input[data-extable-fr="replace-toggle"]');
+    if (!e) return;
+    const i = this.editMode === "readonly";
+    t.dataset.extableFrReadonly = i ? "1" : "0", i ? (e.checked = !1, this.findReplace?.setMode("find"), t.dataset.extableFrMode = "find") : t.dataset.extableFrMode = e.checked ? "replace" : "find";
+  }
+  // Public API: table-level state callbacks
+  getTableState() {
+    const t = this.renderer instanceof nt ? "html" : "canvas", e = this.commandQueue.listApplied(), i = this.editMode === "commit" ? e : [], n = i.length, s = (() => {
+      const l = /* @__PURE__ */ new Set();
+      for (const h of i)
+        h.kind === "edit" && (!h.rowId || h.colKey === void 0 || l.add(`${h.rowId}::${String(h.colKey)}`));
+      return l.size;
+    })(), o = this.dataModel.getValidationErrors().map((l) => ({
+      scope: "validation",
+      message: l.message,
+      target: { rowId: l.rowId, colKey: l.colKey }
+    })), r = this.dataModel.getDiagnostics().map((l) => l.diag ? {
+      scope: l.diag.source,
+      message: l.diag.message,
+      target: { rowId: l.rowId, colKey: l.colKey }
+    } : null).filter(Boolean);
+    r.sort((l, h) => {
+      const u = l.target?.rowId ? this.dataModel.getRowIndex(l.target.rowId) : -1, f = h.target?.rowId ? this.dataModel.getRowIndex(h.target.rowId) : -1;
+      if (u !== f) return u - f;
+      const p = l.target?.colKey !== void 0 ? this.dataModel.getColumnIndex(l.target.colKey) : -1, d = h.target?.colKey !== void 0 ? this.dataModel.getColumnIndex(h.target.colKey) : -1;
+      return p !== d ? p - d : l.scope !== h.scope ? l.scope < h.scope ? -1 : 1 : l.message < h.message ? -1 : l.message > h.message ? 1 : 0;
+    });
+    const a = [
+      ...o,
+      ...r.slice(0, 200),
+      ...this.activeErrors
+    ];
+    return {
+      canCommit: this.editMode === "commit" && n > 0,
+      pendingCommandCount: n,
+      pendingCellCount: s,
+      undoRedo: { canUndo: this.commandQueue.canUndo(), canRedo: this.commandQueue.canRedo() },
+      renderMode: t,
+      ui: { searchPanelOpen: this.isSearchPanelVisible() },
+      activeErrors: a
+    };
+  }
+  subscribeTableState(t) {
+    return this.tableStateListeners.add(t), t(this.getTableState(), null), () => this.tableStateListeners.delete(t);
+  }
+  emitTableState() {
+    const t = this.getTableState(), e = this.lastTableState, i = (() => {
+      if (!e || e.activeErrors.length !== t.activeErrors.length) return !1;
+      for (let s = 0; s < t.activeErrors.length; s += 1) {
+        const o = e.activeErrors[s], r = t.activeErrors[s];
+        if (!o || !r || o.scope !== r.scope || o.message !== r.message) return !1;
+        const a = o.target, l = r.target;
+        if (!(!a && !l) && (!a || !l || (a.rowId ?? null) !== (l.rowId ?? null) || String(a.colKey ?? "") !== String(l.colKey ?? "")))
+          return !1;
+      }
+      return !0;
+    })();
+    if (!(e && e.canCommit === t.canCommit && e.pendingCommandCount === t.pendingCommandCount && e.pendingCellCount === t.pendingCellCount && e.undoRedo.canUndo === t.undoRedo.canUndo && e.undoRedo.canRedo === t.undoRedo.canRedo && e.renderMode === t.renderMode && e.ui.searchPanelOpen === t.ui.searchPanelOpen && i)) {
+      this.lastTableState = t;
+      for (const s of this.tableStateListeners) s(t, e);
+    }
+  }
+  // Public API: selection callbacks
+  getSelectionSnapshot() {
+    const t = this.selectionRanges, e = this.dataModel.getSchema(), i = this.activeCell, n = i?.rowId ?? null, s = i?.colKey ?? null, o = n ? this.dataModel.getRowIndex(n) : null, r = s !== null ? e.columns.findIndex((y) => String(y.key) === String(s)) : null, a = r !== null && r >= 0 ? e.columns[r] : null, l = n && a ? this.dataModel.resolveCellValue(n, a) : null, h = n && a ? this.dataModel.resolveConditionalStyle(n, a) : null, u = l?.textOverride ?? (h?.forceErrorText ? "#ERROR" : void 0), f = l ? l.value : null, p = (() => {
+      if (u) return u;
+      const y = f;
+      if (y == null) return "";
+      if (y instanceof Date) return y.toISOString();
+      if (typeof y == "string") return y;
+      if (typeof y == "number" || typeof y == "boolean") return String(y);
+      if (typeof y == "object") {
+        const w = y, S = w.kind;
+        if (S === "enum" && typeof w.value == "string") return w.value;
+        if (S === "tags" && Array.isArray(w.values))
+          return w.values.filter((b) => typeof b == "string").join(", ");
+      }
+      return String(y);
+    })(), d = a?.type ?? null, m = n && s !== null ? this.dataModel.getCellDiagnostic(n, s) : null, g = (() => {
+      if (!n || !a)
+        return { columnStyle: {}, cellStyle: {}, resolved: {} };
+      const { columnStyle: y, cellStyle: w, resolved: S } = me(
+        this.dataModel,
+        n,
+        a
+      );
+      return { columnStyle: y, cellStyle: w, resolved: S };
+    })();
+    return {
+      ranges: [...t],
+      activeRowIndex: o !== null && o >= 0 ? o : null,
+      activeRowKey: n,
+      activeColumnIndex: r !== null && r >= 0 ? r : null,
+      activeColumnKey: s,
+      activeValueRaw: f,
+      activeValueDisplay: p,
+      activeValueType: d,
+      diagnostic: m,
+      styles: g
+    };
+  }
+  subscribeSelection(t) {
+    return this.selectionListeners.add(t), t(this.getSelectionSnapshot(), null, "selection"), () => this.selectionListeners.delete(t);
+  }
+  emitSelection(t) {
+    const e = this.getSelectionSnapshot(), i = this.lastSelectionSnapshot;
+    this.lastSelectionSnapshot = e;
+    for (const n of this.selectionListeners) n(e, i, t);
+  }
+  getRowStateSnapshot(t) {
+    const e = this.dataModel.getRowIndex(t);
+    if (e < 0) return null;
+    const i = this.buildRow(t);
+    if (!i) return null;
+    const n = this.editMode === "commit" ? this.dataModel.getPending().get(t) ?? void 0 : void 0, s = this.getTableState().activeErrors.filter((o) => o.target?.rowId === t);
+    return {
+      rowId: t,
+      rowIndex: e,
+      data: i,
+      pending: n,
+      diagnostics: s.length ? s : void 0
+    };
+  }
+  subscribeRowState(t) {
+    this.rowStateListeners.add(t);
+    const e = this.dataModel.listAllRows();
+    for (const i of e) {
+      const n = this.getRowStateSnapshot(i.id);
+      n && (this.lastRowStates.set(i.id, n), t(i.id, n, null, "new"));
+    }
+    return () => this.rowStateListeners.delete(t);
+  }
+  emitRowState(t, e) {
+    const i = this.lastRowStates.get(t) ?? null;
+    if (e === "delete") {
+      this.lastRowStates.delete(t);
+      for (const s of this.rowStateListeners) s(t, null, i, e);
+      return;
+    }
+    const n = this.getRowStateSnapshot(t);
+    if (n) {
+      this.lastRowStates.set(t, n);
+      for (const s of this.rowStateListeners) s(t, n, i, e);
+    }
+  }
+  // Public API: value updates
+  setCellValue(t, e, i) {
+    const n = typeof t == "string" ? t : this.dataModel.listRows()[t]?.id, s = n ? se(this.dataModel, { rowId: n, colKey: e }) : null;
+    if (!s || this.isCellReadonly(s.rowId, s.colKey)) return;
+    const o = this.dataModel.getCell(s.rowId, s.colKey), r = typeof i == "function" ? i(o) : i;
+    this.handleEdit(
+      { kind: "edit", rowId: s.rowId, colKey: s.colKey, next: r },
+      this.editMode === "direct"
+    );
+  }
+  setValueToSelection(t) {
+    const e = this.dataModel.getSchema(), i = this.dataModel.listRows(), n = /* @__PURE__ */ new Set();
+    for (const s of this.selectionRanges) {
+      if (s.kind !== "cells") continue;
+      const o = Math.min(s.startRow, s.endRow), r = Math.max(s.startRow, s.endRow), a = Math.min(s.startCol, s.endCol), l = Math.max(s.startCol, s.endCol);
+      for (let h = o; h <= r; h += 1) {
+        const u = i[h];
+        if (u)
+          for (let f = a; f <= l; f += 1) {
+            const p = e.columns[f];
+            if (!p) continue;
+            const d = `${u.id}::${String(p.key)}`;
+            if (n.has(d) || (n.add(d), this.isCellReadonly(u.id, p.key))) continue;
+            const m = this.dataModel.getCell(u.id, p.key), g = typeof t == "function" ? t(m) : t;
+            this.handleEdit(
+              { kind: "edit", rowId: u.id, colKey: p.key, next: g },
+              this.editMode === "direct"
+            );
+          }
+      }
+    }
+  }
+  // Backward compatible aliases.
+  openFindReplaceDialog(t = "find") {
+    this.showSearchPanel(t);
+  }
+  closeFindReplaceDialog() {
+    this.hideSearchPanel();
+  }
+  ensureFindReplace() {
+    this.findReplaceEnabled && (this.findReplace || (this.findReplace = new le(
+      this.dataModel,
+      (t, e) => this.selectionManager?.navigateToCell(t, e),
+      (t, e, i) => this.handleEdit({ kind: "edit", rowId: t, colKey: e, next: i }, this.editMode === "direct"),
+      (t, e) => !this.isCellReadonly(t, e)
+    )), this.findReplaceUiEnabled && this.ensureFindReplaceSidebar());
+  }
+  ensureFindReplaceSidebar() {
+    if (this.findReplaceSidebar) {
+      if (this.findReplaceSidebar.isConnected) return;
+      this.findReplaceSidebar = null;
+    }
+    this.ensureShell();
+    const t = this.shell ?? this.root, e = document.createElement("aside");
+    e.className = "extable-search-sidebar", e.innerHTML = `
+      <div class="extable-search-header">
+        <div class="extable-search-row">
+          <label class="extable-search-label">
+            <span class="extable-search-title">Find</span>
+            <input data-extable-fr="query" type="text" />
+          </label>
+          <button type="button" data-extable-fr="close" class="extable-search-close">×</button>
+        </div>
+        <div class="extable-search-row">
+          <label><input data-extable-fr="case" type="checkbox" /> <span>Case</span></label>
+          <label><input data-extable-fr="regex" type="checkbox" /> <span>Regex</span></label>
+          <label data-extable-fr="replace-toggle-row"><input data-extable-fr="replace-toggle" type="checkbox" /> <span>Replace</span></label>
+        </div>
+        <div class="extable-search-row extable-search-replace-row" data-extable-fr="replace-row">
+          <label class="extable-search-label">
+            <span class="extable-search-title">Replace</span>
+            <input data-extable-fr="replace" type="text" />
+          </label>
+        </div>
+        <div class="extable-search-row extable-search-status">
+          <span data-extable-fr="status"></span>
+          <span data-extable-fr="error" class="extable-search-error"></span>
+        </div>
+      </div>
+      <div class="extable-search-body">
+        <div class="extable-search-actions">
+          <button type="button" data-extable-fr="prev">Prev</button>
+          <button type="button" data-extable-fr="next">Next</button>
+          <button type="button" data-extable-fr="replace-current" data-extable-fr-only="replace">Replace</button>
+          <button type="button" data-extable-fr="replace-all" data-extable-fr-only="replace">Replace All</button>
+        </div>
+        <div class="extable-search-results" data-extable-fr="results">
+          <table class="extable-search-table" data-extable-fr="results-table">
+            <thead>
+              <tr><th>Cell</th><th>Text</th></tr>
+            </thead>
+            <tbody data-extable-fr="results-tbody"></tbody>
+          </table>
+        </div>
+      </div>
+    `, t.appendChild(e), this.findReplaceSidebar = e;
+    const i = e.querySelector('input[data-extable-fr="query"]'), n = e.querySelector('input[data-extable-fr="replace"]'), s = e.querySelector(
+      'input[data-extable-fr="replace-toggle"]'
+    ), o = e.querySelector(
+      '[data-extable-fr="replace-toggle-row"]'
+    ), r = e.querySelector('input[data-extable-fr="case"]'), a = e.querySelector('input[data-extable-fr="regex"]'), l = e.querySelector('button[data-extable-fr="prev"]'), h = e.querySelector('button[data-extable-fr="next"]'), u = e.querySelector(
+      'button[data-extable-fr="replace-current"]'
+    ), f = e.querySelector(
+      'button[data-extable-fr="replace-all"]'
+    ), p = e.querySelector('button[data-extable-fr="close"]'), d = e.querySelector('[data-extable-fr="results-tbody"]');
+    if (!i || !n || !s || !o || !r || !a || !l || !h || !u || !f || !p || !d) {
+      _(e), this.findReplaceSidebar = null;
+      return;
+    }
+    i.addEventListener("input", () => this.findReplace?.setQuery(i.value)), n.addEventListener("input", () => this.findReplace?.setReplace(n.value)), r.addEventListener(
+      "change",
+      () => this.findReplace?.setOptions({ caseInsensitive: r.checked })
+    ), a.addEventListener(
+      "change",
+      () => this.findReplace?.setOptions({ regex: a.checked })
+    ), s.addEventListener("change", () => {
+      if (this.editMode === "readonly") {
+        s.checked = !1, this.findReplace?.setMode("find"), e.dataset.extableFrMode = "find";
+        return;
+      }
+      const g = s.checked ? "replace" : "find";
+      this.findReplace?.setMode(g), e.dataset.extableFrMode = g;
+    }), this.updateFindReplaceReadonlyUI(), l.addEventListener("click", () => this.findReplace?.prev()), h.addEventListener("click", () => this.findReplace?.next()), u.addEventListener("click", () => this.findReplace?.replaceCurrent()), f.addEventListener("click", () => this.findReplace?.replaceAll()), p.addEventListener("click", () => this.hideSearchPanel());
+    const m = (g, y = 140) => g.length > y ? `${g.slice(0, y - 1)}…` : g;
+    d.addEventListener("click", (g) => {
+      const y = g.target?.closest("tr[data-index]"), w = y ? Number(y.dataset.index) : -1;
+      Number.isFinite(w) && w >= 0 && this.findReplace?.activateIndex(w);
+    }), d.addEventListener("keydown", (g) => {
+      if (g.key !== "Enter") return;
+      const y = g.target?.closest("tr[data-index]"), w = y ? Number(y.dataset.index) : -1;
+      Number.isFinite(w) && w >= 0 && this.findReplace?.activateIndex(w);
+    }), this.updateFindReplaceReadonlyUI(), this.findReplaceSidebarUnsub = this.findReplace?.subscribe((g) => {
+      const y = e.querySelector('[data-extable-fr="replace-row"]'), w = e.querySelector('[data-extable-fr="status"]'), S = e.querySelector('[data-extable-fr="error"]');
+      if (!(!y || !w || !S)) {
+        i.value = g.query, n.value = g.replace, r.checked = g.options.caseInsensitive, a.checked = g.options.regex, s.checked = g.mode === "replace", y.style.display = g.mode === "replace" ? "block" : "none", u.style.display = g.mode === "replace" ? "inline-block" : "none", f.style.display = g.mode === "replace" ? "inline-block" : "none", w.textContent = `${g.matches.length} matches`, S.textContent = g.error ?? "", l.disabled = g.matches.length === 0, h.disabled = g.matches.length === 0, u.disabled = g.matches.length === 0 || g.activeIndex < 0, f.disabled = g.matches.length === 0, d.innerHTML = "";
+        for (let b = 0; b < g.matches.length; b += 1) {
+          const C = g.matches[b];
+          if (!C) continue;
+          const v = document.createElement("tr");
+          v.dataset.index = String(b), v.tabIndex = 0, v.className = "extable-search-result-row", b === g.activeIndex && (v.dataset.active = "1");
+          const R = document.createElement("td");
+          R.textContent = `R${C.rowIndex + 1}C${C.colIndex + 1}`;
+          const I = document.createElement("td"), x = m(C.text);
+          I.textContent = x, I.title = C.text, v.appendChild(R), v.appendChild(I), d.appendChild(v);
+        }
+      }
+    }) ?? null;
+  }
+  teardownFindReplace() {
+    this.findReplaceSidebarUnsub?.(), this.findReplaceSidebarUnsub = null, this.findReplaceSidebar && (_(this.findReplaceSidebar), this.findReplaceSidebar = null), this.findReplace?.destroy(), this.findReplace = null;
+  }
+  // External toggle for host apps.
+  stableValueKey(t) {
+    if (t === null) return "null";
+    if (t === void 0) return "undefined";
+    if (t instanceof Date) return `date:${t.getTime()}`;
+    if (typeof t == "string") return `s:${t}`;
+    if (typeof t == "number") return `n:${Number.isNaN(t) ? "NaN" : String(t)}`;
+    if (typeof t == "boolean") return `b:${t ? "1" : "0"}`;
+    if (typeof t == "object") {
+      const e = t, i = e.kind;
+      if (i === "enum" && typeof e.value == "string") return `enum:${e.value}`;
+      if (i === "tags" && Array.isArray(e.values))
+        return `tags:${e.values.filter((n) => typeof n == "string").join("|")}`;
+    }
+    try {
+      return `json:${JSON.stringify(t)}`;
+    } catch {
+      return `str:${String(t)}`;
+    }
+  }
+  ensureFilterSort() {
+    this.ensureFilterSortSidebar(), this.ensureFilterSortHeaderIntegration(), this.ensureFilterSortEscape();
+  }
+  ensureFilterSortEscape() {
+    this.filterSortKeydown || (this.filterSortKeydown = (t) => {
+      this.isFilterSortPanelVisible() && t.key === "Escape" && (t.preventDefault(), t.stopPropagation(), this.hideFilterSortPanel());
+    }, document.addEventListener("keydown", this.filterSortKeydown, !0));
+  }
+  ensureFilterSortHeaderIntegration() {
+    if (this.filterSortClickCapture) return;
+    const t = this.viewportEl ?? this.root;
+    this.filterSortClickCapture = (e) => {
+      const n = e.target?.closest('button[data-extable-fs-open="1"]');
+      if (!n) return;
+      const s = n.dataset.extableColKey ?? n.closest("th[data-col-key]")?.dataset.colKey;
+      s && (e.preventDefault(), e.stopPropagation(), this.showFilterSortPanel(s));
+    }, t.addEventListener("click", this.filterSortClickCapture, !0), this.filterSortOpenEvent = (e) => {
+      const s = e.detail?.colKey;
+      s != null && this.showFilterSortPanel(String(s));
+    }, t.addEventListener("extable:filter-sort-open", this.filterSortOpenEvent);
+  }
+  ensureFilterSortSidebar() {
+    if (this.filterSortSidebar) {
+      if (this.filterSortSidebar.isConnected) return;
+      this.filterSortSidebar = null;
+    }
+    this.ensureShell();
+    const t = this.shell ?? this.root, e = document.createElement("aside");
+    e.className = "extable-filter-sort-sidebar", e.innerHTML = `
+      <div class="extable-filter-sort-header">
+        <div class="extable-filter-sort-row">
+          <div class="extable-filter-sort-title" data-extable-fs="title">Sort/Filter</div>
+          <button type="button" data-extable-fs="close" class="extable-filter-sort-close">×</button>
+        </div>
+      </div>
+      <div class="extable-filter-sort-body">
+        <div class="extable-filter-sort-section extable-filter-sort-section-filter">
+          <div class="extable-filter-sort-section-title">Filter</div>
+          <div class="extable-filter-sort-actions">
+            <label><input type="checkbox" data-extable-fs="col-errors" /> Errors</label>
+            <label><input type="checkbox" data-extable-fs="col-warnings" /> Warnings</label>
+          </div>
+          <input data-extable-fs="search" type="text" placeholder="Search values" />
+          <div class="extable-filter-sort-values" data-extable-fs="values"></div>
+          <div class="extable-filter-sort-actions" data-align="split">
+            <button type="button" data-extable-fs="select-all">Select All</button>
+            <button type="button" data-extable-fs="select-none">Select None</button>
+            <button type="button" data-extable-fs="apply-filter">Apply</button>
+            <button type="button" data-extable-fs="clear-filter">Clear</button>
+          </div>
+        </div>
+        <div class="extable-filter-sort-section extable-filter-sort-section-sort">
+          <div class="extable-filter-sort-section-title">Sort</div>
+          <div class="extable-filter-sort-actions" data-align="right">
+            <button type="button" data-extable-fs="sort-asc">Sort Asc</button>
+            <button type="button" data-extable-fs="sort-desc">Sort Desc</button>
+            <button type="button" data-extable-fs="clear-sort">Clear Sort</button>
+          </div>
+        </div>
+      </div>
+    `, t.appendChild(e), this.filterSortSidebar = e;
+    const i = e.querySelector('button[data-extable-fs="close"]'), n = e.querySelector('input[data-extable-fs="col-errors"]'), s = e.querySelector(
+      'input[data-extable-fs="col-warnings"]'
+    ), o = e.querySelector('input[data-extable-fs="search"]'), r = e.querySelector('[data-extable-fs="values"]'), a = e.querySelector('button[data-extable-fs="select-all"]'), l = e.querySelector('button[data-extable-fs="select-none"]'), h = e.querySelector(
+      'button[data-extable-fs="apply-filter"]'
+    ), u = e.querySelector(
+      'button[data-extable-fs="clear-filter"]'
+    ), f = e.querySelector('button[data-extable-fs="sort-asc"]'), p = e.querySelector(
+      'button[data-extable-fs="sort-desc"]'
+    ), d = e.querySelector(
+      'button[data-extable-fs="clear-sort"]'
+    );
+    if (!i || !n || !s || !o || !r || !a || !l || !h || !u || !f || !p || !d) {
+      _(e), this.filterSortSidebar = null;
+      return;
+    }
+    i.addEventListener("click", () => this.hideFilterSortPanel()), n.addEventListener("change", () => {
+      this.filterSortDraft && (this.filterSortDraft.diagErrors = n.checked);
+    }), s.addEventListener("change", () => {
+      this.filterSortDraft && (this.filterSortDraft.diagWarnings = s.checked);
+    }), o.addEventListener("input", () => {
+      this.filterSortDraft && (this.filterSortDraft.search = o.value, this.renderFilterSortValues());
+    }), r.addEventListener("change", (m) => {
+      const g = m.target?.closest(
+        'input[type="checkbox"][data-fs-val]'
+      );
+      if (!g || !this.filterSortDraft) return;
+      const y = g.dataset.fsVal ?? "";
+      y && (y === "__blanks__" ? this.filterSortDraft.includeBlanks = g.checked : g.checked ? this.filterSortDraft.selected.add(y) : this.filterSortDraft.selected.delete(y));
+    }), a.addEventListener("click", () => {
+      this.filterSortDraft && (this.filterSortDraft.selected = new Set(this.filterSortDraft.values.map((m) => m.key)), this.filterSortDraft.includeBlanks = this.filterSortDraft.hasBlanks, this.renderFilterSortValues());
+    }), l.addEventListener("click", () => {
+      this.filterSortDraft && (this.filterSortDraft.selected = /* @__PURE__ */ new Set(), this.filterSortDraft.includeBlanks = !1, this.renderFilterSortValues());
+    }), h.addEventListener("click", () => this.applyFilterSortDraft()), u.addEventListener("click", () => this.clearFilterSortForActiveColumn()), f.addEventListener("click", () => this.setSortForActiveColumn("asc")), p.addEventListener("click", () => this.setSortForActiveColumn("desc")), d.addEventListener("click", () => this.clearSort()), this.filterSortSidebarUnsub = this.dataModel.subscribe(() => {
+      this.isFilterSortPanelVisible() && this.filterSortActiveColumnKey && (this.buildFilterSortDraft(this.filterSortActiveColumnKey), this.renderFilterSortSidebar());
+    });
+  }
+  showFilterSortPanel(t) {
+    this.hideSearchPanel(), this.filterSortActiveColumnKey = t, this.buildFilterSortDraft(t), this.root.classList.toggle("extable-filter-sort-open", !0), this.renderFilterSortSidebar(), (this.filterSortSidebar?.querySelector('input[data-extable-fs="search"]') ?? null)?.focus();
+  }
+  hideFilterSortPanel() {
+    this.root.classList.toggle("extable-filter-sort-open", !1), this.filterSortActiveColumnKey = null, this.filterSortDraft = null;
+  }
+  toggleFilterSortPanel(t) {
+    this.isFilterSortPanelVisible() ? this.hideFilterSortPanel() : this.showFilterSortPanel(t);
+  }
+  buildFilterSortDraft(t) {
+    const e = this.dataModel.getView(), n = this.dataModel.getSchema().columns.find((f) => String(f.key) === String(t));
+    if (!n) {
+      this.filterSortDraft = null;
+      return;
+    }
+    const s = this.filterSortDraft && String(this.filterSortDraft.colKey) === String(n.key) ? this.filterSortDraft.search : "", o = this.dataModel.getDistinctValuesForColumn(n.key), r = o.values.map((f) => ({ ...f, key: this.stableValueKey(f.value) })), a = (e.filters ?? []).find(
+      (f) => f.kind === "values" && String(f.key) === String(n.key)
+    ), l = /* @__PURE__ */ new Set();
+    if (a)
+      for (const f of a.values ?? []) l.add(this.stableValueKey(f));
+    else
+      for (const f of r) l.add(f.key);
+    const h = a ? !!a.includeBlanks : o.hasBlanks, u = e.columnDiagnostics?.[String(n.key)];
+    this.filterSortDraft = {
+      colKey: n.key,
+      values: r,
+      hasBlanks: o.hasBlanks,
+      selected: l,
+      includeBlanks: h,
+      diagErrors: !!u?.errors,
+      diagWarnings: !!u?.warnings,
+      search: s
+    };
+  }
+  renderFilterSortSidebar() {
+    if (!this.filterSortSidebar) return;
+    const t = this.filterSortSidebar.querySelector('[data-extable-fs="title"]'), e = this.filterSortSidebar.querySelector(
+      'input[data-extable-fs="col-errors"]'
+    ), i = this.filterSortSidebar.querySelector(
+      'input[data-extable-fs="col-warnings"]'
+    ), n = this.filterSortSidebar.querySelector(
+      'input[data-extable-fs="search"]'
+    );
+    if (!t || !e || !i || !n) return;
+    const s = this.filterSortSidebar.querySelector(
+      'button[data-extable-fs="sort-asc"]'
+    ), o = this.filterSortSidebar.querySelector(
+      'button[data-extable-fs="sort-desc"]'
+    ), r = this.filterSortDraft;
+    if (!r) {
+      t.textContent = "Sort/Filter", e.checked = !1, i.checked = !1, n.value = "", s && (s.dataset.active = "0"), o && (o.dataset.active = "0"), this.renderFilterSortValues();
+      return;
+    }
+    const h = this.dataModel.getSchema().columns.find((p) => String(p.key) === String(r.colKey))?.header ?? String(r.colKey);
+    t.textContent = `Sort/Filter: ${h}`, e.checked = r.diagErrors, i.checked = r.diagWarnings, n.value = r.search;
+    const f = this.dataModel.getView().sorts?.find((p) => String(p.key) === String(r.colKey));
+    s && (s.dataset.active = f?.dir === "asc" ? "1" : "0"), o && (o.dataset.active = f?.dir === "desc" ? "1" : "0"), this.renderFilterSortValues();
+  }
+  renderFilterSortValues() {
+    if (!this.filterSortSidebar) return;
+    const t = this.filterSortSidebar.querySelector('[data-extable-fs="values"]');
+    if (!t) return;
+    t.innerHTML = "";
+    const e = this.filterSortDraft;
+    if (!e) return;
+    const i = e.search.trim().toLowerCase();
+    if (e.values.length + (e.hasBlanks ? 1 : 0) > 100 && !i) {
+      const o = document.createElement("div");
+      o.textContent = "Too many values (100+). Type to search.", t.appendChild(o);
+      return;
+    }
+    if (e.hasBlanks) {
+      const o = document.createElement("label"), r = document.createElement("input");
+      r.type = "checkbox", r.dataset.fsVal = "__blanks__", r.checked = e.includeBlanks;
+      const a = document.createElement("span");
+      a.textContent = "(Blanks)", o.appendChild(r), o.appendChild(a), t.appendChild(o);
+    }
+    const s = i ? e.values.filter((o) => o.label.toLowerCase().includes(i)) : e.values;
+    for (const o of s.slice(0, 200)) {
+      const r = document.createElement("label"), a = document.createElement("input");
+      a.type = "checkbox", a.dataset.fsVal = o.key, a.checked = e.selected.has(o.key);
+      const l = document.createElement("span");
+      l.textContent = o.label, r.appendChild(a), r.appendChild(l), t.appendChild(r);
+    }
+  }
+  applyFilterSortDraft() {
+    const t = this.filterSortDraft;
+    if (!t) return;
+    const e = this.dataModel.getView(), i = [...e.filters ?? []].filter(
+      (a) => !(a.kind === "values" && String(a.key) === String(t.colKey))
+    ), s = t.selected.size === t.values.length && t.includeBlanks === !!t.hasBlanks ? i : [
+      ...i,
+      {
+        kind: "values",
+        key: t.colKey,
+        values: t.values.filter((a) => t.selected.has(a.key)).map((a) => a.value),
+        includeBlanks: t.includeBlanks
+      }
+    ], o = { ...e.columnDiagnostics ?? {} };
+    t.diagErrors || t.diagWarnings ? o[String(t.colKey)] = {
+      errors: t.diagErrors,
+      warnings: t.diagWarnings
+    } : delete o[String(t.colKey)];
+    const r = {
+      ...e,
+      filters: s.length ? s : void 0,
+      columnDiagnostics: Object.keys(o).length ? o : void 0
+    };
+    this.setView(r);
+  }
+  clearFilterSortForActiveColumn() {
+    const t = this.filterSortActiveColumnKey;
+    if (t == null) return;
+    const e = this.dataModel.getView(), i = [...e.filters ?? []].filter(
+      (o) => !(o.kind === "values" && String(o.key) === String(t))
+    ), n = { ...e.columnDiagnostics ?? {} };
+    delete n[String(t)];
+    const s = {
+      ...e,
+      filters: i.length ? i : void 0,
+      columnDiagnostics: Object.keys(n).length ? n : void 0
+    };
+    this.setView(s), this.buildFilterSortDraft(t), this.renderFilterSortSidebar();
+  }
+  setSortForActiveColumn(t) {
+    const e = this.filterSortActiveColumnKey;
+    if (e == null) return;
+    const n = { ...this.dataModel.getView(), sorts: [{ key: e, dir: t }] };
+    this.setView(n), this.buildFilterSortDraft(e), this.renderFilterSortSidebar();
+  }
+  clearSort() {
+    const t = this.dataModel.getView();
+    if (!t.sorts?.length) return;
+    const e = { ...t, sorts: void 0 };
+    this.setView(e), this.filterSortActiveColumnKey !== null && (this.buildFilterSortDraft(this.filterSortActiveColumnKey), this.renderFilterSortSidebar());
+  }
+  teardownFilterSort() {
+    this.filterSortSidebarUnsub?.(), this.filterSortSidebarUnsub = null, this.filterSortSidebar && (_(this.filterSortSidebar), this.filterSortSidebar = null), this.filterSortKeydown && (document.removeEventListener("keydown", this.filterSortKeydown, !0), this.filterSortKeydown = null), this.filterSortClickCapture && ((this.viewportEl ?? this.root).removeEventListener(
+      "click",
+      this.filterSortClickCapture,
+      !0
+    ), this.filterSortClickCapture = null), this.filterSortOpenEvent && ((this.viewportEl ?? this.root).removeEventListener(
+      "extable:filter-sort-open",
+      this.filterSortOpenEvent
+    ), this.filterSortOpenEvent = null), this.root.classList.toggle("extable-filter-sort-open", !1), this.filterSortActiveColumnKey = null, this.filterSortDraft = null;
+  }
+  initViewportState() {
+    const t = this.getScrollHost();
+    this.viewportState = {
+      scrollTop: t.scrollTop,
+      scrollLeft: t.scrollLeft,
+      clientWidth: t.clientWidth,
+      clientHeight: t.clientHeight,
+      deltaX: 0,
+      deltaY: 0,
+      timestamp: performance.now()
+    };
+  }
+  updateViewportFromRoot() {
+    this.viewportState || this.initViewportState();
+    const t = this.viewportState ?? {
+      scrollTop: 0,
+      scrollLeft: 0,
+      timestamp: performance.now()
+    }, e = this.getScrollHost(), i = {
+      scrollTop: e.scrollTop,
+      scrollLeft: e.scrollLeft,
+      clientWidth: e.clientWidth,
+      clientHeight: e.clientHeight,
+      deltaX: e.scrollLeft - t.scrollLeft,
+      deltaY: e.scrollTop - t.scrollTop,
+      timestamp: performance.now()
+    };
+    this.viewportState = i, this.rafId === null && (this.rafId = requestAnimationFrame(() => this.flushRender()));
+  }
+  flushRender() {
+    this.rafId = null, this.viewportState && (this.selectionManager?.onScroll(this.viewportState.scrollTop, this.viewportState.scrollLeft), !(this.renderer instanceof nt) && this.safeRender(this.viewportState));
+  }
+}
+function Ee(c, t) {
+  return new xe({
+    root: document.createElement("div"),
+    defaultData: c.data,
+    defaultView: c.view,
+    schema: c.schema,
+    options: t
+  });
+}
+function Te(c, t) {
+  return t.remount(c), t;
+}
+export {
+  xe as ExtableCore,
+  le as FindReplaceController,
+  Ee as createTablePlaceholder,
+  Ie as defineSchema,
+  Te as mountTable
+};
+//# sourceMappingURL=index.js.map