@particle-academy/holy-sheet 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3247 @@
+'use strict';
+
+// src/util.ts
+function isNumericString(v) {
+  if (typeof v === "number") return Number.isFinite(v);
+  if (typeof v !== "string") return false;
+  return /^\s*[+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/.test(v);
+}
+function numericStringToNumber(v) {
+  return v.includes(".") ? parseFloat(v) : parseInt(v, 10);
+}
+function formatFloat(v) {
+  let s = v.toFixed(14);
+  s = s.replace(/0+$/, "").replace(/\.$/, "");
+  return s === "" || s === "-0" ? "0" : s;
+}
+function typeOf(value) {
+  if (value === null || value === void 0) return "null";
+  if (Array.isArray(value)) return "array";
+  switch (typeof value) {
+    case "object":
+      return "object";
+    case "boolean":
+      return "bool";
+    case "number":
+      return Number.isInteger(value) ? "int" : "float";
+    case "string":
+      return "string";
+    default:
+      return typeof value;
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/schema/inference.ts
+var SAMPLE_SIZE = 50;
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+var ISO_DATETIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:?\d{2})?$/;
+var HEADER_INTEGER = /(^|[\s_])(count|qty|quantity|num|number|id|n)([\s_]|$)/i;
+var HEADER_CURRENCY = /(price|amount|cost|revenue|fee|total|salary|budget|balance)/i;
+var HEADER_PERCENT = /(rate|percent|growth|yoy|margin|share|ratio)/i;
+var Inference = {
+  detect(columnValues, headerName, options = {}) {
+    const sample = nonNullSample(columnValues);
+    if (sample.length === 0) return { header: headerName, type: "auto" };
+    if (allBoolean(sample)) return { header: headerName, type: "boolean" };
+    const allNum = allNumeric(sample);
+    const allInRange = allNum && allInRange01(sample);
+    const allInt = allNum && allInteger(sample);
+    const allDate = allMatch(sample, ISO_DATE);
+    const allDateTime = allMatch(sample, ISO_DATETIME);
+    if (allDate) return { header: headerName, type: "date" };
+    if (allDateTime) return { header: headerName, type: "datetime" };
+    if (allNum) {
+      if (HEADER_PERCENT.test(headerName) && allInRange) {
+        return { header: headerName, type: "percent", decimals: detectDecimals(sample) || 1 };
+      }
+      if (HEADER_CURRENCY.test(headerName)) {
+        return {
+          header: headerName,
+          type: "currency",
+          currency: options.currency ?? "USD",
+          decimals: detectDecimals(sample) ?? void 0
+        };
+      }
+      if (HEADER_INTEGER.test(headerName) && allInt) {
+        return { header: headerName, type: "integer" };
+      }
+      if (allInt) return { header: headerName, type: "integer" };
+      const col = { header: headerName, type: "number" };
+      const decimals = detectDecimals(sample);
+      if (decimals !== null && decimals > 0) col.decimals = decimals;
+      return col;
+    }
+    if (allStringish(sample)) return { header: headerName, type: "string" };
+    return { header: headerName, type: "auto" };
+  }
+};
+function nonNullSample(values) {
+  const out = [];
+  for (const v of values) {
+    if (v === null || v === void 0) continue;
+    out.push(v);
+    if (out.length >= SAMPLE_SIZE) break;
+  }
+  return out;
+}
+function allBoolean(sample) {
+  return sample.every((v) => typeof v === "boolean");
+}
+function allNumeric(sample) {
+  return sample.every((v) => {
+    if (typeof v === "boolean") return false;
+    if (typeof v === "number") return Number.isFinite(v);
+    return typeof v === "string" && isNumericString(v);
+  });
+}
+function allInteger(sample) {
+  return sample.every((v) => {
+    if (typeof v === "number") return Number.isInteger(v);
+    return typeof v === "string" && /^-?\d+$/.test(v);
+  });
+}
+function allInRange01(sample) {
+  return sample.every((v) => {
+    const f = Number(v);
+    return f >= 0 && f <= 1;
+  });
+}
+function detectDecimals(sample) {
+  let max = 0;
+  let sawFloat = false;
+  for (const v of sample) {
+    const s = typeof v === "string" ? v : String(v);
+    if (s.includes(".")) {
+      sawFloat = true;
+      const frac = (s.split(".", 2)[1] ?? "").replace(/0+$/, "");
+      if (frac.length > max) max = frac.length;
+    }
+  }
+  if (!sawFloat) return 0;
+  return Math.max(max, 2);
+}
+function allMatch(sample, regex) {
+  return sample.every((v) => typeof v === "string" && regex.test(v));
+}
+function allStringish(sample) {
+  return sample.every((v) => typeof v === "string");
+}
+
+// src/helpers/array-builder.ts
+var ArrayBuilder = {
+  build(rows, headers = null, sheetName = "Sheet 1", options = {}) {
+    let hdrs = headers;
+    let data = rows;
+    if (hdrs === null) {
+      if (rows.length === 0) return wrap([], [], sheetName, options);
+      hdrs = (rows[0] ?? []).map((v) => String(v));
+      data = rows.slice(1);
+    }
+    const columns = inferColumns(data, hdrs, options);
+    return wrap(columns, data, sheetName, options);
+  }
+};
+function inferColumns(rows, headers, options) {
+  return headers.map((headerName, i) => {
+    const columnValues = rows.map((row) => row[i] ?? null);
+    return Inference.detect(columnValues, String(headerName), options);
+  });
+}
+function wrap(columns, rows, sheetName, options) {
+  const sheet = { name: sheetName, columns, rows };
+  if (options.theme !== void 0) sheet.theme = options.theme;
+  if (options.totals && typeof options.totals === "object") sheet.totals = options.totals;
+  if (options.frozenRows !== void 0) sheet.frozenRows = Math.trunc(Number(options.frozenRows));
+  if (options.frozenCols !== void 0) sheet.frozenCols = Math.trunc(Number(options.frozenCols));
+  return { sheets: [sheet] };
+}
+
+// src/helpers/csv-builder.ts
+var CsvBuilder = {
+  build(csv, options = {}) {
+    const delimiter = options.delimiter ?? ",";
+    const enclosure = options.enclosure ?? '"';
+    const sheetName = options.sheetName ?? "Sheet 1";
+    const rows = parseRows(csv, delimiter, enclosure);
+    if (rows.length === 0) {
+      return { sheets: [{ name: sheetName, columns: [], rows: [] }] };
+    }
+    const headers = rows[0].map((v) => String(v));
+    const dataRows = rows.slice(1).map(
+      (row) => row.map((cell) => isNumericString(cell) ? numericStringToNumber(cell) : cell)
+    );
+    return ArrayBuilder.build(dataRows, headers, sheetName, options);
+  }
+};
+function parseRows(csv, delimiter, quote) {
+  const rows = [];
+  let field = "";
+  let row = [];
+  let inQuotes = false;
+  let started = false;
+  const pushField = () => {
+    row.push(field);
+    field = "";
+    started = true;
+  };
+  const pushRow = () => {
+    pushField();
+    rows.push(row);
+    row = [];
+    started = false;
+  };
+  for (let i = 0; i < csv.length; i++) {
+    const ch = csv[i];
+    if (inQuotes) {
+      if (ch === quote) {
+        if (csv[i + 1] === quote) {
+          field += quote;
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        field += ch;
+      }
+      continue;
+    }
+    if (ch === quote) {
+      inQuotes = true;
+      started = true;
+      continue;
+    }
+    if (ch === delimiter) {
+      pushField();
+      continue;
+    }
+    if (ch === "\r") {
+      if (csv[i + 1] === "\n") i++;
+      pushRow();
+      continue;
+    }
+    if (ch === "\n") {
+      pushRow();
+      continue;
+    }
+    field += ch;
+    started = true;
+  }
+  if (field !== "" || row.length > 0 || started) pushRow();
+  return rows.filter((r) => !(r.length === 1 && r[0] === ""));
+}
+
+// src/workbook/cell-address.ts
+var CellAddress = {
+  /** 0-based column index → Excel-style letters. */
+  letter(index) {
+    if (index < 0) {
+      throw new Error(`[holy-sheet] column index must be \u2265 0, got ${index}`);
+    }
+    let letters = "";
+    let n = index;
+    do {
+      letters = String.fromCharCode(65 + n % 26) + letters;
+      n = Math.floor(n / 26) - 1;
+    } while (n >= 0);
+    return letters;
+  },
+  /** Column-letters → 0-based index. */
+  index(letters) {
+    const up = letters.trim().toUpperCase();
+    if (up === "" || !/^[A-Z]+$/.test(up)) {
+      throw new Error(`[holy-sheet] invalid column letters: '${up}'`);
+    }
+    let idx = 0;
+    for (let i = 0; i < up.length; i++) {
+      idx = idx * 26 + (up.charCodeAt(i) - 64);
+    }
+    return idx - 1;
+  },
+  /** Parse an A1 address into [columnIndex, rowNumber] (1-based row), or null. */
+  parse(address) {
+    const m = /^([A-Z]+)(\d+)$/.exec(address.trim().toUpperCase());
+    if (!m) return null;
+    return [CellAddress.index(m[1]), parseInt(m[2], 10)];
+  }
+};
+
+// src/workbook/cell.ts
+var Cell = class {
+  constructor(address, value, formula = null, format = null, comment = null, cachedValue = null) {
+    this.address = address;
+    this.value = value;
+    this.formula = formula;
+    this.format = format;
+    this.comment = comment;
+    this.cachedValue = cachedValue;
+  }
+  excelType() {
+    if (this.formula !== null) return "str";
+    if (typeof this.value === "string") return "inlineStr";
+    if (typeof this.value === "boolean") return "b";
+    return "n";
+  }
+};
+
+// src/workbook/cell-comment.ts
+var CellComment = class {
+  constructor(text, author = null, color = null) {
+    this.text = text;
+    this.author = author;
+    this.color = color;
+  }
+};
+
+// src/workbook/cell-format.ts
+var CellFormat = class _CellFormat {
+  constructor(p = {}) {
+    this.bold = p.bold ?? false;
+    this.italic = p.italic ?? false;
+    this.textAlign = p.textAlign ?? null;
+    this.displayFormat = p.displayFormat ?? null;
+    this.decimals = p.decimals ?? null;
+    this.color = p.color ?? null;
+    this.backgroundColor = p.backgroundColor ?? null;
+    this.fontSize = p.fontSize ?? null;
+    this.borderTop = p.borderTop ?? null;
+    this.borderRight = p.borderRight ?? null;
+    this.borderBottom = p.borderBottom ?? null;
+    this.borderLeft = p.borderLeft ?? null;
+    this.currency = p.currency ?? null;
+  }
+  /** Stable dedup key (JSON of ordered fields — replaces PHP md5(serialize)). */
+  key() {
+    return JSON.stringify([
+      this.bold,
+      this.italic,
+      this.textAlign,
+      this.displayFormat,
+      this.decimals,
+      this.color,
+      this.backgroundColor,
+      this.fontSize,
+      this.borderTop,
+      this.borderRight,
+      this.borderBottom,
+      this.borderLeft,
+      this.currency
+    ]);
+  }
+  isEmpty() {
+    return !this.bold && !this.italic && this.textAlign === null && this.displayFormat === null && this.decimals === null && this.color === null && this.backgroundColor === null && this.fontSize === null && this.borderTop === null && this.borderRight === null && this.borderBottom === null && this.borderLeft === null && this.currency === null;
+  }
+  static fromInput(a) {
+    return new _CellFormat({
+      bold: Boolean(a.bold ?? false),
+      italic: Boolean(a.italic ?? false),
+      textAlign: a.textAlign ?? null,
+      displayFormat: a.displayFormat ?? null,
+      decimals: a.decimals != null ? Math.trunc(a.decimals) : null,
+      color: a.color ?? null,
+      backgroundColor: a.backgroundColor ?? null,
+      fontSize: a.fontSize != null ? Math.trunc(a.fontSize) : null,
+      borderTop: a.borderTop ?? null,
+      borderRight: a.borderRight ?? null,
+      borderBottom: a.borderBottom ?? null,
+      borderLeft: a.borderLeft ?? null,
+      currency: a.currency ?? null
+    });
+  }
+  /** Merge another format on top of this one (other wins where set). */
+  mergeWith(other) {
+    if (other === null) return this;
+    return new _CellFormat({
+      bold: other.bold || this.bold,
+      italic: other.italic || this.italic,
+      textAlign: other.textAlign ?? this.textAlign,
+      displayFormat: other.displayFormat ?? this.displayFormat,
+      decimals: other.decimals ?? this.decimals,
+      color: other.color ?? this.color,
+      backgroundColor: other.backgroundColor ?? this.backgroundColor,
+      fontSize: other.fontSize ?? this.fontSize,
+      borderTop: other.borderTop ?? this.borderTop,
+      borderRight: other.borderRight ?? this.borderRight,
+      borderBottom: other.borderBottom ?? this.borderBottom,
+      borderLeft: other.borderLeft ?? this.borderLeft,
+      currency: other.currency ?? this.currency
+    });
+  }
+};
+
+// src/workbook/merged-region.ts
+var MergedRegion = class {
+  constructor(start, end) {
+    this.start = start;
+    this.end = end;
+  }
+  ref() {
+    return `${this.start}:${this.end}`;
+  }
+};
+
+// src/workbook/sheet.ts
+var Sheet = class {
+  constructor(name, cells = /* @__PURE__ */ new Map(), mergedRegions = [], columnWidths = /* @__PURE__ */ new Map(), frozenRows = 0, frozenCols = 0) {
+    this.name = name;
+    this.cells = cells;
+    this.mergedRegions = mergedRegions;
+    this.columnWidths = columnWidths;
+    this.frozenRows = frozenRows;
+    this.frozenCols = frozenCols;
+  }
+  /** rowNumber → (colLetter → Cell), sorted by ascending row number. */
+  rows() {
+    const rows = /* @__PURE__ */ new Map();
+    for (const [address, cell] of this.cells) {
+      const m = /^([A-Z]+)(\d+)$/.exec(address);
+      if (!m) continue;
+      const rowNum = parseInt(m[2], 10);
+      let row = rows.get(rowNum);
+      if (!row) {
+        row = /* @__PURE__ */ new Map();
+        rows.set(rowNum, row);
+      }
+      row.set(m[1], cell);
+    }
+    return new Map([...rows.entries()].sort((a, b) => a[0] - b[0]));
+  }
+  hasComments() {
+    for (const c of this.cells.values()) if (c.comment !== null) return true;
+    return false;
+  }
+  comments() {
+    const out = [];
+    for (const c of this.cells.values()) {
+      if (c.comment !== null) out.push({ address: c.address, comment: c.comment });
+    }
+    return out;
+  }
+};
+
+// src/workbook/workbook.ts
+var Workbook = class {
+  constructor(sheets, meta = {}) {
+    this.sheets = sheets;
+    this.meta = meta;
+  }
+};
+
+// src/writer/format/date-converter.ts
+function parseToUtcMs(value) {
+  const s = value.trim();
+  if (s === "") return null;
+  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.\d+)?)?)?\s*(Z|[+-]\d{2}:?\d{2})?$/.exec(
+    s
+  );
+  if (m) {
+    const [, y, mo, d, h, mi, se, tz] = m;
+    let ms = Date.UTC(+y, +mo - 1, +d, h ? +h : 0, mi ? +mi : 0, se ? +se : 0);
+    if (tz && tz !== "Z") {
+      const sign = tz[0] === "-" ? -1 : 1;
+      const clean = tz.slice(1).replace(":", "");
+      const offMin = sign * (parseInt(clean.slice(0, 2), 10) * 60 + parseInt(clean.slice(2, 4) || "0", 10));
+      ms -= offMin * 6e4;
+    }
+    return ms;
+  }
+  const fallback = Date.parse(s);
+  return Number.isNaN(fallback) ? null : fallback;
+}
+var DateConverter = {
+  toSerial(value, includeTime = false) {
+    const ts = value instanceof Date ? value.getTime() : parseToUtcMs(value);
+    if (ts === null) return 0;
+    const epoch = Date.UTC(1899, 11, 30, 0, 0, 0);
+    let days = (ts - epoch) / 864e5;
+    if (!includeTime) days = Math.floor(days);
+    return days;
+  }
+};
+
+// src/schema/theme.ts
+var Theme = class {
+  constructor(key) {
+    this.key = key;
+  }
+  headerFormat() {
+    switch (this.key) {
+      case "default":
+      case "business":
+        return new CellFormat({
+          bold: true,
+          color: "#FFFFFF",
+          backgroundColor: this.key === "business" ? "#1F2937" : "#374151"
+        });
+      case "minimal":
+        return new CellFormat({ bold: true, borderBottom: "#000000" });
+      default:
+        return null;
+    }
+  }
+  dataFormat(rowIndexZeroBased) {
+    if ((this.key === "default" || this.key === "business") && rowIndexZeroBased % 2 === 1) {
+      return new CellFormat({ backgroundColor: "#F3F4F6" });
+    }
+    return null;
+  }
+  totalsFormat() {
+    switch (this.key) {
+      case "default":
+      case "business":
+      case "minimal":
+        return new CellFormat({ bold: true, borderTop: "#000000" });
+      default:
+        return null;
+    }
+  }
+};
+
+// src/schema/normalizer.ts
+var Normalizer = class {
+  normalize(schema) {
+    const sheets = [];
+    for (const sheetSchema of schema.sheets) {
+      sheets.push(this.normalizeSheet(sheetSchema));
+    }
+    return new Workbook(sheets, schema.meta ?? {});
+  }
+  normalizeSheet(sheet) {
+    const name = String(sheet.name);
+    if (sheet.cells != null) {
+      return new Sheet(
+        name,
+        this.normalizeCellMap(sheet.cells),
+        this.normalizeMerges(sheet.mergedRegions ?? []),
+        this.normalizeColumnWidths(sheet.columnWidths ?? {}),
+        toInt(sheet.frozenRows ?? 0),
+        toInt(sheet.frozenCols ?? 0)
+      );
+    }
+    const cells = /* @__PURE__ */ new Map();
+    const columns = sheet.columns ?? [];
+    const rows = sheet.rows ?? [];
+    const themeKey = sheet.theme ?? "default";
+    const theme = new Theme(themeKey);
+    let headerOffset = 0;
+    const columnFormats = /* @__PURE__ */ new Map();
+    const columnByHeader = /* @__PURE__ */ new Map();
+    columns.forEach((columnDef, colIdx) => {
+      columnFormats.set(colIdx, this.columnFormat(columnDef));
+      if (isPlainObject(columnDef) && columnDef.header !== void 0) {
+        columnByHeader.set(String(columnDef.header), colIdx);
+      }
+    });
+    if (columns.length > 0) {
+      columns.forEach((columnDef, col) => {
+        const address = CellAddress.letter(col) + "1";
+        const header = isPlainObject(columnDef) ? columnDef.header ?? "" : String(columnDef);
+        cells.set(address, new Cell(address, String(header), null, theme.headerFormat()));
+      });
+      headerOffset = 1;
+    }
+    rows.forEach((row, r) => {
+      row.forEach((value, c) => {
+        const address = CellAddress.letter(c) + (r + 1 + headerOffset);
+        const columnFormat = columnFormats.get(c) ?? null;
+        const rowBand = theme.dataFormat(r);
+        const merged = rowBand !== null ? columnFormat ? columnFormat.mergeWith(rowBand) : rowBand : columnFormat;
+        cells.set(address, this.buildCell(address, value, merged));
+      });
+    });
+    if (sheet.totals && isPlainObject(sheet.totals) && Object.keys(sheet.totals).length > 0 && rows.length > 0 && columns.length > 0) {
+      const totalsRow = rows.length + 1 + headerOffset;
+      const totalsTheme = theme.totalsFormat();
+      const labelAddr = CellAddress.letter(0) + totalsRow;
+      cells.set(labelAddr, new Cell(labelAddr, "Total", null, totalsTheme));
+      for (const [headerKey, aggOp] of Object.entries(sheet.totals)) {
+        if (!columnByHeader.has(headerKey)) continue;
+        const colIdx = columnByHeader.get(headerKey);
+        const colLetter = CellAddress.letter(colIdx);
+        const rangeStart = colLetter + (headerOffset + 1);
+        const rangeEnd = colLetter + (rows.length + headerOffset);
+        const func = String(aggOp).toUpperCase();
+        if (!["SUM", "AVG", "COUNT", "MIN", "MAX"].includes(func)) continue;
+        const excelFunc = func === "AVG" ? "AVERAGE" : func;
+        const address = colLetter + totalsRow;
+        const colFmt = columnFormats.get(colIdx) ?? null;
+        const combined = colFmt ? colFmt.mergeWith(totalsTheme) : totalsTheme;
+        cells.set(address, new Cell(address, null, `${excelFunc}(${rangeStart}:${rangeEnd})`, combined));
+      }
+    }
+    return new Sheet(
+      name,
+      cells,
+      this.normalizeMerges(sheet.mergedRegions ?? []),
+      this.normalizeColumnWidths(sheet.columnWidths ?? {}),
+      toInt(sheet.frozenRows ?? 0),
+      toInt(sheet.frozenCols ?? 0)
+    );
+  }
+  normalizeCellMap(map) {
+    const cells = /* @__PURE__ */ new Map();
+    for (const [address, cellData] of Object.entries(map)) {
+      const format = cellData && isPlainObject(cellData.format) ? CellFormat.fromInput(cellData.format) : null;
+      const comment = cellData && isPlainObject(cellData.comment) ? new CellComment(
+        String(cellData.comment.text ?? ""),
+        cellData.comment.author ?? null,
+        cellData.comment.color ?? null
+      ) : null;
+      const rawValue = cellData?.value ?? null;
+      cells.set(
+        address,
+        new Cell(
+          address,
+          this.coerceValue(rawValue, format),
+          cellData?.formula ?? null,
+          format,
+          comment,
+          cellData?.computedValue ?? null
+        )
+      );
+    }
+    return cells;
+  }
+  normalizeMerges(list) {
+    const out = [];
+    for (const m of list) {
+      if (m && m.start !== void 0 && m.end !== void 0) {
+        out.push(new MergedRegion(String(m.start), String(m.end)));
+      }
+    }
+    return out;
+  }
+  normalizeColumnWidths(widths) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [key, px] of Object.entries(widths)) {
+      out.set(parseInt(key, 10), Number(px));
+    }
+    return out;
+  }
+  columnFormat(columnDef) {
+    if (typeof columnDef === "string") return null;
+    const type = columnDef.type ?? "auto";
+    const decimals = columnDef.decimals != null ? toInt(columnDef.decimals) : null;
+    const currency = columnDef.currency ?? null;
+    switch (type) {
+      case "integer":
+        return new CellFormat({ displayFormat: "number", decimals: 0 });
+      case "number":
+        return decimals !== null ? new CellFormat({ displayFormat: "number", decimals }) : null;
+      case "percent":
+        return new CellFormat({ displayFormat: "percentage", decimals: decimals ?? 1 });
+      case "currency":
+        return new CellFormat({ displayFormat: "currency", decimals: decimals ?? 2, currency });
+      case "date":
+        return new CellFormat({ displayFormat: "date" });
+      case "datetime":
+        return new CellFormat({ displayFormat: "datetime" });
+      default:
+        return null;
+    }
+  }
+  buildCell(address, value, columnFormat) {
+    if (isPlainObject(value)) {
+      const cellFormat = isPlainObject(value.format) ? CellFormat.fromInput(value.format) : null;
+      const merged = columnFormat ? columnFormat.mergeWith(cellFormat) : cellFormat;
+      const comment = isPlainObject(value.comment) ? new CellComment(
+        String(value.comment.text ?? ""),
+        value.comment.author ?? null,
+        value.comment.color ?? null
+      ) : null;
+      const rawValue = value.value ?? null;
+      return new Cell(
+        address,
+        this.coerceValue(rawValue, merged),
+        value.formula ?? null,
+        merged,
+        comment,
+        value.computedValue ?? null
+      );
+    }
+    return new Cell(address, this.coerceValue(value, columnFormat), null, columnFormat);
+  }
+  coerceValue(value, format) {
+    if (value === null || value === void 0) return null;
+    const df = format?.displayFormat;
+    if (df === "date" || df === "datetime") {
+      if (value instanceof Date || typeof value === "string" && value.trim() !== "") {
+        return DateConverter.toSerial(value, df === "datetime");
+      }
+    }
+    if (typeof value === "string" && isNumericString(value)) {
+      return numericStringToNumber(value);
+    }
+    if (value instanceof Date) {
+      return DateConverter.toSerial(value, true);
+    }
+    if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      return String(value);
+    }
+    return value;
+  }
+};
+function toInt(v) {
+  const n = Math.trunc(Number(v));
+  return Number.isFinite(n) ? n : 0;
+}
+
+// src/schema/formula-linter.ts
+var ERR_VALUE = "#VALUE!";
+var ERR_REF = "#REF!";
+var ERR_NAME = "#NAME?";
+var ERR_DIV0 = "#DIV/0!";
+var ERR_CIRC = "#CIRC!";
+var LinterError = class extends Error {
+  constructor(errorCode) {
+    super(errorCode);
+    this.errorCode = errorCode;
+  }
+};
+var FormulaLinter = class {
+  constructor() {
+    this.index = /* @__PURE__ */ new Map();
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  lint(schema) {
+    const workbook = new Normalizer().normalize(schema);
+    this.index = this.buildIndex(workbook);
+    this.cache = /* @__PURE__ */ new Map();
+    const issues = [];
+    for (const sheet of workbook.sheets) {
+      for (const [address, cell] of sheet.cells) {
+        if (cell.formula === null) continue;
+        const key = sheet.name + "!" + address;
+        const result = this.evaluate(cell.formula, sheet.name, [key]);
+        this.cache.set(key, result);
+        if (this.isError(result)) {
+          issues.push({
+            sheet: sheet.name,
+            address,
+            formula: cell.formula,
+            error: result,
+            hint: this.hint(result, cell.formula, sheet.name)
+          });
+        }
+      }
+    }
+    return issues;
+  }
+  buildIndex(wb) {
+    const index = /* @__PURE__ */ new Map();
+    for (const sheet of wb.sheets) {
+      for (const [address, cell] of sheet.cells) {
+        index.set(sheet.name + "!" + address, cell);
+      }
+    }
+    return index;
+  }
+  isError(v) {
+    return typeof v === "string" && v.length > 0 && v[0] === "#";
+  }
+  evaluate(formula, defaultSheet, stack) {
+    try {
+      const c = { tokens: this.tokenize(formula), pos: 0 };
+      const result = this.parseExpr(c, defaultSheet, stack);
+      if (c.pos < c.tokens.length) return ERR_NAME;
+      return result;
+    } catch (e) {
+      if (e instanceof LinterError) return e.errorCode;
+      return ERR_NAME;
+    }
+  }
+  // ---- Tokenizer ----
+  tokenize(src) {
+    const tokens = [];
+    let i = 0;
+    const len = src.length;
+    const isSpace = (ch) => /\s/.test(ch);
+    const isDigit = (ch) => ch >= "0" && ch <= "9";
+    const isAlpha = (ch) => /[A-Za-z]/.test(ch);
+    const isAlnum = (ch) => /[A-Za-z0-9]/.test(ch);
+    while (i < len) {
+      const ch = src[i];
+      if (isSpace(ch)) {
+        i++;
+        continue;
+      }
+      if (isDigit(ch) || ch === "." && i + 1 < len && isDigit(src[i + 1])) {
+        const start = i;
+        while (i < len && (isDigit(src[i]) || src[i] === ".")) i++;
+        tokens.push({ type: "NUMBER", value: src.slice(start, i) });
+        continue;
+      }
+      if (ch === '"') {
+        i++;
+        const start = i;
+        while (i < len && src[i] !== '"') i++;
+        const value = src.slice(start, i);
+        i++;
+        tokens.push({ type: "STRING", value });
+        continue;
+      }
+      if (isAlpha(ch) || ch === "_" || ch === "$") {
+        const start = i;
+        while (i < len && (isAlnum(src[i]) || src[i] === "_" || src[i] === "$" || src[i] === ".")) i++;
+        tokens.push({ type: "IDENT", value: src.slice(start, i) });
+        continue;
+      }
+      if (i + 1 < len) {
+        const two = src.slice(i, i + 2);
+        if (two === "<=" || two === ">=" || two === "<>") {
+          tokens.push({ type: "OP", value: two });
+          i += 2;
+          continue;
+        }
+      }
+      if ("+-*/^%&=<>(),:!".includes(ch)) {
+        tokens.push({ type: "OP", value: ch });
+        i++;
+        continue;
+      }
+      throw new LinterError(ERR_NAME);
+    }
+    return tokens;
+  }
+  // ---- Parser (recursive descent) ----
+  peek(c) {
+    return c.tokens[c.pos];
+  }
+  isOp(c, ...vals) {
+    const t = c.tokens[c.pos];
+    return !!t && t.type === "OP" && vals.includes(t.value);
+  }
+  parseExpr(c, sheet, stack) {
+    let left = this.parseConcat(c, sheet, stack);
+    while (this.isOp(c, "=", "<", ">", "<=", ">=", "<>")) {
+      const op = c.tokens[c.pos].value;
+      c.pos++;
+      const right = this.parseConcat(c, sheet, stack);
+      left = this.compare(left, right, op);
+    }
+    return left;
+  }
+  parseConcat(c, sheet, stack) {
+    let left = this.parseArith(c, sheet, stack);
+    while (this.isOp(c, "&")) {
+      c.pos++;
+      const right = this.parseArith(c, sheet, stack);
+      left = this.coerceString(left) + this.coerceString(right);
+    }
+    return left;
+  }
+  parseArith(c, sheet, stack) {
+    let left = this.parseTerm(c, sheet, stack);
+    while (this.isOp(c, "+", "-")) {
+      const op = c.tokens[c.pos].value;
+      c.pos++;
+      const right = this.parseTerm(c, sheet, stack);
+      const a = this.coerceNumber(left);
+      const b = this.coerceNumber(right);
+      left = op === "+" ? a + b : a - b;
+    }
+    return left;
+  }
+  parseTerm(c, sheet, stack) {
+    let left = this.parseUnary(c, sheet, stack);
+    while (this.isOp(c, "*", "/", "%", "^")) {
+      const op = c.tokens[c.pos].value;
+      c.pos++;
+      const right = this.parseUnary(c, sheet, stack);
+      const a = this.coerceNumber(left);
+      const b = this.coerceNumber(right);
+      switch (op) {
+        case "*":
+          left = a * b;
+          break;
+        case "/":
+          if (b === 0) throw new LinterError(ERR_DIV0);
+          left = a / b;
+          break;
+        case "%":
+          left = a / 100 * b;
+          break;
+        case "^":
+          left = a ** b;
+          break;
+      }
+    }
+    return left;
+  }
+  parseUnary(c, sheet, stack) {
+    if (this.isOp(c, "-")) {
+      c.pos++;
+      const v = this.parseUnary(c, sheet, stack);
+      return -this.coerceNumber(v);
+    }
+    if (this.isOp(c, "+")) {
+      c.pos++;
+      return this.parseUnary(c, sheet, stack);
+    }
+    return this.parsePrimary(c, sheet, stack);
+  }
+  parsePrimary(c, sheet, stack) {
+    const tok = this.peek(c);
+    if (!tok) throw new LinterError(ERR_NAME);
+    if (tok.type === "OP" && tok.value === "(") {
+      c.pos++;
+      const val = this.parseExpr(c, sheet, stack);
+      this.expectOp(c, ")");
+      return val;
+    }
+    if (tok.type === "NUMBER") {
+      c.pos++;
+      return parseFloat(tok.value);
+    }
+    if (tok.type === "STRING") {
+      c.pos++;
+      return tok.value;
+    }
+    if (tok.type === "IDENT") {
+      const next = c.tokens[c.pos + 1];
+      const next2 = c.tokens[c.pos + 2];
+      if (next && next.type === "OP" && next.value === "!" && next2 && next2.type === "IDENT") {
+        const sheetName = this.cleanSheetName(tok.value);
+        c.pos += 2;
+        const startTok = c.tokens[c.pos].value;
+        c.pos++;
+        return this.resolveRefOrRange(startTok, sheetName, c, stack);
+      }
+      if (next && next.type === "OP" && next.value === "(") {
+        const name = tok.value.toUpperCase();
+        c.pos += 2;
+        const args = [];
+        if (!this.isOp(c, ")")) {
+          for (; ; ) {
+            args.push(this.parseExpr(c, sheet, stack));
+            if (this.isOp(c, ",")) {
+              c.pos++;
+              continue;
+            }
+            break;
+          }
+        }
+        this.expectOp(c, ")");
+        return this.callFunction(name, args);
+      }
+      const upper = tok.value.toUpperCase();
+      if (upper === "TRUE" || upper === "FALSE") {
+        c.pos++;
+        return upper === "TRUE";
+      }
+      c.pos++;
+      return this.resolveRefOrRange(tok.value, sheet, c, stack);
+    }
+    throw new LinterError(ERR_NAME);
+  }
+  resolveRefOrRange(startRef, defaultSheet, c, stack) {
+    const cleanStart = this.cleanRef(startRef);
+    if (cleanStart === null) throw new LinterError(ERR_REF);
+    const next = c.tokens[c.pos + 1];
+    if (this.isOp(c, ":") && next && next.type === "IDENT") {
+      const endRef = next.value;
+      c.pos += 2;
+      const cleanEnd = this.cleanRef(endRef);
+      if (cleanEnd === null) throw new LinterError(ERR_REF);
+      return this.resolveRange(defaultSheet, cleanStart, cleanEnd, stack);
+    }
+    return this.resolveCell(defaultSheet, cleanStart, stack);
+  }
+  cleanRef(ref) {
+    const r = ref.replace(/\$/g, "").toUpperCase();
+    return /^[A-Z]+\d+$/.test(r) ? r : null;
+  }
+  cleanSheetName(name) {
+    if (name.length >= 2 && name[0] === "'" && name[name.length - 1] === "'") {
+      return name.slice(1, -1);
+    }
+    return name;
+  }
+  resolveCell(sheet, a1, stack) {
+    const key = sheet + "!" + a1;
+    if (stack.includes(key)) return ERR_CIRC;
+    if (this.cache.has(key)) return this.cache.get(key);
+    const cell = this.index.get(key);
+    if (!cell) return null;
+    if (cell.formula !== null) {
+      const result = this.evaluate(cell.formula, sheet, [...stack, key]);
+      this.cache.set(key, result);
+      return result;
+    }
+    return cell.value;
+  }
+  resolveRange(sheet, start, end, stack) {
+    const a = CellAddress.parse(start);
+    const b = CellAddress.parse(end);
+    if (a === null || b === null) throw new LinterError(ERR_REF);
+    const col1 = Math.min(a[0], b[0]);
+    const row1 = Math.min(a[1], b[1]);
+    const col2 = Math.max(a[0], b[0]);
+    const row2 = Math.max(a[1], b[1]);
+    const values = [];
+    for (let r = row1; r <= row2; r++) {
+      for (let col = col1; col <= col2; col++) {
+        values.push(this.resolveCell(sheet, CellAddress.letter(col) + r, stack));
+      }
+    }
+    return values;
+  }
+  expectOp(c, op) {
+    const t = c.tokens[c.pos];
+    if (!t || t.type !== "OP" || t.value !== op) throw new LinterError(ERR_NAME);
+    c.pos++;
+  }
+  // ---- Coercion / comparison / functions ----
+  coerceNumber(v) {
+    if (this.isError(v)) throw new LinterError(v);
+    if (Array.isArray(v)) {
+      for (const item of v) {
+        if (typeof item === "number") return item;
+        if (typeof item === "string" && isNumericString(item)) return Number(item);
+      }
+      throw new LinterError(ERR_VALUE);
+    }
+    if (typeof v === "number") return v;
+    if (typeof v === "boolean") return v ? 1 : 0;
+    if (v === null) return 0;
+    if (typeof v === "string" && isNumericString(v)) return Number(v);
+    throw new LinterError(ERR_VALUE);
+  }
+  coerceString(v) {
+    if (this.isError(v)) throw new LinterError(v);
+    if (v === null) return "";
+    if (typeof v === "boolean") return v ? "TRUE" : "FALSE";
+    if (Array.isArray(v)) return v.map((x) => this.coerceString(x)).join("");
+    return String(v);
+  }
+  compare(a, b, op) {
+    const cmp = this.cmpVal(a, b);
+    switch (op) {
+      case "=":
+        return cmp === 0;
+      case "<>":
+        return cmp !== 0;
+      case "<":
+        return cmp < 0;
+      case ">":
+        return cmp > 0;
+      case "<=":
+        return cmp <= 0;
+      case ">=":
+        return cmp >= 0;
+      default:
+        return false;
+    }
+  }
+  cmpVal(a, b) {
+    const an = typeof a === "number" || typeof a === "string" && isNumericString(a);
+    const bn = typeof b === "number" || typeof b === "string" && isNumericString(b);
+    if (an && bn) {
+      const x = Number(a);
+      const y = Number(b);
+      return x < y ? -1 : x > y ? 1 : 0;
+    }
+    const sa = String(a);
+    const sb = String(b);
+    return sa < sb ? -1 : sa > sb ? 1 : 0;
+  }
+  callFunction(name, args) {
+    const flat = this.flatten(args);
+    switch (name) {
+      case "SUM":
+        return flat.filter((v) => this.isNumericLike(v)).reduce((s, v) => s + this.maybeNum(v), 0);
+      case "AVERAGE":
+      case "AVG":
+        return this.avg(flat);
+      case "COUNT":
+        return flat.filter((v) => this.isNumericLike(v)).length;
+      case "COUNTA":
+        return flat.filter((v) => v !== null && v !== "").length;
+      case "MIN":
+        return this.minMax(flat, true);
+      case "MAX":
+        return this.minMax(flat, false);
+      case "IF":
+        return this.ifFn(args);
+      case "ROUND":
+        return phpRound(this.coerceNumber(args[0] ?? 0), Math.trunc(this.coerceNumber(args[1] ?? 0)));
+      case "ABS":
+        return Math.abs(this.coerceNumber(args[0] ?? 0));
+      case "LEN":
+        return this.coerceString(args[0] ?? "").length;
+      case "UPPER":
+        return this.coerceString(args[0] ?? "").toUpperCase();
+      case "LOWER":
+        return this.coerceString(args[0] ?? "").toLowerCase();
+      case "CONCAT":
+      case "CONCATENATE":
+        return flat.map((v) => this.coerceString(v)).join("");
+      case "TRUE":
+        return true;
+      case "FALSE":
+        return false;
+      default:
+        return ERR_NAME;
+    }
+  }
+  flatten(args) {
+    const out = [];
+    for (const a of args) {
+      if (Array.isArray(a)) for (const x of a) out.push(x);
+      else out.push(a);
+    }
+    return out;
+  }
+  isNumericLike(v) {
+    return typeof v === "number" || typeof v === "string" && isNumericString(v) || typeof v === "boolean";
+  }
+  maybeNum(v) {
+    return typeof v === "boolean" ? v ? 1 : 0 : Number(v);
+  }
+  avg(flat) {
+    const nums = flat.filter((v) => this.isNumericLike(v));
+    if (nums.length === 0) return ERR_DIV0;
+    return nums.reduce((s, v) => s + this.maybeNum(v), 0) / nums.length;
+  }
+  minMax(flat, min) {
+    const nums = flat.filter((v) => this.isNumericLike(v));
+    if (nums.length === 0) return 0;
+    const vals = nums.map((v) => this.maybeNum(v));
+    return min ? Math.min(...vals) : Math.max(...vals);
+  }
+  ifFn(args) {
+    if (args.length < 2) return ERR_VALUE;
+    const cond = args[0];
+    const truthy = typeof cond === "boolean" ? cond : cond !== null && cond !== 0 && cond !== "" && cond !== "FALSE";
+    return truthy ? args[1] : args[2] ?? false;
+  }
+  // ---- Hints ----
+  hint(error2, formula, sheet) {
+    switch (error2) {
+      case ERR_VALUE:
+        return this.hintValue(formula, sheet);
+      case ERR_REF:
+        return "A cell reference points to a cell that doesn't exist in the workbook. Check column letters and row numbers.";
+      case ERR_NAME:
+        return "The formula references an unknown function or has a syntax error. Holy Sheet supports: SUM, AVERAGE, COUNT, COUNTA, MIN, MAX, IF, ROUND, ABS, LEN, UPPER, LOWER, CONCAT.";
+      case ERR_DIV0:
+        return "Division by zero \u2014 the divisor evaluated to 0.";
+      case ERR_CIRC:
+        return "Circular reference \u2014 the formula directly or transitively depends on its own cell.";
+      default:
+        return "Formula evaluation failed.";
+    }
+  }
+  hintValue(formula, sheet) {
+    const re = /(?:([A-Za-z][A-Za-z0-9_]*)!)?\$?([A-Z]+)\$?(\d+)/gi;
+    const offenders = [];
+    for (const m of formula.matchAll(re)) {
+      const sheetName = m[1] ? m[1] : sheet;
+      const a1 = m[2].toUpperCase() + m[3];
+      const key = sheetName + "!" + a1;
+      const cell = this.index.get(key);
+      if (!cell) continue;
+      const value = this.cache.has(key) ? this.cache.get(key) : cell.formula !== null ? null : cell.value;
+      if (typeof value === "string" && !isNumericString(value) && value !== "") {
+        const row = parseInt(m[3], 10);
+        const col = m[2];
+        const next = sheetName + "!" + col.toUpperCase() + (row + 1);
+        const nextCell = this.index.get(next);
+        let suggestion = "";
+        if (nextCell && isNumericString(nextCell.value)) {
+          suggestion = ` Did you mean ${col.toUpperCase()}${row + 1}? (it holds ${String(nextCell.value)})`;
+        }
+        offenders.push(`${a1} = "${value}" (string)${suggestion}`);
+      }
+    }
+    if (offenders.length > 0) {
+      return "Arithmetic on a non-numeric cell: " + offenders.join("; ");
+    }
+    return "A non-numeric value was used in arithmetic. Check that all referenced cells contain numbers.";
+  }
+};
+function phpRound(x, n) {
+  const factor = 10 ** n;
+  return Math.sign(x) * Math.round(Math.abs(x) * factor) / factor;
+}
+
+// src/exceptions.ts
+var SchemaException = class _SchemaException extends Error {
+  constructor(errors, message) {
+    super(message ?? summarize(errors));
+    this.name = "SchemaException";
+    this.errors = errors;
+    Object.setPrototypeOf(this, _SchemaException.prototype);
+  }
+  static fromErrors(errors) {
+    return new _SchemaException(errors);
+  }
+  getErrors() {
+    return this.errors;
+  }
+};
+function summarize(errors) {
+  if (errors.length === 1) {
+    const e = errors[0];
+    return `[holy-sheet] schema invalid at ${e.path}: expected ${e.expected}, got ${e.got}`;
+  }
+  const first = errors[0];
+  const rest = errors.length - 1;
+  return `[holy-sheet] schema invalid at ${first.path}: expected ${first.expected}, got ${first.got} (+${rest} more)`;
+}
+
+// src/schema/repairer.ts
+var VALID_THEMES = ["default", "minimal", "plain", "business"];
+var ISO_DATE2 = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+var NUMERIC_TYPES = ["number", "integer", "currency", "percent"];
+var Repairer = class {
+  constructor() {
+    this.repairs = [];
+  }
+  repair(schema) {
+    this.repairs = [];
+    let s = clone(schema);
+    s = this.repairTopLevel(s);
+    if (Array.isArray(s.sheets)) {
+      s.sheets = s.sheets.map((sheet, i) => this.repairSheet(sheet, `sheets[${i}]`));
+    }
+    return [s, this.repairs];
+  }
+  repairTopLevel(schema) {
+    if (schema.sheets == null && schema.sheet != null) {
+      const value = schema.sheet;
+      delete schema.sheet;
+      schema.sheets = Array.isArray(value) ? value : [value];
+      this.repairs.push("renamed top-level 'sheet' \u2192 'sheets'");
+    }
+    return schema;
+  }
+  repairSheet(sheet, path) {
+    if (!isPlainObject(sheet)) return sheet;
+    if (sheet.rows == null && sheet.row != null) {
+      sheet.rows = sheet.row;
+      delete sheet.row;
+      this.repairs.push(`renamed '${path}.row' \u2192 '${path}.rows'`);
+    }
+    if (sheet.rows != null && isPlainObject(sheet.rows)) {
+      const keys = Object.keys(sheet.rows);
+      const allIntegerKeys = keys.every((k) => /^\d+$/.test(k));
+      if (allIntegerKeys) {
+        sheet.rows = Object.values(sheet.rows);
+        this.repairs.push(`converted '${path}.rows' from integer-keyed object to indexed list`);
+      }
+    }
+    if (sheet.theme != null && !VALID_THEMES.includes(sheet.theme)) {
+      const original = sheet.theme;
+      sheet.theme = "default";
+      this.repairs.push(`changed '${path}.theme' from '${original}' to 'default' (unknown theme)`);
+    }
+    if (sheet.cells != null && isPlainObject(sheet.cells)) {
+      const cleaned = {};
+      let changed = false;
+      for (const [addr, data] of Object.entries(sheet.cells)) {
+        const trimmed = addr.trim();
+        if (trimmed !== addr) changed = true;
+        cleaned[trimmed] = data;
+      }
+      if (changed) {
+        sheet.cells = cleaned;
+        this.repairs.push(`trimmed whitespace from cell addresses in '${path}.cells'`);
+      }
+    }
+    if (sheet.columns != null && sheet.rows != null && Array.isArray(sheet.columns) && Array.isArray(sheet.rows)) {
+      this.repairColumnTypeInference(sheet, path);
+      this.repairStringifiedNumerics(sheet);
+    }
+    return sheet;
+  }
+  repairColumnTypeInference(sheet, path) {
+    sheet.columns.forEach((col, colIdx) => {
+      if (!isPlainObject(col)) return;
+      if (col.type !== void 0 && col.type !== "auto") return;
+      const values = [];
+      for (const row of sheet.rows) {
+        if (Array.isArray(row) && colIdx < row.length) values.push(row[colIdx]);
+      }
+      const nonNull = values.filter((v) => v !== null && v !== void 0);
+      if (nonNull.length === 0) return;
+      const allDateLike = nonNull.every((v) => typeof v === "string" && ISO_DATE2.test(v));
+      if (allDateLike) {
+        const type = String(nonNull[0]).includes("T") ? "datetime" : "date";
+        sheet.columns[colIdx].type = type;
+        this.repairs.push(`inferred '${path}.columns[${colIdx}].type' = '${type}' from row values`);
+      }
+    });
+  }
+  repairStringifiedNumerics(sheet) {
+    sheet.columns.forEach((col, colIdx) => {
+      if (!isPlainObject(col)) return;
+      const type = col.type ?? "auto";
+      if (!NUMERIC_TYPES.includes(type)) return;
+      sheet.rows.forEach((row) => {
+        if (!Array.isArray(row)) return;
+        const value = row[colIdx];
+        if (typeof value === "string" && isNumericString(value)) {
+          row[colIdx] = numericStringToNumber(value);
+        }
+      });
+    });
+  }
+};
+function clone(v) {
+  return typeof structuredClone === "function" ? structuredClone(v) : JSON.parse(JSON.stringify(v));
+}
+
+// src/schema/validator.ts
+var VALID_THEMES2 = ["default", "minimal", "plain", "business"];
+var ALLOWED_TYPES = [
+  "auto",
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "date",
+  "datetime",
+  "currency",
+  "percent",
+  "formula"
+];
+var Validator = class {
+  validate(schema) {
+    const errors = [];
+    if (schema == null || !Array.isArray(schema.sheets)) {
+      errors.push(
+        error(
+          "sheets",
+          "array",
+          typeOf(schema?.sheets ?? null),
+          schema?.sheets ?? null,
+          'Top-level "sheets" must be an array of sheet definitions.'
+        )
+      );
+      return errors;
+    }
+    if (schema.sheets.length === 0) {
+      errors.push(
+        error("sheets", "non-empty array", "empty array", [], "A workbook must contain at least one sheet.")
+      );
+      return errors;
+    }
+    schema.sheets.forEach((sheet, i) => {
+      errors.push(...this.validateSheet(sheet, `sheets[${i}]`));
+    });
+    return errors;
+  }
+  assert(schema) {
+    const errors = this.validate(schema);
+    if (errors.length > 0) throw SchemaException.fromErrors(errors);
+  }
+  validateAndRepair(schema) {
+    const [repairedSchema, repairs] = new Repairer().repair(schema);
+    const errors = this.validate(repairedSchema);
+    return { schema: repairedSchema, errors, repairs };
+  }
+  validateSheet(sheet, path) {
+    const errors = [];
+    if (!isPlainObject(sheet)) {
+      return [
+        error(
+          path,
+          "object",
+          typeOf(sheet),
+          sheet,
+          'Each sheet must be an object with at least a "name" key.'
+        )
+      ];
+    }
+    if (typeof sheet.name !== "string" || sheet.name.trim() === "") {
+      errors.push(
+        error(
+          `${path}.name`,
+          "non-empty string",
+          typeOf(sheet.name ?? null),
+          sheet.name ?? null,
+          "Sheet name is required and visible in Excel's tab strip."
+        )
+      );
+    }
+    const hasColumnsRows = sheet.rows != null || sheet.columns != null;
+    const hasCells = sheet.cells != null;
+    if (!hasColumnsRows && !hasCells) {
+      errors.push(
+        error(
+          path,
+          "object with rows OR cells",
+          "object without either",
+          sheet,
+          "A sheet needs either {columns, rows} (row-oriented) or {cells} (sparse A1-keyed) data."
+        )
+      );
+    }
+    if (sheet.columns != null) {
+      if (!Array.isArray(sheet.columns)) {
+        errors.push(
+          error(
+            `${path}.columns`,
+            "array",
+            typeOf(sheet.columns),
+            sheet.columns,
+            "Columns must be an array of column definitions."
+          )
+        );
+      } else {
+        sheet.columns.forEach((col, j) => {
+          errors.push(...this.validateColumn(col, `${path}.columns[${j}]`));
+        });
+      }
+    }
+    if (sheet.rows != null) {
+      if (!Array.isArray(sheet.rows)) {
+        errors.push(
+          error(`${path}.rows`, "array", typeOf(sheet.rows), sheet.rows, "Rows must be an array of arrays.")
+        );
+      } else {
+        sheet.rows.forEach((row, j) => {
+          if (!Array.isArray(row)) {
+            errors.push(
+              error(
+                `${path}.rows[${j}]`,
+                "array",
+                typeOf(row),
+                row,
+                "Each row is an array of cell values, in column order."
+              )
+            );
+          }
+        });
+      }
+    }
+    if (sheet.cells != null) {
+      if (!isPlainObject(sheet.cells)) {
+        errors.push(
+          error(
+            `${path}.cells`,
+            "object keyed by A1 address",
+            typeOf(sheet.cells),
+            sheet.cells,
+            'Cells must be an object/map keyed by A1 references like "A1", "B2".'
+          )
+        );
+      }
+    }
+    if (sheet.theme != null && !VALID_THEMES2.includes(sheet.theme)) {
+      errors.push(
+        error(
+          `${path}.theme`,
+          "one of: default, minimal, plain, business",
+          "unknown",
+          sheet.theme,
+          "Pick a built-in theme or omit for default."
+        )
+      );
+    }
+    return errors;
+  }
+  validateColumn(col, path) {
+    if (!isPlainObject(col)) {
+      return [
+        error(path, "object", typeOf(col), col, 'Each column is an object with at least a "header" key.')
+      ];
+    }
+    const errors = [];
+    if (typeof col.header !== "string") {
+      errors.push(
+        error(
+          `${path}.header`,
+          "string",
+          typeOf(col.header ?? null),
+          col.header ?? null,
+          "Column header is the visible label in row 1."
+        )
+      );
+    }
+    if (col.type !== void 0 && !ALLOWED_TYPES.includes(col.type)) {
+      errors.push(
+        error(
+          `${path}.type`,
+          "one of: " + ALLOWED_TYPES.join(", "),
+          "unknown",
+          col.type,
+          'Pick a supported type or omit for "auto" (inferred per cell).'
+        )
+      );
+    }
+    return errors;
+  }
+};
+function error(path, expected, got, value, hint) {
+  return { path, expected, got, value, hint };
+}
+
+// src/zip/crc32.ts
+var TABLE = /* @__PURE__ */ (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/zip/zip-writer.ts
+var encoder = new TextEncoder();
+var DOS_TIME = 0;
+var DOS_DATE = 33;
+function zipSync(files) {
+  const localParts = [];
+  const centralParts = [];
+  let offset = 0;
+  for (const f of files) {
+    const nameBytes = encoder.encode(f.name);
+    const crc = crc32(f.data);
+    const size = f.data.length;
+    const lh = new Uint8Array(30 + nameBytes.length);
+    const ldv = new DataView(lh.buffer);
+    ldv.setUint32(0, 67324752, true);
+    ldv.setUint16(4, 20, true);
+    ldv.setUint16(6, 2048, true);
+    ldv.setUint16(8, 0, true);
+    ldv.setUint16(10, DOS_TIME, true);
+    ldv.setUint16(12, DOS_DATE, true);
+    ldv.setUint32(14, crc, true);
+    ldv.setUint32(18, size, true);
+    ldv.setUint32(22, size, true);
+    ldv.setUint16(26, nameBytes.length, true);
+    ldv.setUint16(28, 0, true);
+    lh.set(nameBytes, 30);
+    localParts.push(lh, f.data);
+    const cd = new Uint8Array(46 + nameBytes.length);
+    const cdv = new DataView(cd.buffer);
+    cdv.setUint32(0, 33639248, true);
+    cdv.setUint16(4, 20, true);
+    cdv.setUint16(6, 20, true);
+    cdv.setUint16(8, 2048, true);
+    cdv.setUint16(10, 0, true);
+    cdv.setUint16(12, DOS_TIME, true);
+    cdv.setUint16(14, DOS_DATE, true);
+    cdv.setUint32(16, crc, true);
+    cdv.setUint32(20, size, true);
+    cdv.setUint32(24, size, true);
+    cdv.setUint16(28, nameBytes.length, true);
+    cdv.setUint16(30, 0, true);
+    cdv.setUint16(32, 0, true);
+    cdv.setUint16(34, 0, true);
+    cdv.setUint16(36, 0, true);
+    cdv.setUint32(38, 0, true);
+    cdv.setUint32(42, offset, true);
+    cd.set(nameBytes, 46);
+    centralParts.push(cd);
+    offset += lh.length + f.data.length;
+  }
+  const localSize = offset;
+  const centralSize = centralParts.reduce((s, c) => s + c.length, 0);
+  const eocd = new Uint8Array(22);
+  const edv = new DataView(eocd.buffer);
+  edv.setUint32(0, 101010256, true);
+  edv.setUint16(4, 0, true);
+  edv.setUint16(6, 0, true);
+  edv.setUint16(8, files.length, true);
+  edv.setUint16(10, files.length, true);
+  edv.setUint32(12, centralSize, true);
+  edv.setUint32(16, localSize, true);
+  edv.setUint16(20, 0, true);
+  const out = new Uint8Array(localSize + centralSize + 22);
+  let p = 0;
+  for (const part of localParts) {
+    out.set(part, p);
+    p += part.length;
+  }
+  for (const part of centralParts) {
+    out.set(part, p);
+    p += part.length;
+  }
+  out.set(eocd, p);
+  return out;
+}
+
+// src/zip/inflate.ts
+var Tree = class {
+  constructor() {
+    // number of codes with a given bit length
+    this.table = new Uint16Array(16);
+    // symbols sorted by code
+    this.trans = new Uint16Array(288);
+  }
+};
+var LENGTH_BITS = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0
+]);
+var LENGTH_BASE = new Uint16Array([
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258
+]);
+var DIST_BITS = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13
+]);
+var DIST_BASE = new Uint16Array([
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577
+]);
+var CLC_INDEX = new Uint8Array([
+  16,
+  17,
+  18,
+  0,
+  8,
+  7,
+  9,
+  6,
+  10,
+  5,
+  11,
+  4,
+  12,
+  3,
+  13,
+  2,
+  14,
+  1,
+  15
+]);
+function buildFixedTrees(lt, dt) {
+  let i;
+  for (i = 0; i < 7; i++) lt.table[i] = 0;
+  lt.table[7] = 24;
+  lt.table[8] = 152;
+  lt.table[9] = 112;
+  for (i = 0; i < 24; i++) lt.trans[i] = 256 + i;
+  for (i = 0; i < 144; i++) lt.trans[24 + i] = i;
+  for (i = 0; i < 8; i++) lt.trans[24 + 144 + i] = 280 + i;
+  for (i = 0; i < 112; i++) lt.trans[24 + 144 + 8 + i] = 144 + i;
+  for (i = 0; i < 5; i++) dt.table[i] = 0;
+  dt.table[5] = 32;
+  for (i = 0; i < 32; i++) dt.trans[i] = i;
+}
+var OFFS = new Uint16Array(16);
+function buildTree(t, lengths, off, num) {
+  let i;
+  let sum = 0;
+  for (i = 0; i < 16; i++) t.table[i] = 0;
+  for (i = 0; i < num; i++) t.table[lengths[off + i]]++;
+  t.table[0] = 0;
+  for (i = 0; i < 16; i++) {
+    OFFS[i] = sum;
+    sum += t.table[i];
+  }
+  for (i = 0; i < num; i++) {
+    const len = lengths[off + i];
+    if (len) t.trans[OFFS[len]++] = i;
+  }
+}
+var Reader = class {
+  constructor(source) {
+    this.index = 0;
+    this.tag = 0;
+    this.bitcount = 0;
+    this.source = source;
+  }
+};
+function getBit(d) {
+  if (d.bitcount-- === 0) {
+    d.tag = d.source[d.index++];
+    d.bitcount = 7;
+  }
+  const bit = d.tag & 1;
+  d.tag >>>= 1;
+  return bit;
+}
+function readBits(d, num, base) {
+  if (!num) return base;
+  let val = 0;
+  for (let i = 0; i < num; i++) val |= getBit(d) << i;
+  return val + base;
+}
+function decodeSymbol(d, t) {
+  let sum = 0;
+  let cur = 0;
+  let len = 0;
+  do {
+    cur = 2 * cur + getBit(d);
+    len++;
+    sum += t.table[len];
+    cur -= t.table[len];
+  } while (cur >= 0);
+  return t.trans[sum + cur];
+}
+function decodeTrees(d, lt, dt) {
+  const lengths = new Uint8Array(288 + 32);
+  const hlit = readBits(d, 5, 257);
+  const hdist = readBits(d, 5, 1);
+  const hclen = readBits(d, 4, 4);
+  let i;
+  for (i = 0; i < 19; i++) lengths[i] = 0;
+  for (i = 0; i < hclen; i++) {
+    const clen = readBits(d, 3, 0);
+    lengths[CLC_INDEX[i]] = clen;
+  }
+  const codeTree = new Tree();
+  buildTree(codeTree, lengths, 0, 19);
+  for (let num = 0; num < hlit + hdist; ) {
+    const sym = decodeSymbol(d, codeTree);
+    switch (sym) {
+      case 16: {
+        const prev = lengths[num - 1];
+        for (let length = readBits(d, 2, 3); length; length--) lengths[num++] = prev;
+        break;
+      }
+      case 17:
+        for (let length = readBits(d, 3, 3); length; length--) lengths[num++] = 0;
+        break;
+      case 18:
+        for (let length = readBits(d, 7, 11); length; length--) lengths[num++] = 0;
+        break;
+      default:
+        lengths[num++] = sym;
+        break;
+    }
+  }
+  buildTree(lt, lengths, 0, hlit);
+  buildTree(dt, lengths, hlit, hdist);
+}
+var Out = class {
+  constructor() {
+    this.buf = new Uint8Array(1024);
+    this.len = 0;
+  }
+  push(b) {
+    if (this.len >= this.buf.length) {
+      const next = new Uint8Array(this.buf.length * 2);
+      next.set(this.buf);
+      this.buf = next;
+    }
+    this.buf[this.len++] = b;
+  }
+};
+function inflateBlockData(d, out, lt, dt) {
+  for (; ; ) {
+    const sym = decodeSymbol(d, lt);
+    if (sym === 256) return;
+    if (sym < 256) {
+      out.push(sym);
+    } else {
+      const lengthSym = sym - 257;
+      const length = readBits(d, LENGTH_BITS[lengthSym], LENGTH_BASE[lengthSym]);
+      const distSym = decodeSymbol(d, dt);
+      const dist = readBits(d, DIST_BITS[distSym], DIST_BASE[distSym]);
+      const offs = out.len - dist;
+      for (let i = 0; i < length; i++) out.push(out.buf[offs + i]);
+    }
+  }
+}
+function inflateUncompressedBlock(d, out) {
+  d.bitcount = 0;
+  let length = d.source[d.index + 1] * 256 + d.source[d.index];
+  d.index += 4;
+  for (; length; length--) out.push(d.source[d.index++]);
+}
+function inflateRaw(source) {
+  const d = new Reader(source);
+  const out = new Out();
+  const lt = new Tree();
+  const dt = new Tree();
+  let bfinal;
+  do {
+    bfinal = getBit(d);
+    const btype = readBits(d, 2, 0);
+    if (btype === 0) {
+      inflateUncompressedBlock(d, out);
+    } else if (btype === 1) {
+      buildFixedTrees(lt, dt);
+      inflateBlockData(d, out, lt, dt);
+    } else if (btype === 2) {
+      decodeTrees(d, lt, dt);
+      inflateBlockData(d, out, lt, dt);
+    } else {
+      throw new Error("holy-sheet: invalid DEFLATE block type");
+    }
+  } while (!bfinal);
+  return out.buf.subarray(0, out.len);
+}
+
+// src/zip/zip-reader.ts
+var decoder = new TextDecoder();
+function unzipSync(data) {
+  const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  let eocd = -1;
+  for (let i = data.length - 22; i >= 0; i--) {
+    if (dv.getUint32(i, true) === 101010256) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new Error("holy-sheet: not a zip archive (no EOCD record)");
+  const count = dv.getUint16(eocd + 10, true);
+  let cd = dv.getUint32(eocd + 16, true);
+  const result = {};
+  for (let n = 0; n < count; n++) {
+    if (dv.getUint32(cd, true) !== 33639248) break;
+    const method = dv.getUint16(cd + 10, true);
+    const compSize = dv.getUint32(cd + 20, true);
+    const nameLen = dv.getUint16(cd + 28, true);
+    const extraLen = dv.getUint16(cd + 30, true);
+    const commentLen = dv.getUint16(cd + 32, true);
+    const localOffset = dv.getUint32(cd + 42, true);
+    const name = decoder.decode(data.subarray(cd + 46, cd + 46 + nameLen));
+    const lhNameLen = dv.getUint16(localOffset + 26, true);
+    const lhExtraLen = dv.getUint16(localOffset + 28, true);
+    const dataStart = localOffset + 30 + lhNameLen + lhExtraLen;
+    const raw = data.subarray(dataStart, dataStart + compSize);
+    let content;
+    if (method === 0) content = raw.slice();
+    else if (method === 8) content = inflateRaw(raw);
+    else throw new Error(`holy-sheet: unsupported zip method ${method} for "${name}"`);
+    result[name] = content;
+    cd += 46 + nameLen + extraLen + commentLen;
+  }
+  return result;
+}
+
+// src/reader/xml.ts
+function localName(name) {
+  const idx = name.indexOf(":");
+  return idx >= 0 ? name.slice(idx + 1) : name;
+}
+function unescapeXml(s) {
+  if (s.indexOf("&") < 0) return s;
+  return s.replace(/&(#x?[0-9a-fA-F]+|\w+);/g, (m, ent) => {
+    switch (ent) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default:
+        if (ent[0] === "#") {
+          const code = ent[1] === "x" || ent[1] === "X" ? parseInt(ent.slice(2), 16) : parseInt(ent.slice(1), 10);
+          return Number.isFinite(code) ? String.fromCodePoint(code) : m;
+        }
+        return m;
+    }
+  });
+}
+function findTagEnd(src, from) {
+  let quote = "";
+  for (let i = from; i < src.length; i++) {
+    const ch = src[i];
+    if (quote) {
+      if (ch === quote) quote = "";
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+    } else if (ch === ">") {
+      return i;
+    }
+  }
+  return src.length;
+}
+var ATTR_RE = /([^\s=/]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+function parseTag(inner) {
+  const trimmed = inner.trim();
+  let i = 0;
+  while (i < trimmed.length && !/\s/.test(trimmed[i])) i++;
+  const name = trimmed.slice(0, i);
+  const attrs = {};
+  const rest = trimmed.slice(i);
+  for (const m of rest.matchAll(ATTR_RE)) {
+    const key = localName(m[1]);
+    const value = unescapeXml(m[3] ?? m[4] ?? "");
+    attrs[key] = value;
+  }
+  return { name, attrs };
+}
+function parseXml(src) {
+  let i = 0;
+  const n = src.length;
+  const root = { name: "#root", attrs: {}, children: [], text: "" };
+  const stack = [root];
+  while (i < n) {
+    if (src[i] === "<") {
+      if (src.startsWith("<!--", i)) {
+        const end2 = src.indexOf("-->", i);
+        i = end2 < 0 ? n : end2 + 3;
+        continue;
+      }
+      if (src.startsWith("<![CDATA[", i)) {
+        const end2 = src.indexOf("]]>", i);
+        stack[stack.length - 1].text += src.slice(i + 9, end2 < 0 ? n : end2);
+        i = end2 < 0 ? n : end2 + 3;
+        continue;
+      }
+      if (src.startsWith("<?", i)) {
+        const end2 = src.indexOf("?>", i);
+        i = end2 < 0 ? n : end2 + 2;
+        continue;
+      }
+      if (src.startsWith("<!", i)) {
+        const end2 = src.indexOf(">", i);
+        i = end2 < 0 ? n : end2 + 1;
+        continue;
+      }
+      if (src[i + 1] === "/") {
+        const end2 = src.indexOf(">", i);
+        if (stack.length > 1) stack.pop();
+        i = end2 < 0 ? n : end2 + 1;
+        continue;
+      }
+      const end = findTagEnd(src, i + 1);
+      const tagContent = src.slice(i + 1, end);
+      const selfClosing = tagContent.endsWith("/");
+      const { name, attrs } = parseTag(selfClosing ? tagContent.slice(0, -1) : tagContent);
+      const node = { name: localName(name), attrs, children: [], text: "" };
+      stack[stack.length - 1].children.push(node);
+      if (!selfClosing) stack.push(node);
+      i = end + 1;
+    } else {
+      const next = src.indexOf("<", i);
+      const stop = next < 0 ? n : next;
+      stack[stack.length - 1].text += unescapeXml(src.slice(i, stop));
+      i = stop;
+    }
+  }
+  return root.children[0] ?? null;
+}
+function el(node, name) {
+  return node?.children.find((c) => c.name === name);
+}
+function els(node, name) {
+  return node ? node.children.filter((c) => c.name === name) : [];
+}
+function at(node, name) {
+  return node?.attrs[name];
+}
+
+// src/reader/comments-parser.ts
+var CommentsParser = {
+  parse(commentsXml) {
+    const xml = parseXml(commentsXml);
+    if (!xml) return {};
+    const authors = els(el(xml, "authors"), "author").map((a) => a.text);
+    const out = {};
+    for (const c of els(el(xml, "commentList"), "comment")) {
+      const ref = c.attrs["ref"] ?? "";
+      const authorIdx = c.attrs["authorId"] !== void 0 ? parseInt(c.attrs["authorId"], 10) : -1;
+      const author = authors[authorIdx] ?? null;
+      out[ref] = new CellComment(extractText(el(c, "text")), author);
+    }
+    return out;
+  }
+};
+function extractText(textNode) {
+  if (!textNode) return "";
+  const parts = [];
+  for (const r of els(textNode, "r")) parts.push(el(r, "t")?.text ?? "");
+  for (const t of els(textNode, "t")) parts.push(t.text);
+  return parts.join("");
+}
+
+// src/reader/format/date-inverter.ts
+var DateInverter = {
+  toIso(serial, includeTime = false) {
+    const epoch = Date.UTC(1899, 11, 30, 0, 0, 0);
+    const ms = epoch + Math.round(serial * 86400) * 1e3;
+    const d = new Date(ms);
+    const pad = (n) => String(n).padStart(2, "0");
+    const date = `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
+    if (!includeTime) return date;
+    return `${date}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}Z`;
+  }
+};
+
+// src/reader/rels-parser.ts
+var RelsParser = {
+  parse(relsXml) {
+    const xml = parseXml(relsXml);
+    if (!xml) return {};
+    const rels = {};
+    for (const rel of els(xml, "Relationship")) {
+      const id = rel.attrs["Id"] ?? "";
+      rels[id] = { Target: rel.attrs["Target"] ?? "", Type: rel.attrs["Type"] ?? "" };
+    }
+    return rels;
+  },
+  byType(rels, typeUriContains) {
+    const out = {};
+    for (const [id, rel] of Object.entries(rels)) {
+      if (rel.Type.includes(typeUriContains)) out[id] = rel;
+    }
+    return out;
+  }
+};
+
+// src/reader/shared-strings-parser.ts
+var SharedStringsParser = {
+  parse(xml) {
+    const doc = parseXml(xml);
+    if (!doc) return [];
+    return els(doc, "si").map(renderSi);
+  }
+};
+function renderSi(si) {
+  const t = el(si, "t");
+  if (t) return t.text;
+  return els(si, "r").map((run) => el(run, "t")?.text ?? "").join("");
+}
+
+// src/reader/format/num-fmt-parser.ts
+var BUILTIN = {
+  0: "General",
+  1: "0",
+  2: "0.00",
+  3: "#,##0",
+  4: "#,##0.00",
+  9: "0%",
+  10: "0.00%",
+  11: "0.00E+00",
+  12: "# ?/?",
+  13: "# ??/??",
+  14: "mm-dd-yy",
+  15: "d-mmm-yy",
+  16: "d-mmm",
+  17: "mmm-yy",
+  18: "h:mm AM/PM",
+  19: "h:mm:ss AM/PM",
+  20: "h:mm",
+  21: "h:mm:ss",
+  22: "m/d/yy h:mm",
+  37: "#,##0 ;(#,##0)",
+  38: "#,##0 ;[Red](#,##0)",
+  39: "#,##0.00;(#,##0.00)",
+  40: "#,##0.00;[Red](#,##0.00)",
+  45: "mm:ss",
+  46: "[h]:mm:ss",
+  47: "mmss.0",
+  48: "##0.0E+0",
+  49: "@"
+};
+var SYMBOL_TO_ISO = {
+  $: "USD",
+  "\u20AC": "EUR",
+  "\xA3": "GBP",
+  "\xA5": "JPY",
+  "\u20B9": "INR",
+  "\u20A9": "KRW"
+};
+var NumFmtParser = {
+  parse(formatCode) {
+    if (formatCode === null) return null;
+    const code = formatCode;
+    if (code === "" || code === "General" || code === "@") {
+      return { displayFormat: code === "@" ? "text" : "auto" };
+    }
+    if (looksLikeDate(code)) {
+      return { displayFormat: hasTimeComponent(code) ? "datetime" : "date" };
+    }
+    if (code.includes("%")) {
+      return { displayFormat: "percentage", decimals: decimalsAfter(code) };
+    }
+    const m = /^"([^"]+)"/u.exec(code);
+    if (m) {
+      const iso = SYMBOL_TO_ISO[m[1]];
+      const result = { displayFormat: "currency", decimals: decimalsAfter(code) };
+      if (iso !== void 0) result.currency = iso;
+      return result;
+    }
+    if (/^#?,?#?#?0(\.0+)?$/.test(code.split(";")[0])) {
+      return { displayFormat: "number", decimals: decimalsAfter(code) };
+    }
+    return null;
+  },
+  parseBuiltin(id) {
+    const code = BUILTIN[id];
+    if (code === void 0) return null;
+    return NumFmtParser.parse(code);
+  }
+};
+function looksLikeDate(code) {
+  const stripped = code.replace(/"[^"]*"|\[[^\]]*\]/gu, "");
+  return /[ymd]/i.test(stripped);
+}
+function hasTimeComponent(code) {
+  const stripped = code.replace(/"[^"]*"|\[[^\]]*\]/gu, "");
+  return /[hHsS]/.test(stripped) || stripped.toLowerCase().includes("mm:");
+}
+function decimalsAfter(code) {
+  const section = code.split(";")[0];
+  const m = /0\.(0+)/.exec(section);
+  return m ? m[1].length : 0;
+}
+
+// src/reader/styles-parser.ts
+var StylesParser = {
+  parse(stylesXml) {
+    const xml = parseXml(stylesXml);
+    if (!xml) return [];
+    const numFmts = parseNumFmts(xml);
+    const fonts = parseFonts(xml);
+    const fills = parseFills(xml);
+    const borders = parseBorders(xml);
+    const xfs = [];
+    for (const xf of els(el(xml, "cellXfs"), "xf")) {
+      const fontId = xf.attrs["fontId"] !== void 0 ? parseInt(xf.attrs["fontId"], 10) : 0;
+      const fillId = xf.attrs["fillId"] !== void 0 ? parseInt(xf.attrs["fillId"], 10) : 0;
+      const borderId = xf.attrs["borderId"] !== void 0 ? parseInt(xf.attrs["borderId"], 10) : 0;
+      const numFmtId = xf.attrs["numFmtId"] !== void 0 ? parseInt(xf.attrs["numFmtId"], 10) : 0;
+      const alignment = el(xf, "alignment");
+      const align = alignment && alignment.attrs["horizontal"] !== void 0 ? alignment.attrs["horizontal"] : null;
+      const font = fonts[fontId] ?? null;
+      const fill = fills[fillId] ?? null;
+      const border = borders[borderId] ?? null;
+      const customCode = numFmts[numFmtId];
+      const numFmtParsed = customCode !== void 0 ? NumFmtParser.parse(customCode) : NumFmtParser.parseBuiltin(numFmtId);
+      if (xfs.length === 0 && font === null && fill === null && border === null && !numFmtParsed && align === null) {
+        xfs.push(null);
+        continue;
+      }
+      xfs.push(buildCellFormat(font, fill, border, numFmtParsed, align));
+    }
+    return xfs;
+  }
+};
+function parseNumFmts(xml) {
+  const map = {};
+  for (const nf of els(el(xml, "numFmts"), "numFmt")) {
+    map[parseInt(nf.attrs["numFmtId"] ?? "0", 10)] = nf.attrs["formatCode"] ?? "";
+  }
+  return map;
+}
+function parseFonts(xml) {
+  return els(el(xml, "fonts"), "font").map((f) => {
+    const sz = el(f, "sz");
+    const color = el(f, "color");
+    return {
+      bold: !!el(f, "b"),
+      italic: !!el(f, "i"),
+      size: sz ? Math.trunc(Number(at(sz, "val"))) : 11,
+      color: color && at(color, "rgb") !== void 0 ? argbToHex(at(color, "rgb")) : null
+    };
+  });
+}
+function parseFills(xml) {
+  return els(el(xml, "fills"), "fill").map((fill) => {
+    const pf = el(fill, "patternFill");
+    const pattern = pf ? at(pf, "patternType") ?? "" : "none";
+    if (pattern !== "solid") return null;
+    const fg = el(pf, "fgColor");
+    return fg && at(fg, "rgb") !== void 0 ? argbToHex(at(fg, "rgb")) : null;
+  });
+}
+function parseBorders(xml) {
+  return els(el(xml, "borders"), "border").map((b) => {
+    const rec = { top: null, right: null, bottom: null, left: null };
+    for (const side of ["top", "right", "bottom", "left"]) {
+      const sideEl = el(b, side);
+      const color = el(sideEl, "color");
+      if (sideEl && at(sideEl, "style") !== void 0 && at(sideEl, "style") !== "" && color && at(color, "rgb") !== void 0) {
+        rec[side] = argbToHex(at(color, "rgb"));
+      }
+    }
+    return rec;
+  });
+}
+function buildCellFormat(font, fill, border, numFmt, align) {
+  return new CellFormat({
+    bold: font?.bold ?? false,
+    italic: font?.italic ?? false,
+    textAlign: align,
+    displayFormat: numFmt?.displayFormat ?? null,
+    decimals: numFmt?.decimals ?? null,
+    color: font?.color ?? null,
+    backgroundColor: fill,
+    fontSize: font && font.size !== 11 ? font.size : null,
+    borderTop: border?.top ?? null,
+    borderRight: border?.right ?? null,
+    borderBottom: border?.bottom ?? null,
+    borderLeft: border?.left ?? null,
+    currency: numFmt?.currency ?? null
+  });
+}
+function argbToHex(argb) {
+  const a = argb.toUpperCase();
+  if (a.length === 8) return "#" + a.slice(2);
+  if (a.length === 6) return "#" + a;
+  return "#000000";
+}
+
+// src/reader/worksheet-parser.ts
+var WorksheetParser = {
+  parse(worksheetXml, name, stylesIndex, comments = {}, sharedStrings = []) {
+    const xml = parseXml(worksheetXml);
+    if (!xml) return new Sheet(name);
+    const cells = parseCells(xml, stylesIndex, comments, sharedStrings);
+    const merges = parseMerges(xml);
+    const columnWidths = parseColumnWidths(xml);
+    const [frozenRows, frozenCols] = parseFrozen(xml);
+    return new Sheet(name, cells, merges, columnWidths, frozenRows, frozenCols);
+  }
+};
+function parseCells(xml, stylesIndex, comments, sharedStrings) {
+  const cells = /* @__PURE__ */ new Map();
+  const sheetData = el(xml, "sheetData");
+  if (!sheetData) return cells;
+  for (const row of els(sheetData, "row")) {
+    for (const c of els(row, "c")) {
+      const address = c.attrs["r"] ?? "";
+      if (address === "") continue;
+      const type = c.attrs["t"] ?? "n";
+      const styleIdx = c.attrs["s"] !== void 0 ? parseInt(c.attrs["s"], 10) : 0;
+      const format = stylesIndex[styleIdx] ?? null;
+      let formula = null;
+      let cachedValue = null;
+      let value = null;
+      const f = el(c, "f");
+      const v = el(c, "v");
+      if (f) {
+        formula = f.text;
+        cachedValue = v ? coerceValue(v.text, type) : null;
+      } else if (type === "inlineStr" && el(c, "is") && el(el(c, "is"), "t")) {
+        value = el(el(c, "is"), "t").text;
+      } else if (type === "s" && v) {
+        const idx = parseInt(v.text, 10);
+        value = sharedStrings[idx] ?? "";
+      } else if (v) {
+        value = coerceValue(v.text, type);
+      }
+      const comment = comments[address] ?? null;
+      cells.set(address, new Cell(address, value, formula, format, comment, cachedValue));
+    }
+  }
+  return cells;
+}
+function coerceValue(raw, type) {
+  if (type === "b") return raw === "1" || raw === "true" || raw === "TRUE";
+  if (type === "str") return raw;
+  if (type === "inlineStr") return raw;
+  if (raw === "") return null;
+  if (/^-?\d+$/.test(raw)) return parseInt(raw, 10);
+  if (/^\s*[+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/.test(raw)) return parseFloat(raw);
+  return raw;
+}
+function parseMerges(xml) {
+  const out = [];
+  for (const m of els(el(xml, "mergeCells"), "mergeCell")) {
+    const ref = m.attrs["ref"] ?? "";
+    if (ref.includes(":")) {
+      const [start, end] = ref.split(":", 2);
+      out.push(new MergedRegion(start, end));
+    }
+  }
+  return out;
+}
+function parseColumnWidths(xml) {
+  const out = /* @__PURE__ */ new Map();
+  for (const col of els(el(xml, "cols"), "col")) {
+    if (col.attrs["customWidth"] === void 0) continue;
+    const min = parseInt(col.attrs["min"] ?? "0", 10);
+    const max = parseInt(col.attrs["max"] ?? "0", 10);
+    const excelWidth = Number(col.attrs["width"] ?? "0");
+    const px = excelWidth * 7 + 5;
+    for (let i = min; i <= max; i++) out.set(i - 1, Math.round(px));
+  }
+  return out;
+}
+function parseFrozen(xml) {
+  for (const view of els(el(xml, "sheetViews"), "sheetView")) {
+    const pane = el(view, "pane");
+    if (!pane) continue;
+    const rows = at(pane, "ySplit") !== void 0 ? parseInt(at(pane, "ySplit"), 10) : 0;
+    const cols = at(pane, "xSplit") !== void 0 ? parseInt(at(pane, "xSplit"), 10) : 0;
+    return [rows, cols];
+  }
+  return [0, 0];
+}
+
+// src/reader/xlsx-reader.ts
+var decoder2 = new TextDecoder();
+var XlsxReader = class {
+  describe(bytes) {
+    return this.workbookToSchema(this.readWorkbook(bytes));
+  }
+  readWorkbook(bytes) {
+    const files = unzipSync(bytes);
+    const getText = (name) => files[name] ? decoder2.decode(files[name]) : null;
+    const stylesXml = getText("xl/styles.xml");
+    const stylesIndex = stylesXml ? StylesParser.parse(stylesXml) : [];
+    const sharedStringsXml = getText("xl/sharedStrings.xml");
+    const sharedStrings = sharedStringsXml ? SharedStringsParser.parse(sharedStringsXml) : [];
+    const workbookXml = getText("xl/workbook.xml");
+    if (workbookXml === null) throw new Error("[holy-sheet] missing xl/workbook.xml");
+    const workbookRelsXml = getText("xl/_rels/workbook.xml.rels");
+    const workbookRels = workbookRelsXml ? RelsParser.parse(workbookRelsXml) : {};
+    const workbookDoc = parseXml(workbookXml);
+    if (!workbookDoc) throw new Error("[holy-sheet] failed to parse xl/workbook.xml");
+    const sheets = [];
+    let i = 0;
+    for (const sheetEl of els(el(workbookDoc, "sheets"), "sheet")) {
+      const name = at(sheetEl, "name") ?? "";
+      const rId = at(sheetEl, "id") ?? "";
+      const target = workbookRels[rId]?.Target;
+      if (target == null) continue;
+      const sheetPath = "xl/" + target.replace(/^\//, "");
+      const worksheetXml = getText(sheetPath);
+      if (worksheetXml === null) continue;
+      const sheetNum = i + 1;
+      const sheetRelsXml = getText(`xl/worksheets/_rels/sheet${sheetNum}.xml.rels`);
+      let comments = {};
+      if (sheetRelsXml) {
+        const sheetRels = RelsParser.parse(sheetRelsXml);
+        for (const cr of Object.values(RelsParser.byType(sheetRels, "/comments"))) {
+          const commentsPath = resolveRelativePath(sheetPath, cr.Target);
+          const commentsXml = getText(commentsPath);
+          if (commentsXml) comments = { ...comments, ...CommentsParser.parse(commentsXml) };
+        }
+      }
+      sheets.push(WorksheetParser.parse(worksheetXml, name, stylesIndex, comments, sharedStrings));
+      i++;
+    }
+    const meta = this.parseDocProps(getText("docProps/core.xml"));
+    return new Workbook(sheets, meta);
+  }
+  parseDocProps(coreXml) {
+    if (coreXml === null) return {};
+    const core = parseXml(coreXml);
+    if (!core) return {};
+    const meta = {};
+    const creator = el(core, "creator");
+    if (creator) meta["creator"] = creator.text;
+    const created = el(core, "created");
+    if (created) meta["created"] = created.text;
+    return meta;
+  }
+  workbookToSchema(workbook) {
+    const schema = { sheets: workbook.sheets.map((s) => this.sheetToSchema(s)) };
+    if (Object.keys(workbook.meta).length > 0) schema["meta"] = workbook.meta;
+    return schema;
+  }
+  sheetToSchema(sheet) {
+    const cells = {};
+    for (const [address, cell] of sheet.cells) {
+      const cellSchema = this.cellToSchema(cell);
+      if (cellSchema === null) continue;
+      cells[address] = cellSchema;
+    }
+    const out = { name: sheet.name, cells };
+    if (sheet.mergedRegions.length > 0) {
+      out["mergedRegions"] = sheet.mergedRegions.map((m) => ({ start: m.start, end: m.end }));
+    }
+    if (sheet.columnWidths.size > 0) {
+      const widths = {};
+      for (const [k, v] of sheet.columnWidths) widths[k] = v;
+      out["columnWidths"] = widths;
+    }
+    if (sheet.frozenRows > 0) out["frozenRows"] = sheet.frozenRows;
+    if (sheet.frozenCols > 0) out["frozenCols"] = sheet.frozenCols;
+    return out;
+  }
+  cellToSchema(cell) {
+    let value = cell.value;
+    const format = cell.format;
+    if (format !== null && (format.displayFormat === "date" || format.displayFormat === "datetime") && isNumericString(value)) {
+      value = DateInverter.toIso(Number(value), format.displayFormat === "datetime");
+    }
+    const out = { value };
+    if (cell.formula !== null) out["formula"] = cell.formula;
+    if (cell.cachedValue !== null) out["computedValue"] = cell.cachedValue;
+    if (format !== null && !format.isEmpty()) out["format"] = formatToObject(format);
+    if (cell.comment !== null) out["comment"] = commentToObject(cell.comment);
+    if (Object.keys(out).length === 1 && out["value"] === null) return null;
+    return out;
+  }
+};
+function formatToObject(f) {
+  const out = {};
+  if (f.bold) out["bold"] = true;
+  if (f.italic) out["italic"] = true;
+  if (f.textAlign !== null) out["textAlign"] = f.textAlign;
+  if (f.displayFormat !== null) out["displayFormat"] = f.displayFormat;
+  if (f.decimals !== null) out["decimals"] = f.decimals;
+  if (f.color !== null) out["color"] = f.color;
+  if (f.backgroundColor !== null) out["backgroundColor"] = f.backgroundColor;
+  if (f.fontSize !== null) out["fontSize"] = f.fontSize;
+  if (f.borderTop !== null) out["borderTop"] = f.borderTop;
+  if (f.borderRight !== null) out["borderRight"] = f.borderRight;
+  if (f.borderBottom !== null) out["borderBottom"] = f.borderBottom;
+  if (f.borderLeft !== null) out["borderLeft"] = f.borderLeft;
+  if (f.currency !== null) out["currency"] = f.currency;
+  return out;
+}
+function commentToObject(c) {
+  const out = { text: c.text };
+  if (c.author !== null) out["author"] = c.author;
+  if (c.color !== null) out["color"] = c.color;
+  return out;
+}
+function resolveRelativePath(base, target) {
+  const baseDir = base.includes("/") ? base.slice(0, base.lastIndexOf("/")) : ".";
+  const combined = baseDir + "/" + target;
+  const parts = [];
+  for (const segment of combined.split("/")) {
+    if (segment === "..") parts.pop();
+    else if (segment !== "" && segment !== ".") parts.push(segment);
+  }
+  return parts.join("/");
+}
+
+// src/xml.ts
+var CONTROL_CHARS = new RegExp("[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F]", "g");
+function xmlEscape(s) {
+  return s.replace(CONTROL_CHARS, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/writer/format/num-fmt-builder.ts
+var NumFmtBuilder = {
+  build(format) {
+    const df = format.displayFormat;
+    const decimals = format.decimals;
+    if (df === null || df === "auto" || df === "text") return null;
+    switch (df) {
+      case "number":
+        return numberFormat(decimals);
+      case "percentage":
+        return percentFormat(decimals);
+      case "currency":
+        return currencyFormat(format.currency, decimals);
+      case "date":
+        return "yyyy-mm-dd";
+      case "datetime":
+        return "yyyy-mm-dd hh:mm:ss";
+      default:
+        return null;
+    }
+  }
+};
+function numberFormat(decimals) {
+  if (decimals === null || decimals <= 0) return "#,##0";
+  return "#,##0." + "0".repeat(decimals);
+}
+function percentFormat(decimals) {
+  const d = decimals ?? 1;
+  if (d <= 0) return "0%";
+  return "0." + "0".repeat(d) + "%";
+}
+function currencyFormat(currency, decimals) {
+  const symbol = currencySymbol(currency ?? "USD");
+  const d = decimals ?? 2;
+  const body = d <= 0 ? "#,##0" : "#,##0." + "0".repeat(d);
+  return `"${symbol}"${body};-"${symbol}"${body}`;
+}
+function currencySymbol(iso) {
+  switch (iso.toUpperCase()) {
+    case "USD":
+      return "$";
+    case "EUR":
+      return "\u20AC";
+    case "GBP":
+      return "\xA3";
+    case "JPY":
+      return "\xA5";
+    case "CNY":
+      return "\xA5";
+    case "INR":
+      return "\u20B9";
+    case "AUD":
+      return "A$";
+    case "CAD":
+      return "C$";
+    case "CHF":
+      return "CHF";
+    case "KRW":
+      return "\u20A9";
+    default:
+      return iso + " ";
+  }
+}
+
+// src/writer/styles-registry.ts
+var StylesRegistry = class {
+  constructor() {
+    this.xfIndex = /* @__PURE__ */ new Map([["__default__", 0]]);
+    this.xfs = [{ fontId: 0, fillId: 0, borderId: 0, numFmtId: 0, align: null }];
+    this.fontIndex = /* @__PURE__ */ new Map([["__default__", 0]]);
+    this.fonts = [{ size: 11, name: "Calibri", color: null, bold: false, italic: false }];
+    this.fillIndex = /* @__PURE__ */ new Map([
+      ["__none__", 0],
+      ["__gray125__", 1]
+    ]);
+    this.fills = [
+      { type: "none" },
+      { type: "gray125" }
+    ];
+    this.borderIndex = /* @__PURE__ */ new Map([["__default__", 0]]);
+    this.borders = [{ top: null, right: null, bottom: null, left: null }];
+    this.numFmtIndex = /* @__PURE__ */ new Map();
+    this.numFmts = /* @__PURE__ */ new Map();
+    this.nextNumFmtId = 164;
+  }
+  register(format) {
+    if (format === null || format.isEmpty()) return 0;
+    const key = format.key();
+    const existing = this.xfIndex.get(key);
+    if (existing !== void 0) return existing;
+    const fontId = this.fontFor(format);
+    const fillId = this.fillFor(format);
+    const borderId = this.borderFor(format);
+    const numFmtId = this.numFmtFor(format);
+    this.xfs.push({ fontId, fillId, borderId, numFmtId, align: format.textAlign });
+    const idx = this.xfs.length - 1;
+    this.xfIndex.set(key, idx);
+    return idx;
+  }
+  fontFor(f) {
+    const rec = {
+      size: f.fontSize ?? 11,
+      name: "Calibri",
+      color: f.color,
+      bold: f.bold,
+      italic: f.italic
+    };
+    const key = JSON.stringify(rec);
+    const existing = this.fontIndex.get(key);
+    if (existing !== void 0) return existing;
+    this.fonts.push(rec);
+    const idx = this.fonts.length - 1;
+    this.fontIndex.set(key, idx);
+    return idx;
+  }
+  fillFor(f) {
+    if (f.backgroundColor === null) return 0;
+    const key = f.backgroundColor.toUpperCase();
+    const existing = this.fillIndex.get(key);
+    if (existing !== void 0) return existing;
+    this.fills.push({ type: "solid", fg: key });
+    const idx = this.fills.length - 1;
+    this.fillIndex.set(key, idx);
+    return idx;
+  }
+  borderFor(f) {
+    if (!f.borderTop && !f.borderRight && !f.borderBottom && !f.borderLeft) return 0;
+    const rec = {
+      top: f.borderTop,
+      right: f.borderRight,
+      bottom: f.borderBottom,
+      left: f.borderLeft
+    };
+    const key = JSON.stringify(rec);
+    const existing = this.borderIndex.get(key);
+    if (existing !== void 0) return existing;
+    this.borders.push(rec);
+    const idx = this.borders.length - 1;
+    this.borderIndex.set(key, idx);
+    return idx;
+  }
+  numFmtFor(f) {
+    const code = NumFmtBuilder.build(f);
+    if (code === null) return 0;
+    const existing = this.numFmtIndex.get(code);
+    if (existing !== void 0) return existing;
+    const id = this.nextNumFmtId++;
+    this.numFmts.set(id, code);
+    this.numFmtIndex.set(code, id);
+    return id;
+  }
+  toXml() {
+    let numFmtsXml = "";
+    if (this.numFmts.size > 0) {
+      let records = "";
+      for (const [id, code] of this.numFmts) {
+        records += `<numFmt numFmtId="${id}" formatCode="${xmlEscape(code)}"/>`;
+      }
+      numFmtsXml = `<numFmts count="${this.numFmts.size}">${records}</numFmts>`;
+    }
+    let fontsXml = `<fonts count="${this.fonts.length}">`;
+    for (const f of this.fonts) {
+      fontsXml += "<font>";
+      fontsXml += `<sz val="${Number(f.size)}"/>`;
+      if (f.bold) fontsXml += "<b/>";
+      if (f.italic) fontsXml += "<i/>";
+      if (f.color) fontsXml += `<color rgb="${hexToArgb(f.color)}"/>`;
+      fontsXml += `<name val="${xmlEscape(f.name)}"/>`;
+      fontsXml += "</font>";
+    }
+    fontsXml += "</fonts>";
+    let fillsXml = `<fills count="${this.fills.length}">`;
+    for (const fill of this.fills) {
+      if (fill.type === "none") {
+        fillsXml += '<fill><patternFill patternType="none"/></fill>';
+      } else if (fill.type === "gray125") {
+        fillsXml += '<fill><patternFill patternType="gray125"/></fill>';
+      } else {
+        fillsXml += `<fill><patternFill patternType="solid"><fgColor rgb="${hexToArgb(fill.fg)}"/></patternFill></fill>`;
+      }
+    }
+    fillsXml += "</fills>";
+    let bordersXml = `<borders count="${this.borders.length}">`;
+    for (const b of this.borders) {
+      bordersXml += "<border>";
+      for (const side of ["left", "right", "top", "bottom"]) {
+        const color = b[side];
+        if (!color) {
+          bordersXml += `<${side}/>`;
+        } else {
+          bordersXml += `<${side} style="thin"><color rgb="${hexToArgb(color)}"/></${side}>`;
+        }
+      }
+      bordersXml += "<diagonal/></border>";
+    }
+    bordersXml += "</borders>";
+    let cellXfsXml = `<cellXfs count="${this.xfs.length}">`;
+    for (const xf of this.xfs) {
+      let apply = "";
+      if (xf.fontId > 0) apply += ' applyFont="1"';
+      if (xf.fillId > 0) apply += ' applyFill="1"';
+      if (xf.borderId > 0) apply += ' applyBorder="1"';
+      if (xf.numFmtId > 0) apply += ' applyNumberFormat="1"';
+      if (xf.align) apply += ' applyAlignment="1"';
+      cellXfsXml += `<xf numFmtId="${xf.numFmtId}" fontId="${xf.fontId}" fillId="${xf.fillId}" borderId="${xf.borderId}" xfId="0"${apply}>`;
+      if (xf.align) cellXfsXml += `<alignment horizontal="${xmlEscape(xf.align)}"/>`;
+      cellXfsXml += "</xf>";
+    }
+    cellXfsXml += "</cellXfs>";
+    return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' + numFmtsXml + fontsXml + fillsXml + bordersXml + '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>' + cellXfsXml + '<cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles><dxfs count="0"/><tableStyles count="0" defaultTableStyle="TableStyleMedium2" defaultPivotStyle="PivotStyleLight16"/></styleSheet>';
+  }
+};
+function hexToArgb(hex) {
+  const h = hex.replace(/^#/, "");
+  if (h.length === 6) return "FF" + h.toUpperCase();
+  if (h.length === 8) return h.toUpperCase();
+  return "FF000000";
+}
+
+// src/writer/xlsx-writer.ts
+var encoder2 = new TextEncoder();
+var XlsxWriter = class {
+  toBytes(workbook) {
+    const styles = new StylesRegistry();
+    const sheetXmls = workbook.sheets.map((sheet) => this.sheetXml(sheet, styles));
+    const sheetsWithComments = [];
+    workbook.sheets.forEach((sheet, i) => {
+      if (sheet.hasComments()) sheetsWithComments.push(i);
+    });
+    const files = [];
+    const add = (name, xml) => {
+      files.push({ name, data: encoder2.encode(xml) });
+    };
+    add("[Content_Types].xml", this.contentTypesXml(workbook, sheetsWithComments));
+    add("_rels/.rels", this.rootRelsXml());
+    add("xl/workbook.xml", this.workbookXml(workbook));
+    add("xl/_rels/workbook.xml.rels", this.workbookRelsXml(workbook));
+    add("xl/styles.xml", styles.toXml());
+    add("docProps/core.xml", this.coreXml(workbook));
+    add("docProps/app.xml", this.appXml());
+    workbook.sheets.forEach((sheet, i) => {
+      const n = i + 1;
+      add(`xl/worksheets/sheet${n}.xml`, sheetXmls[i]);
+      if (sheet.hasComments()) {
+        add(`xl/worksheets/_rels/sheet${n}.xml.rels`, this.sheetRelsXml(n));
+        add(`xl/comments${n}.xml`, this.commentsXml(sheet));
+        add(`xl/drawings/vmlDrawing${n}.vml`, this.vmlDrawingXml(sheet));
+      }
+    });
+    return zipSync(files);
+  }
+  contentTypesXml(workbook, sheetsWithComments) {
+    let overrides = '<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/><Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/><Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/><Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>';
+    workbook.sheets.forEach((_, i) => {
+      const n = i + 1;
+      overrides += `<Override PartName="/xl/worksheets/sheet${n}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`;
+    });
+    for (const i of sheetsWithComments) {
+      const n = i + 1;
+      overrides += `<Override PartName="/xl/comments${n}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"/>`;
+    }
+    let defaults = '<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/>';
+    if (sheetsWithComments.length > 0) {
+      defaults += '<Default Extension="vml" ContentType="application/vnd.openxmlformats-officedocument.vmlDrawing"/>';
+    }
+    return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">' + defaults + overrides + "</Types>";
+  }
+  rootRelsXml() {
+    return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/><Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/></Relationships>';
+  }
+  workbookXml(workbook) {
+    let sheets = "";
+    workbook.sheets.forEach((sheet, i) => {
+      const name = this.escape(sheet.name);
+      const sheetId = i + 1;
+      const rId = "rId" + (i + 1);
+      sheets += `<sheet name="${name}" sheetId="${sheetId}" r:id="${rId}"/>`;
+    });
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets>${sheets}</sheets></workbook>`;
+  }
+  workbookRelsXml(workbook) {
+    let rels = "";
+    workbook.sheets.forEach((_, i) => {
+      const rId = "rId" + (i + 1);
+      rels += `<Relationship Id="${rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${i + 1}.xml"/>`;
+    });
+    rels += `<Relationship Id="rId${workbook.sheets.length + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`;
+    return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">' + rels + "</Relationships>";
+  }
+  sheetRelsXml(sheetNum) {
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing" Target="../drawings/vmlDrawing${sheetNum}.vml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments" Target="../comments${sheetNum}.xml"/></Relationships>`;
+  }
+  sheetXml(sheet, styles) {
+    let sheetViewsXml = "";
+    if (sheet.frozenRows > 0 || sheet.frozenCols > 0) {
+      const topLeft = CellAddress.letter(sheet.frozenCols) + (sheet.frozenRows + 1);
+      const pane = "<pane" + (sheet.frozenCols > 0 ? ` xSplit="${sheet.frozenCols}"` : "") + (sheet.frozenRows > 0 ? ` ySplit="${sheet.frozenRows}"` : "") + ` topLeftCell="${topLeft}" activePane="bottomRight" state="frozen"/>`;
+      sheetViewsXml = `<sheetViews><sheetView workbookViewId="0">${pane}</sheetView></sheetViews>`;
+    }
+    let colsXml = "";
+    if (sheet.columnWidths.size > 0) {
+      colsXml = "<cols>";
+      for (const [colIdx, px] of sheet.columnWidths) {
+        const excelWidth = Math.max(1, (px - 5) / 7);
+        const colNum = colIdx + 1;
+        colsXml += `<col min="${colNum}" max="${colNum}" width="${excelWidth.toFixed(4)}" customWidth="1"/>`;
+      }
+      colsXml += "</cols>";
+    }
+    let rowsXml = "";
+    for (const [rowIndex, row] of sheet.rows()) {
+      let cellsXml = "";
+      const sortedCols = [...row.keys()].sort();
+      for (const col of sortedCols) {
+        cellsXml += this.cellXml(row.get(col), styles);
+      }
+      rowsXml += `<row r="${rowIndex}">${cellsXml}</row>`;
+    }
+    let mergesXml = "";
+    if (sheet.mergedRegions.length > 0) {
+      mergesXml = `<mergeCells count="${sheet.mergedRegions.length}">`;
+      for (const merge of sheet.mergedRegions) mergesXml += `<mergeCell ref="${merge.ref()}"/>`;
+      mergesXml += "</mergeCells>";
+    }
+    const legacyDrawing = sheet.hasComments() ? '<legacyDrawing r:id="rId1"/>' : "";
+    return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">' + sheetViewsXml + colsXml + `<sheetData>${rowsXml}</sheetData>` + mergesXml + legacyDrawing + "</worksheet>";
+  }
+  cellXml(cell, styles) {
+    const ref = cell.address;
+    const type = cell.excelType();
+    const styleIdx = styles.register(cell.format);
+    const sAttr = styleIdx > 0 ? ` s="${styleIdx}"` : "";
+    if (cell.formula !== null) {
+      const f = this.escape(cell.formula.replace(/^=+/, ""));
+      const cached = cell.cachedValue ?? cell.value;
+      const v2 = cached !== null ? `<v>${this.escape(String(cached))}</v>` : "";
+      return `<c r="${ref}"${sAttr}><f>${f}</f>${v2}</c>`;
+    }
+    if (type === "inlineStr") {
+      const t = this.escape(String(cell.value));
+      return `<c r="${ref}"${sAttr} t="inlineStr"><is><t xml:space="preserve">${t}</t></is></c>`;
+    }
+    if (type === "b") {
+      const v2 = cell.value === true ? "1" : "0";
+      return `<c r="${ref}"${sAttr} t="b"><v>${v2}</v></c>`;
+    }
+    if (cell.value === null) {
+      return `<c r="${ref}"${sAttr}/>`;
+    }
+    let v;
+    if (typeof cell.value === "number") {
+      v = Number.isInteger(cell.value) ? String(cell.value) : formatFloat(cell.value);
+    } else {
+      v = String(cell.value);
+    }
+    if (v === "") v = "0";
+    return `<c r="${ref}"${sAttr}><v>${v}</v></c>`;
+  }
+  commentsXml(sheet) {
+    const authors = [];
+    let commentList = "";
+    for (const entry of sheet.comments()) {
+      const author = entry.comment.author ?? "Author";
+      if (!authors.includes(author)) authors.push(author);
+      const authorIdx = authors.indexOf(author);
+      const text = this.escape(entry.comment.text);
+      commentList += `<comment ref="${entry.address}" authorId="${authorIdx}"><text><r><t xml:space="preserve">${text}</t></r></text></comment>`;
+    }
+    let authorsXml = "<authors>";
+    for (const a of authors) authorsXml += `<author>${this.escape(a)}</author>`;
+    authorsXml += "</authors>";
+    return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">' + authorsXml + `<commentList>${commentList}</commentList></comments>`;
+  }
+  vmlDrawingXml(sheet) {
+    let shapes = "";
+    let shapeId = 1024;
+    for (const entry of sheet.comments()) {
+      const m = /^([A-Z]+)(\d+)$/.exec(entry.address);
+      const col = CellAddress.index(m[1]);
+      const row = parseInt(m[2], 10) - 1;
+      shapeId++;
+      shapes += `<v:shape id="_x0000_s${shapeId}" type="#_x0000_t202" style="position:absolute;margin-left:60pt;margin-top:5pt;width:108pt;height:60pt;z-index:1;visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto"><v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/><v:path o:connecttype="none"/><v:textbox><div style="text-align:left"></div></v:textbox><x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>${col + 1}, 15, ${row}, 10, ${col + 3}, 31, ${row + 4}, 18</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>${row}</x:Row><x:Column>${col}</x:Column></x:ClientData></v:shape>`;
+    }
+    return '<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel"><o:shapelayout v:ext="edit"><o:idmap v:ext="edit" data="1"/></o:shapelayout><v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe"><v:stroke joinstyle="miter"/><v:path gradientshapeok="t" o:connecttype="rect"/></v:shapetype>' + shapes + "</xml>";
+  }
+  coreXml(workbook) {
+    const now = workbook.meta["created"] ?? gmDateZ();
+    const creator = this.escape(String(workbook.meta["creator"] ?? "Holy Sheet"));
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><dc:creator>${creator}</dc:creator><cp:lastModifiedBy>${creator}</cp:lastModifiedBy><dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created><dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified></cp:coreProperties>`;
+  }
+  appXml() {
+    return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"><Application>Holy Sheet</Application><DocSecurity>0</DocSecurity><ScaleCrop>false</ScaleCrop><SharedDoc>false</SharedDoc><HyperlinksChanged>false</HyperlinksChanged><AppVersion>1.0</AppVersion></Properties>';
+  }
+  escape(s) {
+    return xmlEscape(s);
+  }
+};
+function gmDateZ() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+
+// src/holy-sheet.schema.json
+var holy_sheet_schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://github.com/Particle-Academy/holy-sheet/skills/holy-sheet.schema.json",
+  title: "Holy Sheet workbook schema",
+  description: "Input format for HolySheet\\Agent::write(). Describes a multi-sheet xlsx workbook agentically. v0.2.0 supports scalar values, formulas (cached), and multiple sheets. Styles, formats, comments, merges land in subsequent minors.",
+  type: "object",
+  required: ["sheets"],
+  additionalProperties: false,
+  properties: {
+    sheets: {
+      type: "array",
+      minItems: 1,
+      description: "One or more sheets. The first sheet is shown when the file opens.",
+      items: { $ref: "#/definitions/Sheet" }
+    },
+    meta: {
+      type: "object",
+      description: "Optional workbook metadata surfaced in Excel's File \u2192 Info pane.",
+      properties: {
+        creator: { type: "string" },
+        created: { type: "string", description: "ISO-8601 datetime. Defaults to now()." }
+      },
+      additionalProperties: true
+    }
+  },
+  definitions: {
+    Sheet: {
+      type: "object",
+      required: ["name"],
+      additionalProperties: false,
+      oneOf: [
+        { required: ["columns", "rows"], description: "Row-oriented (agent-ergonomic)." },
+        { required: ["cells"], description: "Sparse A1-keyed map (fancy-sheets passthrough)." }
+      ],
+      properties: {
+        name: {
+          type: "string",
+          minLength: 1,
+          maxLength: 31,
+          description: "Tab label in Excel. Excel limits to 31 chars and forbids /\\?*[]:"
+        },
+        columns: {
+          type: "array",
+          items: { $ref: "#/definitions/Column" },
+          description: "When present, the first row is the header row. Column types are applied to every row in that column."
+        },
+        rows: {
+          type: "array",
+          items: {
+            type: "array",
+            description: "One row of cell values, in column order. Use null for missing values.",
+            items: { $ref: "#/definitions/CellValue" }
+          }
+        },
+        cells: {
+          type: "object",
+          description: "Sparse A1-keyed map. Use this shape when exporting from <Spreadsheet>.",
+          additionalProperties: { $ref: "#/definitions/CellData" },
+          patternProperties: {
+            "^[A-Z]+[1-9][0-9]*$": { $ref: "#/definitions/CellData" }
+          }
+        },
+        totals: {
+          type: "object",
+          description: "Symbolic aggregations appended below the data. Key = column header; value = aggregation. Lands in 0.7.",
+          additionalProperties: {
+            type: "string",
+            enum: ["sum", "avg", "count", "min", "max"]
+          }
+        },
+        theme: {
+          type: "string",
+          enum: ["default", "minimal", "plain", "business"],
+          default: "default",
+          description: "Pre-baked style preset. Lands in 0.3."
+        },
+        mergedRegions: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["start", "end"],
+            properties: {
+              start: { type: "string", description: "A1 ref of top-left." },
+              end: { type: "string", description: "A1 ref of bottom-right." }
+            }
+          },
+          description: "Cells to merge. Lands in 0.5."
+        },
+        columnWidths: {
+          type: "object",
+          description: "Override widths in pixels. Keys are 0-based column indexes. Lands in 0.5.",
+          additionalProperties: { type: "number", minimum: 0 }
+        },
+        frozenRows: { type: "integer", minimum: 0, description: "Lands in 0.5." },
+        frozenCols: { type: "integer", minimum: 0, description: "Lands in 0.5." }
+      }
+    },
+    Column: {
+      type: "object",
+      required: ["header"],
+      additionalProperties: false,
+      properties: {
+        header: { type: "string" },
+        type: {
+          type: "string",
+          enum: ["auto", "string", "number", "integer", "boolean", "date", "datetime", "currency", "percent", "formula"],
+          default: "auto",
+          description: "Cell type applied to every value in this column. 'auto' infers per cell."
+        },
+        currency: {
+          type: "string",
+          description: "ISO-4217 code (USD, EUR, JPY, ...) when type=currency. Defaults to config('holy-sheet.locale')."
+        },
+        decimals: {
+          type: "integer",
+          minimum: 0,
+          maximum: 10,
+          description: "Display decimals for number/currency/percent. Default 2 for currency, 1 for percent, 0 for integer, none for number."
+        },
+        format: {
+          type: "string",
+          description: "Custom Excel number format string. Overrides type-derived format. Power-user escape hatch."
+        },
+        width: { type: "number", minimum: 0, description: "Column width in pixels. Same as columnWidths but per-column." }
+      }
+    },
+    CellValue: {
+      description: "A primitive value, null, or an object {value, formula, format, comment} for per-cell control.",
+      oneOf: [
+        { type: "string" },
+        { type: "number" },
+        { type: "boolean" },
+        { type: "null" },
+        { $ref: "#/definitions/CellData" }
+      ]
+    },
+    CellData: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        value: {
+          description: "Raw cell value.",
+          oneOf: [
+            { type: "string" },
+            { type: "number" },
+            { type: "boolean" },
+            { type: "null" }
+          ]
+        },
+        formula: {
+          type: "string",
+          description: "Formula without leading '='. e.g. 'SUM(A1:A10)' or 'Sheet2!B5+1'."
+        },
+        computedValue: {
+          description: "Cached value from a previous evaluation. When present, Excel shows it without recomputing on open.",
+          oneOf: [{ type: "string" }, { type: "number" }, { type: "boolean" }, { type: "null" }]
+        },
+        format: { $ref: "#/definitions/CellFormat" },
+        comment: { $ref: "#/definitions/CellComment" }
+      }
+    },
+    CellFormat: {
+      type: "object",
+      description: "Per-cell format. Lands in 0.3.",
+      additionalProperties: false,
+      properties: {
+        bold: { type: "boolean" },
+        italic: { type: "boolean" },
+        textAlign: { type: "string", enum: ["left", "center", "right"] },
+        displayFormat: {
+          type: "string",
+          enum: ["auto", "text", "number", "date", "datetime", "percentage", "currency"]
+        },
+        decimals: { type: "integer", minimum: 0, maximum: 10 },
+        color: { type: "string", description: "Hex color (#RRGGBB) for text." },
+        backgroundColor: { type: "string", description: "Hex color for cell fill." },
+        fontSize: { type: "integer", minimum: 6, maximum: 72 },
+        borderTop: { type: "string" },
+        borderRight: { type: "string" },
+        borderBottom: { type: "string" },
+        borderLeft: { type: "string" }
+      }
+    },
+    CellComment: {
+      type: "object",
+      description: "Lands in 0.6.",
+      required: ["text"],
+      additionalProperties: false,
+      properties: {
+        text: { type: "string" },
+        author: { type: "string" },
+        color: { type: "string", description: "Hex color for the corner triangle indicator." }
+      }
+    }
+  }
+};
+
+// src/agent.ts
+var VERSION = "1.0.0";
+function toU8(input) {
+  return input instanceof Uint8Array ? input : new Uint8Array(input);
+}
+var Agent = {
+  /** Validate a schema without writing. Empty array = valid. */
+  validate(schema) {
+    return new Validator().validate(schema);
+  },
+  /** xlsx bytes without touching disk. Universal. Throws SchemaException if invalid. */
+  toBytes(schema) {
+    new Validator().assert(schema);
+    const workbook = new Normalizer().normalize(schema);
+    return new XlsxWriter().toBytes(workbook);
+  },
+  /** Write a workbook to disk (Node only). Throws SchemaException if invalid. */
+  async write(schema, path) {
+    new Validator().assert(schema);
+    const workbook = new Normalizer().normalize(schema);
+    const bytes = new XlsxWriter().toBytes(workbook);
+    const fs = await import('fs');
+    fs.writeFileSync(path, bytes);
+    return { path, bytes: bytes.length, sheets: workbook.sheets.length };
+  },
+  /** JSON Schema for LLM tool-use. */
+  toolDefinition() {
+    return holy_sheet_schema_default;
+  },
+  /** Round-trip xlsx bytes back to a schema. Universal. */
+  read(input) {
+    return new XlsxReader().describe(toU8(input));
+  },
+  /** Round-trip an xlsx file on disk back to a schema (Node only). */
+  async describe(path) {
+    const fs = await import('fs');
+    if (!fs.existsSync(path)) return { error: "not_found", path };
+    const bytes = fs.readFileSync(path);
+    return new XlsxReader().describe(new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+  },
+  /** Validate + conservative repairs in one call. */
+  validateAndRepair(schema) {
+    return new Validator().validateAndRepair(schema);
+  },
+  /** Build a schema from a flat array of rows (+ optional headers). */
+  fromArray(rows, headers = null, sheetName = "Sheet 1", options = {}) {
+    return ArrayBuilder.build(rows, headers, sheetName, options);
+  },
+  /** Build a schema from CSV content (read files yourself in Node). */
+  fromCsv(csv, options = {}) {
+    return CsvBuilder.build(csv, options);
+  },
+  /** Evaluate every formula and report Excel-style errors. Empty array = clean. */
+  lint(schema) {
+    return new FormulaLinter().lint(schema);
+  },
+  version() {
+    return VERSION;
+  }
+};
+
+// src/holy-sheet.ts
+var HolySheet = class {
+  validate(schema) {
+    return Agent.validate(schema);
+  }
+  toBytes(schema) {
+    return Agent.toBytes(schema);
+  }
+  write(schema, path) {
+    return Agent.write(schema, path);
+  }
+  toolDefinition() {
+    return Agent.toolDefinition();
+  }
+  read(input) {
+    return Agent.read(input);
+  }
+  describe(path) {
+    return Agent.describe(path);
+  }
+  validateAndRepair(schema) {
+    return Agent.validateAndRepair(schema);
+  }
+  fromArray(rows, headers = null, sheetName = "Sheet 1", options = {}) {
+    return Agent.fromArray(rows, headers, sheetName, options);
+  }
+  fromCsv(csv, options = {}) {
+    return Agent.fromCsv(csv, options);
+  }
+  lint(schema) {
+    return Agent.lint(schema);
+  }
+  getVersion() {
+    return VERSION;
+  }
+  static version() {
+    return VERSION;
+  }
+};
+HolySheet.VERSION = VERSION;
+
+exports.Agent = Agent;
+exports.ArrayBuilder = ArrayBuilder;
+exports.CellAddress = CellAddress;
+exports.CsvBuilder = CsvBuilder;
+exports.FormulaLinter = FormulaLinter;
+exports.HolySheet = HolySheet;
+exports.Inference = Inference;
+exports.Normalizer = Normalizer;
+exports.Repairer = Repairer;
+exports.SchemaException = SchemaException;
+exports.Theme = Theme;
+exports.VERSION = VERSION;
+exports.Validator = Validator;
+exports.XlsxReader = XlsxReader;
+exports.XlsxWriter = XlsxWriter;
+exports.unzipSync = unzipSync;
+exports.zipSync = zipSync;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map