@extable/core 0.3.7 → 0.3.8

package/dist/numberIO-CTEeBhef.js

@@ -0,0 +1,1046 @@
+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"]), F = /* @__PURE__ */ new Set(["HH", "hh", "mm", "ss", "a"]), j = /* @__PURE__ */ new Set([...A, ...F]), 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 T(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 r = t[n];
+    if (r === "'") {
+      i = !i, n += 1;
+      continue;
+    }
+    if (i) {
+      e += r, n += 1;
+      continue;
+    }
+    let o = !1;
+    for (const a of M)
+      if (t.startsWith(a, n)) {
+        e += D[a](s), n += a.length, o = !0;
+        break;
+      }
+    o || (e += r, n += 1);
+  }
+  return e;
+}
+function N(s, t) {
+  return t === "date" ? A.has(s) : t === "time" ? F.has(s) : j.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 r = !1;
+    for (const o of M)
+      if (s.startsWith(o, e)) {
+        if (!N(o, t)) return !1;
+        e += o.length, r = !0;
+        break;
+      }
+    r || (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, r = (Array.isArray(t.enum) ? t.enum : []).map((o) => typeof o == "string" ? o : o && typeof o == "object" && "value" in o ? String(o.value) : String(o.label ?? o));
+      return !n && r.length && !r.includes(e) ? "Not in allowed options" : 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 r of e)
+          if (!i.includes(r)) 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 = T(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, r = typeof i == "string" && i ? i : R();
+      return this.rowVersion.set(r, 0), {
+        id: r,
+        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, r = i !== null && i.length > 0;
+          if (!r && !n)
+            throw new Error(`Column '${e.key}' of type 'enum' must provide either 'enum' options or 'edit.lookup.fetchCandidates'.`);
+          if (r && i.some((a) => a && typeof a == "object"))
+            for (const a of i) {
+              if (!(a && typeof a == "object")) continue;
+              const l = a;
+              if (!Object.prototype.hasOwnProperty.call(l, "label") || !Object.prototype.hasOwnProperty.call(l, "value"))
+                throw new Error(`Column '${e.key}' enum options must be all strings or objects with 'label' and 'value' properties.`);
+            }
+        }
+        if (e.type === "tags") {
+          const i = Array.isArray(e.tags) ? e.tags : e.tags && typeof e.tags == "object" && Array.isArray(e.tags.options) ? e.tags.options : null, r = i !== null && i.length > 0;
+          if (!r && !n)
+            throw new Error(`Column '${e.key}' of type 'tags' must provide either 'tags' options or 'edit.lookup.fetchCandidates'.`);
+          if (r) {
+            for (const o of i)
+              if (typeof o != "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((o) => o.id === t);
+    if (i < 0) return null;
+    const r = this.rows[i];
+    return r ? (this.rebuildBaseIndex(), { row: r, 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, r] of e)
+      this.view.rowHeights[i] !== r && (this.view.rowHeights[i] = r, n = !0);
+    n && this.notify();
+  }
+  getCell(t, e) {
+    const n = this.findRow(t);
+    if (!n) return;
+    const i = n.row, r = this.pending.get(t);
+    return r && e in r ? r[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), r = `${t}::${String(e.key)}::ro`, o = this.columnReadonlyCache.get(r);
+    if (o && o.version === i && o.fnRef === n)
+      return { value: o.value, diagnostic: o.diagnostic };
+    const a = this.getRowObjectEffective(t);
+    if (!a) {
+      const c = { version: i, fnRef: n, value: !1, diagnostic: null };
+      return this.columnReadonlyCache.set(r, c), { value: !1, diagnostic: null };
+    }
+    const l = this.evalReadonlyFn(n, a);
+    return this.columnReadonlyCache.set(r, { version: i, fnRef: n, value: l.value, diagnostic: l.diagnostic }), { value: l.value, diagnostic: l.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), r = this.isRowReadonly(t) || this.isColumnReadonly(e) || !!i.value, o = this.resolveConditionalStyle(t, n).delta, a = this.getCellStyle(t, e), c = this.supportsConditionalReadonly(n.type) && !!(n.style?.readonly || o?.readonly || a?.readonly), f = this.isActionType(n.type), d = f && !!(n.style?.disabled || o?.disabled || a?.disabled), g = r || 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 r = this.findRow(t);
+    if (!r) return;
+    const o = r.row, a = () => {
+      const c = this.rowVersion.get(t) ?? 0;
+      this.rowVersion.set(t, c + 1);
+    };
+    if (i)
+      o.raw[e] = n, this.pending.delete(t), a();
+    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), a();
+    }
+    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, r = /* @__PURE__ */ new Set();
+    for (const [o, a] of Object.entries(e)) {
+      i.raw[o] = a, this.updateValidationForCell(t, o, a);
+      const l = this.schema.columns.find((c) => String(c.key) === String(o));
+      l?.unique && r.add(l.key), this.clearDiagnosticsForCell(t, o);
+    }
+    this.pending.delete(t);
+    for (const o of r) this.recomputeUniqueValidationForColumn(o);
+    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(), r = Math.max(0, Math.min(e, this.rows.length));
+    return this.rows.splice(r, 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, r = (i.filters ?? []).filter((l) => {
+      if (e === void 0) return !0;
+      const c = l?.key;
+      return String(c) !== String(e);
+    }).map((l) => {
+      if (l?.kind === "values") {
+        const d = l;
+        return {
+          kind: "values",
+          key: String(d.key),
+          includeBlanks: !!d.includeBlanks,
+          values: (d.values ?? []).map((g) => this.stableValueKey(g))
+        };
+      }
+      const f = l;
+      return {
+        kind: "op",
+        key: String(f.key),
+        op: String(f.op ?? ""),
+        value: this.stableValueKey(f.value)
+      };
+    }).sort((l, c) => l.key === c.key ? l.kind < c.kind ? -1 : 1 : l.key < c.key ? -1 : 1), o = Object.entries(i.columnDiagnostics ?? {}).filter(([l]) => e !== void 0 ? String(l) !== String(e) : !0).map(([l, c]) => ({
+      key: String(l),
+      errors: !!c?.errors,
+      warnings: !!c?.warnings
+    })).filter((l) => l.errors || l.warnings).sort((l, c) => l.key < c.key ? -1 : l.key > c.key ? 1 : 0), a = n ? (i.sorts ?? []).slice(0, 1).map((l) => ({ key: String(l.key), dir: l.dir })) : [];
+    return JSON.stringify({ filters: r, columnDiagnosticsEntries: o, sorts: a });
+  }
+  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 r = this.stableValueKey(i);
+    for (const o of e.values)
+      if (this.stableValueKey(o) === r) return !0;
+    return !1;
+  }
+  rowPassesColumnDiagnostics(t, e, n) {
+    const i = !!n.errors, r = !!n.warnings;
+    if (!i && !r) return !0;
+    const o = this.resolveFilterColumnKey(e), a = this.getColumns().find((c) => String(c.key) === String(o));
+    a && (this.resolveCellValue(t, a), this.resolveConditionalStyle(t, a));
+    const l = this.getCellMarker(t, o);
+    return l ? l.level === "error" ? i : r : !1;
+  }
+  computeRowsAfterFilter(t) {
+    const e = t?.excludeColumnKey, n = t?.includeSort ?? !0, i = this.view, r = this.getSchema(), o = (i.filters ?? []).filter((u) => {
+      if (e === void 0) return !0;
+      const h = u?.key;
+      return String(h) !== String(e);
+    }), a = Object.entries(i.columnDiagnostics ?? {}).filter(
+      ([u]) => e !== void 0 ? String(u) !== String(e) : !0
+    ), l = [];
+    for (const u of this.rows) {
+      let h = !0;
+      for (const m of o)
+        if (m?.kind === "values" && !this.valuesFilterMatches(u.id, m)) {
+          h = !1;
+          break;
+        }
+      if (h) {
+        for (const [m, p] of a)
+          if (!this.rowPassesColumnDiagnostics(u.id, m, p)) {
+            h = !1;
+            break;
+          }
+        h && l.push(u);
+      }
+    }
+    if (!n) return l;
+    const c = (i.sorts ?? []).slice(0, 1)[0];
+    if (!c) return l;
+    const f = r.columns.find((u) => String(u.key) === String(c.key));
+    if (!f) return l;
+    const d = c.dir === "desc" ? -1 : 1, g = l.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 }), r = /* @__PURE__ */ new Map();
+    for (let a = 0; a < i.length; a += 1) {
+      const l = i[a];
+      l && r.set(l.id, a);
+    }
+    const o = { version: this.dataVersion, key: t, rows: i, indexById: r };
+    return this.visibleRowsCache = o, o;
+  }
+  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 }), r = this.getSchema().columns.find((f) => String(f.key) === String(t));
+    if (!r) {
+      const f = { version: this.dataVersion, values: [], hasBlanks: !1, total: 0 };
+      return this.distinctValueCache.set(e, f), f;
+    }
+    const o = /* @__PURE__ */ new Map();
+    let a = !1;
+    for (const f of i) {
+      const d = this.getFilterCellValue(f.id, r.key);
+      if (this.isBlankValue(d)) {
+        a = !0;
+        continue;
+      }
+      const g = this.stableValueKey(d);
+      if (o.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);
+      })();
+      o.set(g, { value: d, label: y });
+    }
+    const l = [...o.values()].sort(
+      (f, d) => f.label < d.label ? -1 : f.label > d.label ? 1 : 0
+    ), c = {
+      version: this.dataVersion,
+      values: l,
+      hasBlanks: a,
+      total: l.length + (a ? 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, r = this.conditionalDiagnostics.get(n) ?? null;
+    return i ? !r || i.level === "error" ? i : r.level === "error" ? r : i : r;
+  }
+  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, r = n >= 0 ? e.slice(n + 2) : "";
+      return { rowId: i, colKey: r, diag: this.getCellDiagnostic(i, r) };
+    });
+  }
+  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 r = { ...n.raw };
+    for (const [o, a] of Object.entries(i))
+      r[o] = a;
+    return r;
+  }
+  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), r = this.computedCache.get(i);
+    if (r && r.version === n && r.formulaRef === e.formula)
+      return r.diagnostic && this.formulaDiagnostics.set(i, r.diagnostic), {
+        value: r.value,
+        textOverride: r.textOverride,
+        diagnostic: r.diagnostic
+      };
+    const o = this.getRowObjectEffective(t);
+    if (!o) {
+      const a = this.getCell(t, e.key), l = {
+        version: n,
+        formulaRef: e.formula,
+        value: a,
+        diagnostic: null
+      };
+      return this.computedCache.set(i, l), { value: a, diagnostic: null };
+    }
+    try {
+      const a = e.formula(o);
+      if (Array.isArray(a) && a.length >= 2 && a[1] instanceof Error) {
+        const c = {
+          level: "warning",
+          message: a[1].message,
+          source: "formula"
+        }, f = a[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 l = a;
+      return this.computedCache.set(i, { version: n, formulaRef: e.formula, value: l, diagnostic: null }), this.formulaDiagnostics.delete(i), { value: l, diagnostic: null };
+    } catch (a) {
+      const c = { level: "error", message: a instanceof Error ? a.message : String(a), 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 r = this.getRowObjectEffective(t);
+    if (!r) {
+      const a = { version: n, fnRef: e, delta: null, diagnostic: null, forceErrorText: !1 };
+      return this.rowConditionalCache.set(t, a), { delta: null, diagnostic: null, forceErrorText: !1 };
+    }
+    const o = this.evalConditionalStyleFn(e, r);
+    return this.rowConditionalCache.set(t, { version: n, fnRef: e, ...o }), o;
+  }
+  resolveConditionalStyle(t, e) {
+    const n = this.getRowVersion(t), i = this.cellStyleKey(t, e.key), r = this.getRowObjectEffective(t), o = this.resolveRowConditionalStyle(t), a = (g, y) => y ? g ? { ...g, ...y } : { ...y } : g;
+    let l = null, c = null, f = !1;
+    if (l = a(l, o.delta), o.diagnostic && (c = o.diagnostic), f = f || o.forceErrorText, e.conditionalStyle && r) {
+      const g = `${t}::${String(e.key)}::col`, y = this.conditionalCache.get(g);
+      if (y && y.version === n && y.fnRef === e.conditionalStyle)
+        l = a(l, y.delta), y.diagnostic && (c === null || c.level !== "error") && (c = y.diagnostic), f = f || y.forceErrorText;
+      else {
+        const u = this.evalConditionalStyleFn(e.conditionalStyle, r);
+        this.conditionalCache.set(g, { version: n, fnRef: e.conditionalStyle, ...u }), l = a(l, u.delta), u.diagnostic && (c === null || c.level !== "error") && (c = u.diagnostic), f = f || u.forceErrorText;
+      }
+    }
+    const d = this.cellConditionalStyles.get(i);
+    if (d && r) {
+      const g = this.conditionalCache.get(i);
+      if (g && g.version === n && g.fnRef === d)
+        l = a(l, g.delta), g.diagnostic && (c === null || c.level !== "error") && (c = g.diagnostic), f = f || g.forceErrorText;
+      else {
+        const y = this.evalConditionalStyleFn(d, r);
+        this.conditionalCache.set(i, { version: n, fnRef: d, ...y }), l = a(l, 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: l, 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 r = t.get(n);
+      r ? t.set(n, { ...r, message: `${r.message}
+${i.message}` }) : t.set(n, { ...i });
+    }
+    const e = [...t.values()];
+    return e.sort((n, i) => {
+      const r = this.getRowIndex(n.rowId), o = this.getRowIndex(i.rowId);
+      if (r !== o) return r - o;
+      const a = this.getColumnIndex(n.colKey), l = this.getColumnIndex(i.colKey);
+      return a - l;
+    }), e;
+  }
+  getCellValidationMessage(t, e) {
+    const n = this.cellStyleKey(t, e), i = this.baseValidationErrors.get(n)?.message ?? null, r = this.uniqueValidationErrors.get(n)?.message ?? null;
+    return i ? r ? `${i}
+${r}` : i : r;
+  }
+  getCellMarker(t, e) {
+    const n = this.getCellDiagnostic(t, e), i = this.getCellValidationMessage(t, e);
+    if (!n && !i) return null;
+    const r = i ? "error" : n?.level ?? "warning", o = [n?.message ?? null, i].filter(Boolean).join(`
+`);
+    return { level: r, message: o };
+  }
+  updateValidationForCell(t, e, n) {
+    const i = this.schema.columns.find((a) => String(a.key) === String(e));
+    if (!i) return;
+    const r = $(n, i), o = this.cellStyleKey(t, e);
+    r ? this.baseValidationErrors.set(o, { rowId: t, colKey: e, message: r }) : 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 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((r) => typeof r == "string").join(",");
+        return i === "" ? null : i;
+      }
+    }
+    return String(t);
+  }
+  recomputeUniqueValidationForColumn(t) {
+    const e = String(t);
+    if (this.schema.columns.find((r) => String(r.key) === e)?.type === "boolean") return;
+    for (const r of Array.from(this.uniqueValidationErrors.keys())) {
+      const o = r.indexOf("::");
+      (o >= 0 ? r.slice(o + 2) : "") === e && this.uniqueValidationErrors.delete(r);
+    }
+    const i = /* @__PURE__ */ new Map();
+    for (const r of this.rows) {
+      const o = this.getCell(r.id, t), a = this.normalizeUniqueValue(o);
+      if (!a) continue;
+      const l = i.get(a) ?? [];
+      l.push(r.id), i.set(a, l);
+    }
+    for (const r of i.values()) {
+      if (r.length < 2) continue;
+      const o = r.map((l) => this.getDisplayIndex(l)).filter((l) => typeof l == "number" && Number.isFinite(l)).sort((l, c) => l - c), a = o.length ? o.join(", ") : r.join(", ");
+      for (const l of r) {
+        const c = this.cellStyleKey(l, t);
+        this.uniqueValidationErrors.set(c, {
+          rowId: l,
+          colKey: t,
+          message: `Duplicate value
+Rows: ${a}`
+        });
+      }
+    }
+  }
+  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((r) => String(r.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 = T(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, _ = 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 r = t.columnWidths?.[String(i.key)] ?? i.width ?? e, o = n[i.type] ?? 0;
+    return r + o;
+  });
+}
+function it(s, t, e = _) {
+  const n = Math.max(1, e - t);
+  return Math.max(n, s);
+}
+function K(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 = K(e), i = s.resolveConditionalStyle(t, e).delta ?? {}, r = s.getCellStyle(t, e.key) ?? {}, o = V(V(n, i), r);
+  return { columnStyle: n, cellStyle: r, resolved: o };
+}
+function rt(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 ot(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 P(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(), r = e[3] ?? "";
+  let o = 10, a = /^[0-9]+$/;
+  if (i === "0b" ? (o = 2, a = /^[01]+$/) : i === "0o" ? (o = 8, a = /^[0-7]+$/) : i === "0x" && (o = 16, a = /^[0-9a-fA-F]+$/), !r || !a.test(r)) return NaN;
+  const l = Number.parseInt(r, o);
+  return n * l;
+};
+function ut(s) {
+  const t = P(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,
+  ot as a,
+  at as b,
+  K 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,
+  T as p,
+  ft as q,
+  U as r,
+  rt as s,
+  G as t,
+  P as u,
+  it as v,
+  X as w,
+  q as x,
+  st as y
+};
+//# sourceMappingURL=numberIO-CTEeBhef.js.map