@alosha/xlsx 0.2.0 → 0.3.1

package/dist/chunk-6XXKAKLS.js

@@ -0,0 +1,3663 @@
+import { zipSync, unzipSync } from 'fflate';
+
+// src/errors.ts
+var AloshaXlsxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function isAloshaXlsxError(e) {
+  return e instanceof AloshaXlsxError;
+}
+var InvalidAddressError = class extends AloshaXlsxError {
+  constructor(address) {
+    super(`Invalid cell address: ${JSON.stringify(address)}`);
+    this.address = address;
+  }
+  address;
+  code = "INVALID_ADDRESS";
+};
+var InvalidRangeError = class extends AloshaXlsxError {
+  constructor(range) {
+    super(`Invalid range: ${JSON.stringify(range)}`);
+    this.range = range;
+  }
+  range;
+  code = "INVALID_RANGE";
+};
+var InvalidWorksheetNameError = class _InvalidWorksheetNameError extends AloshaXlsxError {
+  constructor(worksheetName, reason) {
+    super(_InvalidWorksheetNameError.messageFor(worksheetName, reason));
+    this.worksheetName = worksheetName;
+    this.reason = reason;
+  }
+  worksheetName;
+  reason;
+  code = "INVALID_WORKSHEET_NAME";
+  static messageFor(name, reason) {
+    switch (reason) {
+      case "empty":
+        return "Worksheet name cannot be empty.";
+      case "edge-quote":
+        return `Worksheet name cannot start or end with a single quote: ${JSON.stringify(name)}`;
+      case "illegal-characters":
+        return `Worksheet name ${JSON.stringify(name)} cannot include any of: * ? : \\ / [ ]`;
+    }
+  }
+};
+var ReservedWorksheetNameError = class extends AloshaXlsxError {
+  constructor(worksheetName) {
+    super(`Worksheet name is reserved and cannot be used: ${JSON.stringify(worksheetName)}`);
+    this.worksheetName = worksheetName;
+  }
+  worksheetName;
+  code = "RESERVED_WORKSHEET_NAME";
+};
+var DuplicateWorksheetNameError = class extends AloshaXlsxError {
+  constructor(worksheetName) {
+    super(`Worksheet name already exists: ${JSON.stringify(worksheetName)}`);
+    this.worksheetName = worksheetName;
+  }
+  worksheetName;
+  code = "DUPLICATE_WORKSHEET_NAME";
+};
+var WorksheetNameTooLongError = class _WorksheetNameTooLongError extends AloshaXlsxError {
+  constructor(worksheetName, maxLength = _WorksheetNameTooLongError.MAX_LENGTH) {
+    super(
+      `Worksheet name exceeds ${maxLength} characters (got ${worksheetName.length}): ${JSON.stringify(worksheetName)}`
+    );
+    this.worksheetName = worksheetName;
+    this.maxLength = maxLength;
+  }
+  worksheetName;
+  maxLength;
+  code = "WORKSHEET_NAME_TOO_LONG";
+  /** Excel's hard cap on sheet-name length. */
+  static MAX_LENGTH = 31;
+};
+var MergeConflictError = class extends AloshaXlsxError {
+  constructor(range) {
+    super(`Cannot merge cells: range ${JSON.stringify(range)} overlaps an existing merge.`);
+    this.range = range;
+  }
+  range;
+  code = "MERGE_CONFLICT";
+};
+var InvalidRowNumberError = class extends AloshaXlsxError {
+  constructor(expected, actual) {
+    super(`Invalid row number in model: expected ${expected}, got ${actual}.`);
+    this.expected = expected;
+    this.actual = actual;
+  }
+  expected;
+  actual;
+  code = "INVALID_ROW_NUMBER";
+};
+var InvalidCellValueError = class _InvalidCellValueError extends AloshaXlsxError {
+  constructor(value) {
+    super(`Unsupported cell value: ${_InvalidCellValueError.describe(value)}`);
+    this.value = value;
+  }
+  value;
+  code = "INVALID_CELL_VALUE";
+  static describe(value) {
+    const t = value === null ? "null" : typeof value;
+    return t === "object" ? `object ${Object.prototype.toString.call(value)}` : `${t} (${String(value)})`;
+  }
+};
+var UnsupportedFeatureError = class extends AloshaXlsxError {
+  constructor(feature, detail) {
+    super(
+      detail === void 0 ? `Feature not yet supported in @alosha/xlsx: ${feature}` : `${feature}: ${detail}`
+    );
+    this.feature = feature;
+    this.detail = detail;
+  }
+  feature;
+  detail;
+  code = "UNSUPPORTED_FEATURE";
+};
+var InvalidPackageError = class extends AloshaXlsxError {
+  constructor(reason) {
+    super(`Invalid .xlsx package: ${reason}`);
+    this.reason = reason;
+  }
+  reason;
+  code = "INVALID_PACKAGE";
+};
+
+// src/model/enums.ts
+var CellType = /* @__PURE__ */ ((CellType2) => {
+  CellType2[CellType2["Null"] = 0] = "Null";
+  CellType2[CellType2["Number"] = 1] = "Number";
+  CellType2[CellType2["String"] = 2] = "String";
+  CellType2[CellType2["Boolean"] = 3] = "Boolean";
+  CellType2[CellType2["Date"] = 4] = "Date";
+  CellType2[CellType2["Error"] = 5] = "Error";
+  CellType2[CellType2["RichText"] = 6] = "RichText";
+  CellType2[CellType2["Hyperlink"] = 7] = "Hyperlink";
+  CellType2[CellType2["Formula"] = 8] = "Formula";
+  CellType2[CellType2["Merge"] = 9] = "Merge";
+  CellType2[CellType2["SharedString"] = 10] = "SharedString";
+  return CellType2;
+})(CellType || {});
+var FormulaType = /* @__PURE__ */ ((FormulaType2) => {
+  FormulaType2[FormulaType2["None"] = 0] = "None";
+  FormulaType2[FormulaType2["Master"] = 1] = "Master";
+  FormulaType2[FormulaType2["Shared"] = 2] = "Shared";
+  return FormulaType2;
+})(FormulaType || {});
+
+// src/model/cell-value.ts
+function detectType(v) {
+  if (v === null) return 0 /* Null */;
+  if (typeof v === "string") return 2 /* String */;
+  if (typeof v === "number") return 1 /* Number */;
+  if (typeof v === "boolean") return 3 /* Boolean */;
+  if (v instanceof Date) return 4 /* Date */;
+  if ("text" in v && "hyperlink" in v) return 7 /* Hyperlink */;
+  if ("formula" in v || "sharedFormula" in v) return 8 /* Formula */;
+  if ("richText" in v) return 6 /* RichText */;
+  if ("error" in v) return 5 /* Error */;
+  throw new InvalidCellValueError(v);
+}
+function toStored(v) {
+  switch (detectType(v)) {
+    case 0 /* Null */:
+      return { type: 0 /* Null */ };
+    case 2 /* String */:
+      return { type: 2 /* String */, value: v };
+    case 1 /* Number */:
+      return { type: 1 /* Number */, value: v };
+    case 3 /* Boolean */:
+      return { type: 3 /* Boolean */, value: v };
+    case 4 /* Date */:
+      return { type: 4 /* Date */, value: v };
+    case 7 /* Hyperlink */:
+      return { type: 7 /* Hyperlink */, value: v };
+    case 8 /* Formula */:
+      return { type: 8 /* Formula */, value: v };
+    case 6 /* RichText */:
+      return { type: 6 /* RichText */, value: v };
+    case 5 /* Error */:
+      return { type: 5 /* Error */, value: v };
+    default:
+      throw new InvalidCellValueError(v);
+  }
+}
+function fromStored(s) {
+  switch (s.type) {
+    case 0 /* Null */:
+    case 9 /* Merge */:
+    case 10 /* SharedString */:
+      return null;
+    case 1 /* Number */:
+    case 2 /* String */:
+    case 3 /* Boolean */:
+    case 4 /* Date */:
+    case 5 /* Error */:
+    case 6 /* RichText */:
+    case 7 /* Hyperlink */:
+    case 8 /* Formula */:
+      return s.value;
+  }
+}
+function effectiveType(s) {
+  if (s.type !== 8 /* Formula */) return s.type;
+  const { result } = s.value;
+  if (result === void 0) return 0 /* Null */;
+  if (typeof result === "number") return 1 /* Number */;
+  if (typeof result === "string") return 2 /* String */;
+  if (typeof result === "boolean") return 3 /* Boolean */;
+  if (result instanceof Date) return 4 /* Date */;
+  return 5 /* Error */;
+}
+function primitiveToText(value) {
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (value instanceof Date) return value.toISOString();
+  return value.error;
+}
+function toText(s) {
+  switch (s.type) {
+    case 0 /* Null */:
+    case 9 /* Merge */:
+    case 10 /* SharedString */:
+      return "";
+    case 1 /* Number */:
+    case 2 /* String */:
+    case 3 /* Boolean */:
+    case 4 /* Date */:
+    case 5 /* Error */:
+      return primitiveToText(s.value);
+    case 6 /* RichText */:
+      return s.value.richText.map((run) => run.text).join("");
+    case 7 /* Hyperlink */:
+      return s.value.text;
+    case 8 /* Formula */: {
+      const { result } = s.value;
+      return result === void 0 ? "" : primitiveToText(result);
+    }
+  }
+}
+var CSV_SPECIAL_RE = /["\n\r,]/;
+function toCsv(s) {
+  const text = toText(s);
+  if (!CSV_SPECIAL_RE.test(text)) return text;
+  return `"${text.replace(/"/g, '""')}"`;
+}
+
+// src/model/style.ts
+function mergeField(colField, rowField, cellField) {
+  if (colField === void 0 && rowField === void 0 && cellField === void 0) {
+    return void 0;
+  }
+  return { ...colField, ...rowField, ...cellField };
+}
+function resolveCellStyle(rowStyle, colStyle, cellStyle) {
+  const result = {};
+  const numFmt = cellStyle?.numFmt ?? rowStyle?.numFmt ?? colStyle?.numFmt;
+  if (numFmt !== void 0) result.numFmt = numFmt;
+  const font = mergeField(colStyle?.font, rowStyle?.font, cellStyle?.font);
+  if (font !== void 0) result.font = font;
+  const alignment = mergeField(colStyle?.alignment, rowStyle?.alignment, cellStyle?.alignment);
+  if (alignment !== void 0) result.alignment = alignment;
+  const protection = mergeField(colStyle?.protection, rowStyle?.protection, cellStyle?.protection);
+  if (protection !== void 0) result.protection = protection;
+  const border = mergeField(colStyle?.border, rowStyle?.border, cellStyle?.border);
+  if (border !== void 0) result.border = border;
+  const fill = cellStyle?.fill ?? rowStyle?.fill ?? colStyle?.fill;
+  if (fill !== void 0) result.fill = fill;
+  return result;
+}
+
+// src/model/cell.ts
+var Cell = class {
+  constructor(rowRef, columnRef, address) {
+    this.rowRef = rowRef;
+    this.columnRef = columnRef;
+    this.address = address;
+    this._master = this;
+    this._style = resolveCellStyle(rowRef.style, columnRef.style);
+  }
+  rowRef;
+  columnRef;
+  address;
+  _stored = { type: 0 /* Null */ };
+  _style;
+  _master;
+  get row() {
+    return this.rowRef.number;
+  }
+  get col() {
+    return this.columnRef.number;
+  }
+  get $col$row() {
+    return `$${this.columnRef.letter}$${this.rowRef.number}`;
+  }
+  /** The stored value this cell resolves through: itself, or (if merged) its master. */
+  get resolvedStored() {
+    return this.isMerged ? this._master.resolvedStored : this._stored;
+  }
+  get value() {
+    return fromStored(this.resolvedStored);
+  }
+  set value(v) {
+    if (this.isMerged) {
+      this._master.value = v;
+      return;
+    }
+    this._stored = toStored(v);
+  }
+  /** This cell's own marker type — `Merge` for a slave, even though `value`/`text` delegate. */
+  get type() {
+    return this._stored.type;
+  }
+  get effectiveType() {
+    return effectiveType(this.resolvedStored);
+  }
+  get text() {
+    return toText(this.resolvedStored);
+  }
+  toString() {
+    return this.text;
+  }
+  toCsvString() {
+    return toCsv(this.resolvedStored);
+  }
+  get isMerged() {
+    return this._master !== this;
+  }
+  /** The master cell of this cell's merge region; itself if unmerged. */
+  get master() {
+    return this._master;
+  }
+  merge(master, ignoreStyle = false) {
+    this._master = master;
+    this._stored = { type: 9 /* Merge */, master: master.address };
+    if (!ignoreStyle) this._style = master.style;
+  }
+  unmerge() {
+    this._master = this;
+    this._stored = { type: 0 /* Null */ };
+  }
+  get formula() {
+    const s = this.resolvedStored;
+    return s.type === 8 /* Formula */ ? s.value.formula : void 0;
+  }
+  get result() {
+    const s = this.resolvedStored;
+    return s.type === 8 /* Formula */ ? s.value.result : void 0;
+  }
+  get formulaType() {
+    const s = this.resolvedStored;
+    if (s.type !== 8 /* Formula */) return 0 /* None */;
+    return s.value.sharedFormula !== void 0 ? 2 /* Shared */ : 1 /* Master */;
+  }
+  get style() {
+    return this._style;
+  }
+  set style(s) {
+    this._style = s;
+  }
+  get numFmt() {
+    return this._style.numFmt;
+  }
+  set numFmt(v) {
+    this._style = { ...this._style, numFmt: v };
+  }
+  get font() {
+    return this._style.font;
+  }
+  set font(v) {
+    this._style = { ...this._style, font: v };
+  }
+  get alignment() {
+    return this._style.alignment;
+  }
+  set alignment(v) {
+    this._style = { ...this._style, alignment: v };
+  }
+  get border() {
+    return this._style.border;
+  }
+  set border(v) {
+    this._style = { ...this._style, border: v };
+  }
+  get fill() {
+    return this._style.fill;
+  }
+  set fill(v) {
+    this._style = { ...this._style, fill: v };
+  }
+  get protection() {
+    return this._style.protection;
+  }
+  set protection(v) {
+    this._style = { ...this._style, protection: v };
+  }
+  get model() {
+    const m = { address: this.address, type: this.type };
+    switch (this._stored.type) {
+      case 0 /* Null */:
+      case 9 /* Merge */:
+        break;
+      case 8 /* Formula */:
+        if (this._stored.value.formula !== void 0) m.formula = this._stored.value.formula;
+        if (this._stored.value.result !== void 0) m.result = this._stored.value.result;
+        break;
+      default:
+        m.value = fromStored(this._stored);
+    }
+    if (Object.keys(this._style).length > 0) m.style = this._style;
+    return m;
+  }
+  set model(m) {
+    this._master = this;
+    switch (m.type) {
+      case 9 /* Merge */:
+        this._stored = { type: 9 /* Merge */, master: this.address };
+        break;
+      case 8 /* Formula */:
+        this._stored = toStored({
+          formula: m.formula,
+          result: m.result
+        });
+        break;
+      case 0 /* Null */:
+        this._stored = { type: 0 /* Null */ };
+        break;
+      default:
+        this.value = m.value;
+    }
+    this._style = m.style ?? {};
+  }
+};
+
+// src/address/col-cache.ts
+var MAX_ROW = 1048576;
+var MAX_COL = 16384;
+var LETTER_RE = /^[A-Za-z]+$/;
+var ADDRESS_RE = /^([A-Za-z]+)(\d+)$/;
+var SHEET_PREFIX_RE = /^(?:'([^']*)'|([^'!]+))!/;
+var CELL_REF_RE = /^\$?([A-Za-z]+)\$?(\d+)$/;
+var colLetterToNumberCache = /* @__PURE__ */ new Map();
+var colNumberToLetterCache = /* @__PURE__ */ new Map();
+var decodeAddressCache = /* @__PURE__ */ new Map();
+function colLetterToNumber(letter) {
+  const cached = colLetterToNumberCache.get(letter);
+  if (cached !== void 0) return cached;
+  if (!LETTER_RE.test(letter)) {
+    throw new InvalidAddressError(letter);
+  }
+  const upper = letter.toUpperCase();
+  let col = 0;
+  for (let i = 0; i < upper.length; i++) {
+    col = col * 26 + (upper.charCodeAt(i) - 64);
+  }
+  colLetterToNumberCache.set(letter, col);
+  return col;
+}
+function colNumberToLetter(col) {
+  const cached = colNumberToLetterCache.get(col);
+  if (cached !== void 0) return cached;
+  if (!Number.isInteger(col) || col < 1) {
+    throw new InvalidAddressError(String(col));
+  }
+  let n = col;
+  let letters = "";
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    letters = String.fromCharCode(65 + rem) + letters;
+    n = Math.floor((n - 1) / 26);
+  }
+  colNumberToLetterCache.set(col, letters);
+  return letters;
+}
+function encodeAddress(row, col) {
+  return `${colNumberToLetter(col)}${row}`;
+}
+function decodeAddress(address) {
+  const cached = decodeAddressCache.get(address);
+  if (cached !== void 0) return cached;
+  const match = ADDRESS_RE.exec(address);
+  if (!match) {
+    throw new InvalidAddressError(address);
+  }
+  const [, letters, digits] = match;
+  const col = colLetterToNumber(letters);
+  const row = Number.parseInt(digits, 10);
+  if (row < 1 || row > MAX_ROW || col < 1 || col > MAX_COL) {
+    throw new InvalidAddressError(address);
+  }
+  const decoded = { row, col, address: `${letters.toUpperCase()}${row}` };
+  decodeAddressCache.set(address, decoded);
+  return decoded;
+}
+function decodeEx(address) {
+  let sheetName;
+  let rest = address;
+  const sheetMatch = SHEET_PREFIX_RE.exec(address);
+  if (sheetMatch) {
+    sheetName = sheetMatch[1] ?? sheetMatch[2];
+    rest = address.slice(sheetMatch[0].length);
+  }
+  const cellMatch = CELL_REF_RE.exec(rest);
+  if (!cellMatch) {
+    throw new InvalidAddressError(address);
+  }
+  const [, letters, digits] = cellMatch;
+  const decoded = decodeAddress(`${letters}${digits}`);
+  return {
+    ...decoded,
+    $col$row: `$${colNumberToLetter(decoded.col)}$${decoded.row}`,
+    ...sheetName !== void 0 ? { sheetName } : {}
+  };
+}
+function validateAddress(address) {
+  decodeAddress(address);
+}
+
+// src/address/range.ts
+function isDecodedLike(value) {
+  return typeof value === "object" && value !== null && !(value instanceof Range) && typeof value.row === "number" && typeof value.col === "number" && typeof value.address === "string";
+}
+function assertValidBox(box, source) {
+  for (const n of [box.top, box.left, box.bottom, box.right]) {
+    if (!Number.isInteger(n) || n < 1) {
+      throw new InvalidRangeError(source);
+    }
+  }
+}
+function decodeTwoRefs(a, b, source) {
+  try {
+    const d1 = decodeEx(a);
+    const d2 = decodeEx(b);
+    return {
+      top: d1.row,
+      left: d1.col,
+      bottom: d2.row,
+      right: d2.col,
+      sheetName: d1.sheetName ?? d2.sheetName
+    };
+  } catch {
+    throw new InvalidRangeError(source);
+  }
+}
+function parseRangeString(source) {
+  const parts = source.split(":");
+  if (parts.length === 1) {
+    return decodeTwoRefs(parts[0], parts[0], source);
+  }
+  if (parts.length === 2) {
+    const [p0, p1] = parts;
+    if (p0 === "" || p1 === "") throw new InvalidRangeError(source);
+    return decodeTwoRefs(p0, p1, source);
+  }
+  throw new InvalidRangeError(source);
+}
+function resolveSource(source) {
+  if (source instanceof Range) {
+    return {
+      top: source.top,
+      left: source.left,
+      bottom: source.bottom,
+      right: source.right,
+      sheetName: source.sheetName
+    };
+  }
+  if (typeof source === "string") {
+    return parseRangeString(source);
+  }
+  if (Array.isArray(source)) {
+    if (source.length === 4 && source.every((n) => typeof n === "number")) {
+      const [top, left, bottom, right] = source;
+      return { top, left, bottom, right };
+    }
+    if (source.length === 2 && source.every((s) => typeof s === "string")) {
+      const [a, b] = source;
+      return decodeTwoRefs(a, b, source);
+    }
+    throw new InvalidRangeError(source);
+  }
+  if (isDecodedLike(source)) {
+    return { top: source.row, left: source.col, bottom: source.row, right: source.col };
+  }
+  throw new InvalidRangeError(source);
+}
+var Range = class {
+  top;
+  left;
+  bottom;
+  right;
+  sheetName;
+  constructor(sourceOrTop, left, bottom, right) {
+    let box;
+    if (sourceOrTop === void 0) {
+      box = { top: 1, left: 1, bottom: 1, right: 1 };
+    } else if (typeof sourceOrTop === "number") {
+      if (left === void 0 || bottom === void 0 || right === void 0) {
+        throw new InvalidRangeError([sourceOrTop, left, bottom, right]);
+      }
+      box = { top: sourceOrTop, left, bottom, right };
+      assertValidBox(box, [sourceOrTop, left, bottom, right]);
+    } else {
+      box = resolveSource(sourceOrTop);
+      assertValidBox(box, sourceOrTop);
+    }
+    this.top = Math.min(box.top, box.bottom);
+    this.bottom = Math.max(box.top, box.bottom);
+    this.left = Math.min(box.left, box.right);
+    this.right = Math.max(box.left, box.right);
+    if (box.sheetName !== void 0) this.sheetName = box.sheetName;
+  }
+  /** Top-left address, e.g. 'A1'. */
+  get tl() {
+    return encodeAddress(this.top, this.left);
+  }
+  /** Bottom-right address, e.g. 'B2'. */
+  get br() {
+    return encodeAddress(this.bottom, this.right);
+  }
+  /** 'A1:B2'. */
+  get range() {
+    return `${this.tl}:${this.br}`;
+  }
+  /** Total cell count covered by the box. */
+  get count() {
+    return (this.bottom - this.top + 1) * (this.right - this.left + 1);
+  }
+  /** Grows the box to include the given box (union of bounds). */
+  expand(top, left, bottom, right) {
+    this.top = Math.min(this.top, top);
+    this.left = Math.min(this.left, left);
+    this.bottom = Math.max(this.bottom, bottom);
+    this.right = Math.max(this.right, right);
+  }
+  /** Whether the given address falls within this box. */
+  contains(address) {
+    const d = decodeEx(address);
+    return d.row >= this.top && d.row <= this.bottom && d.col >= this.left && d.col <= this.right;
+  }
+  /** Whether this box overlaps another box. */
+  intersects(other) {
+    return this.left <= other.right && other.left <= this.right && this.top <= other.bottom && other.top <= this.bottom;
+  }
+  /** Visits every address in the box, row-major (row-by-row, left-to-right within a row). */
+  forEachAddress(cb) {
+    for (let row = this.top; row <= this.bottom; row++) {
+      for (let col = this.left; col <= this.right; col++) {
+        cb(encodeAddress(row, col), row, col);
+      }
+    }
+  }
+};
+
+// src/model/column.ts
+var DEFAULT_COLUMN_WIDTH = 9;
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  return aKeys.every(
+    (key) => deepEqual(a[key], b[key])
+  );
+}
+var Column = class _Column {
+  constructor(host, number, defn) {
+    this.host = host;
+    this.number = number;
+    if (defn) {
+      if (defn.key !== void 0) this.key = defn.key;
+      if (defn.width !== void 0) this.width = defn.width;
+      if (defn.hidden !== void 0) this.hidden = defn.hidden;
+      if (defn.outlineLevel !== void 0) this.outlineLevel = defn.outlineLevel;
+      if (defn.style !== void 0) this._style = defn.style;
+      if (defn.header !== void 0) this.header = defn.header;
+    }
+  }
+  host;
+  number;
+  key;
+  width;
+  hidden = false;
+  outlineLevel = 0;
+  _header;
+  _style = {};
+  get letter() {
+    return colNumberToLetter(this.number);
+  }
+  get collapsed() {
+    return this.outlineLevel > this.host.properties.outlineLevelCol;
+  }
+  get isCustomWidth() {
+    return this.width !== void 0 && this.width !== DEFAULT_COLUMN_WIDTH;
+  }
+  get isDefault() {
+    return !this.isCustomWidth && !this.hidden && this.outlineLevel === 0 && this.key === void 0 && this._header === void 0 && Object.keys(this._style).length === 0;
+  }
+  get header() {
+    return this._header;
+  }
+  /** Writes the header text(s) into this column's top cell(s): row 1 for a string, rows 1..N
+   *  for a string array (SPEC §6 — "header assignment writes the top row cells' values"). */
+  set header(h) {
+    this._header = h;
+    if (h === void 0) return;
+    const lines = Array.isArray(h) ? h : [h];
+    lines.forEach((text, i) => {
+      this.host.getRow(i + 1).getCell(this.number).value = text;
+    });
+  }
+  get values() {
+    const result = [];
+    this.host.eachRow((row, n) => {
+      const cell = row.findCell(this.number);
+      if (cell) result[n] = cell.value;
+    });
+    return result;
+  }
+  set values(vals) {
+    vals.forEach((val, i) => {
+      if (i === 0 || val === void 0) return;
+      this.host.getRow(i).getCell(this.number).value = val;
+    });
+  }
+  eachCell(optsOrCb, maybeCb) {
+    const includeEmpty = typeof optsOrCb === "object" ? optsOrCb.includeEmpty : false;
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    this.host.eachRow({ includeEmpty }, (row, n) => {
+      const cell = includeEmpty ? row.getCell(this.number) : row.findCell(this.number);
+      if (cell) cb(cell, n);
+    });
+  }
+  applyToCells(fn) {
+    this.eachCell(fn);
+  }
+  get style() {
+    return this._style;
+  }
+  set style(s) {
+    this._style = s;
+    this.applyToCells((cell) => {
+      cell.style = s;
+    });
+  }
+  get numFmt() {
+    return this._style.numFmt;
+  }
+  set numFmt(v) {
+    this._style = { ...this._style, numFmt: v };
+    this.applyToCells((cell) => {
+      cell.numFmt = v;
+    });
+  }
+  get font() {
+    return this._style.font;
+  }
+  set font(v) {
+    this._style = { ...this._style, font: v };
+    this.applyToCells((cell) => {
+      cell.font = v;
+    });
+  }
+  get alignment() {
+    return this._style.alignment;
+  }
+  set alignment(v) {
+    this._style = { ...this._style, alignment: v };
+    this.applyToCells((cell) => {
+      cell.alignment = v;
+    });
+  }
+  get border() {
+    return this._style.border;
+  }
+  set border(v) {
+    this._style = { ...this._style, border: v };
+    this.applyToCells((cell) => {
+      cell.border = v;
+    });
+  }
+  get fill() {
+    return this._style.fill;
+  }
+  set fill(v) {
+    this._style = { ...this._style, fill: v };
+    this.applyToCells((cell) => {
+      cell.fill = v;
+    });
+  }
+  get protection() {
+    return this._style.protection;
+  }
+  set protection(v) {
+    this._style = { ...this._style, protection: v };
+    this.applyToCells((cell) => {
+      cell.protection = v;
+    });
+  }
+  get defn() {
+    const d = {};
+    if (this.key !== void 0) d.key = this.key;
+    if (this._header !== void 0) d.header = this._header;
+    if (this.width !== void 0) d.width = this.width;
+    if (this.hidden) d.hidden = true;
+    if (this.outlineLevel !== 0) d.outlineLevel = this.outlineLevel;
+    if (Object.keys(this._style).length > 0) d.style = this._style;
+    return d;
+  }
+  set defn(d) {
+    this.key = d.key;
+    this.width = d.width;
+    this.hidden = d.hidden ?? false;
+    this.outlineLevel = d.outlineLevel ?? 0;
+    this._style = d.style ?? {};
+    this.header = d.header;
+  }
+  /** Whether two columns share the same OOXML-relevant attributes (used to compress runs). */
+  equivalentTo(other) {
+    return this.width === other.width && this.hidden === other.hidden && this.outlineLevel === other.outlineLevel && deepEqual(this._style, other._style);
+  }
+  static rangeOf(start, end) {
+    const range = { min: start.number, max: end.number };
+    if (start.width !== void 0) range.width = start.width;
+    if (start.hidden) range.hidden = true;
+    if (start.outlineLevel !== 0) range.outlineLevel = start.outlineLevel;
+    if (Object.keys(start._style).length > 0) range.style = start._style;
+    return range;
+  }
+  /** Run-length compress an array of Columns into `<col min max>` ranges. */
+  static toModel(columns) {
+    if (columns.length === 0) return void 0;
+    const sorted = [...columns].sort((a, b) => a.number - b.number);
+    const ranges = [];
+    let start = sorted[0];
+    let prev = start;
+    for (let i = 1; i < sorted.length; i++) {
+      const col = sorted[i];
+      if (col.number === prev.number + 1 && col.equivalentTo(prev)) {
+        prev = col;
+        continue;
+      }
+      ranges.push(_Column.rangeOf(start, prev));
+      start = col;
+      prev = col;
+    }
+    ranges.push(_Column.rangeOf(start, prev));
+    return ranges;
+  }
+  /** Expands `<col min max>` ranges back into individual Columns. */
+  static fromModel(host, cols) {
+    if (cols.length === 0) return null;
+    const columns = [];
+    for (const range of cols) {
+      for (let n = range.min; n <= range.max; n++) {
+        columns.push(
+          new _Column(host, n, {
+            width: range.width,
+            hidden: range.hidden,
+            outlineLevel: range.outlineLevel,
+            style: range.style
+          })
+        );
+      }
+    }
+    return columns;
+  }
+};
+
+// src/model/row.ts
+var Row = class {
+  constructor(worksheet, number) {
+    this.worksheet = worksheet;
+    this.number = number;
+  }
+  worksheet;
+  number;
+  height;
+  hidden = false;
+  outlineLevel = 0;
+  /** Sparse, 1-indexed by column number; index 0 is never assigned. */
+  _cells = [];
+  _style = {};
+  get collapsed() {
+    return this.outlineLevel > this.worksheet.properties.outlineLevelRow;
+  }
+  resolveColNumber(col) {
+    if (typeof col === "number") return col;
+    const byKey = this.worksheet.getColumnKey(col);
+    if (byKey) return byKey.number;
+    return colLetterToNumber(col);
+  }
+  getCell(col) {
+    const colNumber = this.resolveColNumber(col);
+    const existing = this._cells[colNumber];
+    if (existing) return existing;
+    const column = this.worksheet.getColumn(colNumber);
+    const cell = new Cell(this, column, encodeAddress(this.number, colNumber));
+    this._cells[colNumber] = cell;
+    return cell;
+  }
+  findCell(col) {
+    return this._cells[col];
+  }
+  eachCell(optsOrCb, maybeCb) {
+    const includeEmpty = typeof optsOrCb === "object" ? optsOrCb.includeEmpty : false;
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    if (includeEmpty) {
+      const max = this._cells.length - 1;
+      for (let col = 1; col <= max; col++) {
+        cb(this.getCell(col), col);
+      }
+    } else {
+      this._cells.forEach((cell, col) => {
+        cb(cell, col);
+      });
+    }
+  }
+  get hasValues() {
+    return this._cells.some((cell) => cell !== void 0 && cell.type !== 0 /* Null */);
+  }
+  get cellCount() {
+    return Math.max(this._cells.length - 1, 0);
+  }
+  get actualCellCount() {
+    let count = 0;
+    for (const cell of this._cells) if (cell !== void 0) count++;
+    return count;
+  }
+  get dimensions() {
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    this._cells.forEach((_cell, col) => {
+      if (col < min) min = col;
+      if (col > max) max = col;
+    });
+    return min === Number.POSITIVE_INFINITY ? null : { min, max };
+  }
+  get values() {
+    const arr = [];
+    this._cells.forEach((cell, col) => {
+      arr[col] = cell.value;
+    });
+    return arr;
+  }
+  set values(v) {
+    this._cells = [];
+    if (v === void 0 || v === null) return;
+    if (Array.isArray(v)) {
+      const offset = v[0] !== void 0 ? 1 : 0;
+      v.forEach((val, index) => {
+        if (val === void 0) return;
+        const col = index + offset;
+        if (col < 1) return;
+        this.getCell(col).value = val;
+      });
+      return;
+    }
+    for (const [key, val] of Object.entries(v)) {
+      this.getCell(key).value = val;
+    }
+  }
+  splice(start, count, ...inserts) {
+    const currentMax = this._cells.length - 1;
+    const insertCount = inserts.length;
+    const tail = [];
+    for (let col = start + count; col <= currentMax; col++) {
+      const cell = this._cells[col];
+      tail[col - (start + count)] = cell ? { value: cell.value, style: cell.style } : void 0;
+    }
+    this._cells.length = Math.min(this._cells.length, start);
+    inserts.forEach((val, i) => {
+      this.getCell(start + i).value = val;
+    });
+    tail.forEach((entry, i) => {
+      if (!entry) return;
+      const cell = this.getCell(start + insertCount + i);
+      cell.value = entry.value;
+      cell.style = entry.style;
+    });
+  }
+  applyToCells(fn) {
+    this._cells.forEach((cell) => {
+      fn(cell);
+    });
+  }
+  get style() {
+    return this._style;
+  }
+  set style(s) {
+    this._style = s;
+    this.applyToCells((cell) => {
+      cell.style = s;
+    });
+  }
+  get numFmt() {
+    return this._style.numFmt;
+  }
+  set numFmt(v) {
+    this._style = { ...this._style, numFmt: v };
+    this.applyToCells((cell) => {
+      cell.numFmt = v;
+    });
+  }
+  get font() {
+    return this._style.font;
+  }
+  set font(v) {
+    this._style = { ...this._style, font: v };
+    this.applyToCells((cell) => {
+      cell.font = v;
+    });
+  }
+  get alignment() {
+    return this._style.alignment;
+  }
+  set alignment(v) {
+    this._style = { ...this._style, alignment: v };
+    this.applyToCells((cell) => {
+      cell.alignment = v;
+    });
+  }
+  get border() {
+    return this._style.border;
+  }
+  set border(v) {
+    this._style = { ...this._style, border: v };
+    this.applyToCells((cell) => {
+      cell.border = v;
+    });
+  }
+  get fill() {
+    return this._style.fill;
+  }
+  set fill(v) {
+    this._style = { ...this._style, fill: v };
+    this.applyToCells((cell) => {
+      cell.fill = v;
+    });
+  }
+  get protection() {
+    return this._style.protection;
+  }
+  set protection(v) {
+    this._style = { ...this._style, protection: v };
+    this.applyToCells((cell) => {
+      cell.protection = v;
+    });
+  }
+  get model() {
+    const cells = [];
+    this._cells.forEach((cell) => {
+      cells.push(cell.model);
+    });
+    const m = { number: this.number, cells };
+    if (this.height !== void 0) m.height = this.height;
+    if (this.hidden) m.hidden = true;
+    if (this.outlineLevel !== 0) m.outlineLevel = this.outlineLevel;
+    if (Object.keys(this._style).length > 0) m.style = this._style;
+    return m;
+  }
+  set model(m) {
+    if (m.number !== this.number) {
+      throw new InvalidRowNumberError(this.number, m.number);
+    }
+    this._cells = [];
+    this.height = m.height;
+    this.hidden = m.hidden ?? false;
+    this.outlineLevel = m.outlineLevel ?? 0;
+    this._style = m.style ?? {};
+    for (const cellModel of m.cells) {
+      const col = decodeAddress(cellModel.address).col;
+      this.getCell(col).model = cellModel;
+    }
+  }
+};
+
+// src/model/worksheet.ts
+var ILLEGAL_NAME_CHARS = /[*?:\\/[\]]/;
+function validateWorksheetNameFormat(name) {
+  if (name.length === 0) throw new InvalidWorksheetNameError(name, "empty");
+  if (name.length > WorksheetNameTooLongError.MAX_LENGTH) throw new WorksheetNameTooLongError(name);
+  if (ILLEGAL_NAME_CHARS.test(name))
+    throw new InvalidWorksheetNameError(name, "illegal-characters");
+  if (name.startsWith("'") || name.endsWith("'")) {
+    throw new InvalidWorksheetNameError(name, "edge-quote");
+  }
+  if (name.toLowerCase() === "history") throw new ReservedWorksheetNameError(name);
+}
+function normalizeMergeArgs(cells) {
+  if (cells.length === 1) return new Range(cells[0]);
+  if (cells.length === 2 && typeof cells[0] === "string" && typeof cells[1] === "string") {
+    return new Range([cells[0], cells[1]]);
+  }
+  if (cells.length === 4 && cells.every((c) => typeof c === "number")) {
+    return new Range(
+      cells[0],
+      cells[1],
+      cells[2],
+      cells[3]
+    );
+  }
+  throw new InvalidRangeError(cells);
+}
+var Worksheet = class {
+  orderNo;
+  state = "visible";
+  workbook;
+  properties;
+  views = [];
+  pageSetup;
+  headerFooter;
+  _id;
+  _name;
+  _rows = /* @__PURE__ */ new Map();
+  _columns = /* @__PURE__ */ new Map();
+  _columnsByKey = /* @__PURE__ */ new Map();
+  /** Active merge regions keyed by their master (top-left) cell address. */
+  _merges = /* @__PURE__ */ new Map();
+  constructor(workbook, id, name, orderNo) {
+    this.workbook = workbook;
+    this._id = id;
+    this._name = name;
+    this.orderNo = orderNo;
+    this.properties = {
+      outlineLevelCol: 0,
+      outlineLevelRow: 0,
+      defaultRowHeight: 15,
+      dyDescent: 55
+    };
+  }
+  // --- identity ---------------------------------------------------------------------------------
+  get id() {
+    return this._id;
+  }
+  get name() {
+    return this._name;
+  }
+  set name(value) {
+    validateWorksheetNameFormat(value);
+    const lower = value.toLowerCase();
+    for (const ws of this.workbook.worksheets) {
+      if (ws !== this && ws.name.toLowerCase() === lower) {
+        throw new DuplicateWorksheetNameError(value);
+      }
+    }
+    this._name = value;
+  }
+  // --- rows -------------------------------------------------------------------------------------
+  getRow(row) {
+    let r = this._rows.get(row);
+    if (!r) {
+      r = new Row(this, row);
+      this._rows.set(row, r);
+    }
+    return r;
+  }
+  getRows(start, length) {
+    if (length < 1) return void 0;
+    const rows = [];
+    for (let i = 0; i < length; i++) rows.push(this.getRow(start + i));
+    return rows;
+  }
+  findRow(row) {
+    return this._rows.get(row);
+  }
+  addRow(data, options) {
+    const row = this.getRow(this.rowCount + 1);
+    row.values = data;
+    this.applyInheritance(row, options);
+    return row;
+  }
+  addRows(rows, options) {
+    return rows.map((data) => this.addRow(data, options));
+  }
+  insertRow(pos, value, options) {
+    this.spliceRows(pos, 0, value);
+    const row = this.getRow(pos);
+    this.applyInheritance(row, options);
+    return row;
+  }
+  applyInheritance(row, options) {
+    if (!options?.inheritFrom) return;
+    const sourceNumber = options.inheritFrom === "above" ? row.number - 1 : row.number + 1;
+    const source = this._rows.get(sourceNumber);
+    if (!source) return;
+    row.style = source.style;
+    source.eachCell({ includeEmpty: options.includeEmpty ?? false }, (cell, col) => {
+      row.getCell(col).style = cell.style;
+    });
+  }
+  duplicateRow(rowNum, count, insert = false) {
+    const snapshot = this.snapshotRow(this.getRow(rowNum));
+    if (insert) {
+      const blanks = Array.from({ length: count }, () => []);
+      this.spliceRows(rowNum + 1, 0, ...blanks);
+    }
+    for (let i = 1; i <= count; i++) this.restoreRow(rowNum + i, snapshot);
+  }
+  spliceRows(start, count, ...inserts) {
+    const delta = inserts.length - count;
+    const oldMerges = [...this._merges.values()].map((r) => ({
+      top: r.top,
+      left: r.left,
+      bottom: r.bottom,
+      right: r.right
+    }));
+    const snapshots = /* @__PURE__ */ new Map();
+    for (const [num2, row] of this._rows) snapshots.set(num2, this.snapshotRow(row));
+    this._rows.clear();
+    this._merges.clear();
+    for (const [num2, snap] of snapshots) {
+      if (num2 < start) {
+        this.restoreRow(num2, snap);
+      } else if (num2 >= start + count) {
+        this.restoreRow(num2 + delta, snap);
+      }
+    }
+    inserts.forEach((values, i) => {
+      this.getRow(start + i).values = values;
+    });
+    for (const m of oldMerges) {
+      if (m.top >= start + count) {
+        this.applyMerge(new Range(m.top + delta, m.left, m.bottom + delta, m.right));
+      } else if (m.bottom < start) {
+        this.applyMerge(new Range(m.top, m.left, m.bottom, m.right));
+      }
+    }
+  }
+  snapshotRow(row) {
+    const cells = [];
+    row.eachCell((cell, col) => {
+      cells.push({ col, value: cell.value, style: cell.style });
+    });
+    return {
+      height: row.height,
+      hidden: row.hidden,
+      outlineLevel: row.outlineLevel,
+      style: row.style,
+      cells
+    };
+  }
+  restoreRow(num2, snap) {
+    const row = this.getRow(num2);
+    row.height = snap.height;
+    row.hidden = snap.hidden;
+    row.outlineLevel = snap.outlineLevel;
+    row.style = snap.style;
+    for (const c of snap.cells) {
+      const cell = row.getCell(c.col);
+      cell.value = c.value;
+      cell.style = c.style;
+    }
+  }
+  eachRow(optsOrCb, maybeCb) {
+    const includeEmpty = typeof optsOrCb === "object" ? optsOrCb.includeEmpty : false;
+    const cb = typeof optsOrCb === "function" ? optsOrCb : maybeCb;
+    if (includeEmpty) {
+      const max = this.rowCount;
+      for (let n = 1; n <= max; n++) cb(this.getRow(n), n);
+    } else {
+      const sorted = [...this._rows.entries()].sort((a, b) => a[0] - b[0]);
+      for (const [n, row] of sorted) cb(row, n);
+    }
+  }
+  getSheetValues() {
+    const result = [];
+    this.eachRow((row, n) => {
+      result[n] = row.values;
+    });
+    return result;
+  }
+  get rowCount() {
+    let max = 0;
+    for (const n of this._rows.keys()) if (n > max) max = n;
+    return max;
+  }
+  get actualRowCount() {
+    let count = 0;
+    for (const row of this._rows.values()) if (row.hasValues) count++;
+    return count;
+  }
+  get lastRow() {
+    const rc = this.rowCount;
+    return rc >= 1 ? this._rows.get(rc) : void 0;
+  }
+  // --- columns ----------------------------------------------------------------------------------
+  get columns() {
+    const count = this.columnCount;
+    const arr = [];
+    for (let n = 1; n <= count; n++) arr.push(this.getColumn(n));
+    return arr;
+  }
+  set columns(defns) {
+    defns.forEach((defn, i) => {
+      const col = this.getColumn(i + 1);
+      col.defn = { ...col.defn, ...defn };
+      if (defn.key !== void 0) this._columnsByKey.set(defn.key, col);
+    });
+  }
+  getColumn(idOrKey) {
+    if (typeof idOrKey === "number") return this.getOrCreateColumn(idOrKey);
+    const byKey = this._columnsByKey.get(idOrKey);
+    if (byKey) return byKey;
+    return this.getOrCreateColumn(colLetterToNumber(idOrKey));
+  }
+  getOrCreateColumn(n) {
+    let c = this._columns.get(n);
+    if (!c) {
+      c = new Column(this, n);
+      this._columns.set(n, c);
+    }
+    return c;
+  }
+  get columnCount() {
+    let max = 0;
+    for (const n of this._columns.keys()) if (n > max) max = n;
+    this.eachRow((row) => {
+      const d = row.dimensions;
+      if (d && d.max > max) max = d.max;
+    });
+    return max;
+  }
+  get actualColumnCount() {
+    const cols = /* @__PURE__ */ new Set();
+    this.eachRow((row) => {
+      row.eachCell((cell, col) => {
+        if (cell.type !== 0 /* Null */) cols.add(col);
+      });
+    });
+    return cols.size;
+  }
+  get lastColumn() {
+    const cc = this.columnCount;
+    return cc >= 1 ? this.getColumn(cc) : void 0;
+  }
+  spliceColumns(start, count, ...inserts) {
+    const delta = inserts.length - count;
+    this.eachRow((row) => {
+      const rowInserts = inserts.map((colVals) => colVals[row.number] ?? null);
+      row.splice(start, count, ...rowInserts);
+    });
+    const oldColumns = [...this._columns.entries()];
+    this._columns.clear();
+    this._columnsByKey.clear();
+    for (const [n, col] of oldColumns) {
+      let newNumber;
+      if (n < start) newNumber = n;
+      else if (n >= start + count) newNumber = n + delta;
+      else continue;
+      const moved = new Column(this, newNumber, col.defn);
+      this._columns.set(newNumber, moved);
+      if (moved.key !== void 0) this._columnsByKey.set(moved.key, moved);
+    }
+    const oldMerges = [...this._merges.values()].map((r) => ({
+      top: r.top,
+      left: r.left,
+      bottom: r.bottom,
+      right: r.right
+    }));
+    this._merges.clear();
+    for (const m of oldMerges) {
+      if (m.left >= start + count) {
+        this.applyMerge(new Range(m.top, m.left + delta, m.bottom, m.right + delta));
+      } else if (m.right < start) {
+        this.applyMerge(new Range(m.top, m.left, m.bottom, m.right));
+      }
+    }
+  }
+  // --- column keys ------------------------------------------------------------------------------
+  getColumnKey(key) {
+    return this._columnsByKey.get(key);
+  }
+  setColumnKey(key, column) {
+    column.key = key;
+    this._columnsByKey.set(key, column);
+  }
+  deleteColumnKey(key) {
+    const col = this._columnsByKey.get(key);
+    if (col) col.key = void 0;
+    this._columnsByKey.delete(key);
+  }
+  eachColumnKey(cb) {
+    for (const [key, col] of this._columnsByKey) cb(col, key);
+  }
+  // --- cells ------------------------------------------------------------------------------------
+  getCell(r, c) {
+    if (c === void 0) {
+      const d = decodeAddress(r);
+      return this.getRow(d.row).getCell(d.col);
+    }
+    return this.getRow(r).getCell(c);
+  }
+  findCell(r, c) {
+    let rowNum;
+    let colNum;
+    if (c === void 0) {
+      const d = decodeAddress(r);
+      rowNum = d.row;
+      colNum = d.col;
+    } else {
+      rowNum = r;
+      colNum = this.toColNumber(c);
+    }
+    const row = this._rows.get(rowNum);
+    return row?.findCell(colNum);
+  }
+  toColNumber(col) {
+    if (typeof col === "number") return col;
+    const byKey = this._columnsByKey.get(col);
+    if (byKey) return byKey.number;
+    return colLetterToNumber(col);
+  }
+  // --- merges -----------------------------------------------------------------------------------
+  mergeCells(...cells) {
+    const range = normalizeMergeArgs(cells);
+    for (const existing of this._merges.values()) {
+      if (range.intersects(existing)) throw new MergeConflictError(range.range);
+    }
+    this.applyMerge(range);
+  }
+  unMergeCells(...cells) {
+    const range = normalizeMergeArgs(cells);
+    for (const [key, existing] of [...this._merges.entries()]) {
+      if (!range.intersects(existing)) continue;
+      existing.forEachAddress((_addr, row, col) => {
+        if (row === existing.top && col === existing.left) return;
+        this.getRow(row).getCell(col).unmerge();
+      });
+      this._merges.delete(key);
+    }
+  }
+  /** Links the slave cells of `range` to its top-left master and records the region. */
+  applyMerge(range) {
+    const master = this.getCell(range.top, range.left);
+    range.forEachAddress((_addr, row, col) => {
+      if (row === range.top && col === range.left) return;
+      this.getRow(row).getCell(col).merge(master);
+    });
+    this._merges.set(master.address, range);
+  }
+  get hasMerges() {
+    return this._merges.size > 0;
+  }
+  get dimensions() {
+    let top = Number.POSITIVE_INFINITY;
+    let left = Number.POSITIVE_INFINITY;
+    let bottom = Number.NEGATIVE_INFINITY;
+    let right = Number.NEGATIVE_INFINITY;
+    this.eachRow((row, n) => {
+      const d = row.dimensions;
+      if (!d) return;
+      if (n < top) top = n;
+      if (n > bottom) bottom = n;
+      if (d.min < left) left = d.min;
+      if (d.max > right) right = d.max;
+    });
+    if (top === Number.POSITIVE_INFINITY) return new Range(1, 1, 1, 1);
+    return new Range(top, left, bottom, right);
+  }
+  // --- model ------------------------------------------------------------------------------------
+  get model() {
+    const rows = [...this._rows.entries()].sort((a, b) => a[0] - b[0]).map(([, row]) => row.model);
+    const columns = Column.toModel([...this._columns.values()]);
+    const m = {
+      id: this._id,
+      name: this._name,
+      orderNo: this.orderNo,
+      state: this.state,
+      properties: { ...this.properties },
+      views: this.views.map((v) => ({ ...v })),
+      rows,
+      merges: [...this._merges.values()].map((r) => r.range)
+    };
+    if (columns) m.columns = columns;
+    if (this.pageSetup !== void 0) m.pageSetup = this.pageSetup;
+    if (this.headerFooter !== void 0) m.headerFooter = this.headerFooter;
+    return m;
+  }
+  set model(m) {
+    this._id = m.id;
+    this._name = m.name;
+    this.orderNo = m.orderNo;
+    this.state = m.state;
+    this.properties = { ...m.properties };
+    this.views = m.views.map((v) => ({ ...v }));
+    this.pageSetup = m.pageSetup;
+    this.headerFooter = m.headerFooter;
+    this._rows.clear();
+    this._columns.clear();
+    this._columnsByKey.clear();
+    this._merges.clear();
+    if (m.columns) {
+      const cols = Column.fromModel(this, m.columns) ?? [];
+      for (const col of cols) {
+        this._columns.set(col.number, col);
+        if (col.key !== void 0) this._columnsByKey.set(col.key, col);
+      }
+    }
+    for (const rowModel of m.rows) {
+      this.getRow(rowModel.number).model = rowModel;
+    }
+    for (const mergeStr of m.merges) this.applyMerge(new Range(mergeStr));
+  }
+};
+
+// src/model/workbook.ts
+var Workbook = class {
+  creator;
+  lastModifiedBy;
+  created;
+  modified;
+  lastPrinted;
+  title;
+  subject;
+  keywords;
+  category;
+  description;
+  company;
+  manager;
+  properties = {};
+  calcProperties = {};
+  views = [];
+  _byId = /* @__PURE__ */ new Map();
+  _sheets = [];
+  _nextId = 1;
+  constructor() {
+    const now = /* @__PURE__ */ new Date();
+    this.created = now;
+    this.modified = now;
+  }
+  /** Ordered, O(n). A fresh copy so callers cannot mutate the backing order. */
+  get worksheets() {
+    return [...this._sheets];
+  }
+  addWorksheet(name, options) {
+    const resolvedName = name ?? this.uniqueSheetName();
+    validateWorksheetNameFormat(resolvedName);
+    const lower = resolvedName.toLowerCase();
+    for (const ws2 of this._sheets) {
+      if (ws2.name.toLowerCase() === lower) throw new DuplicateWorksheetNameError(resolvedName);
+    }
+    const id = this._nextId++;
+    const ws = new Worksheet(this, id, resolvedName, this._sheets.length);
+    if (options) {
+      if (options.state) ws.state = options.state;
+      if (options.properties) ws.properties = { ...ws.properties, ...options.properties };
+      if (options.views) ws.views = options.views;
+      if (options.pageSetup !== void 0) ws.pageSetup = options.pageSetup;
+      if (options.headerFooter !== void 0) ws.headerFooter = options.headerFooter;
+    }
+    this._byId.set(id, ws);
+    this._sheets.push(ws);
+    return ws;
+  }
+  uniqueSheetName() {
+    const taken = new Set(this._sheets.map((w) => w.name.toLowerCase()));
+    let n = this._sheets.length + 1;
+    let candidate = `Sheet${n}`;
+    while (taken.has(candidate.toLowerCase())) {
+      n++;
+      candidate = `Sheet${n}`;
+    }
+    return candidate;
+  }
+  getWorksheet(idOrName) {
+    if (idOrName === void 0) return this._sheets[0];
+    if (typeof idOrName === "number") return this._byId.get(idOrName);
+    return this._sheets.find((w) => w.name === idOrName);
+  }
+  removeWorksheet(idOrName) {
+    const ws = typeof idOrName === "number" ? this._byId.get(idOrName) : this._sheets.find((w) => w.name === idOrName);
+    if (!ws) return;
+    this._byId.delete(ws.id);
+    this._sheets = this._sheets.filter((w) => w !== ws);
+    this.reindex();
+  }
+  /** Keeps `orderNo` equal to array position after a removal. */
+  reindex() {
+    this._sheets.forEach((w, i) => {
+      w.orderNo = i;
+    });
+  }
+  eachSheet(cb) {
+    for (const ws of this._sheets) cb(ws, ws.id);
+  }
+  // --- model ------------------------------------------------------------------------------------
+  get model() {
+    const m = {
+      created: this.created,
+      modified: this.modified,
+      properties: { ...this.properties },
+      calcProperties: { ...this.calcProperties },
+      views: this.views.map((v) => ({ ...v })),
+      sheets: this._sheets.map((w) => w.model),
+      nextId: this._nextId
+    };
+    if (this.creator !== void 0) m.creator = this.creator;
+    if (this.lastModifiedBy !== void 0) m.lastModifiedBy = this.lastModifiedBy;
+    if (this.lastPrinted !== void 0) m.lastPrinted = this.lastPrinted;
+    if (this.title !== void 0) m.title = this.title;
+    if (this.subject !== void 0) m.subject = this.subject;
+    if (this.keywords !== void 0) m.keywords = this.keywords;
+    if (this.category !== void 0) m.category = this.category;
+    if (this.description !== void 0) m.description = this.description;
+    if (this.company !== void 0) m.company = this.company;
+    if (this.manager !== void 0) m.manager = this.manager;
+    return m;
+  }
+  set model(m) {
+    this.creator = m.creator;
+    this.lastModifiedBy = m.lastModifiedBy;
+    this.created = m.created;
+    this.modified = m.modified;
+    this.lastPrinted = m.lastPrinted;
+    this.title = m.title;
+    this.subject = m.subject;
+    this.keywords = m.keywords;
+    this.category = m.category;
+    this.description = m.description;
+    this.company = m.company;
+    this.manager = m.manager;
+    this.properties = { ...m.properties };
+    this.calcProperties = { ...m.calcProperties };
+    this.views = m.views.map((v) => ({ ...v }));
+    this._byId.clear();
+    this._sheets = [];
+    for (const sheetModel of m.sheets) {
+      const ws = new Worksheet(this, sheetModel.id, sheetModel.name, sheetModel.orderNo);
+      ws.model = sheetModel;
+      this._byId.set(ws.id, ws);
+      this._sheets.push(ws);
+    }
+    this._nextId = m.nextId;
+  }
+};
+
+// src/xlsx/date.ts
+var MS_PER_DAY = 864e5;
+var EPOCH_1900 = Date.UTC(1899, 11, 31);
+var EPOCH_1904 = Date.UTC(1904, 0, 1);
+var LEAP_BUG_SERIAL = 60;
+function dateToSerial(d, date1904 = false) {
+  if (date1904) {
+    return (d.getTime() - EPOCH_1904) / MS_PER_DAY;
+  }
+  const raw = (d.getTime() - EPOCH_1900) / MS_PER_DAY;
+  return raw >= LEAP_BUG_SERIAL ? raw + 1 : raw;
+}
+function serialToDate(serial, date1904 = false) {
+  if (date1904) {
+    return new Date(EPOCH_1904 + serial * MS_PER_DAY);
+  }
+  const adjusted = serial > LEAP_BUG_SERIAL ? serial - 1 : serial;
+  return new Date(EPOCH_1900 + adjusted * MS_PER_DAY);
+}
+
+// src/xlsx/parts/constants.ts
+var NS = {
+  spreadsheetml: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+  relationships: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+  contentTypes: "http://schemas.openxmlformats.org/package/2006/content-types",
+  packageRels: "http://schemas.openxmlformats.org/package/2006/relationships",
+  coreProps: "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+  extProps: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+  docPropsVt: "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes",
+  dc: "http://purl.org/dc/elements/1.1/",
+  dcterms: "http://purl.org/dc/terms/",
+  dcmitype: "http://purl.org/dc/dcmitype/",
+  xsi: "http://www.w3.org/2001/XMLSchema-instance"
+};
+var CONTENT_TYPE = {
+  rels: "application/vnd.openxmlformats-package.relationships+xml",
+  xml: "application/xml",
+  workbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
+  worksheet: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml",
+  styles: "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml",
+  sharedStrings: "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml",
+  theme: "application/vnd.openxmlformats-officedocument.theme+xml",
+  coreProps: "application/vnd.openxmlformats-package.core-properties+xml",
+  extProps: "application/vnd.openxmlformats-officedocument.extended-properties+xml"
+};
+var REL_TYPE = {
+  officeDocument: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+  coreProps: "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties",
+  extProps: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties",
+  worksheet: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",
+  styles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
+  sharedStrings: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings",
+  theme: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme"
+};
+var PART_PATH = {
+  contentTypes: "[Content_Types].xml",
+  rootRels: "_rels/.rels",
+  coreProps: "docProps/core.xml",
+  appProps: "docProps/app.xml",
+  workbook: "xl/workbook.xml",
+  workbookRels: "xl/_rels/workbook.xml.rels",
+  styles: "xl/styles.xml",
+  sharedStrings: "xl/sharedStrings.xml",
+  theme: "xl/theme/theme1.xml"
+};
+
+// src/xml/xml-reader.ts
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+var ENTITY_RE = /&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z][a-zA-Z0-9]*);/g;
+function decodeEntities(s) {
+  if (!s.includes("&")) return s;
+  return s.replace(ENTITY_RE, (match, ent) => {
+    if (ent.startsWith("#x") || ent.startsWith("#X")) {
+      const code = Number.parseInt(ent.slice(2), 16);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : match;
+    }
+    if (ent.startsWith("#")) {
+      const code = Number.parseInt(ent.slice(1), 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : match;
+    }
+    const named = NAMED_ENTITIES[ent];
+    return named !== void 0 ? named : match;
+  });
+}
+function isSpace(c) {
+  return c === " " || c === "	" || c === "\n" || c === "\r";
+}
+function findTagEnd(xml, start) {
+  let i = start;
+  let quote;
+  while (i < xml.length) {
+    const c = xml[i];
+    if (quote) {
+      if (c === quote) quote = void 0;
+    } else if (c === '"' || c === "'") {
+      quote = c;
+    } else if (c === ">") {
+      return i;
+    }
+    i++;
+  }
+  return xml.length;
+}
+function parseOpenTag(inner) {
+  const len = inner.length;
+  let i = 0;
+  while (i < len && !isSpace(inner[i])) i++;
+  const name = inner.slice(0, i);
+  const attrs = {};
+  while (i < len) {
+    while (i < len && isSpace(inner[i])) i++;
+    if (i >= len) break;
+    let j = i;
+    while (j < len && inner[j] !== "=" && !isSpace(inner[j])) j++;
+    const attrName = inner.slice(i, j);
+    if (!attrName) break;
+    while (j < len && isSpace(inner[j])) j++;
+    if (inner[j] === "=") {
+      j++;
+      while (j < len && isSpace(inner[j])) j++;
+      const quote = inner[j];
+      j++;
+      const valStart = j;
+      while (j < len && inner[j] !== quote) j++;
+      attrs[attrName] = decodeEntities(inner.slice(valStart, j));
+      j++;
+      i = j;
+    } else {
+      attrs[attrName] = "";
+      i = j;
+    }
+  }
+  return { name, attrs };
+}
+function* parseXml(xml) {
+  const len = xml.length;
+  let i = 0;
+  while (i < len) {
+    if (xml[i] === "<") {
+      if (xml.startsWith("<?", i)) {
+        const end = xml.indexOf("?>", i + 2);
+        i = end === -1 ? len : end + 2;
+        continue;
+      }
+      if (xml.startsWith("<!--", i)) {
+        const end = xml.indexOf("-->", i + 4);
+        i = end === -1 ? len : end + 3;
+        continue;
+      }
+      if (xml.startsWith("<![CDATA[", i)) {
+        const end = xml.indexOf("]]>", i + 9);
+        const text = end === -1 ? xml.slice(i + 9) : xml.slice(i + 9, end);
+        i = end === -1 ? len : end + 3;
+        if (text.length > 0) yield { kind: "text", text };
+        continue;
+      }
+      if (xml.startsWith("<!", i)) {
+        const end = xml.indexOf(">", i + 2);
+        i = end === -1 ? len : end + 1;
+        continue;
+      }
+      if (xml[i + 1] === "/") {
+        const end = xml.indexOf(">", i + 2);
+        const name2 = xml.slice(i + 2, end === -1 ? len : end).trim();
+        i = end === -1 ? len : end + 1;
+        yield { kind: "close", name: name2 };
+        continue;
+      }
+      const tagEnd = findTagEnd(xml, i + 1);
+      const selfClosing = xml[tagEnd - 1] === "/";
+      const inner = xml.slice(i + 1, selfClosing ? tagEnd - 1 : tagEnd);
+      const { name, attrs } = parseOpenTag(inner);
+      i = tagEnd === len ? len : tagEnd + 1;
+      yield { kind: "open", name, attrs, selfClosing };
+      continue;
+    }
+    const next = xml.indexOf("<", i);
+    const raw = next === -1 ? xml.slice(i) : xml.slice(i, next);
+    i = next === -1 ? len : next;
+    if (raw.length > 0) yield { kind: "text", text: decodeEntities(raw) };
+  }
+}
+function localName(name) {
+  const idx = name.indexOf(":");
+  return idx === -1 ? name : name.slice(idx + 1);
+}
+function cursor(xml) {
+  const gen = parseXml(xml);
+  let lookahead;
+  let hasLookahead = false;
+  function pull() {
+    const result = gen.next();
+    return result.done ? void 0 : result.value;
+  }
+  function next() {
+    if (hasLookahead) {
+      hasLookahead = false;
+      const ev = lookahead;
+      lookahead = void 0;
+      return ev;
+    }
+    return pull();
+  }
+  function peek() {
+    if (!hasLookahead) {
+      lookahead = pull();
+      hasLookahead = true;
+    }
+    return lookahead;
+  }
+  function textUntilClose(name) {
+    let text = "";
+    let depth = 1;
+    for (let ev = next(); ev; ev = next()) {
+      if (ev.kind === "text") {
+        text += ev.text;
+      } else if (ev.kind === "open") {
+        if (ev.name === name && !ev.selfClosing) depth++;
+      } else if (ev.kind === "close" && ev.name === name) {
+        depth--;
+        if (depth === 0) break;
+      }
+    }
+    return text;
+  }
+  function eachChild(name, onOpen) {
+    for (let ev = next(); ev; ev = next()) {
+      if (ev.kind === "close" && ev.name === name) break;
+      if (ev.kind === "open") onOpen(ev);
+    }
+  }
+  return { next, peek, textUntilClose, eachChild };
+}
+
+// src/xml/xml-writer.ts
+var XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+function escapeXmlText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXmlAttr(s) {
+  return escapeXmlText(s).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function needsWhitespacePreserve(s) {
+  return /^\s|\s$/.test(s);
+}
+var XmlWriter = class {
+  buffer = "";
+  constructor(opts) {
+    if (opts?.declaration !== false) {
+      this.buffer = XML_DECLARATION;
+    }
+  }
+  /** Serialize an attribute record, omitting `undefined`/`null` and rendering booleans as `1`/`0`. */
+  renderAttrs(attrs) {
+    if (!attrs) return "";
+    let out = "";
+    for (const key of Object.keys(attrs)) {
+      const value = attrs[key];
+      if (value === void 0 || value === null) continue;
+      const raw = typeof value === "boolean" ? value ? "1" : "0" : String(value);
+      out += ` ${key}="${escapeXmlAttr(raw)}"`;
+    }
+    return out;
+  }
+  /** Open an element: `<tag …>`. */
+  open(tag, attrs) {
+    this.buffer += `<${tag}${this.renderAttrs(attrs)}>`;
+    return this;
+  }
+  /** Self-closing element with attributes only: `<tag …/>`. */
+  leaf(tag, attrs) {
+    this.buffer += `<${tag}${this.renderAttrs(attrs)}/>`;
+    return this;
+  }
+  /** Element with escaped text content: `<tag …>text</tag>`. A `<t>` whose text has leading/trailing
+   *  whitespace automatically gains `xml:space="preserve"` (explicit attrs win if they set it). */
+  el(tag, text, attrs) {
+    const finalAttrs = tag === "t" && needsWhitespacePreserve(text) ? { "xml:space": "preserve", ...attrs } : attrs;
+    this.buffer += `<${tag}${this.renderAttrs(finalAttrs)}>${escapeXmlText(text)}</${tag}>`;
+    return this;
+  }
+  /** Append escaped text content at the current position. */
+  text(value) {
+    this.buffer += escapeXmlText(value);
+    return this;
+  }
+  /** Append already-serialized markup verbatim (escape hatch for composing sub-builders). */
+  raw(xml) {
+    this.buffer += xml;
+    return this;
+  }
+  /** Close an element: `</tag>`. */
+  close(tag) {
+    this.buffer += `</${tag}>`;
+    return this;
+  }
+  toString() {
+    return this.buffer;
+  }
+  toBytes() {
+    return new TextEncoder().encode(this.buffer);
+  }
+};
+function readZipArchive(data) {
+  const unzipped = unzipSync(data);
+  return new Map(Object.entries(unzipped));
+}
+function writeZipArchive(entries) {
+  return zipSync(Object.fromEntries(entries));
+}
+
+// src/xlsx/read/package.ts
+var decoder = new TextDecoder();
+function openPackage(bytes) {
+  const zip = readZip(bytes);
+  const entry = (path) => zip.get(path);
+  const text = (path) => {
+    const raw = zip.get(path);
+    return raw === void 0 ? void 0 : decoder.decode(raw);
+  };
+  const rootRelsXml = text(PART_PATH.rootRels);
+  if (rootRelsXml === void 0) {
+    throw new InvalidPackageError(`missing ${PART_PATH.rootRels}`);
+  }
+  const officeDocRel = parseRels(rootRelsXml).find((r) => r.type === REL_TYPE.officeDocument);
+  if (!officeDocRel) {
+    throw new InvalidPackageError(`${PART_PATH.rootRels} has no officeDocument relationship`);
+  }
+  const workbookPath = resolveRelTarget("", officeDocRel.target);
+  const contentTypesXml = text(PART_PATH.contentTypes);
+  if (contentTypesXml === void 0) {
+    throw new UnsupportedFeatureError(
+      `package is missing ${PART_PATH.contentTypes}; not a recognizable OOXML package`
+    );
+  }
+  assertSpreadsheetPackage(contentTypesXml, workbookPath);
+  if (entry(workbookPath) === void 0) {
+    throw new InvalidPackageError(`workbook part not found at ${workbookPath}`);
+  }
+  const workbookDir = dirname(workbookPath);
+  const workbookRelsXml = text(relsPathFor(workbookPath));
+  const relsMap = /* @__PURE__ */ new Map();
+  if (workbookRelsXml !== void 0) {
+    for (const rel of parseRels(workbookRelsXml)) {
+      relsMap.set(rel.id, { type: rel.type, target: resolveRelTarget(workbookDir, rel.target) });
+    }
+  }
+  return {
+    entry,
+    text,
+    workbookRels: () => relsMap,
+    workbookPath: () => workbookPath
+  };
+}
+function readZip(bytes) {
+  try {
+    return readZipArchive(bytes);
+  } catch (e) {
+    throw new InvalidPackageError(`could not read zip archive: ${e.message}`);
+  }
+}
+function parseRels(xml) {
+  const c = cursor(xml);
+  let ev = c.next();
+  while (ev && !(ev.kind === "open" && ev.name === "Relationships")) ev = c.next();
+  if (ev?.kind !== "open") return [];
+  const rels = [];
+  if (!ev.selfClosing) {
+    c.eachChild(ev.name, (child) => {
+      if (child.name !== "Relationship") return;
+      rels.push({
+        id: child.attrs.Id ?? "",
+        type: child.attrs.Type ?? "",
+        target: child.attrs.Target ?? ""
+      });
+    });
+  }
+  return rels;
+}
+function assertSpreadsheetPackage(contentTypesXml, workbookPath) {
+  const c = cursor(contentTypesXml);
+  let ev = c.next();
+  while (ev && !(ev.kind === "open" && ev.name === "Types")) ev = c.next();
+  if (ev?.kind !== "open") {
+    throw new UnsupportedFeatureError(
+      `${PART_PATH.contentTypes} has no <Types> root; not a recognizable OOXML package`
+    );
+  }
+  let isSpreadsheet = false;
+  if (!ev.selfClosing) {
+    c.eachChild(ev.name, (child) => {
+      if (child.name !== "Override") return;
+      const partName = child.attrs.PartName?.replace(/^\//, "");
+      if (partName === workbookPath && child.attrs.ContentType === CONTENT_TYPE.workbook) {
+        isSpreadsheet = true;
+      }
+    });
+  }
+  if (!isSpreadsheet) {
+    throw new UnsupportedFeatureError(
+      `package does not declare ${workbookPath} as a spreadsheet workbook in ${PART_PATH.contentTypes}`
+    );
+  }
+}
+function dirname(path) {
+  const idx = path.lastIndexOf("/");
+  return idx === -1 ? "" : path.slice(0, idx);
+}
+function relsPathFor(partPath) {
+  const dir = dirname(partPath);
+  const base = dir ? partPath.slice(dir.length + 1) : partPath;
+  return dir ? `${dir}/_rels/${base}.rels` : `_rels/${base}.rels`;
+}
+function resolveRelTarget(baseDir, target) {
+  if (target.startsWith("/")) return target.slice(1);
+  const parts = baseDir ? baseDir.split("/") : [];
+  for (const seg of target.split("/")) {
+    if (seg === "" || seg === ".") continue;
+    if (seg === "..") parts.pop();
+    else parts.push(seg);
+  }
+  return parts.join("/");
+}
+
+// src/xlsx/read/props.ts
+function fromW3CDTF(text) {
+  return new Date(text);
+}
+function applyCoreProps(wb, xml) {
+  const c = cursor(xml);
+  let ev = c.next();
+  while (ev && !(ev.kind === "open" && localName(ev.name) === "coreProperties")) ev = c.next();
+  if (ev?.kind !== "open" || ev.selfClosing) return;
+  c.eachChild(ev.name, (child) => {
+    const name = localName(child.name);
+    const text = child.selfClosing ? "" : c.textUntilClose(child.name);
+    switch (name) {
+      case "creator":
+        wb.creator = text;
+        break;
+      case "title":
+        wb.title = text;
+        break;
+      case "subject":
+        wb.subject = text;
+        break;
+      case "description":
+        wb.description = text;
+        break;
+      case "keywords":
+        wb.keywords = text;
+        break;
+      case "category":
+        wb.category = text;
+        break;
+      case "lastModifiedBy":
+        wb.lastModifiedBy = text;
+        break;
+      case "created":
+        wb.created = fromW3CDTF(text);
+        break;
+      case "modified":
+        wb.modified = fromW3CDTF(text);
+        break;
+    }
+  });
+}
+function applyAppProps(wb, xml) {
+  const c = cursor(xml);
+  let ev = c.next();
+  while (ev && !(ev.kind === "open" && localName(ev.name) === "Properties")) ev = c.next();
+  if (ev?.kind !== "open" || ev.selfClosing) return;
+  c.eachChild(ev.name, (child) => {
+    const name = localName(child.name);
+    const text = child.selfClosing ? "" : c.textUntilClose(child.name);
+    if (name === "Company") wb.company = text;
+    else if (name === "Manager") wb.manager = text;
+  });
+}
+
+// src/xlsx/read/shared-strings.ts
+function parseSharedStrings(xml) {
+  const c = cursor(xml);
+  let ev = c.next();
+  while (ev && !(ev.kind === "open" && localName(ev.name) === "sst")) ev = c.next();
+  if (ev?.kind !== "open" || ev.selfClosing) return [];
+  const entries = [];
+  c.eachChild(ev.name, (child) => {
+    if (localName(child.name) !== "si") return;
+    entries.push(child.selfClosing ? "" : parseRichString(c, child.name));
+  });
+  return entries;
+}
+function parseRichString(c, container) {
+  let text;
+  const runs = [];
+  c.eachChild(container, (child) => {
+    const name = localName(child.name);
+    if (name === "t") {
+      text = child.selfClosing ? "" : c.textUntilClose(child.name);
+    } else if (name === "r") {
+      runs.push(child.selfClosing ? { text: "" } : parseRun(c, child.name));
+    } else if (!child.selfClosing) {
+      c.textUntilClose(child.name);
+    }
+  });
+  return runs.length > 0 ? { richText: runs } : text ?? "";
+}
+function parseRun(c, rName) {
+  let text = "";
+  let font;
+  c.eachChild(rName, (child) => {
+    const name = localName(child.name);
+    if (name === "t") {
+      text = child.selfClosing ? "" : c.textUntilClose(child.name);
+    } else if (name === "rPr") {
+      font = child.selfClosing ? {} : parseRunProps(c, child.name);
+    } else if (!child.selfClosing) {
+      c.textUntilClose(child.name);
+    }
+  });
+  return font ? { text, font } : { text };
+}
+function parseRunProps(c, rPrName) {
+  const font = {};
+  c.eachChild(rPrName, (child) => {
+    const name = localName(child.name);
+    switch (name) {
+      case "rFont":
+        font.name = child.attrs.val;
+        break;
+      case "charset":
+        font.charset = Number(child.attrs.val);
+        break;
+      case "family":
+        font.family = Number(child.attrs.val);
+        break;
+      case "b":
+        font.bold = readBool(child.attrs.val);
+        break;
+      case "i":
+        font.italic = readBool(child.attrs.val);
+        break;
+      case "strike":
+        font.strike = readBool(child.attrs.val);
+        break;
+      case "outline":
+        font.outline = readBool(child.attrs.val);
+        break;
+      case "color":
+        font.color = parseColor(child.attrs);
+        break;
+      case "sz":
+        font.size = Number(child.attrs.val);
+        break;
+      case "u":
+        font.underline = child.attrs.val ?? true;
+        break;
+      case "vertAlign":
+        font.vertAlign = child.attrs.val;
+        break;
+      case "scheme":
+        font.scheme = child.attrs.val;
+        break;
+    }
+    if (!child.selfClosing) c.textUntilClose(child.name);
+  });
+  return font;
+}
+function parseColor(attrs) {
+  if (attrs.rgb !== void 0) return { argb: attrs.rgb };
+  if (attrs.theme !== void 0) return { theme: Number(attrs.theme) };
+  if (attrs.indexed !== void 0) return { indexed: Number(attrs.indexed) };
+  return void 0;
+}
+function readBool(val) {
+  return val === void 0 || val !== "0" && val !== "false";
+}
+
+// src/xlsx/styles.ts
+var SPREADSHEETML_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+var FIRST_CUSTOM_NUMFMT_ID = 164;
+var DEFAULT_FONT = {
+  size: 11,
+  color: { theme: 1 },
+  name: "Calibri",
+  family: 2,
+  scheme: "minor"
+};
+var DEFAULT_CELL_STYLE_XF = '<xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>';
+var BUILTIN_NUMFMT_BY_CODE = /* @__PURE__ */ new Map([
+  ["General", 0],
+  ["0", 1],
+  ["0.00", 2],
+  ["#,##0", 3],
+  ["#,##0.00", 4],
+  ["0%", 9],
+  ["0.00%", 10],
+  ["0.00E+00", 11],
+  ["# ?/?", 12],
+  ["# ??/??", 13],
+  ["mm-dd-yy", 14],
+  ["d-mmm-yy", 15],
+  ["d-mmm", 16],
+  ["mmm-yy", 17],
+  ["h:mm AM/PM", 18],
+  ["h:mm:ss AM/PM", 19],
+  ["h:mm", 20],
+  ["h:mm:ss", 21],
+  ["m/d/yy h:mm", 22],
+  ["#,##0 ;(#,##0)", 37],
+  ["#,##0 ;[Red](#,##0)", 38],
+  ["#,##0.00;(#,##0.00)", 39],
+  ["#,##0.00;[Red](#,##0.00)", 40],
+  ["mm:ss", 45],
+  ["[h]:mm:ss", 46],
+  ["mmss.0", 47],
+  ["##0.0E+0", 48],
+  ["@", 49]
+]);
+function createStyles() {
+  return new StylesBuilder();
+}
+var InternPool = class {
+  ids = /* @__PURE__ */ new Map();
+  xml = [];
+  constructor(seeds) {
+    for (const seed of seeds) this.intern(seed);
+  }
+  intern(rendered) {
+    const existing = this.ids.get(rendered);
+    if (existing !== void 0) return existing;
+    const id = this.xml.length;
+    this.ids.set(rendered, id);
+    this.xml.push(rendered);
+    return id;
+  }
+  get count() {
+    return this.xml.length;
+  }
+};
+var StylesBuilder = class {
+  fonts = new InternPool([renderFont(DEFAULT_FONT)]);
+  fills = new InternPool([
+    renderFill({ type: "pattern", pattern: "none" }),
+    renderFill({ type: "pattern", pattern: "gray125" })
+  ]);
+  borders = new InternPool([renderBorder(void 0)]);
+  cellXfs = new InternPool([
+    renderXf({ numFmtId: 0, fontId: 0, fillId: 0, borderId: 0 })
+  ]);
+  /** Custom number-format code → allocated id (≥ 164), and the `<numFmt>` fragments in id order. */
+  customNumFmtIds = /* @__PURE__ */ new Map();
+  numFmtXml = [];
+  nextNumFmtId = FIRST_CUSTOM_NUMFMT_ID;
+  /** Fast path for the common case of one Style object shared across many cells. */
+  cache = /* @__PURE__ */ new WeakMap();
+  addStyle(style) {
+    if (style === void 0) return 0;
+    const cached = this.cache.get(style);
+    if (cached !== void 0) return cached;
+    const numFmtId = this.internNumFmt(style.numFmt);
+    const fontId = style.font ? this.fonts.intern(renderFont(style.font)) : 0;
+    const fillId = style.fill ? this.fills.intern(renderFill(style.fill)) : 0;
+    const borderId = style.border ? this.borders.intern(renderBorder(style.border)) : 0;
+    const id = this.cellXfs.intern(
+      renderXf({
+        numFmtId,
+        fontId,
+        fillId,
+        borderId,
+        alignment: style.alignment,
+        protection: style.protection
+      })
+    );
+    this.cache.set(style, id);
+    return id;
+  }
+  internNumFmt(code) {
+    if (code === void 0) return 0;
+    const builtin = BUILTIN_NUMFMT_BY_CODE.get(code);
+    if (builtin !== void 0) return builtin;
+    const existing = this.customNumFmtIds.get(code);
+    if (existing !== void 0) return existing;
+    const id = this.nextNumFmtId++;
+    this.customNumFmtIds.set(code, id);
+    this.numFmtXml.push(renderNumFmt(id, code));
+    return id;
+  }
+  toXml() {
+    const w = new XmlWriter();
+    w.open("styleSheet", { xmlns: SPREADSHEETML_NS });
+    if (this.numFmtXml.length > 0) {
+      w.open("numFmts", { count: this.numFmtXml.length });
+      for (const x of this.numFmtXml) w.raw(x);
+      w.close("numFmts");
+    }
+    w.open("fonts", { count: this.fonts.count });
+    for (const x of this.fonts.xml) w.raw(x);
+    w.close("fonts");
+    w.open("fills", { count: this.fills.count });
+    for (const x of this.fills.xml) w.raw(x);
+    w.close("fills");
+    w.open("borders", { count: this.borders.count });
+    for (const x of this.borders.xml) w.raw(x);
+    w.close("borders");
+    w.open("cellStyleXfs", { count: 1 });
+    w.raw(DEFAULT_CELL_STYLE_XF);
+    w.close("cellStyleXfs");
+    w.open("cellXfs", { count: this.cellXfs.count });
+    for (const x of this.cellXfs.xml) w.raw(x);
+    w.close("cellXfs");
+    w.open("cellStyles", { count: 1 });
+    w.leaf("cellStyle", { name: "Normal", xfId: 0, builtinId: 0 });
+    w.close("cellStyles");
+    w.leaf("dxfs", { count: 0 });
+    w.leaf("tableStyles", {
+      count: 0,
+      defaultTableStyle: "TableStyleMedium2",
+      defaultPivotStyle: "PivotStyleLight16"
+    });
+    w.close("styleSheet");
+    return w.toString();
+  }
+};
+function renderFont(font) {
+  const w = new XmlWriter({ declaration: false });
+  w.open("font");
+  if (font.bold) w.leaf("b");
+  if (font.italic) w.leaf("i");
+  if (font.strike) w.leaf("strike");
+  if (font.outline) w.leaf("outline");
+  renderUnderline(w, font.underline);
+  if (font.vertAlign) w.leaf("vertAlign", { val: font.vertAlign });
+  if (font.size !== void 0) w.leaf("sz", { val: font.size });
+  if (font.color) renderColor(w, "color", font.color);
+  if (font.name !== void 0) w.leaf("name", { val: font.name });
+  if (font.family !== void 0) w.leaf("family", { val: font.family });
+  if (font.charset !== void 0) w.leaf("charset", { val: font.charset });
+  if (font.scheme) w.leaf("scheme", { val: font.scheme });
+  w.close("font");
+  return w.toString();
+}
+function renderFill(fill) {
+  const w = new XmlWriter({ declaration: false });
+  w.open("fill");
+  if (fill.type === "pattern") {
+    if (fill.fgColor || fill.bgColor) {
+      w.open("patternFill", { patternType: fill.pattern });
+      if (fill.fgColor) renderColor(w, "fgColor", fill.fgColor);
+      if (fill.bgColor) renderColor(w, "bgColor", fill.bgColor);
+      w.close("patternFill");
+    } else {
+      w.leaf("patternFill", { patternType: fill.pattern });
+    }
+  } else if (fill.gradient === "angle") {
+    w.open("gradientFill", { degree: fill.degree });
+    renderStops(w, fill.stops);
+    w.close("gradientFill");
+  } else {
+    w.open("gradientFill", {
+      type: "path",
+      left: fill.center.left,
+      right: fill.center.left,
+      top: fill.center.top,
+      bottom: fill.center.top
+    });
+    renderStops(w, fill.stops);
+    w.close("gradientFill");
+  }
+  w.close("fill");
+  return w.toString();
+}
+function renderStops(w, stops) {
+  for (const stop of stops) {
+    w.open("stop", { position: stop.position });
+    renderColor(w, "color", stop.color);
+    w.close("stop");
+  }
+}
+function renderBorder(borders) {
+  const w = new XmlWriter({ declaration: false });
+  w.open("border", {
+    diagonalUp: borders?.diagonal?.up || void 0,
+    diagonalDown: borders?.diagonal?.down || void 0
+  });
+  renderBorderSide(w, "left", borders?.left);
+  renderBorderSide(w, "right", borders?.right);
+  renderBorderSide(w, "top", borders?.top);
+  renderBorderSide(w, "bottom", borders?.bottom);
+  renderBorderSide(w, "diagonal", borders?.diagonal);
+  w.close("border");
+  return w.toString();
+}
+function renderBorderSide(w, tag, side) {
+  if (!side || side.style === void 0) {
+    w.leaf(tag);
+    return;
+  }
+  if (!side.color) {
+    w.leaf(tag, { style: side.style });
+    return;
+  }
+  w.open(tag, { style: side.style });
+  renderColor(w, "color", side.color);
+  w.close(tag);
+}
+function renderNumFmt(id, code) {
+  const w = new XmlWriter({ declaration: false });
+  w.leaf("numFmt", { numFmtId: id, formatCode: code });
+  return w.toString();
+}
+function renderXf(xf) {
+  const alignmentXml = xf.alignment ? renderAlignment(xf.alignment) : "";
+  const protectionXml = xf.protection ? renderProtection(xf.protection) : "";
+  const attrs = {
+    numFmtId: xf.numFmtId,
+    fontId: xf.fontId,
+    fillId: xf.fillId,
+    borderId: xf.borderId,
+    xfId: 0,
+    applyNumberFormat: xf.numFmtId !== 0 || void 0,
+    applyFont: xf.fontId !== 0 || void 0,
+    applyFill: xf.fillId !== 0 || void 0,
+    applyBorder: xf.borderId !== 0 || void 0,
+    applyAlignment: alignmentXml !== "" || void 0,
+    applyProtection: protectionXml !== "" || void 0
+  };
+  const w = new XmlWriter({ declaration: false });
+  if (alignmentXml === "" && protectionXml === "") {
+    w.leaf("xf", attrs);
+  } else {
+    w.open("xf", attrs);
+    if (alignmentXml) w.raw(alignmentXml);
+    if (protectionXml) w.raw(protectionXml);
+    w.close("xf");
+  }
+  return w.toString();
+}
+function renderAlignment(a) {
+  const attrs = {
+    horizontal: a.horizontal,
+    vertical: a.vertical,
+    textRotation: convertTextRotation(a.textRotation),
+    wrapText: a.wrapText || void 0,
+    indent: a.indent,
+    shrinkToFit: a.shrinkToFit || void 0,
+    readingOrder: convertReadingOrder(a.readingOrder)
+  };
+  if (!hasDefinedValue(attrs)) return "";
+  const w = new XmlWriter({ declaration: false });
+  w.leaf("alignment", attrs);
+  return w.toString();
+}
+function renderProtection(p) {
+  const attrs = { locked: p.locked, hidden: p.hidden };
+  if (!hasDefinedValue(attrs)) return "";
+  const w = new XmlWriter({ declaration: false });
+  w.leaf("protection", attrs);
+  return w.toString();
+}
+function renderColor(w, tag, color) {
+  if (color.argb !== void 0) w.leaf(tag, { rgb: color.argb });
+  else if (color.theme !== void 0) w.leaf(tag, { theme: color.theme });
+  else if (color.indexed !== void 0) w.leaf(tag, { indexed: color.indexed });
+}
+function renderUnderline(w, underline) {
+  if (underline === void 0 || underline === false || underline === "none") return;
+  if (underline === true) {
+    w.leaf("u");
+    return;
+  }
+  w.leaf("u", { val: underline });
+}
+function convertTextRotation(textRotation) {
+  if (textRotation === void 0) return void 0;
+  if (textRotation === "vertical") return 255;
+  const r = Math.round(textRotation);
+  if (r >= 0 && r <= 90) return r;
+  if (r < 0 && r >= -90) return 90 - r;
+  return void 0;
+}
+function convertReadingOrder(readingOrder) {
+  if (readingOrder === "ltr") return 1;
+  if (readingOrder === "rtl") return 2;
+  return void 0;
+}
+function hasDefinedValue(attrs) {
+  for (const key of Object.keys(attrs)) {
+    if (attrs[key] !== void 0) return true;
+  }
+  return false;
+}
+
+// src/xlsx/read/styles.ts
+var BUILTIN_NUMFMT_BY_ID = /* @__PURE__ */ new Map();
+for (const [code, id] of BUILTIN_NUMFMT_BY_CODE) BUILTIN_NUMFMT_BY_ID.set(id, code);
+function parseStyles(xml) {
+  if (xml === void 0) return EMPTY_TABLE;
+  const root = parseTree(xml);
+  if (root === void 0) return EMPTY_TABLE;
+  const customNumFmts = parseNumFmts(findChild(root, "numFmts"));
+  const fonts = mapChildren(findChild(root, "fonts"), "font", parseFont);
+  const fills = mapChildren(findChild(root, "fills"), "fill", parseFill);
+  const borders = mapChildren(findChild(root, "borders"), "border", parseBorder);
+  const xfs = mapChildren(findChild(root, "cellXfs"), "xf", parseXf);
+  const numFmtCode = (id) => customNumFmts.get(id) ?? BUILTIN_NUMFMT_BY_ID.get(id);
+  const styleFor = (index) => {
+    if (!Number.isInteger(index) || index <= 0 || index >= xfs.length) return {};
+    const xf = xfs[index];
+    if (xf === void 0) return {};
+    const style = {};
+    if (xf.numFmtId !== 0 || xf.applyNumberFormat) {
+      const code = numFmtCode(xf.numFmtId);
+      if (code !== void 0 && code !== "General") style.numFmt = code;
+    }
+    if (xf.fontId !== 0 || xf.applyFont) {
+      const font = fonts[xf.fontId];
+      if (font !== void 0 && hasKeys(font)) style.font = font;
+    }
+    if (xf.fillId !== 0 || xf.applyFill) {
+      const fill = fills[xf.fillId];
+      if (fill !== void 0) style.fill = fill;
+    }
+    if (xf.borderId !== 0 || xf.applyBorder) {
+      const border = borders[xf.borderId];
+      if (border !== void 0 && hasKeys(border)) style.border = border;
+    }
+    if (xf.alignment !== void 0 && hasKeys(xf.alignment)) style.alignment = xf.alignment;
+    if (xf.protection !== void 0 && hasKeys(xf.protection)) style.protection = xf.protection;
+    return style;
+  };
+  const isDateStyle = (index) => {
+    if (!Number.isInteger(index) || index < 0 || index >= xfs.length) return false;
+    const xf = xfs[index];
+    if (xf === void 0) return false;
+    const id = xf.numFmtId;
+    if (id >= 14 && id <= 22 || id >= 45 && id <= 47) return true;
+    const code = numFmtCode(id);
+    return code !== void 0 && isDateFormatCode(code);
+  };
+  return { styleFor, isDateStyle };
+}
+var EMPTY_TABLE = {
+  styleFor: () => ({}),
+  isDateStyle: () => false
+};
+function isDateFormatCode(code) {
+  const n = code.length;
+  let i = 0;
+  while (i < n) {
+    const ch = code[i];
+    if (ch === void 0) break;
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === '"') {
+      i++;
+      while (i < n && code[i] !== '"') i++;
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      const close = code.indexOf("]", i);
+      const first = code[i + 1];
+      if (first !== void 0 && "hHmMsS".includes(first)) return true;
+      i = close === -1 ? n : close + 1;
+      continue;
+    }
+    if ("yYmMdDhHsS".includes(ch)) return true;
+    i++;
+  }
+  return false;
+}
+function parseXf(el) {
+  const xf = {
+    numFmtId: numAttr(el, "numFmtId", 0),
+    fontId: numAttr(el, "fontId", 0),
+    fillId: numAttr(el, "fillId", 0),
+    borderId: numAttr(el, "borderId", 0),
+    applyNumberFormat: attrTrue(el.attrs.applyNumberFormat),
+    applyFont: attrTrue(el.attrs.applyFont),
+    applyFill: attrTrue(el.attrs.applyFill),
+    applyBorder: attrTrue(el.attrs.applyBorder)
+  };
+  const alignmentEl = findChild(el, "alignment");
+  if (alignmentEl !== void 0) xf.alignment = parseAlignment(alignmentEl);
+  const protectionEl = findChild(el, "protection");
+  if (protectionEl !== void 0) xf.protection = parseProtection(protectionEl);
+  return xf;
+}
+function parseAlignment(el) {
+  const a = {};
+  if (el.attrs.horizontal !== void 0)
+    a.horizontal = el.attrs.horizontal;
+  if (el.attrs.vertical !== void 0) a.vertical = el.attrs.vertical;
+  if (el.attrs.textRotation !== void 0) {
+    const rotation = inverseTextRotation(Number(el.attrs.textRotation));
+    if (rotation !== void 0) a.textRotation = rotation;
+  }
+  if (attrTrue(el.attrs.wrapText)) a.wrapText = true;
+  if (el.attrs.indent !== void 0) a.indent = Number(el.attrs.indent);
+  if (attrTrue(el.attrs.shrinkToFit)) a.shrinkToFit = true;
+  if (el.attrs.readingOrder === "1") a.readingOrder = "ltr";
+  else if (el.attrs.readingOrder === "2") a.readingOrder = "rtl";
+  return a;
+}
+function inverseTextRotation(val) {
+  if (val === 255) return "vertical";
+  if (val >= 0 && val <= 90) return val;
+  if (val > 90 && val <= 180) return 90 - val;
+  return void 0;
+}
+function parseProtection(el) {
+  const p = {};
+  if (el.attrs.locked !== void 0) p.locked = attrTrue(el.attrs.locked);
+  if (el.attrs.hidden !== void 0) p.hidden = attrTrue(el.attrs.hidden);
+  return p;
+}
+function parseFont(el) {
+  const font = {};
+  for (const c of el.children) {
+    switch (c.name) {
+      case "b":
+        if (elementOn(c.attrs.val)) font.bold = true;
+        break;
+      case "i":
+        if (elementOn(c.attrs.val)) font.italic = true;
+        break;
+      case "strike":
+        if (elementOn(c.attrs.val)) font.strike = true;
+        break;
+      case "outline":
+        if (elementOn(c.attrs.val)) font.outline = true;
+        break;
+      case "u":
+        font.underline = c.attrs.val === void 0 ? true : c.attrs.val;
+        break;
+      case "vertAlign":
+        if (c.attrs.val !== void 0) font.vertAlign = c.attrs.val;
+        break;
+      case "sz":
+        if (c.attrs.val !== void 0) font.size = Number(c.attrs.val);
+        break;
+      case "color": {
+        const color = parseColor2(c);
+        if (color !== void 0) font.color = color;
+        break;
+      }
+      case "name":
+        if (c.attrs.val !== void 0) font.name = c.attrs.val;
+        break;
+      case "family":
+        if (c.attrs.val !== void 0) font.family = Number(c.attrs.val);
+        break;
+      case "charset":
+        if (c.attrs.val !== void 0) font.charset = Number(c.attrs.val);
+        break;
+      case "scheme":
+        if (c.attrs.val !== void 0) font.scheme = c.attrs.val;
+        break;
+    }
+  }
+  return font;
+}
+function parseFill(el) {
+  const patternFill = findChild(el, "patternFill");
+  if (patternFill !== void 0) {
+    const fill = {
+      type: "pattern",
+      pattern: patternFill.attrs.patternType ?? "none"
+    };
+    const fg = findChild(patternFill, "fgColor");
+    if (fg !== void 0) {
+      const color = parseColor2(fg);
+      if (color !== void 0) fill.fgColor = color;
+    }
+    const bg = findChild(patternFill, "bgColor");
+    if (bg !== void 0) {
+      const color = parseColor2(bg);
+      if (color !== void 0) fill.bgColor = color;
+    }
+    return fill;
+  }
+  const gradientFill = findChild(el, "gradientFill");
+  if (gradientFill !== void 0) {
+    const stops = findChildren(gradientFill, "stop").map((stop) => {
+      const colorEl = findChild(stop, "color");
+      return {
+        position: Number(stop.attrs.position ?? 0),
+        color: (colorEl !== void 0 ? parseColor2(colorEl) : void 0) ?? {}
+      };
+    });
+    if (gradientFill.attrs.type === "path") {
+      return {
+        type: "gradient",
+        gradient: "path",
+        center: {
+          left: Number(gradientFill.attrs.left ?? 0),
+          top: Number(gradientFill.attrs.top ?? 0)
+        },
+        stops
+      };
+    }
+    return {
+      type: "gradient",
+      gradient: "angle",
+      degree: Number(gradientFill.attrs.degree ?? 0),
+      stops
+    };
+  }
+  return { type: "pattern", pattern: "none" };
+}
+function parseBorder(el) {
+  const borders = {};
+  const left = parseBorderSide(findChild(el, "left"));
+  if (left !== void 0) borders.left = left;
+  const right = parseBorderSide(findChild(el, "right"));
+  if (right !== void 0) borders.right = right;
+  const top = parseBorderSide(findChild(el, "top"));
+  if (top !== void 0) borders.top = top;
+  const bottom = parseBorderSide(findChild(el, "bottom"));
+  if (bottom !== void 0) borders.bottom = bottom;
+  const diagonalSide = parseBorderSide(findChild(el, "diagonal"));
+  const up = attrTrue(el.attrs.diagonalUp);
+  const down = attrTrue(el.attrs.diagonalDown);
+  if (diagonalSide !== void 0 || up || down) {
+    const diagonal = { ...diagonalSide };
+    if (up) diagonal.up = true;
+    if (down) diagonal.down = true;
+    borders.diagonal = diagonal;
+  }
+  return borders;
+}
+function parseBorderSide(el) {
+  if (el === void 0 || el.attrs.style === void 0) return void 0;
+  const border = { style: el.attrs.style };
+  const colorEl = findChild(el, "color");
+  if (colorEl !== void 0) {
+    const color = parseColor2(colorEl);
+    if (color !== void 0) border.color = color;
+  }
+  return border;
+}
+function parseColor2(el) {
+  if (el.attrs.rgb !== void 0) return { argb: el.attrs.rgb };
+  if (el.attrs.theme !== void 0) return { theme: Number(el.attrs.theme) };
+  if (el.attrs.indexed !== void 0) return { indexed: Number(el.attrs.indexed) };
+  return void 0;
+}
+function parseNumFmts(el) {
+  const map = /* @__PURE__ */ new Map();
+  if (el === void 0) return map;
+  for (const c of findChildren(el, "numFmt")) {
+    const id = c.attrs.numFmtId;
+    const code = c.attrs.formatCode;
+    if (id !== void 0 && code !== void 0) map.set(Number(id), code);
+  }
+  return map;
+}
+function parseTree(xml) {
+  const root = { name: "#root", attrs: {}, children: [] };
+  const stack = [root];
+  for (const ev of parseXml(xml)) {
+    const top = stack[stack.length - 1];
+    if (top === void 0) break;
+    if (ev.kind === "open") {
+      const el = { name: ev.name, attrs: ev.attrs, children: [] };
+      top.children.push(el);
+      if (!ev.selfClosing) stack.push(el);
+    } else if (ev.kind === "close" && stack.length > 1) {
+      stack.pop();
+    }
+  }
+  return root.children[0];
+}
+function findChild(el, name) {
+  return el.children.find((c) => c.name === name);
+}
+function findChildren(el, name) {
+  return el.children.filter((c) => c.name === name);
+}
+function mapChildren(el, name, fn) {
+  if (el === void 0) return [];
+  return findChildren(el, name).map(fn);
+}
+function numAttr(el, name, fallback) {
+  const raw = el.attrs[name];
+  return raw === void 0 ? fallback : Number(raw);
+}
+function elementOn(val) {
+  return val !== "0" && val !== "false" && val !== "off";
+}
+function attrTrue(val) {
+  return val === "1" || val === "true" || val === "on";
+}
+function hasKeys(obj) {
+  for (const _ in obj) return true;
+  return false;
+}
+
+// src/xlsx/read/workbook.ts
+function parseWorkbook(xml) {
+  const header = { sheets: [], date1904: false };
+  const c = cursor(xml);
+  let ev = c.next();
+  while (ev && !(ev.kind === "open" && localName(ev.name) === "workbook")) ev = c.next();
+  if (ev?.kind !== "open" || ev.selfClosing) return header;
+  c.eachChild(ev.name, (child) => {
+    switch (localName(child.name)) {
+      case "workbookPr":
+        if (truthy(child.attrs.date1904)) header.date1904 = true;
+        break;
+      case "bookViews":
+        if (!child.selfClosing) parseBookViews(c, child.name, header);
+        break;
+      case "sheets":
+        if (!child.selfClosing) parseSheets(c, child.name, header);
+        break;
+      default:
+        if (!child.selfClosing) c.textUntilClose(child.name);
+    }
+  });
+  return header;
+}
+function parseBookViews(c, container, header) {
+  c.eachChild(container, (child) => {
+    if (localName(child.name) === "workbookView") {
+      const activeTab = child.attrs.activeTab;
+      if (activeTab !== void 0) {
+        const n = Number(activeTab);
+        if (Number.isFinite(n)) header.activeTab = n;
+      }
+    } else if (!child.selfClosing) {
+      c.textUntilClose(child.name);
+    }
+  });
+}
+function parseSheets(c, container, header) {
+  c.eachChild(container, (child) => {
+    if (localName(child.name) !== "sheet") {
+      if (!child.selfClosing) c.textUntilClose(child.name);
+      return;
+    }
+    header.sheets.push({
+      name: child.attrs.name ?? "",
+      sheetId: Number(child.attrs.sheetId ?? 0),
+      state: normalizeState(child.attrs.state),
+      rId: relId(child)
+    });
+  });
+}
+function relId(sheet) {
+  const direct = sheet.attrs["r:id"];
+  if (direct !== void 0) return direct;
+  for (const key of Object.keys(sheet.attrs)) {
+    if (localName(key) === "id") return sheet.attrs[key] ?? "";
+  }
+  return "";
+}
+function normalizeState(state) {
+  if (state === "hidden") return "hidden";
+  if (state === "veryHidden") return "veryHidden";
+  return "visible";
+}
+function truthy(val) {
+  return val === "1" || val === "true";
+}
+
+// src/xlsx/read/worksheet.ts
+function parseWorksheet(ws, xml, ctx) {
+  const c = cursor(xml);
+  let ev = c.next();
+  while (ev && !(ev.kind === "open" && localName(ev.name) === "worksheet")) ev = c.next();
+  if (ev?.kind !== "open" || ev.selfClosing) return;
+  const merges = [];
+  c.eachChild(ev.name, (child) => {
+    switch (localName(child.name)) {
+      case "cols":
+        if (!child.selfClosing) parseCols(c, child.name, ws, ctx);
+        break;
+      case "sheetData":
+        if (!child.selfClosing) parseSheetData(c, child.name, ws, ctx);
+        break;
+      case "mergeCells":
+        if (!child.selfClosing) collectMerges(c, child.name, merges);
+        break;
+      default:
+        if (!child.selfClosing) c.textUntilClose(child.name);
+    }
+  });
+  for (const ref of merges) ws.mergeCells(ref);
+}
+function parseCols(c, container, ws, ctx) {
+  c.eachChild(container, (col) => {
+    if (localName(col.name) !== "col") {
+      if (!col.selfClosing) c.textUntilClose(col.name);
+      return;
+    }
+    const min = num(col.attrs.min);
+    const max = num(col.attrs.max);
+    if (min === void 0 || max === void 0) return;
+    const width = num(col.attrs.width);
+    const hidden = truthy2(col.attrs.hidden);
+    const outline = num(col.attrs.outlineLevel);
+    const styleIdx = num(col.attrs.style);
+    const style = styleIdx ? ctx.styles.styleFor(styleIdx) : void 0;
+    for (let n = min; n <= max; n++) {
+      const column = ws.getColumn(n);
+      if (width !== void 0) column.width = width;
+      if (hidden) column.hidden = true;
+      if (outline) column.outlineLevel = outline;
+      if (style) column.style = style;
+    }
+  });
+}
+function parseSheetData(c, container, ws, ctx) {
+  let expectedRow = 0;
+  c.eachChild(container, (rowEl) => {
+    if (localName(rowEl.name) !== "row") {
+      if (!rowEl.selfClosing) c.textUntilClose(rowEl.name);
+      return;
+    }
+    expectedRow = num(rowEl.attrs.r) ?? expectedRow + 1;
+    parseRow(c, rowEl, expectedRow, ws, ctx);
+  });
+}
+function parseRow(c, rowEl, rowNumber, ws, ctx) {
+  const row = ws.getRow(rowNumber);
+  const height = num(rowEl.attrs.ht);
+  if (height !== void 0) row.height = height;
+  if (truthy2(rowEl.attrs.hidden)) row.hidden = true;
+  const outline = num(rowEl.attrs.outlineLevel);
+  if (outline) row.outlineLevel = outline;
+  const rowStyleIdx = num(rowEl.attrs.s);
+  if (rowStyleIdx) row.style = ctx.styles.styleFor(rowStyleIdx);
+  if (rowEl.selfClosing) return;
+  let expectedCol = 0;
+  c.eachChild(rowEl.name, (cellEl) => {
+    if (localName(cellEl.name) !== "c") {
+      if (!cellEl.selfClosing) c.textUntilClose(cellEl.name);
+      return;
+    }
+    expectedCol = parseCell(c, cellEl, expectedCol + 1, row, ctx);
+  });
+}
+function parseCell(c, cellEl, fallbackCol, row, ctx) {
+  const col = cellEl.attrs.r !== void 0 ? decodeAddress(cellEl.attrs.r).col : fallbackCol;
+  const styleIdx = num(cellEl.attrs.s) ?? 0;
+  const t = cellEl.attrs.t;
+  let vText;
+  let inlineValue;
+  let formulaExpr;
+  let hasFormula = false;
+  if (!cellEl.selfClosing) {
+    c.eachChild(cellEl.name, (child) => {
+      switch (localName(child.name)) {
+        case "v":
+          vText = child.selfClosing ? "" : c.textUntilClose(child.name);
+          break;
+        case "f":
+          hasFormula = true;
+          formulaExpr = child.selfClosing ? "" : c.textUntilClose(child.name);
+          break;
+        case "is":
+          inlineValue = child.selfClosing ? "" : parseRichString(c, child.name);
+          break;
+        default:
+          if (!child.selfClosing) c.textUntilClose(child.name);
+      }
+    });
+  }
+  const value = hasFormula ? buildFormula(formulaExpr ?? "", t, vText, styleIdx, ctx) : decodeValue(t, vText, inlineValue, styleIdx, ctx);
+  if (value === null && styleIdx === 0 && !hasFormula) return col;
+  const cell = row.getCell(col);
+  if (value !== null) cell.value = value;
+  if (styleIdx !== 0) cell.style = ctx.styles.styleFor(styleIdx);
+  return col;
+}
+function decodeValue(t, vText, inlineValue, styleIdx, ctx) {
+  switch (t) {
+    case "s": {
+      if (vText === void 0) return null;
+      return ctx.sharedStrings[Number(vText)] ?? "";
+    }
+    case "inlineStr":
+      return inlineValue ?? "";
+    case "str":
+      return vText ?? "";
+    case "b":
+      return vText === void 0 ? null : decodeBool(vText);
+    case "e":
+      return vText === void 0 ? null : { error: vText };
+    default: {
+      if (vText === void 0) return null;
+      const n = Number(vText);
+      return ctx.styles.isDateStyle(styleIdx) ? serialToDate(n, ctx.date1904) : n;
+    }
+  }
+}
+function buildFormula(expr, t, vText, styleIdx, ctx) {
+  const result = vText === void 0 ? void 0 : decodeScalar(t, vText, styleIdx, ctx);
+  return result === void 0 ? { formula: expr } : { formula: expr, result };
+}
+function decodeScalar(t, vText, styleIdx, ctx) {
+  switch (t) {
+    case "b":
+      return decodeBool(vText);
+    case "e":
+      return { error: vText };
+    case "str":
+      return vText;
+    case "s": {
+      const entry = ctx.sharedStrings[Number(vText)];
+      if (entry === void 0) return "";
+      return typeof entry === "string" ? entry : entry.richText.map((run) => run.text).join("");
+    }
+    default: {
+      const n = Number(vText);
+      return ctx.styles.isDateStyle(styleIdx) ? serialToDate(n, ctx.date1904) : n;
+    }
+  }
+}
+function collectMerges(c, container, merges) {
+  c.eachChild(container, (mergeCell) => {
+    if (localName(mergeCell.name) === "mergeCell" && mergeCell.attrs.ref !== void 0) {
+      merges.push(mergeCell.attrs.ref);
+    } else if (!mergeCell.selfClosing) {
+      c.textUntilClose(mergeCell.name);
+    }
+  });
+}
+function decodeBool(raw) {
+  if (raw === "1" || raw === "true" || raw === "TRUE") return true;
+  if (raw === "0" || raw === "false" || raw === "FALSE") return false;
+  throw new InvalidCellValueError(raw);
+}
+function num(val) {
+  if (val === void 0) return void 0;
+  const n = Number(val);
+  return Number.isFinite(n) ? n : void 0;
+}
+function truthy2(val) {
+  return val === "1" || val === "true";
+}
+
+// src/xlsx/read-workbook.ts
+function readWorkbookBuffer(bytes, _options) {
+  const pkg = openPackage(bytes);
+  const rels = pkg.workbookRels();
+  let stylesXml;
+  let sharedStringsXml;
+  for (const { type, target } of rels.values()) {
+    if (type === REL_TYPE.styles) stylesXml = pkg.text(target);
+    else if (type === REL_TYPE.sharedStrings) sharedStringsXml = pkg.text(target);
+  }
+  const styles = parseStyles(stylesXml);
+  const sharedStrings = sharedStringsXml !== void 0 ? parseSharedStrings(sharedStringsXml) : [];
+  const workbookXml = pkg.text(pkg.workbookPath()) ?? "";
+  const header = parseWorkbook(workbookXml);
+  const wb = new Workbook();
+  if (header.date1904) wb.properties.date1904 = true;
+  if (header.activeTab !== void 0) wb.views = [{ activeTab: header.activeTab }];
+  const ctx = { sharedStrings, styles, date1904: header.date1904 };
+  for (const sheet of header.sheets) {
+    const ws = wb.addWorksheet(sheet.name, { state: sheet.state });
+    const target = rels.get(sheet.rId)?.target;
+    if (target === void 0) continue;
+    const sheetXml = pkg.text(target);
+    if (sheetXml !== void 0) parseWorksheet(ws, sheetXml, ctx);
+  }
+  const coreXml = pkg.text(PART_PATH.coreProps);
+  if (coreXml !== void 0) applyCoreProps(wb, coreXml);
+  const appXml = pkg.text(PART_PATH.appProps);
+  if (appXml !== void 0) applyAppProps(wb, appXml);
+  return wb;
+}
+async function readWorkbookFile(path, options) {
+  const { readFile } = await import('fs/promises');
+  const bytes = await readFile(path);
+  return readWorkbookBuffer(bytes);
+}
+
+// src/xlsx/shared-strings.ts
+var SPREADSHEETML_NS2 = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+function createSharedStrings() {
+  return new SharedStringsPool();
+}
+var SharedStringsPool = class {
+  index = /* @__PURE__ */ new Map();
+  entries = [];
+  references = 0;
+  add(value) {
+    this.references += 1;
+    const key = keyFor(value);
+    const existing = this.index.get(key);
+    if (existing !== void 0) return existing;
+    const idx = this.entries.length;
+    this.index.set(key, idx);
+    this.entries.push(value);
+    return idx;
+  }
+  get count() {
+    return this.references;
+  }
+  get uniqueCount() {
+    return this.entries.length;
+  }
+  toXml() {
+    if (this.entries.length === 0) return void 0;
+    const w = new XmlWriter();
+    w.open("sst", {
+      xmlns: SPREADSHEETML_NS2,
+      count: this.references,
+      uniqueCount: this.entries.length
+    });
+    for (const entry of this.entries) {
+      w.open("si");
+      if (typeof entry === "string") {
+        w.el("t", entry);
+      } else {
+        for (const run of entry.richText) {
+          w.open("r");
+          const props = renderRunProps(run.font);
+          if (props) w.raw(props);
+          w.el("t", run.text);
+          w.close("r");
+        }
+      }
+      w.close("si");
+    }
+    w.close("sst");
+    return w.toString();
+  }
+};
+function keyFor(value) {
+  return typeof value === "string" ? `s:${value}` : `r:${stableStringify(value.richText)}`;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  const obj = value;
+  const keys = Object.keys(obj).filter((k) => obj[k] !== void 0).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function renderRunProps(font) {
+  if (!font) return "";
+  const w = new XmlWriter({ declaration: false });
+  if (font.name !== void 0) w.leaf("rFont", { val: font.name });
+  if (font.charset !== void 0) w.leaf("charset", { val: font.charset });
+  if (font.family !== void 0) w.leaf("family", { val: font.family });
+  if (font.bold) w.leaf("b");
+  if (font.italic) w.leaf("i");
+  if (font.strike) w.leaf("strike");
+  if (font.outline) w.leaf("outline");
+  if (font.color) renderColor2(w, font.color);
+  if (font.size !== void 0) w.leaf("sz", { val: font.size });
+  renderUnderline2(w, font.underline);
+  if (font.vertAlign) w.leaf("vertAlign", { val: font.vertAlign });
+  if (font.scheme) w.leaf("scheme", { val: font.scheme });
+  const inner = w.toString();
+  return inner === "" ? "" : `<rPr>${inner}</rPr>`;
+}
+function renderColor2(w, color) {
+  if (color.argb !== void 0) w.leaf("color", { rgb: color.argb });
+  else if (color.theme !== void 0) w.leaf("color", { theme: color.theme });
+  else if (color.indexed !== void 0) w.leaf("color", { indexed: color.indexed });
+}
+function renderUnderline2(w, underline) {
+  if (underline === void 0 || underline === false || underline === "none") return;
+  if (underline === true) {
+    w.leaf("u");
+    return;
+  }
+  w.leaf("u", { val: underline });
+}
+
+// src/xlsx/parts/app-props.ts
+function renderAppProps(wb, sheetNames) {
+  const w = new XmlWriter();
+  w.open("Properties", { xmlns: NS.extProps, "xmlns:vt": NS.docPropsVt });
+  w.el("Application", "Microsoft Excel");
+  w.el("DocSecurity", "0");
+  w.el("ScaleCrop", "false");
+  w.open("HeadingPairs");
+  w.open("vt:vector", { size: 2, baseType: "variant" });
+  w.open("vt:variant");
+  w.el("vt:lpstr", "Worksheets");
+  w.close("vt:variant");
+  w.open("vt:variant");
+  w.el("vt:i4", String(sheetNames.length));
+  w.close("vt:variant");
+  w.close("vt:vector");
+  w.close("HeadingPairs");
+  w.open("TitlesOfParts");
+  w.open("vt:vector", { size: sheetNames.length, baseType: "lpstr" });
+  for (const name of sheetNames) w.el("vt:lpstr", name);
+  w.close("vt:vector");
+  w.close("TitlesOfParts");
+  if (wb.company !== void 0) w.el("Company", wb.company);
+  if (wb.manager !== void 0) w.el("Manager", wb.manager);
+  w.el("LinksUpToDate", "false");
+  w.el("SharedDoc", "false");
+  w.el("HyperlinksChanged", "false");
+  w.el("AppVersion", "1.0000");
+  w.close("Properties");
+  return w.toString();
+}
+
+// src/xlsx/parts/content-types.ts
+function renderContentTypes(input) {
+  const w = new XmlWriter();
+  w.open("Types", { xmlns: NS.contentTypes });
+  w.leaf("Default", { Extension: "rels", ContentType: CONTENT_TYPE.rels });
+  w.leaf("Default", { Extension: "xml", ContentType: CONTENT_TYPE.xml });
+  w.leaf("Override", { PartName: `/${PART_PATH.workbook}`, ContentType: CONTENT_TYPE.workbook });
+  for (const file of input.worksheetFiles) {
+    w.leaf("Override", {
+      PartName: `/xl/worksheets/${file}`,
+      ContentType: CONTENT_TYPE.worksheet
+    });
+  }
+  w.leaf("Override", { PartName: `/${PART_PATH.styles}`, ContentType: CONTENT_TYPE.styles });
+  if (input.hasSharedStrings) {
+    w.leaf("Override", {
+      PartName: `/${PART_PATH.sharedStrings}`,
+      ContentType: CONTENT_TYPE.sharedStrings
+    });
+  }
+  w.leaf("Override", { PartName: `/${PART_PATH.theme}`, ContentType: CONTENT_TYPE.theme });
+  w.leaf("Override", { PartName: `/${PART_PATH.coreProps}`, ContentType: CONTENT_TYPE.coreProps });
+  w.leaf("Override", { PartName: `/${PART_PATH.appProps}`, ContentType: CONTENT_TYPE.extProps });
+  w.close("Types");
+  return w.toString();
+}
+
+// src/xlsx/parts/core-props.ts
+function toW3CDTF(date) {
+  return `${date.toISOString().replace(/\.\d{3}Z$/, "Z")}`;
+}
+function renderCoreProps(wb) {
+  const w = new XmlWriter();
+  w.open("cp:coreProperties", {
+    "xmlns:cp": NS.coreProps,
+    "xmlns:dc": NS.dc,
+    "xmlns:dcterms": NS.dcterms,
+    "xmlns:dcmitype": NS.dcmitype,
+    "xmlns:xsi": NS.xsi
+  });
+  if (wb.creator !== void 0) w.el("dc:creator", wb.creator);
+  if (wb.title !== void 0) w.el("dc:title", wb.title);
+  if (wb.subject !== void 0) w.el("dc:subject", wb.subject);
+  if (wb.description !== void 0) w.el("dc:description", wb.description);
+  if (wb.keywords !== void 0) w.el("cp:keywords", wb.keywords);
+  if (wb.category !== void 0) w.el("cp:category", wb.category);
+  if (wb.lastModifiedBy !== void 0) w.el("cp:lastModifiedBy", wb.lastModifiedBy);
+  w.el("dcterms:created", toW3CDTF(wb.created), { "xsi:type": "dcterms:W3CDTF" });
+  w.el("dcterms:modified", toW3CDTF(wb.modified), { "xsi:type": "dcterms:W3CDTF" });
+  w.close("cp:coreProperties");
+  return w.toString();
+}
+
+// src/xlsx/parts/root-rels.ts
+function renderRootRels() {
+  const w = new XmlWriter();
+  w.open("Relationships", { xmlns: NS.packageRels });
+  w.leaf("Relationship", {
+    Id: "rId1",
+    Type: REL_TYPE.officeDocument,
+    Target: PART_PATH.workbook
+  });
+  w.leaf("Relationship", {
+    Id: "rId2",
+    Type: REL_TYPE.coreProps,
+    Target: PART_PATH.coreProps
+  });
+  w.leaf("Relationship", {
+    Id: "rId3",
+    Type: REL_TYPE.extProps,
+    Target: PART_PATH.appProps
+  });
+  w.close("Relationships");
+  return w.toString();
+}
+
+// src/xlsx/parts/theme.ts
+var THEME1_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="Office Theme"><a:themeElements><a:clrScheme name="Office"><a:dk1><a:sysClr val="windowText" lastClr="000000"/></a:dk1><a:lt1><a:sysClr val="window" lastClr="FFFFFF"/></a:lt1><a:dk2><a:srgbClr val="44546A"/></a:dk2><a:lt2><a:srgbClr val="E7E6E6"/></a:lt2><a:accent1><a:srgbClr val="4472C4"/></a:accent1><a:accent2><a:srgbClr val="ED7D31"/></a:accent2><a:accent3><a:srgbClr val="A5A5A5"/></a:accent3><a:accent4><a:srgbClr val="FFC000"/></a:accent4><a:accent5><a:srgbClr val="5B9BD5"/></a:accent5><a:accent6><a:srgbClr val="70AD47"/></a:accent6><a:hlink><a:srgbClr val="0563C1"/></a:hlink><a:folHlink><a:srgbClr val="954F72"/></a:folHlink></a:clrScheme><a:fontScheme name="Office"><a:majorFont><a:latin typeface="Calibri Light" panose="020F0302020204030204"/><a:ea typeface=""/><a:cs typeface=""/></a:majorFont><a:minorFont><a:latin typeface="Calibri" panose="020F0502020204030204"/><a:ea typeface=""/><a:cs typeface=""/></a:minorFont></a:fontScheme><a:fmtScheme name="Office"><a:fillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:gradFill rotWithShape="1"><a:gsLst><a:gs pos="0"><a:schemeClr val="phClr"><a:lumMod val="110000"/><a:satMod val="105000"/><a:tint val="67000"/></a:schemeClr></a:gs><a:gs pos="50000"><a:schemeClr val="phClr"><a:lumMod val="105000"/><a:satMod val="103000"/><a:tint val="73000"/></a:schemeClr></a:gs><a:gs pos="100000"><a:schemeClr val="phClr"><a:lumMod val="105000"/><a:satMod val="109000"/><a:tint val="81000"/></a:schemeClr></a:gs></a:gsLst><a:lin ang="5400000" scaled="0"/></a:gradFill><a:gradFill rotWithShape="1"><a:gsLst><a:gs pos="0"><a:schemeClr val="phClr"><a:satMod val="103000"/><a:lumMod val="102000"/><a:tint val="94000"/></a:schemeClr></a:gs><a:gs pos="50000"><a:schemeClr val="phClr"><a:satMod val="110000"/><a:lumMod val="100000"/><a:shade val="100000"/></a:schemeClr></a:gs><a:gs pos="100000"><a:schemeClr val="phClr"><a:lumMod val="99000"/><a:satMod val="120000"/><a:shade val="78000"/></a:schemeClr></a:gs></a:gsLst><a:lin ang="5400000" scaled="0"/></a:gradFill></a:fillStyleLst><a:lnStyleLst><a:ln w="6350" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:prstDash val="solid"/><a:miter lim="800000"/></a:ln><a:ln w="12700" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:prstDash val="solid"/><a:miter lim="800000"/></a:ln><a:ln w="19050" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:prstDash val="solid"/><a:miter lim="800000"/></a:ln></a:lnStyleLst><a:effectStyleLst><a:effectStyle><a:effectLst/></a:effectStyle><a:effectStyle><a:effectLst/></a:effectStyle><a:effectStyle><a:effectLst><a:outerShdw blurRad="57150" dist="19050" dir="5400000" rotWithShape="0"><a:srgbClr val="000000"><a:alpha val="63000"/></a:srgbClr></a:outerShdw></a:effectLst></a:effectStyle></a:effectStyleLst><a:bgFillStyleLst><a:solidFill><a:schemeClr val="phClr"/></a:solidFill><a:solidFill><a:schemeClr val="phClr"><a:tint val="95000"/><a:satMod val="170000"/></a:schemeClr></a:solidFill><a:gradFill rotWithShape="1"><a:gsLst><a:gs pos="0"><a:schemeClr val="phClr"><a:tint val="93000"/><a:satMod val="150000"/><a:shade val="98000"/><a:lumMod val="102000"/></a:schemeClr></a:gs><a:gs pos="50000"><a:schemeClr val="phClr"><a:tint val="98000"/><a:satMod val="130000"/><a:shade val="90000"/><a:lumMod val="103000"/></a:schemeClr></a:gs><a:gs pos="100000"><a:schemeClr val="phClr"><a:shade val="63000"/><a:satMod val="120000"/></a:schemeClr></a:gs></a:gsLst><a:lin ang="5400000" scaled="0"/></a:gradFill></a:bgFillStyleLst></a:fmtScheme></a:themeElements><a:objectDefaults/><a:extraClrSchemeLst/></a:theme>`;
+function renderTheme() {
+  return THEME1_XML;
+}
+
+// src/xlsx/parts/workbook.ts
+function renderWorkbook(wb, sheets) {
+  const w = new XmlWriter();
+  w.open("workbook", { xmlns: NS.spreadsheetml, "xmlns:r": NS.relationships });
+  if (wb.properties.date1904) {
+    w.leaf("workbookPr", { date1904: true });
+  }
+  const activeTab = typeof wb.views[0]?.activeTab === "number" ? wb.views[0].activeTab : void 0;
+  w.open("bookViews");
+  w.leaf("workbookView", { activeTab });
+  w.close("bookViews");
+  w.open("sheets");
+  for (const sheet of sheets) {
+    w.leaf("sheet", {
+      name: sheet.name,
+      sheetId: sheet.sheetId,
+      state: sheet.state === "visible" ? void 0 : sheet.state,
+      "r:id": sheet.rId
+    });
+  }
+  w.close("sheets");
+  if (wb.calcProperties.fullCalcOnLoad) {
+    w.leaf("calcPr", { calcId: 0, fullCalcOnLoad: true });
+  }
+  w.close("workbook");
+  return w.toString();
+}
+
+// src/xlsx/parts/workbook-rels.ts
+function renderWorkbookRels(rels) {
+  const w = new XmlWriter();
+  w.open("Relationships", { xmlns: NS.packageRels });
+  for (const rel of rels) {
+    w.leaf("Relationship", { Id: rel.rId, Type: rel.type, Target: rel.target });
+  }
+  w.close("Relationships");
+  return w.toString();
+}
+
+// src/xlsx/parts/worksheet.ts
+var DEFAULT_DATE_NUMFMT = "mm-dd-yy";
+function renderWorksheet(ws, ctx) {
+  const model = ws.model;
+  const w = new XmlWriter();
+  w.open("worksheet", { xmlns: NS.spreadsheetml, "xmlns:r": NS.relationships });
+  w.leaf("dimension", { ref: ws.dimensions.range });
+  w.open("sheetViews");
+  w.leaf("sheetView", {
+    workbookViewId: 0,
+    showGridLines: model.properties.showGridLines === false ? false : void 0
+  });
+  w.close("sheetViews");
+  w.leaf("sheetFormatPr", {
+    defaultRowHeight: model.properties.defaultRowHeight ?? 15,
+    defaultColWidth: model.properties.defaultColWidth
+  });
+  renderCols(w, model.columns, ctx);
+  renderSheetData(w, model.rows, ctx);
+  renderMergeCells(w, model.merges);
+  w.close("worksheet");
+  return w.toString();
+}
+function renderCols(w, columns, ctx) {
+  if (!columns || columns.length === 0) return;
+  const fragments = [];
+  for (const range of columns) {
+    const styleId = range.style ? ctx.styles.addStyle(range.style) : 0;
+    const hasWidth = range.width !== void 0;
+    if (!hasWidth && !range.hidden && !range.outlineLevel && styleId === 0) continue;
+    const col = new XmlWriter({ declaration: false });
+    col.leaf("col", {
+      min: range.min,
+      max: range.max,
+      width: range.width,
+      customWidth: hasWidth ? true : void 0,
+      style: styleId !== 0 ? styleId : void 0,
+      hidden: range.hidden || void 0,
+      outlineLevel: range.outlineLevel || void 0
+    });
+    fragments.push(col.toString());
+  }
+  if (fragments.length === 0) return;
+  w.open("cols");
+  for (const f of fragments) w.raw(f);
+  w.close("cols");
+}
+function renderSheetData(w, rows, ctx) {
+  w.open("sheetData");
+  for (const row of rows) {
+    const styleId = row.style ? ctx.styles.addStyle(row.style) : 0;
+    let cellsXml = "";
+    for (const cell of row.cells) {
+      cellsXml += renderCell(cell, ctx);
+    }
+    const hasAttrs = row.height !== void 0 || row.hidden || (row.outlineLevel ?? 0) !== 0 || styleId !== 0;
+    if (cellsXml === "" && !hasAttrs) continue;
+    w.open("row", {
+      r: row.number,
+      ht: row.height,
+      customHeight: row.height !== void 0 ? true : void 0,
+      hidden: row.hidden || void 0,
+      outlineLevel: row.outlineLevel || void 0,
+      s: styleId !== 0 ? styleId : void 0,
+      customFormat: styleId !== 0 ? true : void 0
+    });
+    w.raw(cellsXml);
+    w.close("row");
+  }
+  w.close("sheetData");
+}
+function renderCell(cell, ctx) {
+  const styleId = cell.style ? ctx.styles.addStyle(cell.style) : 0;
+  const r = cell.address;
+  switch (cell.type) {
+    case 0 /* Null */:
+    case 9 /* Merge */:
+      return styleId !== 0 ? leafCell(r, styleId) : "";
+    case 1 /* Number */:
+      return valueCell(r, styleId, void 0, String(cell.value));
+    case 3 /* Boolean */:
+      return valueCell(r, styleId, "b", cell.value ? "1" : "0");
+    case 4 /* Date */: {
+      const s = cell.style?.numFmt ? styleId : ctx.styles.addStyle({ ...cell.style, numFmt: DEFAULT_DATE_NUMFMT });
+      return valueCell(r, s, void 0, String(dateToSerial(cell.value, ctx.date1904)));
+    }
+    case 5 /* Error */:
+      return valueCell(r, styleId, "e", cell.value.error);
+    case 2 /* String */:
+      return stringCell(r, styleId, cell.value, ctx);
+    case 7 /* Hyperlink */:
+      return stringCell(r, styleId, cell.value.text, ctx);
+    case 6 /* RichText */:
+      return richTextCell(r, styleId, cell.value, ctx);
+    case 8 /* Formula */:
+      return formulaCell(r, styleId, cell, ctx);
+    default:
+      return styleId !== 0 ? leafCell(r, styleId) : "";
+  }
+}
+function valueCell(r, s, t, raw) {
+  const w = new XmlWriter({ declaration: false });
+  w.open("c", { r, s: s !== 0 ? s : void 0, t });
+  w.el("v", raw);
+  w.close("c");
+  return w.toString();
+}
+function leafCell(r, s) {
+  const w = new XmlWriter({ declaration: false });
+  w.leaf("c", { r, s });
+  return w.toString();
+}
+function stringCell(r, s, value, ctx) {
+  if (ctx.useSharedStrings) {
+    return valueCell(r, s, "s", String(ctx.sharedStrings.add(value)));
+  }
+  const w = new XmlWriter({ declaration: false });
+  w.open("c", { r, s: s !== 0 ? s : void 0, t: "inlineStr" });
+  w.open("is");
+  w.el("t", value);
+  w.close("is");
+  w.close("c");
+  return w.toString();
+}
+function richTextCell(r, s, value, ctx) {
+  if (ctx.useSharedStrings) {
+    return valueCell(r, s, "s", String(ctx.sharedStrings.add(value)));
+  }
+  const text = value.richText.map((run) => run.text).join("");
+  return stringCell(r, s, text, { ...ctx, useSharedStrings: false });
+}
+function formulaCell(r, s, cell, ctx) {
+  const expr = (cell.formula ?? "").replace(/^=/, "");
+  const result = cell.result;
+  let t;
+  let cachedV;
+  if (result === void 0) {
+    cachedV = void 0;
+  } else if (typeof result === "number") {
+    cachedV = String(result);
+  } else if (typeof result === "boolean") {
+    t = "b";
+    cachedV = result ? "1" : "0";
+  } else if (result instanceof Date) {
+    cachedV = String(dateToSerial(result, ctx.date1904));
+  } else if (typeof result === "object" && result !== null && "error" in result) {
+    t = "e";
+    cachedV = result.error;
+  } else {
+    t = "str";
+    cachedV = String(result);
+  }
+  const w = new XmlWriter({ declaration: false });
+  w.open("c", { r, s: s !== 0 ? s : void 0, t });
+  w.el("f", expr);
+  if (cachedV !== void 0) w.el("v", cachedV);
+  w.close("c");
+  return w.toString();
+}
+function renderMergeCells(w, merges) {
+  if (merges.length === 0) return;
+  w.open("mergeCells", { count: merges.length });
+  for (const ref of merges) w.leaf("mergeCell", { ref });
+  w.close("mergeCells");
+}
+
+// src/xlsx/write-workbook.ts
+function writeWorkbookBuffer(wb, options) {
+  const useSharedStrings = options?.useSharedStrings !== false;
+  const useStyles = options?.useStyles !== false;
+  const date1904 = wb.properties.date1904 === true;
+  const worksheets = wb.worksheets;
+  const sheetRels = worksheets.map((ws, i) => ({
+    rId: `rId${i + 1}`,
+    fileName: `sheet${i + 1}.xml`,
+    sheetId: ws.id,
+    name: ws.name,
+    state: ws.state
+  }));
+  const sharedStrings = createSharedStrings();
+  const styles = createStyles();
+  const cellStyles = useStyles ? styles : { addStyle: () => 0, toXml: styles.toXml.bind(styles) };
+  const ctx = { styles: cellStyles, sharedStrings, useSharedStrings, date1904 };
+  const worksheetXml = /* @__PURE__ */ new Map();
+  worksheets.forEach((ws, i) => {
+    worksheetXml.set(sheetRels[i].fileName, renderWorksheet(ws, ctx));
+  });
+  const sharedStringsXml = useSharedStrings ? sharedStrings.toXml() : void 0;
+  const hasSharedStrings = sharedStringsXml !== void 0;
+  let counter = worksheets.length;
+  const stylesRId = `rId${++counter}`;
+  const sharedRId = hasSharedStrings ? `rId${++counter}` : void 0;
+  const themeRId = `rId${++counter}`;
+  const workbookRels = sheetRels.map((s) => ({
+    rId: s.rId,
+    type: REL_TYPE.worksheet,
+    target: `worksheets/${s.fileName}`
+  }));
+  workbookRels.push({ rId: stylesRId, type: REL_TYPE.styles, target: "styles.xml" });
+  if (sharedRId) {
+    workbookRels.push({
+      rId: sharedRId,
+      type: REL_TYPE.sharedStrings,
+      target: "sharedStrings.xml"
+    });
+  }
+  workbookRels.push({ rId: themeRId, type: REL_TYPE.theme, target: "theme/theme1.xml" });
+  const enc = new TextEncoder();
+  const entries = /* @__PURE__ */ new Map();
+  const put = (path, xml) => entries.set(path, enc.encode(xml));
+  put(
+    PART_PATH.contentTypes,
+    renderContentTypes({ worksheetFiles: sheetRels.map((s) => s.fileName), hasSharedStrings })
+  );
+  put(PART_PATH.rootRels, renderRootRels());
+  put(PART_PATH.coreProps, renderCoreProps(wb));
+  put(
+    PART_PATH.appProps,
+    renderAppProps(
+      wb,
+      sheetRels.map((s) => s.name)
+    )
+  );
+  put(PART_PATH.workbook, renderWorkbook(wb, sheetRels));
+  put(PART_PATH.workbookRels, renderWorkbookRels(workbookRels));
+  put(PART_PATH.styles, styles.toXml());
+  if (sharedStringsXml !== void 0) put(PART_PATH.sharedStrings, sharedStringsXml);
+  put(PART_PATH.theme, renderTheme());
+  for (const [file, xml] of worksheetXml) put(`xl/worksheets/${file}`, xml);
+  return writeZipArchive(entries);
+}
+async function writeWorkbookFile(wb, path, options) {
+  const bytes = writeWorkbookBuffer(wb, options);
+  const { writeFile } = await import('fs/promises');
+  await writeFile(path, bytes);
+}
+
+// src/index.ts
+async function drainStream(stream) {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+    total += chunk.length;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+Object.defineProperty(Workbook.prototype, "xlsx", {
+  configurable: true,
+  get() {
+    return {
+      writeBuffer: (options) => Promise.resolve(writeWorkbookBuffer(this, options)),
+      writeFile: (path, options) => writeWorkbookFile(this, path, options),
+      load: (data, options) => {
+        this.model = readWorkbookBuffer(data).model;
+        return Promise.resolve(this);
+      },
+      readFile: async (path, options) => {
+        this.model = (await readWorkbookFile(path)).model;
+        return this;
+      },
+      read: async (stream, options) => {
+        this.model = readWorkbookBuffer(await drainStream(stream)).model;
+        return this;
+      }
+    };
+  }
+});
+var version = "0.0.0";
+
+export { AloshaXlsxError, Cell, CellType, Column, DEFAULT_COLUMN_WIDTH, DuplicateWorksheetNameError, FormulaType, InvalidAddressError, InvalidCellValueError, InvalidPackageError, InvalidRangeError, InvalidRowNumberError, InvalidWorksheetNameError, MergeConflictError, Range, ReservedWorksheetNameError, Row, UnsupportedFeatureError, Workbook, Worksheet, WorksheetNameTooLongError, colLetterToNumber, colNumberToLetter, createSharedStrings, createStyles, dateToSerial, decodeAddress, decodeEx, detectType, effectiveType, encodeAddress, fromStored, isAloshaXlsxError, readWorkbookBuffer, readWorkbookFile, resolveCellStyle, serialToDate, toCsv, toStored, toText, validateAddress, version, writeWorkbookBuffer, writeWorkbookFile };
+//# sourceMappingURL=chunk-6XXKAKLS.js.map
+//# sourceMappingURL=chunk-6XXKAKLS.js.map