@extable/core 0.3.6 → 0.3.8

package/dist/numberIO-DBddtK0s.js

@@ -0,0 +1,1063 @@
+function R() {
+  return typeof crypto < "u" && "randomUUID" in crypto ? crypto.randomUUID() : `row_${Math.random().toString(16).slice(2)}`;
+}
+function q(s) {
+  if (s !== void 0)
+    return Array.isArray(s) ? s : [s];
+}
+function U(s) {
+  if (s)
+    try {
+      s.remove();
+    } catch {
+    }
+}
+const w = (s, t = 2) => s.toString().padStart(t, "0"), D = {
+  yyyy: (s) => w(s.getFullYear(), 4),
+  MM: (s) => w(s.getMonth() + 1),
+  dd: (s) => w(s.getDate()),
+  HH: (s) => w(s.getHours()),
+  hh: (s) => {
+    const t = s.getHours() % 12 || 12;
+    return w(t);
+  },
+  mm: (s) => w(s.getMinutes()),
+  ss: (s) => w(s.getSeconds()),
+  a: (s) => s.getHours() >= 12 ? "PM" : "AM"
+}, M = Object.keys(D).sort((s, t) => t.length - s.length), A = /* @__PURE__ */ new Set(["yyyy", "MM", "dd"]), j = /* @__PURE__ */ new Set(["HH", "hh", "mm", "ss", "a"]), T = /* @__PURE__ */ new Set([...A, ...j]), b = {
+  iso: "yyyy-MM-dd",
+  us: "MM/dd/yyyy",
+  eu: "dd.MM.yyyy"
+}, C = {
+  iso: "HH:mm:ss",
+  "24h": "HH:mm",
+  "12h": "hh:mm a"
+}, S = {
+  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 F(s) {
+  const t = new Date(s);
+  return Number.isNaN(t.getTime()) ? null : t;
+}
+function W(s, t) {
+  let e = "", n = 0, i = !1;
+  for (; n < t.length; ) {
+    const o = t[n];
+    if (o === "'") {
+      i = !i, n += 1;
+      continue;
+    }
+    if (i) {
+      e += o, n += 1;
+      continue;
+    }
+    let r = !1;
+    for (const l of M)
+      if (t.startsWith(l, n)) {
+        e += D[l](s), n += l.length, r = !0;
+        break;
+      }
+    r || (e += o, n += 1);
+  }
+  return e;
+}
+function N(s, t) {
+  return t === "date" ? A.has(s) : t === "time" ? j.has(s) : T.has(s);
+}
+function O(s, t) {
+  let e = 0, n = !1;
+  for (; e < s.length; ) {
+    if (s[e] === "'") {
+      n = !n, e += 1;
+      continue;
+    }
+    if (n) {
+      e += 1;
+      continue;
+    }
+    let o = !1;
+    for (const r of M)
+      if (s.startsWith(r, e)) {
+        if (!N(r, t)) return !1;
+        e += r.length, o = !0;
+        break;
+      }
+    o || (e += 1);
+  }
+  return !0;
+}
+function k(s, t) {
+  if (!s)
+    return t === "date" ? b.iso : t === "time" ? C.iso : S.iso;
+  if (t === "date" && b[s]) return b[s];
+  if (t === "time" && C[s]) return C[s];
+  if (t === "datetime" && S[s]) return S[s];
+  const e = t === "date" ? b.iso : t === "time" ? C.iso : S.iso;
+  return O(s, t) ? s : e;
+}
+const E = (s) => !Number.isNaN(s.getTime()), B = (s) => {
+  if (typeof s == "string") return s;
+  if (s && typeof s == "object") {
+    const t = s;
+    if (t.kind === "enum")
+      return typeof t.value == "string" ? t.value : null;
+  }
+  return null;
+}, H = (s) => {
+  if (Array.isArray(s) && s.every((t) => typeof t == "string")) return s;
+  if (s && typeof s == "object") {
+    const t = s;
+    if (t.kind === "tags") {
+      const e = t.values;
+      return Array.isArray(e) && e.every((n) => typeof n == "string") ? e : null;
+    }
+  }
+  return null;
+};
+function $(s, t) {
+  if (s == null) return null;
+  switch (t.type) {
+    case "string": {
+      if (typeof s != "string") return "Expected a string";
+      const e = t.format;
+      if (e?.maxLength !== void 0 && s.length > e.maxLength)
+        return `Too long (max ${e.maxLength})`;
+      if (e?.regex)
+        try {
+          if (!new RegExp(e.regex).test(s)) return "Does not match pattern";
+        } catch {
+        }
+      return null;
+    }
+    case "number":
+      return typeof s != "number" || !Number.isFinite(s) ? "Expected a number" : t.format?.signed === !1 && s < 0 ? "Expected a non-negative number" : null;
+    case "int":
+      return typeof s != "number" || !Number.isSafeInteger(s) ? "Expected an integer" : null;
+    case "uint":
+      return typeof s != "number" || !Number.isSafeInteger(s) || s < 0 ? "Expected a non-negative integer" : null;
+    case "boolean":
+      return typeof s != "boolean" ? "Expected a boolean" : null;
+    case "enum": {
+      const e = B(s);
+      if (!e) return "Expected an enum value";
+      const n = t.enumAllowCustom ?? !1, i = Array.isArray(t.enum) ? t.enum : [];
+      return !n && i.length && !i.includes(e) ? "Not in allowed options" : null;
+    }
+    case "labeled": {
+      if (!s || typeof s != "object") return "Expected a labeled value";
+      const e = s;
+      if (typeof e.label != "string" || !Object.prototype.hasOwnProperty.call(e, "value"))
+        return "Expected a labeled value";
+      const n = t.enumAllowCustom ?? !1, i = Array.isArray(t.enum) ? t.enum : [];
+      if (!n && i.length) {
+        const o = i.map((l) => typeof l == "object" && l !== null ? String(l.value) : null).filter((l) => l !== null), r = String(e.value ?? "");
+        if (!o.includes(r)) return "Not in allowed options";
+      }
+      return null;
+    }
+    case "tags": {
+      const e = H(s);
+      if (!e) return "Expected a list of tags";
+      const n = t.tagsAllowCustom ?? !1, i = Array.isArray(t.tags) ? t.tags : [];
+      if (!n && i.length) {
+        for (const o of e)
+          if (!i.includes(o)) return "Contains an unknown tag";
+      }
+      return null;
+    }
+    case "date":
+    case "time":
+    case "datetime": {
+      const e = t.format;
+      if (t.type === "date" ? k(e, "date") : t.type === "time" ? k(e, "time") : k(e, "datetime"), s instanceof Date) return E(s) ? null : "Invalid date";
+      if (typeof s == "string") {
+        const n = F(s);
+        return n && E(n) ? null : "Invalid date/time";
+      }
+      return "Expected a date/time string";
+    }
+    default:
+      return null;
+  }
+}
+class X {
+  constructor(t, e, n) {
+    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.columnReadonlyCache = /* @__PURE__ */ new Map(), this.baseValidationErrors = /* @__PURE__ */ new Map(), this.uniqueValidationErrors = /* @__PURE__ */ new Map(), this.notifySuspended = !1, this.notifyDirty = !1, this.validateSchema(e), this.schema = e, this.view = n, 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.columnReadonlyCache.clear(), this.rowConditionalCache.clear(), this.formulaDiagnostics.clear(), this.conditionalDiagnostics.clear(), this.baseValidationErrors.clear(), this.uniqueValidationErrors.clear(), this.rows = (t ?? []).map((e, n) => {
+      const i = e?.id, o = typeof i == "string" && i ? i : R();
+      return this.rowVersion.set(o, 0), {
+        id: o,
+        raw: e,
+        displayIndex: n + 1
+      };
+    }), this.rebuildBaseIndex(), this.recomputeValidationErrors(), this.notify();
+  }
+  setSchema(t) {
+    this.dataVersion += 1, this.validateSchema(t), this.schema = t, this.computedCache.clear(), this.conditionalCache.clear(), this.columnReadonlyCache.clear(), this.rowConditionalCache.clear(), this.formulaDiagnostics.clear(), this.conditionalDiagnostics.clear(), this.recomputeValidationErrors(), this.notify();
+  }
+  validateSchema(t) {
+    if (!(!t || !Array.isArray(t.columns)))
+      for (const e of t.columns) {
+        if (!e || typeof e != "object") continue;
+        const n = e.edit && e.edit.lookup && typeof e.edit.lookup.fetchCandidates == "function";
+        if (e.type === "enum") {
+          const i = Array.isArray(e.enum) ? e.enum : e.enum && typeof e.enum == "object" && Array.isArray(e.enum.options) ? e.enum.options : null, o = i !== null && i.length > 0;
+          if (!o && !n)
+            throw new Error(`Column '${e.key}' of type 'enum' must provide either 'enum' options or 'edit.lookup.fetchCandidates'.`);
+          if (o) {
+            if (i.some((l) => l && typeof l == "object") && String(e.type) !== "labeled")
+              throw new Error(`Column '${e.key}' of type 'enum' may not contain labeled option objects; use type 'labeled' instead.`);
+            if (String(e.type) === "labeled")
+              for (const l of i) {
+                if (!(l && typeof l == "object"))
+                  throw new Error(`Column '${e.key}' labeled options must be objects with 'label' and 'value'.`);
+                const a = l;
+                if (!Object.prototype.hasOwnProperty.call(a, "label") || !Object.prototype.hasOwnProperty.call(a, "value"))
+                  throw new Error(`Column '${e.key}' labeled options must include 'label' and 'value' properties.`);
+              }
+          }
+        }
+        if (e.type === "tags") {
+          const i = Array.isArray(e.tags) ? e.tags : null, o = i !== null && i.length > 0;
+          if (!o && !n)
+            throw new Error(`Column '${e.key}' of type 'tags' must provide either 'tags' options or 'edit.lookup.fetchCandidates'.`);
+          if (o) {
+            for (const r of i)
+              if (typeof r != "string")
+                throw new Error(`Column '${e.key}' tags options must be an array of strings.`);
+          }
+        }
+      }
+  }
+  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 n = this.rows[e];
+    if (n && n.id === t) return { row: n, index: e };
+    const i = this.rows.findIndex((r) => r.id === t);
+    if (i < 0) return null;
+    const o = this.rows[i];
+    return o ? (this.rebuildBaseIndex(), { row: o, index: i }) : 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 n = !1;
+    for (const [i, o] of e)
+      this.view.rowHeights[i] !== o && (this.view.rowHeights[i] = o, n = !0);
+    n && this.notify();
+  }
+  getCell(t, e) {
+    const n = this.findRow(t);
+    if (!n) return;
+    const i = n.row, o = this.pending.get(t);
+    return o && e in o ? o[e] : i.raw[e];
+  }
+  getRawCell(t, e) {
+    const n = this.findRow(t);
+    return n ? n.row.raw[e] : void 0;
+  }
+  isRowReadonly(t) {
+    const e = this.findRow(t);
+    return e ? !!e.row.raw._readonly : !1;
+  }
+  isActionType(t) {
+    return t === "button" || t === "link";
+  }
+  supportsConditionalReadonly(t) {
+    return t === "boolean" || t === "number" || t === "date" || t === "time" || t === "datetime" || t === "string" || t === "enum" || t === "tags";
+  }
+  isColumnReadonly(t) {
+    const e = this.schema.columns.find((n) => n.key === t);
+    return this.isActionType(e?.type) ? !0 : !!(e?.readonly === !0 || e?.formula);
+  }
+  evalReadonlyFn(t, e) {
+    try {
+      const n = t(e);
+      return n instanceof Error ? { value: !1, diagnostic: { level: "warning", message: n.message, source: "conditionalStyle" } } : { value: !!n, diagnostic: null };
+    } catch (n) {
+      return { value: !1, diagnostic: { level: "warning", message: n instanceof Error ? n.message : String(n ?? "error"), source: "conditionalStyle" } };
+    }
+  }
+  resolveColumnReadonly(t, e) {
+    const n = e.readonly;
+    if (!n || typeof n != "function") return { value: !1, diagnostic: null };
+    const i = this.getRowVersion(t), o = `${t}::${String(e.key)}::ro`, r = this.columnReadonlyCache.get(o);
+    if (r && r.version === i && r.fnRef === n)
+      return { value: r.value, diagnostic: r.diagnostic };
+    const l = this.getRowObjectEffective(t);
+    if (!l) {
+      const c = { version: i, fnRef: n, value: !1, diagnostic: null };
+      return this.columnReadonlyCache.set(o, c), { value: !1, diagnostic: null };
+    }
+    const a = this.evalReadonlyFn(n, l);
+    return this.columnReadonlyCache.set(o, { version: i, fnRef: n, value: a.value, diagnostic: a.diagnostic }), { value: a.value, diagnostic: a.diagnostic };
+  }
+  getCellInteraction(t, e) {
+    const n = this.schema.columns.find((h) => String(h.key) === String(e));
+    if (!n) return { readonly: !1, disabled: !1, muted: !1 };
+    const i = this.resolveColumnReadonly(t, n), o = this.isRowReadonly(t) || this.isColumnReadonly(e) || !!i.value, r = this.resolveConditionalStyle(t, n).delta, l = this.getCellStyle(t, e), c = this.supportsConditionalReadonly(n.type) && !!(n.style?.readonly || r?.readonly || l?.readonly), f = this.isActionType(n.type), d = f && !!(n.style?.disabled || r?.disabled || l?.disabled), g = o || c || d, y = !!n.formula;
+    return { readonly: g, disabled: d, muted: d || g && !f && !y };
+  }
+  isReadonly(t, e) {
+    return this.getCellInteraction(t, e).readonly;
+  }
+  setCell(t, e, n, i) {
+    this.dataVersion += 1;
+    const o = this.findRow(t);
+    if (!o) return;
+    const r = o.row, l = () => {
+      const c = this.rowVersion.get(t) ?? 0;
+      this.rowVersion.set(t, c + 1);
+    };
+    if (i)
+      r.raw[e] = n, this.pending.delete(t), l();
+    else {
+      const c = this.getRawCell(t, e), f = this.pending.get(t) ?? {};
+      this.isEqual(c, n) ? delete f[e] : f[e] = n, Object.keys(f).length > 0 ? this.pending.set(t, f) : this.pending.delete(t), l();
+    }
+    this.updateValidationForCell(t, e, this.getCell(t, e)), this.schema.columns.find((c) => c.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 n = this.findRow(t);
+    if (!n) return;
+    const i = n.row, o = /* @__PURE__ */ new Set();
+    for (const [r, l] of Object.entries(e)) {
+      i.raw[r] = l, this.updateValidationForCell(t, r, l);
+      const a = this.schema.columns.find((c) => String(c.key) === String(r));
+      a?.unique && o.add(a.key), this.clearDiagnosticsForCell(t, r);
+    }
+    this.pending.delete(t);
+    for (const r of o) this.recomputeUniqueValidationForColumn(r);
+    this.notify();
+  }
+  clearPending(t) {
+    this.dataVersion += 1, this.pending.delete(t), this.notify();
+  }
+  getPending() {
+    return this.pending;
+  }
+  hasPending(t, e) {
+    const n = this.pending.get(t);
+    return n ? e in n : !1;
+  }
+  insertRow(t) {
+    return this.insertRowAt(t, this.rows.length);
+  }
+  insertRowAt(t, e, n) {
+    this.dataVersion += 1;
+    const i = n ?? R(), o = Math.max(0, Math.min(e, this.rows.length));
+    return this.rows.splice(o, 0, { id: i, raw: t, displayIndex: 0 }), this.reindexRows(), this.rowVersion.set(i, 0), this.rebuildBaseIndex(), this.recomputeValidationErrors(), this.notify(), i;
+  }
+  removeRow(t) {
+    this.dataVersion += 1;
+    const e = this.findRow(t);
+    if (!e) return null;
+    const n = this.rows.splice(e.index, 1)[0];
+    return n ? (this.pending.delete(t), this.rowVersion.delete(t), this.reindexRows(), this.rebuildBaseIndex(), this.recomputeValidationErrors(), this.notify(), { row: n, 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, n = t?.includeSort ?? !0, i = this.view, o = (i.filters ?? []).filter((a) => {
+      if (e === void 0) return !0;
+      const c = a?.key;
+      return String(c) !== String(e);
+    }).map((a) => {
+      if (a?.kind === "values") {
+        const d = a;
+        return {
+          kind: "values",
+          key: String(d.key),
+          includeBlanks: !!d.includeBlanks,
+          values: (d.values ?? []).map((g) => this.stableValueKey(g))
+        };
+      }
+      const f = a;
+      return {
+        kind: "op",
+        key: String(f.key),
+        op: String(f.op ?? ""),
+        value: this.stableValueKey(f.value)
+      };
+    }).sort((a, c) => a.key === c.key ? a.kind < c.kind ? -1 : 1 : a.key < c.key ? -1 : 1), r = Object.entries(i.columnDiagnostics ?? {}).filter(([a]) => e !== void 0 ? String(a) !== String(e) : !0).map(([a, c]) => ({
+      key: String(a),
+      errors: !!c?.errors,
+      warnings: !!c?.warnings
+    })).filter((a) => a.errors || a.warnings).sort((a, c) => a.key < c.key ? -1 : a.key > c.key ? 1 : 0), l = n ? (i.sorts ?? []).slice(0, 1).map((a) => ({ key: String(a.key), dir: a.dir })) : [];
+    return JSON.stringify({ filters: o, columnDiagnosticsEntries: r, sorts: l });
+  }
+  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, n = e.kind;
+      if (n === "enum" && typeof e.value == "string") return `enum:${e.value}`;
+      if (n === "tags" && Array.isArray(e.values))
+        return `tags:${e.values.filter((i) => typeof i == "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((i) => String(i.key) === String(t))?.key ?? t;
+  }
+  getFilterCellValue(t, e) {
+    const n = this.getColumns().find((i) => String(i.key) === String(e));
+    return n ? this.resolveCellValue(t, n).value : this.getCell(t, e);
+  }
+  valuesFilterMatches(t, e) {
+    const n = this.resolveFilterColumnKey(e.key), i = this.getFilterCellValue(t, n);
+    if (this.isBlankValue(i)) return !!e.includeBlanks;
+    if (!e.values || e.values.length === 0) return !1;
+    const o = this.stableValueKey(i);
+    for (const r of e.values)
+      if (this.stableValueKey(r) === o) return !0;
+    return !1;
+  }
+  rowPassesColumnDiagnostics(t, e, n) {
+    const i = !!n.errors, o = !!n.warnings;
+    if (!i && !o) return !0;
+    const r = this.resolveFilterColumnKey(e), l = this.getColumns().find((c) => String(c.key) === String(r));
+    l && (this.resolveCellValue(t, l), this.resolveConditionalStyle(t, l));
+    const a = this.getCellMarker(t, r);
+    return a ? a.level === "error" ? i : o : !1;
+  }
+  computeRowsAfterFilter(t) {
+    const e = t?.excludeColumnKey, n = t?.includeSort ?? !0, i = this.view, o = this.getSchema(), r = (i.filters ?? []).filter((u) => {
+      if (e === void 0) return !0;
+      const h = u?.key;
+      return String(h) !== String(e);
+    }), l = Object.entries(i.columnDiagnostics ?? {}).filter(
+      ([u]) => e !== void 0 ? String(u) !== String(e) : !0
+    ), a = [];
+    for (const u of this.rows) {
+      let h = !0;
+      for (const m of r)
+        if (m?.kind === "values" && !this.valuesFilterMatches(u.id, m)) {
+          h = !1;
+          break;
+        }
+      if (h) {
+        for (const [m, p] of l)
+          if (!this.rowPassesColumnDiagnostics(u.id, m, p)) {
+            h = !1;
+            break;
+          }
+        h && a.push(u);
+      }
+    }
+    if (!n) return a;
+    const c = (i.sorts ?? []).slice(0, 1)[0];
+    if (!c) return a;
+    const f = o.columns.find((u) => String(u.key) === String(c.key));
+    if (!f) return a;
+    const d = c.dir === "desc" ? -1 : 1, g = a.map((u) => {
+      const h = this.getFilterCellValue(u.id, f.key), m = this.isBlankValue(h), p = this.baseIndexById.get(u.id) ?? 0;
+      return { row: u, v: h, blank: m, baseIndex: p };
+    }), y = (u, h) => {
+      if (u === h) return 0;
+      if (u instanceof Date && h instanceof Date) return u.getTime() - h.getTime();
+      if (typeof u == "number" && typeof h == "number") return u - h;
+      if (typeof u == "boolean" && typeof h == "boolean") return u === h ? 0 : u ? 1 : -1;
+      const m = u instanceof Date ? u.toISOString() : typeof u == "string" ? u : String(u), p = h instanceof Date ? h.toISOString() : typeof h == "string" ? h : String(h);
+      return m === p ? 0 : m < p ? -1 : 1;
+    };
+    return g.sort((u, h) => {
+      if (u.blank && h.blank) return u.baseIndex - h.baseIndex;
+      if (u.blank) return 1;
+      if (h.blank) return -1;
+      const m = y(u.v, h.v);
+      return m !== 0 ? m * d : u.baseIndex - h.baseIndex;
+    }), g.map((u) => u.row);
+  }
+  computeVisibleRows() {
+    const t = this.getFilterSortKey(), e = this.visibleRowsCache;
+    if (e && e.version === this.dataVersion && e.key === t) return e;
+    const i = this.computeRowsAfterFilter({ includeSort: !0 }), o = /* @__PURE__ */ new Map();
+    for (let l = 0; l < i.length; l += 1) {
+      const a = i[l];
+      a && o.set(a.id, l);
+    }
+    const r = { version: this.dataVersion, key: t, rows: i, indexById: o };
+    return this.visibleRowsCache = r, r;
+  }
+  getDistinctValuesForColumn(t) {
+    const e = `${String(t)}|${this.getFilterSortKey({ excludeColumnKey: t, includeSort: !1 })}`, n = this.distinctValueCache.get(e);
+    if (n && n.version === this.dataVersion) return n;
+    const i = this.computeRowsAfterFilter({ excludeColumnKey: t, includeSort: !1 }), o = this.getSchema().columns.find((f) => String(f.key) === String(t));
+    if (!o) {
+      const f = { version: this.dataVersion, values: [], hasBlanks: !1, total: 0 };
+      return this.distinctValueCache.set(e, f), f;
+    }
+    const r = /* @__PURE__ */ new Map();
+    let l = !1;
+    for (const f of i) {
+      const d = this.getFilterCellValue(f.id, o.key);
+      if (this.isBlankValue(d)) {
+        l = !0;
+        continue;
+      }
+      const g = this.stableValueKey(d);
+      if (r.has(g)) continue;
+      const y = (() => {
+        if (d instanceof Date) return d.toISOString();
+        if (typeof d == "string") return d;
+        if (typeof d == "number" || typeof d == "boolean") return String(d);
+        if (typeof d == "object" && d) {
+          const u = d, h = u.kind;
+          if (h === "enum" && typeof u.value == "string") return u.value;
+          if (h === "tags" && Array.isArray(u.values))
+            return u.values.filter((m) => typeof m == "string").join(", ");
+        }
+        return String(d);
+      })();
+      r.set(g, { value: d, label: y });
+    }
+    const a = [...r.values()].sort(
+      (f, d) => f.label < d.label ? -1 : f.label > d.label ? 1 : 0
+    ), c = {
+      version: this.dataVersion,
+      values: a,
+      hasBlanks: l,
+      total: a.length + (l ? 1 : 0)
+    };
+    return this.distinctValueCache.set(e, c), c;
+  }
+  cellStyleKey(t, e) {
+    return `${t}::${String(e)}`;
+  }
+  clearDiagnosticsForCell(t, e) {
+    const n = this.cellStyleKey(t, e);
+    this.formulaDiagnostics.delete(n), this.conditionalDiagnostics.delete(n);
+  }
+  getCellDiagnostic(t, e) {
+    const n = this.cellStyleKey(t, e), i = this.formulaDiagnostics.get(n) ?? null, o = this.conditionalDiagnostics.get(n) ?? null;
+    return i ? !o || i.level === "error" ? i : o.level === "error" ? o : i : o;
+  }
+  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 n = e.indexOf("::"), i = n >= 0 ? e.slice(0, n) : e, o = n >= 0 ? e.slice(n + 2) : "";
+      return { rowId: i, colKey: o, diag: this.getCellDiagnostic(i, o) };
+    });
+  }
+  getRowObjectEffective(t) {
+    const e = this.findRow(t);
+    if (!e) return null;
+    const n = e.row, i = this.pending.get(t);
+    if (!i || Object.keys(i).length === 0)
+      return n.raw;
+    const o = { ...n.raw };
+    for (const [r, l] of Object.entries(i))
+      o[r] = l;
+    return o;
+  }
+  resolveCellValue(t, e) {
+    if (!e.formula)
+      return { value: this.getCell(t, e.key), diagnostic: null };
+    const n = this.getRowVersion(t), i = this.cellStyleKey(t, e.key), o = this.computedCache.get(i);
+    if (o && o.version === n && o.formulaRef === e.formula)
+      return o.diagnostic && this.formulaDiagnostics.set(i, o.diagnostic), {
+        value: o.value,
+        textOverride: o.textOverride,
+        diagnostic: o.diagnostic
+      };
+    const r = this.getRowObjectEffective(t);
+    if (!r) {
+      const l = this.getCell(t, e.key), a = {
+        version: n,
+        formulaRef: e.formula,
+        value: l,
+        diagnostic: null
+      };
+      return this.computedCache.set(i, a), { value: l, diagnostic: null };
+    }
+    try {
+      const l = e.formula(r);
+      if (Array.isArray(l) && l.length >= 2 && l[1] instanceof Error) {
+        const c = {
+          level: "warning",
+          message: l[1].message,
+          source: "formula"
+        }, f = l[0];
+        return this.computedCache.set(i, { version: n, formulaRef: e.formula, value: f, diagnostic: c }), this.formulaDiagnostics.set(i, c), { value: f, diagnostic: c };
+      }
+      const a = l;
+      return this.computedCache.set(i, { version: n, formulaRef: e.formula, value: a, diagnostic: null }), this.formulaDiagnostics.delete(i), { value: a, diagnostic: null };
+    } catch (l) {
+      const c = { level: "error", message: l instanceof Error ? l.message : String(l), source: "formula" };
+      return this.computedCache.set(i, {
+        version: n,
+        formulaRef: e.formula,
+        value: null,
+        textOverride: "#ERROR",
+        diagnostic: c
+      }), this.formulaDiagnostics.set(i, c), { value: null, textOverride: "#ERROR", diagnostic: c };
+    }
+  }
+  setCellConditionalStyle(t, e, n) {
+    const i = this.cellStyleKey(t, e);
+    n ? this.cellConditionalStyles.set(i, n) : this.cellConditionalStyles.delete(i), this.conditionalCache.delete(i), this.clearDiagnosticsForCell(t, e), this.notify();
+  }
+  evalConditionalStyleFn(t, e) {
+    try {
+      const n = t(e);
+      return n instanceof Error ? {
+        delta: null,
+        diagnostic: { level: "warning", message: n.message, source: "conditionalStyle" },
+        forceErrorText: !1
+      } : { delta: n ?? null, diagnostic: null, forceErrorText: !1 };
+    } catch (n) {
+      return {
+        delta: null,
+        diagnostic: { level: "error", message: n instanceof Error ? n.message : String(n), source: "conditionalStyle" },
+        forceErrorText: !0
+      };
+    }
+  }
+  resolveRowConditionalStyle(t) {
+    const e = this.getRowConditionalStyleFn();
+    if (!e) return { delta: null, diagnostic: null, forceErrorText: !1 };
+    const n = this.getRowVersion(t), i = this.rowConditionalCache.get(t);
+    if (i && i.version === n && i.fnRef === e)
+      return {
+        delta: i.delta,
+        diagnostic: i.diagnostic,
+        forceErrorText: i.forceErrorText
+      };
+    const o = this.getRowObjectEffective(t);
+    if (!o) {
+      const l = { version: n, fnRef: e, delta: null, diagnostic: null, forceErrorText: !1 };
+      return this.rowConditionalCache.set(t, l), { delta: null, diagnostic: null, forceErrorText: !1 };
+    }
+    const r = this.evalConditionalStyleFn(e, o);
+    return this.rowConditionalCache.set(t, { version: n, fnRef: e, ...r }), r;
+  }
+  resolveConditionalStyle(t, e) {
+    const n = this.getRowVersion(t), i = this.cellStyleKey(t, e.key), o = this.getRowObjectEffective(t), r = this.resolveRowConditionalStyle(t), l = (g, y) => y ? g ? { ...g, ...y } : { ...y } : g;
+    let a = null, c = null, f = !1;
+    if (a = l(a, r.delta), r.diagnostic && (c = r.diagnostic), f = f || r.forceErrorText, e.conditionalStyle && o) {
+      const g = `${t}::${String(e.key)}::col`, y = this.conditionalCache.get(g);
+      if (y && y.version === n && y.fnRef === e.conditionalStyle)
+        a = l(a, y.delta), y.diagnostic && (c === null || c.level !== "error") && (c = y.diagnostic), f = f || y.forceErrorText;
+      else {
+        const u = this.evalConditionalStyleFn(e.conditionalStyle, o);
+        this.conditionalCache.set(g, { version: n, fnRef: e.conditionalStyle, ...u }), a = l(a, u.delta), u.diagnostic && (c === null || c.level !== "error") && (c = u.diagnostic), f = f || u.forceErrorText;
+      }
+    }
+    const d = this.cellConditionalStyles.get(i);
+    if (d && o) {
+      const g = this.conditionalCache.get(i);
+      if (g && g.version === n && g.fnRef === d)
+        a = l(a, g.delta), g.diagnostic && (c === null || c.level !== "error") && (c = g.diagnostic), f = f || g.forceErrorText;
+      else {
+        const y = this.evalConditionalStyleFn(d, o);
+        this.conditionalCache.set(i, { version: n, fnRef: d, ...y }), a = l(a, y.delta), y.diagnostic && (c === null || c.level !== "error") && (c = y.diagnostic), f = f || y.forceErrorText;
+      }
+    }
+    return c ? this.conditionalDiagnostics.set(i, c) : this.conditionalDiagnostics.delete(i), { delta: a, diagnostic: c, forceErrorText: f };
+  }
+  getValidationErrors() {
+    const t = /* @__PURE__ */ new Map();
+    for (const [n, i] of this.baseValidationErrors.entries()) t.set(n, { ...i });
+    for (const [n, i] of this.uniqueValidationErrors.entries()) {
+      const o = t.get(n);
+      o ? t.set(n, { ...o, message: `${o.message}
+${i.message}` }) : t.set(n, { ...i });
+    }
+    const e = [...t.values()];
+    return e.sort((n, i) => {
+      const o = this.getRowIndex(n.rowId), r = this.getRowIndex(i.rowId);
+      if (o !== r) return o - r;
+      const l = this.getColumnIndex(n.colKey), a = this.getColumnIndex(i.colKey);
+      return l - a;
+    }), e;
+  }
+  getCellValidationMessage(t, e) {
+    const n = this.cellStyleKey(t, e), i = this.baseValidationErrors.get(n)?.message ?? null, o = this.uniqueValidationErrors.get(n)?.message ?? null;
+    return i ? o ? `${i}
+${o}` : i : o;
+  }
+  getCellMarker(t, e) {
+    const n = this.getCellDiagnostic(t, e), i = this.getCellValidationMessage(t, e);
+    if (!n && !i) return null;
+    const o = i ? "error" : n?.level ?? "warning", r = [n?.message ?? null, i].filter(Boolean).join(`
+`);
+    return { level: o, message: r };
+  }
+  updateValidationForCell(t, e, n) {
+    const i = this.schema.columns.find((l) => String(l.key) === String(e));
+    if (!i) return;
+    const o = $(n, i), r = this.cellStyleKey(t, e);
+    o ? this.baseValidationErrors.set(r, { rowId: t, colKey: e, message: o }) : this.baseValidationErrors.delete(r);
+  }
+  recomputeValidationErrors() {
+    this.baseValidationErrors.clear(), this.uniqueValidationErrors.clear();
+    for (const t of this.rows)
+      for (const e of this.schema.columns) {
+        const n = this.getCell(t.id, e.key);
+        this.updateValidationForCell(t.id, e.key, n);
+      }
+    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, n = e.kind;
+      if (n === "enum" && typeof e.value == "string")
+        return e.value === "" ? null : e.value;
+      if (n === "tags" && Array.isArray(e.values)) {
+        const i = e.values.filter((o) => typeof o == "string").join(",");
+        return i === "" ? null : i;
+      }
+    }
+    return String(t);
+  }
+  recomputeUniqueValidationForColumn(t) {
+    const e = String(t);
+    if (this.schema.columns.find((o) => String(o.key) === e)?.type === "boolean") return;
+    for (const o of Array.from(this.uniqueValidationErrors.keys())) {
+      const r = o.indexOf("::");
+      (r >= 0 ? o.slice(r + 2) : "") === e && this.uniqueValidationErrors.delete(o);
+    }
+    const i = /* @__PURE__ */ new Map();
+    for (const o of this.rows) {
+      const r = this.getCell(o.id, t), l = this.normalizeUniqueValue(r);
+      if (!l) continue;
+      const a = i.get(l) ?? [];
+      a.push(o.id), i.set(l, a);
+    }
+    for (const o of i.values()) {
+      if (o.length < 2) continue;
+      const r = o.map((a) => this.getDisplayIndex(a)).filter((a) => typeof a == "number" && Number.isFinite(a)).sort((a, c) => a - c), l = r.length ? r.join(", ") : o.join(", ");
+      for (const a of o) {
+        const c = this.cellStyleKey(a, t);
+        this.uniqueValidationErrors.set(c, {
+          rowId: a,
+          colKey: t,
+          message: `Duplicate value
+Rows: ${l}`
+        });
+      }
+    }
+  }
+  getCellStyle(t, e) {
+    return this.cellStyles.get(this.cellStyleKey(t, e)) ?? null;
+  }
+  setCellStyle(t, e, n) {
+    const i = this.cellStyleKey(t, e);
+    !n || Object.keys(n).length === 0 ? this.cellStyles.delete(i) : this.cellStyles.set(i, n), this.notify();
+  }
+  updateColumnStyle(t, e) {
+    const n = this.schema.columns.find((o) => String(o.key) === String(t));
+    if (!n) return;
+    const i = typeof e == "function" ? e(n.style) : e;
+    n.style = i, 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;
+  }
+}
+const x = 864e5;
+function v(s) {
+  const t = F(s);
+  return t ? Number.isNaN(t.getTime()) ? null : t : null;
+}
+function I(s) {
+  const t = /* @__PURE__ */ new Date(`1970-01-01T${s}`);
+  return Number.isNaN(t.getTime()) ? null : t;
+}
+function G(s, t, e) {
+  if (t == null) return null;
+  if (typeof t == "object") {
+    const n = t;
+    if (n.kind === "lookup" && typeof n.value == "string")
+      return n.value;
+    if (typeof n.label == "string" && "value" in n && e.type === "labeled") {
+      const i = n.value;
+      return i == null ? null : typeof i == "string" ? i : typeof i == "number" || typeof i == "boolean" ? String(i) : i instanceof Date ? i.toISOString() : String(i);
+    }
+  }
+  if (e.type === "string" || e.type === "labeled") return null;
+  if (e.type === "boolean") return String(!!t);
+  if ((e.type === "number" || e.type === "int" || e.type === "uint") && typeof t == "number")
+    return String(t);
+  if (e.type === "datetime") {
+    const n = t instanceof Date ? t : v(String(t));
+    return n ? String(n.getTime()) : null;
+  }
+  if (e.type === "date") {
+    const n = t instanceof Date ? t : v(String(t));
+    if (!n) return null;
+    const i = Math.floor(n.getTime() / x) * x;
+    return String(i);
+  }
+  if (e.type === "time") {
+    const n = t instanceof Date ? t : I(String(t));
+    return n ? String(n.getTime() % x) : null;
+  }
+  return null;
+}
+const z = 35, Z = 48, J = 35, P = 80, Y = 6, Q = 8, tt = 4, et = 4;
+function nt(s, t, e = 100) {
+  const n = {
+    // Reserve extra space for browser UI affordances (e.g. date picker icon) and formatting.
+    date: 8
+  };
+  return s.columns.map((i) => {
+    const o = t.columnWidths?.[String(i.key)] ?? i.width ?? e, r = n[i.type] ?? 0;
+    return o + r;
+  });
+}
+function it(s, t, e = P) {
+  const n = Math.max(1, e - t);
+  return Math.max(n, s);
+}
+function _(s) {
+  const t = s.style, e = t?.decorations;
+  return {
+    backgroundColor: t?.backgroundColor,
+    textColor: t?.textColor,
+    bold: e?.bold,
+    italic: e?.italic,
+    underline: e?.underline,
+    strike: e?.strike,
+    readonly: t?.readonly,
+    disabled: t?.disabled
+  };
+}
+function V(s, t) {
+  return t ? {
+    backgroundColor: t.backgroundColor ?? s.backgroundColor,
+    textColor: t.textColor ?? s.textColor,
+    bold: t.bold ?? s.bold,
+    italic: t.italic ?? s.italic,
+    underline: t.underline ?? s.underline,
+    strike: t.strike ?? s.strike,
+    readonly: t.readonly ?? s.readonly,
+    disabled: t.disabled ?? s.disabled
+  } : s;
+}
+function st(s, t, e) {
+  const n = _(e), i = s.resolveConditionalStyle(t, e).delta ?? {}, o = s.getCellStyle(t, e.key) ?? {}, r = V(V(n, i), o);
+  return { columnStyle: n, cellStyle: o, resolved: r };
+}
+function ot(s) {
+  let t = "";
+  s.backgroundColor && (t += `background-color:${s.backgroundColor};`), s.textColor && (t += `color:${s.textColor};`), s.bold && (t += "font-weight:600;"), s.italic && (t += "font-style:italic;");
+  const e = [];
+  return s.underline && e.push("underline"), s.strike && e.push("line-through"), e.length && (t += `text-decoration-line:${e.join(" ")};`), t;
+}
+function rt(s) {
+  if (typeof s == "string") return { label: s };
+  if (!s || typeof s != "object") return null;
+  const t = s, e = t.label, n = t.command, i = t.commandfor;
+  return typeof e != "string" ? null : typeof n == "string" && typeof i == "string" ? { label: e, command: n, commandfor: i } : null;
+}
+function lt(s) {
+  if (typeof s == "string") return s;
+  if (!s || typeof s != "object") return "";
+  const t = s.label;
+  return typeof t == "string" ? t : "";
+}
+function at(s) {
+  if (typeof s == "string") return { label: s, href: s };
+  if (!s || typeof s != "object") return null;
+  const t = s, e = t.label, n = t.href, i = t.target;
+  return typeof e != "string" || typeof n != "string" ? null : typeof i == "string" ? { label: e, href: n, target: i } : i === void 0 ? { label: e, href: n } : null;
+}
+function ct(s) {
+  if (typeof s == "string") return s;
+  if (!s || typeof s != "object") return "";
+  const t = s, e = t.label, n = t.href;
+  return typeof e == "string" ? e : typeof n == "string" ? n : "";
+}
+function K(s) {
+  return s.normalize("NFKC").trim();
+}
+const L = (s) => {
+  const t = s.trim(), e = /^([+-]?)(0[bBoOxX])([0-9a-fA-F]+)$/.exec(t);
+  if (!e) return null;
+  const n = e[1] === "-" ? -1 : 1, i = e[2].toLowerCase(), o = e[3] ?? "";
+  let r = 10, l = /^[0-9]+$/;
+  if (i === "0b" ? (r = 2, l = /^[01]+$/) : i === "0o" ? (r = 8, l = /^[0-7]+$/) : i === "0x" && (r = 16, l = /^[0-9a-fA-F]+$/), !o || !l.test(o)) return NaN;
+  const a = Number.parseInt(o, r);
+  return n * a;
+};
+function ut(s) {
+  const t = K(s);
+  if (t === "") return { ok: !1, reason: "empty" };
+  const e = L(t);
+  if (e !== null)
+    return Number.isFinite(e) ? { ok: !0, value: e } : { ok: !1, reason: "invalid" };
+  const n = Number(t);
+  return Number.isFinite(n) ? { ok: !0, value: n } : { ok: !1, reason: Number.isNaN(n) ? "invalid" : "non-finite" };
+}
+function ft(s, t) {
+  return Number.isFinite(s) ? t === "number" ? { ok: !0, value: s } : Number.isSafeInteger(s) ? t === "uint" && s < 0 ? { ok: !1, reason: "out-of-range" } : { ok: !0, value: s } : { ok: !1, reason: "not-integer" } : { ok: !1, reason: "non-finite" };
+}
+function dt(s, t) {
+  const e = s < 0 ? "-" : "", n = Math.abs(s), i = t === "binary" ? n.toString(2) : t === "octal" ? n.toString(8) : n.toString(16);
+  return `${e}${t === "binary" ? "0b" : t === "octal" ? "0o" : "0x"}${i}`;
+}
+function ht(s, t) {
+  if (!Number.isFinite(s)) return "";
+  if ((t?.format ?? "decimal") === "scientific") {
+    const i = t?.precision;
+    return i !== void 0 && Number.isFinite(i) && i > 0 ? s.toExponential(Math.max(0, Math.floor(i) - 1)) : s.toExponential();
+  }
+  const n = t?.scale;
+  if (n !== void 0 && Number.isFinite(n)) {
+    const i = Math.max(0, Math.floor(n));
+    return s.toFixed(i);
+  }
+  return String(s);
+}
+export {
+  tt as C,
+  J as D,
+  z as H,
+  Z as R,
+  rt as a,
+  at as b,
+  _ as c,
+  lt as d,
+  ct as e,
+  et as f,
+  nt as g,
+  ht as h,
+  dt as i,
+  k as j,
+  W as k,
+  Q as l,
+  V as m,
+  Y as n,
+  ut as o,
+  F as p,
+  ft as q,
+  U as r,
+  ot as s,
+  G as t,
+  K as u,
+  it as v,
+  X as w,
+  q as x,
+  st as y
+};
+//# sourceMappingURL=numberIO-DBddtK0s.js.map