@justybase/spreadsheet-tasks 1.3.3 → 2.1.0

package/dist/cjs/index.js

@@ -0,0 +1,4971 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BiffReaderWriter: () => BiffReaderWriter,
+  BigBuffer: () => BigBuffer,
+  ExcelReaderAbstract: () => ExcelReaderAbstract,
+  F: () => F,
+  INVALID_SHEET_NAME_CHARS: () => INVALID_SHEET_NAME_CHARS,
+  ReaderFactory: () => ReaderFactory,
+  StreamingSheetState: () => StreamingSheetState,
+  XlsbReader: () => XlsbReader,
+  XlsbUpdater: () => XlsbUpdater,
+  XlsbWriter: () => XlsbWriter,
+  XlsxReader: () => XlsxReader,
+  XlsxUpdater: () => XlsxUpdater,
+  XlsxWriter: () => XlsxWriter,
+  applyHeaderWidths: () => applyHeaderWidths,
+  defaultColWidth: () => defaultColWidth,
+  getFormat: () => getFormat,
+  initColWidths: () => initColWidths,
+  isFormattedCell: () => isFormattedCell,
+  sanitizeSheetName: () => sanitizeSheetName,
+  unwrapCell: () => unwrapCell,
+  updateColWidthsFromRows: () => updateColWidthsFromRows
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/BigBuffer.ts
+var import_buffer = require("buffer");
+var BigBuffer = class {
+  constructor(chunkSize = 65536) {
+    this.chunkSize = chunkSize;
+    this.chunks = [];
+    this.currentBuffer = import_buffer.Buffer.alloc(chunkSize);
+    this.cursor = 0;
+  }
+  ensureCapacity(size) {
+    if (this.cursor + size > this.chunkSize) {
+      this._flush();
+    }
+  }
+  _ensureCapacity(size) {
+    this.ensureCapacity(size);
+  }
+  _flush() {
+    if (this.cursor > 0) {
+      this.chunks.push(this.currentBuffer.subarray(0, this.cursor));
+      this.currentBuffer = import_buffer.Buffer.alloc(this.chunkSize);
+      this.cursor = 0;
+    }
+  }
+  write(buffer) {
+    let len = buffer.length;
+    let offset = 0;
+    while (len > 0) {
+      let available = this.chunkSize - this.cursor;
+      if (available === 0) {
+        this._flush();
+        available = this.chunkSize;
+      }
+      const toWrite = Math.min(len, available);
+      buffer.copy(this.currentBuffer, this.cursor, offset, offset + toWrite);
+      this.cursor += toWrite;
+      offset += toWrite;
+      len -= toWrite;
+    }
+  }
+  writeByte(val) {
+    this._ensureCapacity(1);
+    this.currentBuffer[this.cursor] = val;
+    this.cursor++;
+  }
+  writeUnsafeByte(val) {
+    this.currentBuffer[this.cursor++] = val;
+  }
+  writeInt32LE(val) {
+    this._ensureCapacity(4);
+    this.currentBuffer.writeInt32LE(val, this.cursor);
+    this.cursor += 4;
+  }
+  writeUnsafeInt32LE(val) {
+    this.currentBuffer.writeInt32LE(val, this.cursor);
+    this.cursor += 4;
+  }
+  writeDoubleLE(val) {
+    this._ensureCapacity(8);
+    this.currentBuffer.writeDoubleLE(val, this.cursor);
+    this.cursor += 8;
+  }
+  writeUnsafeDoubleLE(val) {
+    this.currentBuffer.writeDoubleLE(val, this.cursor);
+    this.cursor += 8;
+  }
+  writeString(str) {
+    const byteLength = import_buffer.Buffer.byteLength(str, "utf8");
+    if (this.cursor + byteLength <= this.chunkSize) {
+      this.cursor += this.currentBuffer.write(str, this.cursor, "utf8");
+      return;
+    }
+    this._flush();
+    if (byteLength > this.chunkSize) {
+      this.chunks.push(import_buffer.Buffer.from(str, "utf8"));
+    } else {
+      this.cursor += this.currentBuffer.write(str, this.cursor, "utf8");
+    }
+  }
+  writeUtf16LE(str) {
+    const byteLength = str.length * 2;
+    if (this.cursor + byteLength <= this.chunkSize) {
+      for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        this.currentBuffer[this.cursor++] = code & 255;
+        this.currentBuffer[this.cursor++] = code >> 8 & 255;
+      }
+      return;
+    }
+    this._flush();
+    if (byteLength > this.chunkSize) {
+      this.chunks.push(import_buffer.Buffer.from(str, "utf16le"));
+    } else {
+      for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        this.currentBuffer[this.cursor++] = code & 255;
+        this.currentBuffer[this.cursor++] = code >> 8 & 255;
+      }
+    }
+  }
+  getChunks() {
+    if (this.cursor > 0) {
+      this.chunks.push(this.currentBuffer.subarray(0, this.cursor));
+      this.currentBuffer = import_buffer.Buffer.alloc(this.chunkSize);
+      this.cursor = 0;
+    }
+    return this.chunks;
+  }
+  reset() {
+    this.chunks = [];
+    this.cursor = 0;
+  }
+};
+
+// src/ExcelReaderAbstract.ts
+var ExcelReaderAbstract = class {
+  constructor() {
+    this.fieldCount = 0;
+    this.rowCount = 0;
+    this.actualSheetName = "";
+    this.resultsCount = 0;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+  }
+  async close() {
+  }
+  dispose() {
+  }
+  getDateTimeFromOaDate(oaDate) {
+    const ms = oaDate * 864e5 + this._oaEpoch;
+    return new Date(ms);
+  }
+};
+
+// src/BiffReaderWriter.ts
+var BiffReaderWriter = class {
+  constructor(buffer) {
+    this._isSheet = false;
+    this._workbookId = 0;
+    this._recId = null;
+    this._workbookName = null;
+    this._inCellXf = false;
+    this._inNumberFormat = false;
+    this._numberFormatIndex = 0;
+    this._format = 0;
+    this._formatString = null;
+    this._sharedStringValue = null;
+    this._sharedStringUniqueCount = 0;
+    this._cellType = 0;
+    this._intValue = 0;
+    this._doubleVal = 0;
+    this._boolValue = false;
+    this._stringValue = null;
+    this._columnNum = -1;
+    this._xfIndex = 0;
+    this._readCell = false;
+    this._rowIndex = -1;
+    // Start of the current record data (excluding ID and Length)
+    this._recordStart = 0;
+    this._xfIndexToNumFmtId = [];
+    this._customNumFmts = /* @__PURE__ */ new Set();
+    if (!Buffer.isBuffer(buffer)) {
+      throw new Error("BiffReaderWriter expects a Buffer");
+    }
+    this.buffer = buffer;
+    this.pos = 0;
+    this.length = buffer.length;
+  }
+  _tryReadVariableValue() {
+    if (this.pos >= this.length) return null;
+    const b1 = this.buffer[this.pos++];
+    let value = (b1 & 127) >>> 0;
+    if ((b1 & 128) === 0) return value;
+    if (this.pos >= this.length) return null;
+    const b2 = this.buffer[this.pos++];
+    value = ((b2 & 127) << 7 | value) >>> 0;
+    if ((b2 & 128) === 0) return value;
+    if (this.pos >= this.length) return null;
+    const b3 = this.buffer[this.pos++];
+    value = ((b3 & 127) << 14 | value) >>> 0;
+    if ((b3 & 128) === 0) return value;
+    if (this.pos >= this.length) return null;
+    const b4 = this.buffer[this.pos++];
+    value = ((b4 & 127) << 21 | value) >>> 0;
+    return value;
+  }
+  _getDWord(offset) {
+    return this.buffer.readUInt32LE(this._recordStart + offset);
+  }
+  _getInt32(offset) {
+    return this.buffer.readInt32LE(this._recordStart + offset);
+  }
+  _getWord(offset) {
+    return this.buffer.readUInt16LE(this._recordStart + offset);
+  }
+  _getByte(offset) {
+    return this.buffer[this._recordStart + offset];
+  }
+  _getDouble(offset) {
+    return this.buffer.readDoubleLE(this._recordStart + offset);
+  }
+  _getString(offset, length) {
+    const start = this._recordStart + offset;
+    const end = start + length * 2;
+    if (end > this.buffer.length) return "";
+    return this.buffer.toString("utf16le", start, end);
+  }
+  _getNullableString(offsetRef) {
+    const length = this._getDWord(offsetRef.val);
+    offsetRef.val += 4;
+    if (length === 4294967295) return null;
+    const str = this._getString(offsetRef.val, length);
+    offsetRef.val += length * 2;
+    return str;
+  }
+  readWorkbook() {
+    const recordId = this._tryReadVariableValue();
+    const recordLength = this._tryReadVariableValue();
+    if (recordId === null || recordLength === null) return false;
+    const startPos = this.pos;
+    if (startPos + recordLength > this.length) return false;
+    this._recordStart = startPos;
+    this.pos += recordLength;
+    this._isSheet = false;
+    if (recordId === 156) {
+      this._workbookId = this._getDWord(4);
+      const offsetRef = { val: 8 };
+      this._recId = this._getNullableString(offsetRef);
+      const nameLength = this._getDWord(offsetRef.val);
+      this._workbookName = this._getString(offsetRef.val + 4, nameLength);
+      this._isSheet = true;
+    }
+    return true;
+  }
+  readSharedStrings() {
+    const recordId = this._tryReadVariableValue();
+    const recordLength = this._tryReadVariableValue();
+    if (recordId === null || recordLength === null) return false;
+    const startPos = this.pos;
+    if (startPos + recordLength > this.length) return false;
+    this._recordStart = startPos;
+    this.pos += recordLength;
+    this._sharedStringValue = null;
+    if (recordId === 19) {
+      const length = this._getDWord(1);
+      this._sharedStringValue = this._getString(5, length);
+    } else if (recordId === 159) {
+      this._sharedStringUniqueCount = this._getDWord(4);
+    }
+    return true;
+  }
+  readStyles() {
+    const recordId = this._tryReadVariableValue();
+    const recordLength = this._tryReadVariableValue();
+    if (recordId === null || recordLength === null) return false;
+    const startPos = this.pos;
+    if (startPos + recordLength > this.length) return false;
+    this._recordStart = startPos;
+    this.pos += recordLength;
+    const _cellXfStart = 617;
+    const _cellXfEnd = 618;
+    const _numberFormatStart = 615;
+    const _numberFormatEnd = 616;
+    const _xf = 47;
+    const _numberFormat = 44;
+    switch (recordId) {
+      case _cellXfStart:
+        this._inCellXf = true;
+        break;
+      case _cellXfEnd:
+        this._inCellXf = false;
+        break;
+      case _numberFormatStart:
+        this._inNumberFormat = true;
+        break;
+      case _numberFormatEnd:
+        this._inNumberFormat = false;
+        break;
+      case _xf:
+        if (this._inCellXf) {
+          this._numberFormatIndex = this._getWord(2);
+          this._xfIndexToNumFmtId.push(this._numberFormatIndex);
+        }
+        break;
+      case _numberFormat:
+        if (this._inNumberFormat) {
+          this._format = this._getWord(0);
+          const length = this._getDWord(2);
+          this._formatString = this._getString(6, length);
+          const code = this._formatString.toLowerCase();
+          if (code.includes("yy") || code.includes("mm") || code.includes("dd") || code.includes("h:mm")) {
+            this._customNumFmts.add(this._format);
+          }
+        }
+        break;
+    }
+    return true;
+  }
+  _getRkNumber(offset) {
+    const flags = this._getByte(offset);
+    let result = 0;
+    if ((flags & 2) !== 0) {
+      const intVal = this._getInt32(offset);
+      result = intVal >> 2;
+    } else {
+      const raw = this._getInt32(offset);
+      const highBits = raw & 4294967292;
+      const dBuf = Buffer.allocUnsafe(8);
+      dBuf.writeInt32LE(0, 0);
+      dBuf.writeInt32LE(highBits, 4);
+      result = dBuf.readDoubleLE(0);
+    }
+    if ((flags & 1) !== 0) {
+      result /= 100;
+    }
+    return result;
+  }
+  readWorksheet() {
+    const recordId = this._tryReadVariableValue();
+    const recordLength = this._tryReadVariableValue();
+    if (recordId === null || recordLength === null) return false;
+    const startPos = this.pos;
+    if (startPos + recordLength > this.length) return false;
+    this._recordStart = startPos;
+    this.pos += recordLength;
+    this._readCell = false;
+    this._columnNum = -1;
+    const _row = 0;
+    const _blank = 1;
+    const _number = 2;
+    const _boolError = 3;
+    const _bool = 4;
+    const _float = 5;
+    const _string = 6;
+    const _sharedString = 7;
+    const _formulaString = 8;
+    const _formulaNumber = 9;
+    const _formulaBool = 10;
+    const _formulaError = 11;
+    switch (recordId) {
+      case _row:
+        this._rowIndex = this._getInt32(0);
+        break;
+      case _blank:
+      case _boolError:
+      case _formulaError:
+        this._readCell = true;
+        this._cellType = 0;
+        break;
+      case _number:
+        this._doubleVal = this._getRkNumber(8);
+        this._readCell = true;
+        this._cellType = 3;
+        break;
+      case _bool:
+      case _formulaBool:
+        this._boolValue = this._getByte(8) === 1;
+        this._readCell = true;
+        this._cellType = 4;
+        break;
+      case _formulaNumber:
+      case _float:
+        this._doubleVal = this._getDouble(8);
+        this._readCell = true;
+        this._cellType = 3;
+        break;
+      case _string:
+      case _formulaString: {
+        const length = this._getDWord(8);
+        this._stringValue = this._getString(12, length);
+        this._readCell = true;
+        this._cellType = 5;
+        break;
+      }
+      case _sharedString:
+        this._intValue = this._getDWord(8);
+        this._readCell = true;
+        this._cellType = 2;
+        break;
+    }
+    if (this._readCell) {
+      this._columnNum = this._getDWord(0);
+      this._xfIndex = this._getDWord(4) & 16777215;
+    }
+    return true;
+  }
+};
+
+// src/XlsbReader.ts
+var import_adm_zip = __toESM(require("adm-zip"));
+var XlsbReader = class extends ExcelReaderAbstract {
+  constructor() {
+    super();
+    this.zip = null;
+    this.sharedStrings = [];
+    this.sheetNames = [];
+    this.sheets = [];
+    this._currentSheetIndex = -1;
+    this._reader = null;
+    this._currentRow = [];
+    this._pendingRowIndex = -1;
+    this._eof = false;
+    this.xfIdToNumFmtId = [];
+    this.customDateFormats = null;
+  }
+  async open(path2, readSharedStrings = true) {
+    this.zip = new import_adm_zip.default(path2);
+    const wbEntry = this.zip.getEntry("xl/workbook.bin");
+    if (wbEntry) {
+      const buf = wbEntry.getData();
+      const reader = new BiffReaderWriter(buf);
+      while (reader.readWorkbook()) {
+        if (reader._isSheet) {
+          const name = reader._workbookName;
+          const rId = reader._recId;
+          this.sheetNames.push(name);
+          this.sheets.push({ name, rId, path: null });
+        }
+      }
+    }
+    const relsEntry = this.zip.getEntry("xl/_rels/workbook.bin.rels");
+    if (relsEntry) {
+      const xml = relsEntry.getData().toString("utf8");
+      const relRegex = /<Relationship[^>]*Id="([^"]*)"[^>]*Target="([^"]*)"/g;
+      let match;
+      const rIdToTarget = {};
+      while ((match = relRegex.exec(xml)) !== null) {
+        rIdToTarget[match[1]] = match[2];
+      }
+      for (const sheet of this.sheets) {
+        let target = rIdToTarget[sheet.rId];
+        if (target) {
+          if (target.startsWith("/")) target = target.substring(1);
+          if (!target.startsWith("xl/")) target = "xl/" + target;
+          sheet.path = target;
+        }
+      }
+    }
+    if (readSharedStrings) {
+      const ssPath = "xl/sharedStrings.bin";
+      if (this.zip.getEntry(ssPath)) {
+        this._readSharedStrings(ssPath);
+      }
+    }
+    const stylesPath = "xl/styles.bin";
+    if (this.zip.getEntry(stylesPath)) {
+      this._readStyles(stylesPath);
+    }
+    this.resultsCount = this.sheets.length;
+    this._currentSheetIndex = -1;
+  }
+  _readSharedStrings(path2) {
+    const entry = this.zip.getEntry(path2);
+    if (!entry) return;
+    const reader = new BiffReaderWriter(entry.getData());
+    while (reader.readSharedStrings()) {
+      if (reader._sharedStringValue !== null) {
+        this.sharedStrings.push(reader._sharedStringValue);
+      }
+    }
+  }
+  _readStyles(path2) {
+    const entry = this.zip.getEntry(path2);
+    if (!entry) return;
+    const reader = new BiffReaderWriter(entry.getData());
+    while (reader.readStyles()) {
+    }
+    this.xfIdToNumFmtId = reader._xfIndexToNumFmtId;
+    this.customDateFormats = reader._customNumFmts;
+  }
+  getSheetNames() {
+    return this.sheetNames;
+  }
+  async read() {
+    if (this._currentSheetIndex === -1) {
+      this._currentSheetIndex = 0;
+      if (!this._initSheet(0)) return false;
+    }
+    if (this._eof) return false;
+    this._currentRow = [];
+    while (true) {
+      const hasRecord = this._reader.readWorksheet();
+      if (!hasRecord) {
+        this._eof = true;
+        return true;
+      }
+      if (this._reader._rowIndex !== -1 && this._reader._rowIndex !== this._pendingRowIndex) {
+        this._pendingRowIndex = this._reader._rowIndex;
+        return true;
+      }
+      if (this._reader._readCell) {
+        const col = this._reader._columnNum;
+        let val = null;
+        switch (this._reader._cellType) {
+          case 2:
+            val = this.sharedStrings[this._reader._intValue];
+            break;
+          case 3: {
+            val = this._reader._doubleVal;
+            const xfIndex = this._reader._xfIndex;
+            let numFmtId = 0;
+            if (this.xfIdToNumFmtId && xfIndex < this.xfIdToNumFmtId.length) {
+              numFmtId = this.xfIdToNumFmtId[xfIndex];
+            }
+            const isDate = numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47 || this.customDateFormats && this.customDateFormats.has(numFmtId);
+            if (isDate) {
+              try {
+                val = this.getDateTimeFromOaDate(val);
+              } catch {
+              }
+            }
+            break;
+          }
+          case 4:
+            val = this._reader._boolValue;
+            break;
+          case 5:
+            val = this._reader._stringValue;
+            break;
+          default:
+            val = null;
+        }
+        this._currentRow[col] = val;
+        if (col >= this.fieldCount) this.fieldCount = col + 1;
+      }
+    }
+  }
+  _initSheet(index) {
+    if (index >= this.sheets.length) return false;
+    const sheet = this.sheets[index];
+    const entry = this.zip.getEntry(sheet.path);
+    if (!entry) return false;
+    this._reader = new BiffReaderWriter(entry.getData());
+    this._eof = false;
+    this._pendingRowIndex = -1;
+    while (this._reader.readWorksheet()) {
+      if (this._reader._rowIndex !== -1) {
+        this._pendingRowIndex = this._reader._rowIndex;
+        return true;
+      }
+    }
+    this._eof = true;
+    return false;
+  }
+  getValue(i) {
+    if (i < 0 || i >= this._currentRow.length) return null;
+    return this._currentRow[i];
+  }
+};
+
+// src/XlsxReader.ts
+var import_yauzl = __toESM(require("yauzl"));
+
+// src/xmlUtils.ts
+function hasInvalidControlChars(str) {
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c < 32 && c !== 9 && c !== 10 && c !== 13) {
+      return true;
+    }
+  }
+  return false;
+}
+function stripInvalidControlChars(str) {
+  let out = "";
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c === 9 || c === 10 || c === 13 || c >= 32 && c <= 55295 || c >= 57344 && c <= 65533) {
+      out += str[i];
+    }
+  }
+  return out;
+}
+function escapeXmlText(str) {
+  if (!/&|<|>|"|'/.test(str) && !hasInvalidControlChars(str)) {
+    return str;
+  }
+  let out = str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  if (hasInvalidControlChars(out)) {
+    out = stripInvalidControlChars(out);
+  }
+  return out;
+}
+function unescapeXml(str) {
+  if (!str || str.indexOf("&") === -1) return str;
+  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+}
+function columnIndexToLetter(colIndex) {
+  let n = colIndex + 1;
+  let result = "";
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    result = String.fromCharCode(65 + rem) + result;
+    n = Math.floor((n - 1) / 26);
+  }
+  return result;
+}
+function columnLetterToIndex(letter) {
+  let column = 0;
+  const length = letter.length;
+  for (let i = 0; i < length; i++) {
+    column += (letter.charCodeAt(i) - 64) * Math.pow(26, length - i - 1);
+  }
+  return column - 1;
+}
+function trimTrailingEmptyRows(rows) {
+  let end = rows.length;
+  while (end > 0 && rows[end - 1].every((v) => v === null || v === void 0)) {
+    end--;
+  }
+  return end === rows.length ? rows : rows.slice(0, end);
+}
+function parseSharedStringsXml(xml) {
+  const result = [];
+  let pos = 0;
+  while (true) {
+    const siStart = xml.indexOf("<si>", pos);
+    if (siStart === -1) break;
+    const siEnd = xml.indexOf("</si>", siStart);
+    if (siEnd === -1) break;
+    const content = xml.substring(siStart, siEnd);
+    let val = "";
+    let tPos = 0;
+    while (true) {
+      const tStart = content.indexOf("<t", tPos);
+      if (tStart === -1) break;
+      const tagEnd = content.indexOf(">", tStart);
+      const tEnd = content.indexOf("</t>", tagEnd);
+      if (tEnd === -1) break;
+      val += content.substring(tagEnd + 1, tEnd);
+      tPos = tEnd + 4;
+    }
+    result.push(unescapeXml(val));
+    pos = siEnd + 5;
+  }
+  return result;
+}
+
+// src/XlsxReader.ts
+var XlsxReader = class extends ExcelReaderAbstract {
+  constructor() {
+    super();
+    this.zipfile = null;
+    this.sharedStrings = [];
+    this.sheetNames = [];
+    this.sheets = [];
+    this.entries = /* @__PURE__ */ new Map();
+    this._currentSheetIndex = -1;
+    this._sheetXml = null;
+    this._xmlPos = 0;
+    this._currentRow = [];
+    this.xfIdToNumFmtId = [];
+    this.customDateFormats = /* @__PURE__ */ new Set();
+  }
+  async open(path2, readSharedStrings = true) {
+    return new Promise((resolve, reject) => {
+      import_yauzl.default.open(path2, { lazyEntries: true, autoClose: false }, async (err, zipfile) => {
+        if (err) return reject(err);
+        this.zipfile = zipfile;
+        this.entries = /* @__PURE__ */ new Map();
+        zipfile.on("entry", (entry) => {
+          this.entries.set(entry.fileName, entry);
+          zipfile.readEntry();
+        });
+        zipfile.on("end", async () => {
+          try {
+            const wbRelsContent = await this._readZipEntryContent("xl/_rels/workbook.xml.rels");
+            const rIdToTarget = {};
+            if (wbRelsContent) {
+              const relRegex = /<Relationship[^>]*Id="([^"]*)"[^>]*Target="([^"]*)"/g;
+              let match;
+              while ((match = relRegex.exec(wbRelsContent)) !== null) {
+                rIdToTarget[match[1]] = match[2];
+              }
+            }
+            const wbContent = await this._readZipEntryContent("xl/workbook.xml");
+            if (wbContent) {
+              const sheetRegex = /<sheet[^>]*name="([^"]*)"[^>]*sheetId="([^"]*)"[^>]*r:id="([^"]*)"/g;
+              let match;
+              while ((match = sheetRegex.exec(wbContent)) !== null) {
+                const name = unescapeXml(match[1]);
+                const sheetId = match[2];
+                const rId = match[3];
+                const target = rIdToTarget[rId];
+                let fullPath = target;
+                if (!fullPath.startsWith("xl/")) {
+                  fullPath = "xl/" + fullPath;
+                }
+                this.sheetNames.push(name);
+                this.sheets.push({ name, sheetId, rId, path: fullPath });
+              }
+            }
+            if (readSharedStrings) {
+              const ssContent = await this._readZipEntryContent("xl/sharedStrings.xml");
+              if (ssContent) {
+                this._parseSharedStrings(ssContent);
+              }
+            }
+            const stylesContent = await this._readZipEntryContent("xl/styles.xml");
+            if (stylesContent) {
+              this._parseStyles(stylesContent);
+            }
+            this.resultsCount = this.sheets.length;
+            this._currentSheetIndex = -1;
+            resolve();
+          } catch (e) {
+            reject(e);
+          }
+        });
+        zipfile.readEntry();
+      });
+    });
+  }
+  async close() {
+    if (this.zipfile) {
+      this.zipfile.close();
+    }
+  }
+  async _readZipEntryContent(path2) {
+    const entry = this.entries.get(path2);
+    if (!entry) return null;
+    return new Promise((resolve, reject) => {
+      this.zipfile.openReadStream(entry, (err, readStream) => {
+        if (err) return reject(err);
+        const chunks = [];
+        readStream.on("data", (chunk) => chunks.push(chunk));
+        readStream.on("end", () => {
+          resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+        readStream.on("error", reject);
+      });
+    });
+  }
+  _parseSharedStrings(xml) {
+    this.sharedStrings = parseSharedStringsXml(xml);
+  }
+  _parseStyles(xml) {
+    const numFmtRegex = /<numFmt\s+[^>]*numFmtId="(\d+)"[^>]*formatCode="([^"]*)"/g;
+    let match;
+    this.customDateFormats = /* @__PURE__ */ new Set();
+    while ((match = numFmtRegex.exec(xml)) !== null) {
+      const id = parseInt(match[1]);
+      const code = match[2];
+      if (code.toLowerCase().includes("yy") || code.toLowerCase().includes("mm") || code.toLowerCase().includes("dd") || code.toLowerCase().includes("h:mm")) {
+        this.customDateFormats.add(id);
+      }
+    }
+    this.xfIdToNumFmtId = [];
+    const cellXfsStart = xml.indexOf("<cellXfs");
+    if (cellXfsStart !== -1) {
+      const cellXfsEnd = xml.indexOf("</cellXfs>", cellXfsStart);
+      if (cellXfsEnd !== -1) {
+        const cellXfsContent = xml.substring(cellXfsStart, cellXfsEnd);
+        const xfRegex = /<xf\s+[^>]*numFmtId="(\d+)"/g;
+        while ((match = xfRegex.exec(cellXfsContent)) !== null) {
+          const numFmtId = parseInt(match[1]);
+          this.xfIdToNumFmtId.push(numFmtId);
+        }
+      }
+    }
+  }
+  getSheetNames() {
+    return this.sheetNames;
+  }
+  async read() {
+    if (this._currentSheetIndex === -1) {
+      this._currentSheetIndex = 0;
+      await this._initSheet(this._currentSheetIndex);
+    }
+    if (this._readNextRow()) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  async _initSheet(index) {
+    if (index >= this.sheets.length) return;
+    const sheet = this.sheets[index];
+    this.actualSheetName = sheet.name;
+    this._sheetXml = await this._readZipEntryContent(sheet.path);
+    if (!this._sheetXml) {
+      this._sheetXml = "";
+    }
+    this._xmlPos = 0;
+    const sd = this._sheetXml.indexOf("<sheetData>");
+    if (sd !== -1) this._xmlPos = sd + 11;
+  }
+  _readNextRow() {
+    if (!this._sheetXml) return false;
+    const rowStart = this._sheetXml.indexOf("<row", this._xmlPos);
+    if (rowStart === -1) return false;
+    const rowEnd = this._sheetXml.indexOf("</row>", rowStart);
+    if (rowEnd === -1) return false;
+    this._xmlPos = rowEnd + 6;
+    this._parseRowByIndex(rowStart, rowEnd);
+    return true;
+  }
+  _parseRowByIndex(rowStart, rowEnd) {
+    this._currentRow = [];
+    const xml = this._sheetXml;
+    let pos = xml.indexOf(">", rowStart) + 1;
+    while (pos < rowEnd) {
+      const cStart = xml.indexOf("<c", pos);
+      if (cStart === -1 || cStart >= rowEnd) break;
+      const nextTagClose = xml.indexOf(">", cStart);
+      let colIndex = -1;
+      let type = "n";
+      let styleIndex = 0;
+      let currentIdx = cStart + 2;
+      while (currentIdx < nextTagClose) {
+        while (xml.charCodeAt(currentIdx) <= 32 && currentIdx < nextTagClose) currentIdx++;
+        if (currentIdx >= nextTagClose) break;
+        const keyStart = currentIdx;
+        while (xml.charCodeAt(currentIdx) !== 61 && currentIdx < nextTagClose) currentIdx++;
+        const key = xml.substring(keyStart, currentIdx);
+        currentIdx++;
+        if (xml.charCodeAt(currentIdx) === 34) {
+          currentIdx++;
+          const valStart = currentIdx;
+          while (xml.charCodeAt(currentIdx) !== 34 && currentIdx < nextTagClose) currentIdx++;
+          const val2 = xml.substring(valStart, currentIdx);
+          currentIdx++;
+          if (key === "r") {
+            let letterLen = 0;
+            while (letterLen < val2.length && val2.charCodeAt(letterLen) >= 65) letterLen++;
+            colIndex = columnLetterToIndex(val2.substring(0, letterLen));
+          } else if (key === "t") {
+            type = val2;
+          } else if (key === "s") {
+            styleIndex = parseInt(val2, 10);
+          }
+        }
+      }
+      let val = null;
+      if (xml.charCodeAt(nextTagClose - 1) === 47) {
+        pos = nextTagClose + 1;
+      } else {
+        const cEnd = xml.indexOf("</c>", nextTagClose);
+        const cellContentEnd = cEnd !== -1 && cEnd < rowEnd ? cEnd : rowEnd;
+        const vStart = xml.indexOf("<v>", nextTagClose);
+        if (vStart !== -1 && vStart < cellContentEnd) {
+          const vInnerStart = vStart + 3;
+          const vEnd = xml.indexOf("</v>", vInnerStart);
+          if (vEnd !== -1 && vEnd < cellContentEnd) {
+            val = xml.substring(vInnerStart, vEnd);
+          }
+        } else {
+          if (type === "inlineStr") {
+            const tStart = xml.indexOf("<t", nextTagClose);
+            if (tStart !== -1 && tStart < cellContentEnd) {
+              const tContentStart = xml.indexOf(">", tStart) + 1;
+              const tEnd = xml.indexOf("</t>", tContentStart);
+              if (tEnd !== -1 && tEnd < cellContentEnd) {
+                val = xml.substring(tContentStart, tEnd);
+              }
+            }
+          }
+        }
+        pos = cellContentEnd + 4;
+      }
+      let finalVal = null;
+      if (val !== null) {
+        if (type === "s") {
+          const idx = parseInt(val, 10);
+          finalVal = this.sharedStrings[idx];
+        } else if (type === "b") {
+          finalVal = val === "1" || val === "true";
+        } else if (type === "inlineStr") {
+          finalVal = unescapeXml(val);
+        } else if (type === "n" || type === "") {
+          finalVal = parseFloat(val);
+          if (styleIndex > 0 && this.xfIdToNumFmtId) {
+            let numFmtId = 0;
+            if (styleIndex < this.xfIdToNumFmtId.length) {
+              numFmtId = this.xfIdToNumFmtId[styleIndex];
+            }
+            const isDate = numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47 || this.customDateFormats && this.customDateFormats.has(numFmtId);
+            if (isDate) {
+              try {
+                finalVal = this.getDateTimeFromOaDate(finalVal);
+              } catch {
+              }
+            }
+          }
+        }
+      }
+      if (colIndex !== -1) {
+        this._currentRow[colIndex] = finalVal;
+        if (colIndex >= this.fieldCount) this.fieldCount = colIndex + 1;
+      }
+    }
+  }
+  getValue(i) {
+    if (i < 0 || i >= this._currentRow.length) return null;
+    return this._currentRow[i];
+  }
+};
+
+// src/ReaderFactory.ts
+var path = __toESM(require("path"));
+var ReaderFactory = class {
+  /**
+   * @param filePath Path ending in `.xlsb` or `.xlsx`
+   * @throws if the extension is unsupported
+   */
+  static create(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === ".xlsx") {
+      return new XlsxReader();
+    } else if (ext === ".xlsb") {
+      return new XlsbReader();
+    } else {
+      throw new Error(`Unsupported extension: ${ext}`);
+    }
+  }
+};
+
+// src/XlsbWriter.ts
+var fs = __toESM(require("fs"));
+var import_archiver = __toESM(require("archiver"));
+var import_stream = require("stream");
+
+// src/Formats.ts
+var F = {
+  THOUSANDS_SEP: "#,##0",
+  CURRENCY_PLN: '#,##0.00 "z\u0142"',
+  CURRENCY_EUR: "#,##0.00 \u20AC",
+  PERCENTAGE: "0%",
+  SCIENTIFIC: "0.00E+00",
+  TWO_DECIMALS: "#,##0.00",
+  TEXT: "@",
+  LEADING_ZEROS: "000000000",
+  DATE_SHORT: "dd.mm.yyyy",
+  DATE_LONG: "d mmmm yyyy",
+  DATE_DAY_MONTH_YEAR: "dd-mm-yyyy",
+  DATE_ISO: "yyyy-mm-dd",
+  DATE_MONTH_YEAR: "mmmm yyyy",
+  DATE_WEEKDAY: "dddd, d mmmm yyyy",
+  DATE_DAY_MONTH: "d mmmm",
+  DATE_YEAR_ONLY: "yyyy",
+  DATETIME_SHORT: "dd.mm.yyyy hh:mm",
+  DATETIME_LONG: "d mmmm yyyy hh:mm:ss",
+  TIME_HH_MM: "hh:mm",
+  TIME_HH_MM_SS: "hh:mm:ss",
+  TIME_12H: "h:mm AM/PM",
+  DATETIME_24H: "dd.mm.yyyy hh:mm:ss",
+  DATETIME_ISO: 'yyyy-mm-dd"T"hh:mm:ss',
+  TIME_MS: "hh:mm:ss.000"
+};
+function isFormattedCell(val) {
+  return val !== null && val !== void 0 && typeof val === "object" && "format" in val && typeof val.format === "string";
+}
+function unwrapCell(val) {
+  if (isFormattedCell(val)) {
+    return val.value;
+  }
+  return val;
+}
+function getFormat(val) {
+  if (isFormattedCell(val)) {
+    return val.format;
+  }
+  return null;
+}
+
+// src/writerHelpers.ts
+var INVALID_SHEET_NAME_CHARS = /[\\/*?[\]:]/g;
+function sanitizeSheetName(name, sheetCount) {
+  if (!name || typeof name !== "string") {
+    return `Sheet${sheetCount + 1}`;
+  }
+  let sanitized = name.replace(INVALID_SHEET_NAME_CHARS, "_");
+  if (sanitized.length > 31) {
+    sanitized = sanitized.substring(0, 31);
+  }
+  if (sanitized.trim().length === 0) {
+    sanitized = `Sheet${sheetCount + 1}`;
+  }
+  return sanitized;
+}
+function initColWidths(columnCount) {
+  return new Array(columnCount).fill(-1);
+}
+function applyHeaderWidths(colWidths, headers, columnCount) {
+  for (let i = 0; i < columnCount; i++) {
+    const len = headers[i] ? headers[i].length + 1 : 0;
+    let width = 1.25 * len + 2;
+    if (width > 80) width = 80;
+    if (colWidths[i] < width) colWidths[i] = width;
+  }
+}
+function updateColWidthsFromRows(colWidths, rows, sampleLimit = 100) {
+  for (let r = 0; r < Math.min(rows.length, sampleLimit); r++) {
+    const row = rows[r];
+    for (let c = 0; c < row.length; c++) {
+      const raw = row[c];
+      if (raw === null || raw === void 0) continue;
+      const val = isFormattedCell(raw) ? raw.value : raw;
+      const len = val instanceof Date ? 20 : String(val).length + 1;
+      let width = 1.25 * len + 2;
+      if (width > 80) width = 80;
+      if (colWidths[c] < width) colWidths[c] = width;
+    }
+  }
+}
+function defaultColWidth(width, floor = false) {
+  if (width > 0) {
+    return floor ? Math.floor(width) : width;
+  }
+  return 10;
+}
+
+// src/StreamingSheetState.ts
+var StreamingSheetState = class {
+  constructor() {
+    this.isStreaming = false;
+    this.rowNum = 0;
+    this.startCol = 0;
+    this.endCol = 0;
+    this.doAutofilter = false;
+    this.colWidths = [];
+    this.buffer = null;
+  }
+  /**
+   * Begin a streaming sheet session.
+   * @throws if already streaming
+   */
+  begin(columnCount, doAutofilter, buffer) {
+    if (this.isStreaming) {
+      throw new Error("Already in streaming mode. Call endSheet() first.");
+    }
+    this.isStreaming = true;
+    this.buffer = buffer;
+    this.rowNum = 0;
+    this.startCol = 0;
+    this.endCol = columnCount;
+    this.doAutofilter = doAutofilter;
+    this.colWidths = initColWidths(columnCount);
+  }
+  /** Assert streaming mode and return the active buffer. */
+  assertStreaming() {
+    if (!this.isStreaming || !this.buffer) {
+      throw new Error("Not in streaming mode. Call startSheet() first.");
+    }
+    return this.buffer;
+  }
+  /** Reset after endSheet(). */
+  end() {
+    this.isStreaming = false;
+    this.buffer = null;
+    this.rowNum = 0;
+    this.startCol = 0;
+    this.endCol = 0;
+    this.doAutofilter = false;
+    this.colWidths = [];
+  }
+};
+
+// src/XlsbWriter.ts
+var XlsbWriter = class _XlsbWriter {
+  /**
+   * @param filePath Destination `.xlsb` path on disk.
+   */
+  constructor(filePath) {
+    this.sheetCount = 0;
+    this.sheetList = [];
+    this.sstDic = /* @__PURE__ */ new Map();
+    this.sstCntUnique = 0;
+    this.sstCntAll = 0;
+    this._autofilterIsOn = false;
+    this._nextFmtId = 167;
+    this._nextXfIdx = 4;
+    this._stFmtRecords = /* @__PURE__ */ new Map();
+    this.stream = new StreamingSheetState();
+    this.output = fs.createWriteStream(filePath);
+    this.archive = (0, import_archiver.default)("zip");
+    this.archive.pipe(this.output);
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    this._sheet1Bytes = Buffer.from([
+      129,
+      1,
+      0,
+      147,
+      1,
+      23,
+      203,
+      4,
+      2,
+      0,
+      64,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      255,
+      0,
+      0,
+      0,
+      0,
+      148,
+      1,
+      16,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      133,
+      1,
+      0,
+      137,
+      1,
+      30,
+      220,
+      3,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      64,
+      0,
+      0,
+      0,
+      100,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      152,
+      1,
+      36,
+      3,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      138,
+      1,
+      0,
+      134,
+      1,
+      0,
+      37,
+      6,
+      1,
+      0,
+      2,
+      14,
+      0,
+      128,
+      149,
+      8,
+      2,
+      5,
+      0,
+      38,
+      0,
+      229,
+      3,
+      12,
+      255,
+      255,
+      255,
+      255,
+      8,
+      0,
+      44,
+      1,
+      0,
+      0,
+      0,
+      0,
+      145,
+      1,
+      0,
+      37,
+      6,
+      1,
+      0,
+      2,
+      14,
+      0,
+      128,
+      128,
+      8,
+      2,
+      5,
+      0,
+      38,
+      0,
+      0,
+      25,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      44,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      7,
+      12,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      146,
+      1,
+      0,
+      151,
+      4,
+      66,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      221,
+      3,
+      2,
+      16,
+      0,
+      220,
+      3,
+      48,
+      102,
+      102,
+      102,
+      102,
+      102,
+      102,
+      230,
+      63,
+      102,
+      102,
+      102,
+      102,
+      102,
+      102,
+      230,
+      63,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      232,
+      63,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      232,
+      63,
+      51,
+      51,
+      51,
+      51,
+      51,
+      51,
+      211,
+      63,
+      51,
+      51,
+      51,
+      51,
+      51,
+      51,
+      211,
+      63,
+      37,
+      6,
+      1,
+      0,
+      0,
+      16,
+      0,
+      128,
+      128,
+      24,
+      16,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      38,
+      0,
+      130,
+      1,
+      0
+    ]);
+    this._workbookBinStart = Buffer.from([
+      131,
+      1,
+      0,
+      128,
+      1,
+      50,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      2,
+      0,
+      0,
+      0,
+      120,
+      0,
+      108,
+      0,
+      1,
+      0,
+      0,
+      0,
+      55,
+      0,
+      1,
+      0,
+      0,
+      0,
+      54,
+      0,
+      5,
+      0,
+      0,
+      0,
+      50,
+      0,
+      52,
+      0,
+      51,
+      0,
+      50,
+      0,
+      54,
+      0,
+      153,
+      1,
+      12,
+      32,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      37,
+      6,
+      1,
+      0,
+      3,
+      15,
+      0,
+      128,
+      151,
+      16,
+      52,
+      24,
+      0,
+      0,
+      0,
+      67,
+      0,
+      58,
+      0,
+      92,
+      0,
+      115,
+      0,
+      113,
+      0,
+      108,
+      0,
+      115,
+      0,
+      92,
+      0,
+      84,
+      0,
+      101,
+      0,
+      115,
+      0,
+      116,
+      0,
+      121,
+      0,
+      90,
+      0,
+      97,
+      0,
+      112,
+      0,
+      105,
+      0,
+      115,
+      0,
+      117,
+      0,
+      88,
+      0,
+      108,
+      0,
+      115,
+      0,
+      98,
+      0,
+      92,
+      0,
+      38,
+      0,
+      37,
+      6,
+      1,
+      0,
+      0,
+      16,
+      0,
+      128,
+      129,
+      24,
+      130,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      47,
+      0,
+      0,
+      0,
+      49,
+      0,
+      51,
+      0,
+      95,
+      0,
+      110,
+      0,
+      99,
+      0,
+      114,
+      0,
+      58,
+      0,
+      49,
+      0,
+      95,
+      0,
+      123,
+      0,
+      49,
+      0,
+      54,
+      0,
+      53,
+      0,
+      48,
+      0,
+      56,
+      0,
+      68,
+      0,
+      54,
+      0,
+      57,
+      0,
+      45,
+      0,
+      67,
+      0,
+      70,
+      0,
+      56,
+      0,
+      55,
+      0,
+      45,
+      0,
+      52,
+      0,
+      55,
+      0,
+      54,
+      0,
+      57,
+      0,
+      45,
+      0,
+      56,
+      0,
+      52,
+      0,
+      53,
+      0,
+      54,
+      0,
+      45,
+      0,
+      68,
+      0,
+      52,
+      0,
+      65,
+      0,
+      52,
+      0,
+      48,
+      0,
+      49,
+      0,
+      49,
+      0,
+      51,
+      0,
+      49,
+      0,
+      53,
+      0,
+      54,
+      0,
+      55,
+      0,
+      125,
+      0,
+      47,
+      0,
+      0,
+      0,
+      47,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      38,
+      0,
+      135,
+      1,
+      0,
+      37,
+      6,
+      1,
+      0,
+      2,
+      16,
+      0,
+      128,
+      128,
+      24,
+      16,
+      0,
+      0,
+      0,
+      0,
+      13,
+      0,
+      0,
+      0,
+      255,
+      255,
+      255,
+      255,
+      0,
+      0,
+      0,
+      0,
+      38,
+      0,
+      158,
+      1,
+      29,
+      0,
+      0,
+      0,
+      0,
+      158,
+      22,
+      0,
+      0,
+      180,
+      105,
+      0,
+      0,
+      232,
+      38,
+      0,
+      0,
+      88,
+      2,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      120,
+      136,
+      1,
+      0,
+      143,
+      1,
+      0
+    ]);
+    this._workbookBinMiddle = Buffer.from([144, 1, 0]);
+    this._workbookBinEnd = Buffer.from([
+      157,
+      1,
+      26,
+      53,
+      234,
+      2,
+      0,
+      1,
+      0,
+      0,
+      0,
+      100,
+      0,
+      0,
+      0,
+      252,
+      169,
+      241,
+      210,
+      77,
+      98,
+      80,
+      63,
+      1,
+      0,
+      0,
+      0,
+      106,
+      0,
+      155,
+      1,
+      1,
+      0,
+      35,
+      4,
+      3,
+      15,
+      0,
+      0,
+      171,
+      16,
+      1,
+      1,
+      36,
+      0,
+      132,
+      1,
+      0
+    ]);
+    this._stylesBin = Buffer.from([
+      150,
+      2,
+      0,
+      231,
+      4,
+      4,
+      2,
+      0,
+      0,
+      0,
+      44,
+      44,
+      164,
+      0,
+      19,
+      0,
+      0,
+      0,
+      121,
+      0,
+      121,
+      0,
+      121,
+      0,
+      121,
+      0,
+      92,
+      0,
+      45,
+      0,
+      109,
+      0,
+      109,
+      0,
+      92,
+      0,
+      45,
+      0,
+      100,
+      0,
+      100,
+      0,
+      92,
+      0,
+      32,
+      0,
+      104,
+      0,
+      104,
+      0,
+      58,
+      0,
+      109,
+      0,
+      109,
+      0,
+      44,
+      30,
+      166,
+      0,
+      12,
+      0,
+      0,
+      0,
+      121,
+      0,
+      121,
+      0,
+      121,
+      0,
+      121,
+      0,
+      92,
+      0,
+      45,
+      0,
+      109,
+      0,
+      109,
+      0,
+      92,
+      0,
+      45,
+      0,
+      100,
+      0,
+      100,
+      0,
+      232,
+      4,
+      0,
+      227,
+      4,
+      4,
+      1,
+      0,
+      0,
+      0,
+      43,
+      39,
+      220,
+      0,
+      0,
+      0,
+      144,
+      1,
+      0,
+      0,
+      0,
+      2,
+      0,
+      0,
+      7,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      255,
+      2,
+      7,
+      0,
+      0,
+      0,
+      67,
+      0,
+      97,
+      0,
+      108,
+      0,
+      105,
+      0,
+      98,
+      0,
+      114,
+      0,
+      105,
+      0,
+      43,
+      39,
+      220,
+      0,
+      1,
+      0,
+      188,
+      2,
+      0,
+      0,
+      0,
+      2,
+      238,
+      0,
+      7,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      255,
+      2,
+      7,
+      0,
+      0,
+      0,
+      67,
+      0,
+      97,
+      0,
+      108,
+      0,
+      105,
+      0,
+      98,
+      0,
+      114,
+      0,
+      105,
+      0,
+      37,
+      6,
+      1,
+      0,
+      2,
+      14,
+      0,
+      128,
+      129,
+      8,
+      0,
+      38,
+      0,
+      228,
+      4,
+      0,
+      219,
+      4,
+      4,
+      2,
+      0,
+      0,
+      0,
+      45,
+      68,
+      0,
+      0,
+      0,
+      0,
+      3,
+      64,
+      0,
+      0,
+      0,
+      0,
+      0,
+      255,
+      3,
+      65,
+      0,
+      0,
+      255,
+      255,
+      255,
+      255,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      45,
+      68,
+      17,
+      0,
+      0,
+      0,
+      3,
+      64,
+      0,
+      0,
+      0,
+      0,
+      0,
+      255,
+      3,
+      65,
+      0,
+      0,
+      255,
+      255,
+      255,
+      255,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      220,
+      4,
+      0,
+      229,
+      4,
+      4,
+      1,
+      0,
+      0,
+      0,
+      46,
+      51,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      230,
+      4,
+      0,
+      242,
+      4,
+      4,
+      1,
+      0,
+      0,
+      0,
+      47,
+      16,
+      255,
+      255,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      0,
+      0,
+      243,
+      4,
+      0,
+      233,
+      4,
+      4,
+      4,
+      0,
+      0,
+      0,
+      47,
+      16,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      0,
+      0,
+      47,
+      16,
+      0,
+      0,
+      164,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      1,
+      0,
+      47,
+      16,
+      0,
+      0,
+      166,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      1,
+      0,
+      47,
+      16,
+      0,
+      0,
+      0,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16,
+      16,
+      0,
+      0,
+      234,
+      4,
+      0,
+      235,
+      4,
+      4,
+      1,
+      0,
+      0,
+      0,
+      37,
+      6,
+      1,
+      0,
+      2,
+      17,
+      0,
+      128,
+      128,
+      24,
+      16,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      38,
+      0,
+      48,
+      28,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      8,
+      0,
+      0,
+      0,
+      78,
+      0,
+      111,
+      0,
+      114,
+      0,
+      109,
+      0,
+      97,
+      0,
+      108,
+      0,
+      110,
+      0,
+      121,
+      0,
+      236,
+      4,
+      0,
+      249,
+      3,
+      4,
+      0,
+      0,
+      0,
+      0,
+      250,
+      3,
+      0,
+      252,
+      3,
+      80,
+      0,
+      0,
+      0,
+      0,
+      17,
+      0,
+      0,
+      0,
+      84,
+      0,
+      97,
+      0,
+      98,
+      0,
+      108,
+      0,
+      101,
+      0,
+      83,
+      0,
+      116,
+      0,
+      121,
+      0,
+      108,
+      0,
+      101,
+      0,
+      77,
+      0,
+      101,
+      0,
+      100,
+      0,
+      105,
+      0,
+      117,
+      0,
+      109,
+      0,
+      50,
+      0,
+      17,
+      0,
+      0,
+      0,
+      80,
+      0,
+      105,
+      0,
+      118,
+      0,
+      111,
+      0,
+      116,
+      0,
+      83,
+      0,
+      116,
+      0,
+      121,
+      0,
+      108,
+      0,
+      101,
+      0,
+      76,
+      0,
+      105,
+      0,
+      103,
+      0,
+      104,
+      0,
+      116,
+      0,
+      49,
+      0,
+      54,
+      0,
+      253,
+      3,
+      0,
+      35,
+      4,
+      2,
+      14,
+      0,
+      0,
+      235,
+      8,
+      0,
+      246,
+      8,
+      42,
+      0,
+      0,
+      0,
+      0,
+      17,
+      0,
+      0,
+      0,
+      83,
+      0,
+      108,
+      0,
+      105,
+      0,
+      99,
+      0,
+      101,
+      0,
+      114,
+      0,
+      83,
+      0,
+      116,
+      0,
+      121,
+      0,
+      108,
+      0,
+      101,
+      0,
+      76,
+      0,
+      105,
+      0,
+      103,
+      0,
+      104,
+      0,
+      116,
+      0,
+      49,
+      0,
+      247,
+      8,
+      0,
+      236,
+      8,
+      0,
+      36,
+      0,
+      35,
+      4,
+      3,
+      15,
+      0,
+      0,
+      176,
+      16,
+      0,
+      178,
+      16,
+      50,
+      0,
+      0,
+      0,
+      0,
+      21,
+      0,
+      0,
+      0,
+      84,
+      0,
+      105,
+      0,
+      109,
+      0,
+      101,
+      0,
+      83,
+      0,
+      108,
+      0,
+      105,
+      0,
+      99,
+      0,
+      101,
+      0,
+      114,
+      0,
+      83,
+      0,
+      116,
+      0,
+      121,
+      0,
+      108,
+      0,
+      101,
+      0,
+      76,
+      0,
+      105,
+      0,
+      103,
+      0,
+      104,
+      0,
+      116,
+      0,
+      49,
+      0,
+      179,
+      16,
+      0,
+      177,
+      16,
+      0,
+      36,
+      0,
+      151,
+      2,
+      0
+    ]);
+    this._binaryIndexBin = Buffer.from([
+      42,
+      24,
+      0,
+      0,
+      0,
+      0,
+      32,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      149,
+      2,
+      0
+    ]);
+    this._rRkIntegerLowerLimit = -1 << 29;
+    this._rRkIntegerUpperLimit = (1 << 29) - 1;
+    this._autoFilterStartBytes = Buffer.from([161, 1, 16]);
+    this._autoFilterEndBytes = Buffer.from([162, 1, 0]);
+    this._stickHeaderA1bytes = Buffer.from([
+      151,
+      1,
+      29,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      240,
+      63,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      2,
+      0,
+      0,
+      0,
+      3
+    ]);
+    this._magicFilterExcel2016Fix0 = Buffer.from([225, 2, 0, 229, 2, 0, 234, 2]);
+    this._magicFilterExcel2016Fix1 = Buffer.from([
+      39,
+      70,
+      33,
+      0,
+      0,
+      0,
+      0,
+      255,
+      0,
+      0,
+      0,
+      15,
+      0,
+      0,
+      0,
+      95,
+      0,
+      70,
+      0,
+      105,
+      0,
+      108,
+      0,
+      116,
+      0,
+      101,
+      0,
+      114,
+      0,
+      68,
+      0,
+      97,
+      0,
+      116,
+      0,
+      97,
+      0,
+      98,
+      0,
+      97,
+      0,
+      115,
+      0,
+      101,
+      0,
+      15,
+      0,
+      0,
+      0,
+      59,
+      255,
+      0
+    ]);
+    this._magicFilterExcel2016Fix2 = Buffer.from([0, 0, 0, 0, 255, 255, 255, 255]);
+  }
+  /** @deprecated Internal; kept for unit-test access. Prefer sanitizeSheetName(). */
+  _sanitizeSheetName(name) {
+    return sanitizeSheetName(name, this.sheetCount);
+  }
+  _registerFormat(fmtString) {
+    if (this._stFmtRecords.has(fmtString)) {
+      return this._stFmtRecords.get(fmtString).xfIndex;
+    }
+    const numfmtId = this._nextFmtId++;
+    const xfIndex = this._nextXfIdx++;
+    this._stFmtRecords.set(fmtString, { numfmtId, xfIndex });
+    return xfIndex;
+  }
+  static _buildBrtRecord(type, data) {
+    const header = _XlsbWriter._encodeVlq(type);
+    header.push(..._XlsbWriter._encodeVlq(data.length));
+    return Buffer.concat([Buffer.from(header), data]);
+  }
+  static _encodeVlq(value) {
+    const result = [];
+    while (value >= 128) {
+      result.push(value & 127 | 128);
+      value >>>= 7;
+    }
+    result.push(value & 127);
+    return result;
+  }
+  static _buildStFmtRecord(ifmt, fmtString) {
+    const cch = fmtString.length;
+    const remaining = 2 + 4 + cch * 2;
+    const data = Buffer.alloc(2 + remaining);
+    data[0] = 44;
+    data[1] = remaining;
+    data.writeUInt16LE(ifmt, 2);
+    data.writeUInt32LE(cch, 4);
+    data.write(fmtString, 8, cch * 2, "utf16le");
+    return data;
+  }
+  static _buildXfRecord(fontId, ifmt, flags, byte6Extra = 0) {
+    const data = Buffer.alloc(18);
+    data[0] = 47;
+    data[1] = 16;
+    data.writeUInt16LE(fontId, 2);
+    data.writeUInt16LE(ifmt, 4);
+    data[6] = byte6Extra;
+    data[14] = 16;
+    data[15] = 16;
+    data.writeUInt16LE(flags, 16);
+    return data;
+  }
+  _buildStylesBin() {
+    if (this._stFmtRecords.size === 0) {
+      return this._stylesBin;
+    }
+    const base = this._stylesBin;
+    let fontEndOff = -1;
+    for (let i = 3; i < base.length - 3; i++) {
+      if (base[i] === 232 && base[i + 1] === 4 && base[i + 2] === 0) {
+        fontEndOff = i;
+        break;
+      }
+    }
+    let xfBeginOff = -1;
+    for (let i = fontEndOff + 3; i < base.length - 2; i++) {
+      if (base[i] === 233 && base[i + 1] === 4) {
+        xfBeginOff = i;
+        break;
+      }
+    }
+    let xfEndOff = -1;
+    for (let i = xfBeginOff; i < base.length - 3; i++) {
+      if (base[i] === 234 && base[i + 1] === 4 && base[i + 2] === 0) {
+        xfEndOff = i;
+        break;
+      }
+    }
+    let fillBeginOff = -1;
+    for (let i = fontEndOff + 3; i < base.length - 2; i++) {
+      if (base[i] === 227 && base[i + 1] === 4) {
+        fillBeginOff = i;
+        break;
+      }
+    }
+    const totalFmt = 2 + this._stFmtRecords.size;
+    const totalXf = 4 + this._stFmtRecords.size;
+    const parts = [];
+    parts.push(base.subarray(0, 3));
+    const fmtHeader = Buffer.alloc(4);
+    fmtHeader.writeUInt16LE(totalFmt, 0);
+    parts.push(_XlsbWriter._buildBrtRecord(615, fmtHeader));
+    parts.push(_XlsbWriter._buildStFmtRecord(164, "yyyy\\-mm\\-dd\\ hh:mm"));
+    parts.push(_XlsbWriter._buildStFmtRecord(166, "yyyy\\-mm\\-dd"));
+    for (const [fmtString, st] of this._stFmtRecords) {
+      parts.push(_XlsbWriter._buildStFmtRecord(st.numfmtId, fmtString));
+    }
+    parts.push(_XlsbWriter._buildBrtRecord(616, Buffer.alloc(0)));
+    parts.push(base.subarray(fillBeginOff, xfBeginOff));
+    const xfHeader = Buffer.alloc(4);
+    xfHeader.writeUInt16LE(totalXf, 0);
+    parts.push(_XlsbWriter._buildBrtRecord(617, xfHeader));
+    parts.push(_XlsbWriter._buildXfRecord(0, 0, 0));
+    parts.push(_XlsbWriter._buildXfRecord(0, 164, 1));
+    parts.push(_XlsbWriter._buildXfRecord(0, 166, 1));
+    parts.push(_XlsbWriter._buildXfRecord(1, 0, 0, 1));
+    const sortedXf = [...this._stFmtRecords.entries()].sort((a, b) => a[1].xfIndex - b[1].xfIndex);
+    for (const [, st] of sortedXf) {
+      parts.push(_XlsbWriter._buildXfRecord(0, st.numfmtId, 1));
+    }
+    parts.push(_XlsbWriter._buildBrtRecord(618, Buffer.alloc(0)));
+    parts.push(base.subarray(xfEndOff + 3));
+    return Buffer.concat(parts);
+  }
+  /**
+   * Register a worksheet (metadata only). Prefer `writeSheet` / `startSheet` for data.
+   * @param sheetName Display name (sanitized to Excel rules)
+   * @param hidden Whether the sheet is hidden in Excel
+   */
+  addSheet(sheetName, hidden = false) {
+    const sanitizedName = sanitizeSheetName(sheetName, this.sheetCount);
+    this.sheetCount++;
+    this.sheetList.push({
+      name: sanitizedName,
+      pathInArchive: `xl/worksheets/sheet${this.sheetCount}.bin`,
+      hidden,
+      nameInArchive: `sheet${this.sheetCount}.bin`,
+      sheetId: this.sheetCount,
+      filterHeaderRange: null
+    });
+  }
+  /**
+   * Start a new sheet in streaming mode. Call writeRow() for each row, then endSheet() when done.
+   * @param sheetName Name of the sheet
+   * @param columnCount Number of columns in the sheet
+   * @param headers Optional header row
+   * @param options Optional settings (hidden, doAutofilter)
+   */
+  startSheet(sheetName, columnCount, headers, options = {}) {
+    const { hidden = false, doAutofilter = true, sampleRows } = options;
+    this.addSheet(sheetName, hidden);
+    this.stream.begin(columnCount, doAutofilter && headers !== void 0, new BigBuffer());
+    const bigBuf = this.stream.buffer;
+    if (headers) {
+      applyHeaderWidths(this.stream.colWidths, headers, columnCount);
+    }
+    if (sampleRows) {
+      updateColWidthsFromRows(this.stream.colWidths, sampleRows);
+    }
+    const sheetHeader = Buffer.from(this._sheet1Bytes);
+    sheetHeader.writeInt32LE(this.stream.startCol, 40);
+    sheetHeader.writeInt32LE(this.stream.endCol, 44);
+    if (this.sheetCount !== 1) {
+      sheetHeader[54] = 156;
+    }
+    bigBuf.write(sheetHeader.subarray(0, 84));
+    if (headers) {
+      bigBuf.write(this._stickHeaderA1bytes);
+    }
+    bigBuf.write(sheetHeader.subarray(84, 159));
+    bigBuf.writeByte(134);
+    bigBuf.writeByte(3);
+    for (let i = this.stream.startCol; i < this.stream.endCol; i++) {
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(60);
+      bigBuf.writeByte(18);
+      bigBuf.writeInt32LE(i);
+      bigBuf.writeInt32LE(i);
+      const width = defaultColWidth(this.stream.colWidths[i], true);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(Math.max(0, Math.min(255, width)));
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(2);
+    }
+    bigBuf.writeByte(0);
+    bigBuf.writeByte(135);
+    bigBuf.writeByte(3);
+    bigBuf.writeByte(0);
+    bigBuf.write(sheetHeader.subarray(159, 175));
+    bigBuf.write(Buffer.from([38, 0]));
+    if (headers) {
+      this.createRowHeader(bigBuf, this.stream.rowNum, this.stream.startCol, this.stream.endCol);
+      for (let c = 0; c < headers.length; c++) {
+        this.writeString(bigBuf, headers[c], c, true);
+      }
+      this.stream.rowNum++;
+    }
+  }
+  /**
+   * Write a single row in streaming mode. Must be called between startSheet() and endSheet().
+   * @param row Array of cell values
+   */
+  writeRow(row) {
+    const bigBuf = this.stream.assertStreaming();
+    if (row.length !== this.stream.endCol - this.stream.startCol) {
+      throw new Error(
+        `Row length mismatch. Expected ${this.stream.endCol - this.stream.startCol} columns, got ${row.length}`
+      );
+    }
+    this.createRowHeader(bigBuf, this.stream.rowNum, this.stream.startCol, this.stream.endCol);
+    for (let c = 0; c < row.length; c++) {
+      const raw = row[c];
+      if (raw === null || raw === void 0) continue;
+      const fmtString = getFormat(raw);
+      const val = fmtString !== null ? unwrapCell(raw) : raw;
+      const styleNum = fmtString !== null ? this._registerFormat(fmtString) : 0;
+      if (typeof val === "number") {
+        if (Number.isInteger(val)) {
+          if (val >= this._rRkIntegerLowerLimit && val <= this._rRkIntegerUpperLimit) {
+            this.writeRkNumberInteger(bigBuf, val, c, styleNum);
+          } else {
+            this.writeDouble(bigBuf, val, c, styleNum);
+          }
+        } else {
+          this.writeDouble(bigBuf, val, c, styleNum);
+        }
+      } else if (typeof val === "bigint") {
+        this.writeString(bigBuf, val.toString(), c);
+      } else if (typeof val === "boolean") {
+        this.writeBool(bigBuf, val, c);
+      } else if (val instanceof Date) {
+        const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+        this.writeDouble(bigBuf, oaDate, c, fmtString !== null ? styleNum : 1);
+      } else if (val !== null && val !== void 0) {
+        this.writeString(bigBuf, val.toString(), c, false, fmtString !== null ? styleNum : void 0);
+      }
+    }
+    this.stream.rowNum++;
+  }
+  /**
+   * Finalize the current streaming sheet and add it to the archive.
+   * Must be called after startSheet() and writeRow() calls.
+   */
+  endSheet() {
+    const bigBuf = this.stream.assertStreaming();
+    const sheetHeader = Buffer.from(this._sheet1Bytes);
+    bigBuf.write(sheetHeader.subarray(218, 290));
+    if (this.stream.doAutofilter) {
+      this._autofilterIsOn = true;
+      const endRow = this.stream.rowNum;
+      bigBuf.write(this._autoFilterStartBytes);
+      const rowBuf = Buffer.alloc(8);
+      rowBuf.writeInt32LE(0, 0);
+      rowBuf.writeInt32LE(endRow - 1, 4);
+      bigBuf.write(rowBuf);
+      const colBuf = Buffer.alloc(8);
+      colBuf.writeInt32LE(this.stream.startCol, 0);
+      colBuf.writeInt32LE(this.stream.endCol - 1, 4);
+      bigBuf.write(colBuf);
+      bigBuf.write(this._autoFilterEndBytes);
+      const sheet = this.sheetList[this.sheetCount - 1];
+      sheet.filterData = {
+        startRow: 0,
+        endRow: endRow - 1,
+        startColumn: this.stream.startCol,
+        endColumn: this.stream.endCol - 1
+      };
+    }
+    bigBuf.write(sheetHeader.subarray(290));
+    this.archive.append(import_stream.Readable.from(bigBuf.getChunks()), {
+      name: this.sheetList[this.sheetCount - 1].pathInArchive
+    });
+    this.stream.end();
+  }
+  /**
+   * Write an entire sheet in one call (batch mode).
+   * @param rows Data rows (`CellValue` cells; null/undefined = blank)
+   * @param headers Optional header row (bold + frozen + autofilter when enabled)
+   * @param doAutofilter Enable autofilter when headers are present (default true)
+   */
+  writeSheet(rows, headers = null, doAutofilter = true) {
+    const bigBuf = new BigBuffer();
+    let columnCount = 0;
+    if (rows.length > 0) {
+      columnCount = rows[0].length;
+    } else if (headers) {
+      columnCount = headers.length;
+    }
+    const colWidths = initColWidths(columnCount);
+    if (headers) {
+      applyHeaderWidths(colWidths, headers, columnCount);
+    }
+    updateColWidthsFromRows(colWidths, rows);
+    const sheetHeader = Buffer.from(this._sheet1Bytes);
+    const startCol = 0;
+    const endCol = columnCount;
+    sheetHeader.writeInt32LE(startCol, 40);
+    sheetHeader.writeInt32LE(endCol, 44);
+    if (this.sheetCount !== 1) {
+      sheetHeader[54] = 156;
+    }
+    bigBuf.write(sheetHeader.subarray(0, 84));
+    if (headers) {
+      bigBuf.write(this._stickHeaderA1bytes);
+    }
+    bigBuf.write(sheetHeader.subarray(84, 159));
+    bigBuf.writeByte(134);
+    bigBuf.writeByte(3);
+    for (let i = startCol; i < endCol; i++) {
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(60);
+      bigBuf.writeByte(18);
+      bigBuf.writeInt32LE(i);
+      bigBuf.writeInt32LE(i);
+      const width = defaultColWidth(colWidths[i], true);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(Math.max(0, Math.min(255, width)));
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(0);
+      bigBuf.writeByte(2);
+    }
+    bigBuf.writeByte(0);
+    bigBuf.writeByte(135);
+    bigBuf.writeByte(3);
+    bigBuf.writeByte(0);
+    bigBuf.write(sheetHeader.subarray(159, 175));
+    bigBuf.write(Buffer.from([38, 0]));
+    let rowNum = 0;
+    if (headers) {
+      this.createRowHeader(bigBuf, rowNum, startCol, endCol);
+      for (let c = 0; c < headers.length; c++) {
+        this.writeString(bigBuf, headers[c], c, true);
+      }
+      rowNum++;
+    }
+    for (let r = 0; r < rows.length; r++) {
+      this.createRowHeader(bigBuf, rowNum, startCol, endCol);
+      const row = rows[r];
+      for (let c = 0; c < row.length; c++) {
+        const raw = row[c];
+        if (raw === null || raw === void 0) continue;
+        const fmtString = getFormat(raw);
+        const val = fmtString !== null ? unwrapCell(raw) : raw;
+        const styleNum = fmtString !== null ? this._registerFormat(fmtString) : 0;
+        if (typeof val === "number") {
+          if (Number.isInteger(val)) {
+            if (val >= this._rRkIntegerLowerLimit && val <= this._rRkIntegerUpperLimit) {
+              this.writeRkNumberInteger(bigBuf, val, c, styleNum);
+            } else {
+              this.writeDouble(bigBuf, val, c, styleNum);
+            }
+          } else {
+            this.writeDouble(bigBuf, val, c, styleNum);
+          }
+        } else if (typeof val === "bigint") {
+          this.writeString(bigBuf, val.toString(), c);
+        } else if (typeof val === "boolean") {
+          this.writeBool(bigBuf, val, c);
+        } else if (val instanceof Date) {
+          const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+          this.writeDouble(bigBuf, oaDate, c, fmtString !== null ? styleNum : 1);
+        } else if (val !== null && val !== void 0) {
+          this.writeString(bigBuf, val.toString(), c, false, fmtString !== null ? styleNum : void 0);
+        }
+      }
+      rowNum++;
+    }
+    bigBuf.write(sheetHeader.subarray(218, 290));
+    if (doAutofilter && headers) {
+      this._autofilterIsOn = true;
+      const endRow = rows.length + 1;
+      bigBuf.write(this._autoFilterStartBytes);
+      const rowBuf = Buffer.alloc(8);
+      rowBuf.writeInt32LE(0, 0);
+      rowBuf.writeInt32LE(endRow - 1, 4);
+      bigBuf.write(rowBuf);
+      const colBuf = Buffer.alloc(8);
+      colBuf.writeInt32LE(startCol, 0);
+      colBuf.writeInt32LE(endCol - 1, 4);
+      bigBuf.write(colBuf);
+      bigBuf.write(this._autoFilterEndBytes);
+      const sheet = this.sheetList[this.sheetCount - 1];
+      sheet.filterData = {
+        startRow: 0,
+        endRow: rows.length,
+        startColumn: startCol,
+        endColumn: endCol - 1
+      };
+    }
+    bigBuf.write(sheetHeader.subarray(290));
+    this.archive.append(import_stream.Readable.from(bigBuf.getChunks()), { name: this.sheetList[this.sheetCount - 1].pathInArchive });
+  }
+  createRowHeader(bigBuf, rowNumber, startCol, endCol) {
+    bigBuf.ensureCapacity(27);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(25);
+    bigBuf.writeUnsafeInt32LE(rowNumber);
+    bigBuf.writeUnsafeInt32LE(0);
+    bigBuf.writeUnsafeByte(44);
+    bigBuf.writeUnsafeByte(1);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(1);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeInt32LE(startCol);
+    bigBuf.writeUnsafeInt32LE(endCol);
+  }
+  writeRkNumberInteger(bigBuf, val, colNum, styleNum = 0) {
+    bigBuf.ensureCapacity(14);
+    bigBuf.writeUnsafeByte(2);
+    bigBuf.writeUnsafeByte(12);
+    bigBuf.writeUnsafeInt32LE(colNum);
+    bigBuf.writeUnsafeByte(styleNum);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    const rkVal = val << 2 | 2;
+    bigBuf.writeUnsafeInt32LE(rkVal);
+  }
+  writeDouble(bigBuf, val, colNum, styleNum = 0) {
+    bigBuf.ensureCapacity(18);
+    bigBuf.writeUnsafeByte(5);
+    bigBuf.writeUnsafeByte(16);
+    bigBuf.writeUnsafeInt32LE(colNum);
+    bigBuf.writeUnsafeByte(styleNum);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeDoubleLE(val);
+  }
+  writeBool(bigBuf, val, colNum) {
+    bigBuf.ensureCapacity(13);
+    bigBuf.writeUnsafeByte(4);
+    bigBuf.writeUnsafeByte(9);
+    bigBuf.writeUnsafeInt32LE(colNum);
+    bigBuf.writeUnsafeInt32LE(0);
+    bigBuf.writeUnsafeByte(val ? 1 : 0);
+  }
+  writeDateTime(bigBuf, date, colNum) {
+    const oaDate = (date.getTime() - this._oaEpoch) / 864e5;
+    this.writeDouble(bigBuf, oaDate, colNum, 1);
+  }
+  _getDateWidth(_date) {
+    return 19;
+  }
+  writeString(bigBuf, val, colNum, bolded = false, styleOverride) {
+    let index;
+    if (this.sstDic.has(val)) {
+      index = this.sstDic.get(val);
+    } else {
+      index = this.sstCntUnique;
+      this.sstDic.set(val, index);
+      this.sstCntUnique++;
+    }
+    this.sstCntAll++;
+    const styleNum = styleOverride !== void 0 ? styleOverride : bolded ? 3 : 0;
+    bigBuf.ensureCapacity(17);
+    bigBuf.writeUnsafeByte(7);
+    bigBuf.writeUnsafeByte(12);
+    bigBuf.writeUnsafeInt32LE(colNum);
+    bigBuf.writeUnsafeByte(styleNum);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeByte(0);
+    bigBuf.writeUnsafeInt32LE(index);
+  }
+  saveSst() {
+    const bigBuf = new BigBuffer();
+    bigBuf.writeByte(159);
+    bigBuf.writeByte(1);
+    bigBuf.writeByte(8);
+    bigBuf.writeInt32LE(this.sstCntUnique);
+    bigBuf.writeInt32LE(this.sstCntAll);
+    for (const [txt] of this.sstDic) {
+      const txtLen = txt.length;
+      bigBuf.writeByte(19);
+      const recLen = 5 + 2 * txtLen;
+      if (recLen >= 128) {
+        bigBuf.writeByte(128 + recLen % 128);
+        const tmp = recLen >> 7;
+        if (tmp >= 256) {
+          bigBuf.writeByte(128 + tmp % 128);
+        } else {
+          bigBuf.writeByte(tmp);
+        }
+        bigBuf.writeByte(recLen >> 14);
+        if (recLen >> 14 > 0) {
+          bigBuf.writeByte(0);
+        }
+      } else {
+        bigBuf.writeByte(recLen & 255);
+        bigBuf.writeByte(recLen >> 8 & 255);
+      }
+      bigBuf.writeInt32LE(txtLen);
+      bigBuf.writeUtf16LE(txt);
+    }
+    bigBuf.writeByte(160);
+    bigBuf.writeByte(1);
+    bigBuf.writeByte(0);
+    this.archive.append(import_stream.Readable.from(bigBuf.getChunks()), { name: "xl/sharedStrings.bin" });
+  }
+  _writeFilterDefinedName(wbBuffers, sheet, sheetNum) {
+    const filterData = sheet.filterData;
+    const sheetIndex = sheet.sheetId - 1;
+    const fix1 = Buffer.alloc(this._magicFilterExcel2016Fix1.length);
+    this._magicFilterExcel2016Fix1.copy(fix1);
+    const lastIdx = this._magicFilterExcel2016Fix1.length - 2;
+    fix1[7] = sheetIndex;
+    fix1[lastIdx] = sheetNum;
+    wbBuffers.push(fix1);
+    const rowBuf = Buffer.alloc(8);
+    rowBuf.writeInt32LE(filterData.startRow, 0);
+    rowBuf.writeInt32LE(filterData.endRow, 4);
+    wbBuffers.push(rowBuf);
+    const colBuf = Buffer.alloc(4);
+    colBuf.writeInt16LE(filterData.startColumn, 0);
+    colBuf.writeInt16LE(filterData.endColumn, 2);
+    wbBuffers.push(colBuf);
+    wbBuffers.push(this._magicFilterExcel2016Fix2);
+  }
+  /**
+   * Finalize the ZIP package and close the output stream.
+   * Must be awaited before the file is fully written.
+   */
+  finalize() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.saveSst();
+        this.archive.append(this._buildStylesBin(), { name: "xl/styles.bin" });
+        const wbBuffers = [];
+        wbBuffers.push(this._workbookBinStart);
+        for (const sheet of this.sheetList) {
+          const rId = `rId${sheet.sheetId}`;
+          const recLen = 4 + 12 + sheet.name.length * 2 + rId.length * 2;
+          const buf = Buffer.alloc(3 + recLen);
+          buf[0] = 156;
+          buf[1] = 1;
+          buf[2] = recLen;
+          let pos = 3;
+          buf.writeInt32LE(sheet.hidden ? 1 : 0, pos);
+          pos += 4;
+          buf.writeInt32LE(sheet.sheetId, pos);
+          pos += 4;
+          buf.writeInt32LE(rId.length, pos);
+          pos += 4;
+          for (let i = 0; i < rId.length; i++) {
+            const c = rId.charCodeAt(i);
+            buf[pos++] = c & 255;
+            buf[pos++] = c >> 8 & 255;
+          }
+          buf.writeInt32LE(sheet.name.length, pos);
+          pos += 4;
+          for (let i = 0; i < sheet.name.length; i++) {
+            const c = sheet.name.charCodeAt(i);
+            buf[pos++] = c & 255;
+            buf[pos++] = c >> 8 & 255;
+          }
+          wbBuffers.push(buf);
+        }
+        wbBuffers.push(this._workbookBinMiddle);
+        if (this._autofilterIsOn) {
+          const filteredSheets = this.sheetList.filter((s) => s.filterData);
+          const cnt = filteredSheets.length;
+          if (cnt > 0) {
+            wbBuffers.push(this._magicFilterExcel2016Fix0);
+            const firstByte = cnt <= 20 ? 16 + (cnt - 1) * 12 : 128 + (cnt - 21) * 12;
+            const countBuf = cnt <= 10 ? Buffer.from([firstByte, cnt, 0, 0, 0]) : Buffer.from([firstByte, Math.floor((cnt - 1) / 10), cnt, 0, 0, 0]);
+            wbBuffers.push(countBuf);
+            for (let nm = 0; nm < cnt; nm++) {
+              const sheetIndex = filteredSheets[nm].sheetId - 1;
+              const idxBuf = Buffer.alloc(12);
+              idxBuf.writeInt32LE(0, 0);
+              idxBuf[4] = sheetIndex;
+              idxBuf[8] = sheetIndex;
+              wbBuffers.push(idxBuf);
+            }
+            wbBuffers.push(Buffer.from([226, 2, 0]));
+            for (let sheetNum = 0; sheetNum < cnt; sheetNum++) {
+              const sheet = filteredSheets[sheetNum];
+              this._writeFilterDefinedName(wbBuffers, sheet, sheetNum);
+            }
+          }
+        }
+        wbBuffers.push(this._workbookBinEnd);
+        this.archive.append(Buffer.concat(wbBuffers), { name: "xl/workbook.bin" });
+        for (const sheet of this.sheetList) {
+          this.archive.append(this._binaryIndexBin, { name: `xl/worksheets/binaryIndex${sheet.sheetId}.bin` });
+        }
+        let contentTypes = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+<Default Extension="bin" ContentType="application/vnd.ms-excel.sheet.binary.macroEnabled.main"/>
+<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+<Default Extension="xml" ContentType="application/xml"/>`;
+        for (const sheet of this.sheetList) {
+          contentTypes += `<Override PartName="/${sheet.pathInArchive}" ContentType="application/vnd.ms-excel.worksheet"/>`;
+          contentTypes += `<Override PartName="/xl/worksheets/binaryIndex${sheet.sheetId}.bin" ContentType="application/vnd.ms-excel.binIndexWs"/>`;
+        }
+        contentTypes += `<Override PartName="/xl/styles.bin" ContentType="application/vnd.ms-excel.styles"/>
+<Override PartName="/xl/sharedStrings.bin" ContentType="application/vnd.ms-excel.sharedStrings"/>
+</Types>`;
+        this.archive.append(contentTypes, { name: "[Content_Types].xml" });
+        let wbRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`;
+        for (const sheet of this.sheetList) {
+          const rId = `rId${sheet.sheetId}`;
+          wbRels += `<Relationship Id="${rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/${sheet.nameInArchive}"/>`;
+        }
+        wbRels += `<Relationship Id="rId${this.sheetList.length + 2}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.bin"/>
+<Relationship Id="rId${this.sheetList.length + 3}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.bin"/>
+</Relationships>`;
+        this.archive.append(wbRels, { name: "xl/_rels/workbook.bin.rels" });
+        const globalRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.bin"/>
+</Relationships>`;
+        this.archive.append(globalRels, { name: "_rels/.rels" });
+        for (const sheet of this.sheetList) {
+          const wsRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.microsoft.com/office/2006/relationships/xlBinaryIndex" Target="binaryIndex${sheet.sheetId}.bin"/>
+</Relationships>`;
+          this.archive.append(wsRels, { name: `xl/worksheets/_rels/${sheet.nameInArchive}.rels` });
+        }
+        this.output.on("close", () => resolve());
+        this.archive.on("error", (err) => reject(err));
+        this.archive.finalize();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+};
+
+// src/XlsxWriter.ts
+var fs2 = __toESM(require("fs"));
+var import_archiver2 = __toESM(require("archiver"));
+var import_stream2 = require("stream");
+var COLUMN_LETTERS = (() => {
+  const letters = [];
+  for (let i = 65; i < 91; i++) {
+    letters.push(String.fromCharCode(i));
+  }
+  const temp = [];
+  for (const p of letters) {
+    for (let i = 65; i < 91; i++) {
+      temp.push(p + String.fromCharCode(i));
+    }
+  }
+  letters.push(...temp);
+  return letters;
+})();
+var XlsxWriter = class {
+  /**
+   * @param filePath Destination `.xlsx` path on disk.
+   */
+  constructor(filePath) {
+    this.sheetCount = 0;
+    this.sheetList = [];
+    this.sstArray = [];
+    this.sstMap = /* @__PURE__ */ new Map();
+    this.sstCntAll = 0;
+    this._autofilterIsOn = false;
+    // Format registry
+    this._formatRegistry = /* @__PURE__ */ new Map();
+    this._formatXfMap = /* @__PURE__ */ new Map();
+    this._nextNumfmtId = 165;
+    this._nextXfIndex = 4;
+    this.stream = new StreamingSheetState();
+    this.currentColLetters = [];
+    this.output = fs2.createWriteStream(filePath);
+    this.archive = (0, import_archiver2.default)("zip");
+    this.archive.pipe(this.output);
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+  }
+  _getColumnLetter(colIndex) {
+    return colIndex < COLUMN_LETTERS.length ? COLUMN_LETTERS[colIndex] : "A";
+  }
+  /** @deprecated Internal; kept for unit-test access. Prefer sanitizeSheetName(). */
+  _sanitizeSheetName(name) {
+    return sanitizeSheetName(name, this.sheetCount);
+  }
+  _escapeSheetNameForXml(name) {
+    return name.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  _formatSheetNameForFormula(name) {
+    if (/[\s\-+=()!@#$%^&]/.test(name) || /^[0-9]/.test(name)) {
+      const escaped = name.replace(/'/g, "''");
+      return `'${escaped}'`;
+    }
+    return name;
+  }
+  /**
+   * Register a worksheet (metadata only). Prefer `writeSheet` / `startSheet` for data.
+   */
+  addSheet(sheetName, hidden = false) {
+    const sanitizedName = sanitizeSheetName(sheetName, this.sheetCount);
+    this.sheetCount++;
+    const rId = `rId${this.sheetCount}`;
+    const sheetFileName = `sheet${this.sheetCount}.xml`;
+    this.sheetList.push({
+      name: sanitizedName,
+      pathInArchive: `xl/worksheets/${sheetFileName}`,
+      hidden,
+      nameInArchive: sheetFileName,
+      sheetId: this.sheetCount,
+      rId,
+      filterHeaderRange: null
+    });
+  }
+  _needsEscape(str) {
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+      if (c === 38 || c === 60 || c === 62 || c === 34 || c === 39 || c >= 0 && c <= 8 || c === 11 || c === 12 || c >= 14 && c <= 31) {
+        return true;
+      }
+    }
+    return false;
+  }
+  _escape(str) {
+    if (typeof str !== "string") return str;
+    if (!this._needsEscape(str)) return str;
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "");
+  }
+  /**
+   * Start streaming a sheet. Call `writeRow` for each row, then `endSheet`.
+   */
+  startSheet(sheetName, columnCount, headers, options = {}) {
+    const { hidden = false, doAutofilter = true, sampleRows } = options;
+    this.addSheet(sheetName, hidden);
+    this.stream.begin(columnCount, doAutofilter && headers !== void 0, new BigBuffer());
+    const bigBuf = this.stream.buffer;
+    const colLetters = new Array(columnCount);
+    for (let i = 0; i < columnCount; i++) {
+      colLetters[i] = this._getColumnLetter(i);
+    }
+    this.currentColLetters = colLetters;
+    if (headers) {
+      applyHeaderWidths(this.stream.colWidths, headers, columnCount);
+    }
+    if (sampleRows) {
+      updateColWidthsFromRows(this.stream.colWidths, sampleRows);
+    }
+    bigBuf.writeString('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>');
+    bigBuf.writeString('<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">');
+    bigBuf.writeString('<dimension ref="A1"/>');
+    const isFirstSheet = this.sheetCount === 1;
+    if (headers) {
+      if (isFirstSheet) {
+        bigBuf.writeString('<sheetViews><sheetView tabSelected="1" workbookViewId="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen" /><selection pane="bottomLeft" /></sheetView></sheetViews><sheetFormatPr defaultRowHeight="15"/>');
+      } else {
+        bigBuf.writeString('<sheetViews><sheetView workbookViewId="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen" /><selection pane="bottomLeft" /></sheetView></sheetViews><sheetFormatPr defaultRowHeight="15"/>');
+      }
+    } else {
+      if (isFirstSheet) {
+        bigBuf.writeString('<sheetViews><sheetView tabSelected="1" workbookViewId="0"/></sheetViews><sheetFormatPr defaultRowHeight="15"/>');
+      } else {
+        bigBuf.writeString('<sheetViews><sheetView workbookViewId="0"/></sheetViews><sheetFormatPr defaultRowHeight="15"/>');
+      }
+    }
+    bigBuf.writeString("<cols>");
+    for (let i = 0; i < columnCount; i++) {
+      const width = defaultColWidth(this.stream.colWidths[i]);
+      bigBuf.writeString(`<col min="${i + 1}" max="${i + 1}" width="${width}" bestFit="1" customWidth="1" />`);
+    }
+    bigBuf.writeString("</cols><sheetData>");
+    if (headers) {
+      this.stream.rowNum++;
+      bigBuf.writeString(`<row r="${this.stream.rowNum}">`);
+      for (let c = 0; c < headers.length; c++) {
+        this._writeStringCell(bigBuf, headers[c], colLetters[c], this.stream.rowNum, 3);
+      }
+      bigBuf.writeString("</row>");
+    }
+  }
+  /** Write one data row in streaming mode. */
+  writeRow(row) {
+    const bigBuf = this.stream.assertStreaming();
+    if (row.length !== this.stream.endCol - this.stream.startCol) {
+      throw new Error(
+        `Row length mismatch. Expected ${this.stream.endCol - this.stream.startCol} columns, got ${row.length}`
+      );
+    }
+    this.stream.rowNum++;
+    bigBuf.writeString(`<row r="${this.stream.rowNum}">`);
+    for (let c = 0; c < row.length; c++) {
+      const raw = row[c];
+      if (raw === null || raw === void 0) continue;
+      const fmtString = getFormat(raw);
+      const val = fmtString !== null ? unwrapCell(raw) : raw;
+      const xfIdx = fmtString !== null ? this._registerFormat(fmtString) : -1;
+      const styleAttr = xfIdx >= 0 ? ` s="${xfIdx}"` : "";
+      const colRef = this.currentColLetters[c];
+      if (typeof val === "number") {
+        if (Number.isFinite(val)) {
+          bigBuf.writeString(`<c r="${colRef}${this.stream.rowNum}"${styleAttr}><v>${val}</v></c>`);
+        } else {
+          this._writeStringCell(bigBuf, val.toString(), colRef, this.stream.rowNum, xfIdx >= 0 ? xfIdx : void 0);
+        }
+      } else if (typeof val === "bigint") {
+        this._writeStringCell(bigBuf, val.toString(), colRef, this.stream.rowNum, xfIdx >= 0 ? xfIdx : void 0);
+      } else if (typeof val === "boolean") {
+        bigBuf.writeString(`<c r="${colRef}${this.stream.rowNum}" t="b"${styleAttr}><v>${val ? 1 : 0}</v></c>`);
+      } else if (val instanceof Date) {
+        const oaDate = this._toOADate(val);
+        if (Number.isFinite(oaDate)) {
+          const finalStyle = xfIdx >= 0 ? xfIdx : 1;
+          bigBuf.writeString(`<c r="${colRef}${this.stream.rowNum}" s="${finalStyle}"><v>${oaDate}</v></c>`);
+        } else {
+          this._writeStringCell(bigBuf, val.toString(), colRef, this.stream.rowNum, xfIdx >= 0 ? xfIdx : void 0);
+        }
+      } else if (val !== null && val !== void 0) {
+        this._writeStringCell(bigBuf, val.toString(), colRef, this.stream.rowNum, xfIdx >= 0 ? xfIdx : void 0);
+      }
+    }
+    bigBuf.writeString("</row>");
+  }
+  /** Finish the current streaming sheet and append it to the archive. */
+  endSheet() {
+    const bigBuf = this.stream.assertStreaming();
+    bigBuf.writeString("</sheetData>");
+    if (this.stream.doAutofilter && this.stream.endCol > 0) {
+      this._autofilterIsOn = true;
+      const filterRef = `A1:${this.currentColLetters[this.stream.endCol - 1]}${this.stream.rowNum}`;
+      bigBuf.writeString(`<autoFilter ref="${filterRef}"/>`);
+      const sheet = this.sheetList[this.sheetCount - 1];
+      const formulaSheetName = this._formatSheetNameForFormula(sheet.name);
+      sheet.filterHeaderRange = `${formulaSheetName}!$A$1:$${this.currentColLetters[this.stream.endCol - 1]}$${this.stream.rowNum}`;
+    }
+    bigBuf.writeString("</worksheet>");
+    this.archive.append(import_stream2.Readable.from(bigBuf.getChunks()), {
+      name: this.sheetList[this.sheetCount - 1].pathInArchive
+    });
+    this.stream.end();
+    this.currentColLetters = [];
+  }
+  /**
+   * Write an entire sheet in one call (batch mode).
+   */
+  writeSheet(rows, headers = null, doAutofilter = true) {
+    const bigBuf = new BigBuffer();
+    let columnCount = 0;
+    if (rows.length > 0) {
+      columnCount = rows[0].length;
+    } else if (headers) {
+      columnCount = headers.length;
+    }
+    const colWidths = initColWidths(columnCount);
+    const colLetters = new Array(columnCount);
+    for (let i = 0; i < columnCount; i++) {
+      colLetters[i] = this._getColumnLetter(i);
+    }
+    if (headers) {
+      applyHeaderWidths(colWidths, headers, columnCount);
+    }
+    updateColWidthsFromRows(colWidths, rows);
+    bigBuf.writeString('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>');
+    bigBuf.writeString('<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">');
+    const totalRows = rows.length + (headers ? 1 : 0);
+    if (totalRows > 0 && columnCount > 0) {
+      bigBuf.writeString(`<dimension ref="A1:${colLetters[columnCount - 1]}${totalRows}"/>`);
+    } else {
+      bigBuf.writeString('<dimension ref="A1"/>');
+    }
+    const isFirstSheet = this.sheetCount === 1;
+    if (headers) {
+      if (isFirstSheet) {
+        bigBuf.writeString('<sheetViews><sheetView tabSelected="1" workbookViewId="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen" /><selection pane="bottomLeft" /></sheetView></sheetViews><sheetFormatPr defaultRowHeight="15"/>');
+      } else {
+        bigBuf.writeString('<sheetViews><sheetView workbookViewId="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen" /><selection pane="bottomLeft" /></sheetView></sheetViews><sheetFormatPr defaultRowHeight="15"/>');
+      }
+    } else {
+      if (isFirstSheet) {
+        bigBuf.writeString('<sheetViews><sheetView tabSelected="1" workbookViewId="0"/></sheetViews><sheetFormatPr defaultRowHeight="15"/>');
+      } else {
+        bigBuf.writeString('<sheetViews><sheetView workbookViewId="0"/></sheetViews><sheetFormatPr defaultRowHeight="15"/>');
+      }
+    }
+    bigBuf.writeString("<cols>");
+    for (let i = 0; i < columnCount; i++) {
+      const width = defaultColWidth(colWidths[i]);
+      bigBuf.writeString(`<col min="${i + 1}" max="${i + 1}" width="${width}" bestFit="1" customWidth="1" />`);
+    }
+    bigBuf.writeString("</cols><sheetData>");
+    let rowNum = 0;
+    if (headers) {
+      rowNum++;
+      bigBuf.writeString(`<row r="${rowNum}">`);
+      for (let c = 0; c < headers.length; c++) {
+        this._writeStringCell(bigBuf, headers[c], colLetters[c], rowNum, 3);
+      }
+      bigBuf.writeString("</row>");
+    }
+    for (let r = 0; r < rows.length; r++) {
+      rowNum++;
+      bigBuf.writeString(`<row r="${rowNum}">`);
+      const row = rows[r];
+      for (let c = 0; c < row.length; c++) {
+        const raw = row[c];
+        if (raw === null || raw === void 0) continue;
+        const fmtString = getFormat(raw);
+        const val = fmtString !== null ? unwrapCell(raw) : raw;
+        const xfIdx = fmtString !== null ? this._registerFormat(fmtString) : -1;
+        const styleAttr = xfIdx >= 0 ? ` s="${xfIdx}"` : "";
+        const colRef = colLetters[c];
+        if (typeof val === "number") {
+          if (Number.isFinite(val)) {
+            bigBuf.writeString(`<c r="${colRef}${rowNum}"${styleAttr}><v>${val}</v></c>`);
+          } else {
+            this._writeStringCell(bigBuf, val.toString(), colRef, rowNum, xfIdx >= 0 ? xfIdx : void 0);
+          }
+        } else if (typeof val === "bigint") {
+          this._writeStringCell(bigBuf, val.toString(), colRef, rowNum, xfIdx >= 0 ? xfIdx : void 0);
+        } else if (typeof val === "boolean") {
+          bigBuf.writeString(`<c r="${colRef}${rowNum}" t="b"${styleAttr}><v>${val ? 1 : 0}</v></c>`);
+        } else if (val instanceof Date) {
+          const oaDate = this._toOADate(val);
+          if (Number.isFinite(oaDate)) {
+            const finalStyle = xfIdx >= 0 ? xfIdx : 1;
+            bigBuf.writeString(`<c r="${colRef}${rowNum}" s="${finalStyle}"><v>${oaDate}</v></c>`);
+          } else {
+            this._writeStringCell(bigBuf, val.toString(), colRef, rowNum, xfIdx >= 0 ? xfIdx : void 0);
+          }
+        } else if (val !== null && val !== void 0) {
+          this._writeStringCell(bigBuf, val.toString(), colRef, rowNum, xfIdx >= 0 ? xfIdx : void 0);
+        }
+      }
+      bigBuf.writeString("</row>");
+    }
+    bigBuf.writeString("</sheetData>");
+    if (doAutofilter && headers && columnCount > 0) {
+      this._autofilterIsOn = true;
+      const filterRef = `A1:${colLetters[columnCount - 1]}${totalRows}`;
+      bigBuf.writeString(`<autoFilter ref="${filterRef}"/>`);
+      const sheet = this.sheetList[this.sheetCount - 1];
+      const formulaSheetName = this._formatSheetNameForFormula(sheet.name);
+      sheet.filterHeaderRange = `${formulaSheetName}!$A$1:$${colLetters[columnCount - 1]}$${totalRows}`;
+    }
+    bigBuf.writeString("</worksheet>");
+    this.archive.append(import_stream2.Readable.from(bigBuf.getChunks()), {
+      name: this.sheetList[this.sheetCount - 1].pathInArchive
+    });
+  }
+  _writeStringCell(bigBuf, val, colRef, rowNum, styleOverride) {
+    let index = this.sstMap.get(val);
+    if (index === void 0) {
+      index = this.sstArray.length;
+      this.sstArray.push(val);
+      this.sstMap.set(val, index);
+    }
+    this.sstCntAll++;
+    const styleAttr = styleOverride !== void 0 ? ` s="${styleOverride}"` : "";
+    bigBuf.writeString(`<c r="${colRef}${rowNum}" t="s"${styleAttr}><v>${index}</v></c>`);
+  }
+  _registerFormat(fmtString) {
+    if (this._formatXfMap.has(fmtString)) {
+      return this._formatXfMap.get(fmtString);
+    }
+    const numfmtId = this._nextNumfmtId++;
+    this._formatRegistry.set(fmtString, numfmtId);
+    const xfIndex = this._nextXfIndex++;
+    this._formatXfMap.set(fmtString, xfIndex);
+    return xfIndex;
+  }
+  _toOADate(date) {
+    return (date.getTime() - this._oaEpoch) / 864e5;
+  }
+  _getDateWidth(_date) {
+    return 19;
+  }
+  /** Finalize the ZIP package and close the output stream. */
+  finalize() {
+    return new Promise((resolve, reject) => {
+      try {
+        this._writeSharedStrings();
+        this._writeStyles();
+        this._writeWorkbook();
+        this._writeContentTypes();
+        this._writeRels();
+        this.output.on("close", () => {
+          resolve();
+        });
+        this.archive.on("error", (err) => {
+          reject(err);
+        });
+        this.archive.finalize();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  _writeSharedStrings() {
+    const bigBuf = new BigBuffer();
+    bigBuf.writeString('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>');
+    bigBuf.writeString(`<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="${this.sstCntAll}" uniqueCount="${this.sstArray.length}">`);
+    for (let i = 0; i < this.sstArray.length; i++) {
+      const txt = this.sstArray[i];
+      const cleanTxt = this._escape(txt);
+      if (cleanTxt.length > 0 && (cleanTxt[0] === " " || cleanTxt[cleanTxt.length - 1] === " " || /[\t\n\r]/.test(cleanTxt))) {
+        bigBuf.writeString(`<si><t xml:space="preserve">${cleanTxt}</t></si>`);
+      } else {
+        bigBuf.writeString(`<si><t>${cleanTxt}</t></si>`);
+      }
+    }
+    bigBuf.writeString("</sst>");
+    this.archive.append(import_stream2.Readable.from(bigBuf.getChunks()), { name: "xl/sharedStrings.xml" });
+  }
+  _writeStyles() {
+    let numFmts = "";
+    let numFmtCount = 0;
+    const xfEntries = [];
+    xfEntries.push('<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>');
+    xfEntries.push('<xf numFmtId="14" fontId="0" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/>');
+    xfEntries.push('<xf numFmtId="22" fontId="0" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/>');
+    xfEntries.push('<xf numFmtId="0" fontId="1" fillId="0" borderId="0" xfId="0" applyFont="1"/>');
+    for (const [fmtString, numfmtId] of this._formatRegistry) {
+      const escapedFmt = fmtString.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+      numFmts += `<numFmt numFmtId="${numfmtId}" formatCode="${escapedFmt}"/>`;
+      numFmtCount++;
+    }
+    const sortedFormats = [...this._formatXfMap.entries()].sort((a, b) => a[1] - b[1]);
+    for (const [fmtString] of sortedFormats) {
+      const numfmtId = this._formatRegistry.get(fmtString);
+      xfEntries.push(`<xf numFmtId="${numfmtId}" fontId="0" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/>`);
+    }
+    const totalXf = xfEntries.length;
+    const numFmtsSection = numFmtCount > 0 ? `<numFmts count="${numFmtCount}">${numFmts}</numFmts>` : "";
+    const styles = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+${numFmtsSection}
+<fonts count="2">
+<font><sz val="11"/><color theme="1"/><name val="Calibri"/><family val="2"/><scheme val="minor"/></font>
+<font><b/><sz val="11"/><color theme="1"/><name val="Calibri"/><family val="2"/><scheme val="minor"/></font>
+</fonts>
+<fills count="2">
+<fill><patternFill patternType="none"/></fill>
+<fill><patternFill patternType="gray125"/></fill>
+</fills>
+<borders count="1">
+<border><left/><right/><top/><bottom/><diagonal/></border>
+</borders>
+<cellStyleXfs count="1">
+<xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>
+</cellStyleXfs>
+<cellXfs count="${totalXf}">
+${xfEntries.join("\n")}
+</cellXfs>
+<cellStyles count="1">
+<cellStyle name="Normal" xfId="0" builtinId="0"/>
+</cellStyles>
+<dxfs count="0"/>
+<tableStyles count="0" defaultTableStyle="TableStyleMedium2" defaultPivotStyle="PivotStyleLight16"/>
+</styleSheet>`;
+    this.archive.append(styles, { name: "xl/styles.xml" });
+  }
+  _writeWorkbook() {
+    let xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+<fileVersion appName="xl" lastEdited="4" lowestEdited="4" rupBuild="4505"/>
+<workbookPr defaultThemeVersion="124226"/>
+<bookViews><workbookView xWindow="240" yWindow="15" windowWidth="16095" windowHeight="9660"/></bookViews>
+<sheets>`;
+    for (const sheet of this.sheetList) {
+      const state = sheet.hidden ? ' state="hidden"' : "";
+      const escapedName = this._escapeSheetNameForXml(sheet.name);
+      xml += `<sheet name="${escapedName}" sheetId="${sheet.sheetId}"${state} r:id="${sheet.rId}"/>`;
+    }
+    xml += `</sheets>`;
+    if (this._autofilterIsOn) {
+      xml += "<definedNames>";
+      for (const sheet of this.sheetList) {
+        if (sheet.filterHeaderRange) {
+          const localSheetId = sheet.sheetId - 1;
+          const escapedRange = this._escape(sheet.filterHeaderRange);
+          xml += `<definedName name="_xlnm._FilterDatabase" localSheetId="${localSheetId}" hidden="1">${escapedRange}</definedName>`;
+        }
+      }
+      xml += "</definedNames>";
+    }
+    xml += '<calcPr calcId="124519" fullCalcOnLoad="1"/>';
+    xml += `</workbook>`;
+    this.archive.append(xml, { name: "xl/workbook.xml" });
+  }
+  _writeContentTypes() {
+    let xml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+<Default Extension="xml" ContentType="application/xml"/>
+<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>
+<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>`;
+    for (const sheet of this.sheetList) {
+      xml += `<Override PartName="/${sheet.pathInArchive}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`;
+    }
+    xml += `</Types>`;
+    this.archive.append(xml, { name: "[Content_Types].xml" });
+  }
+  _writeRels() {
+    const globalRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+</Relationships>`;
+    this.archive.append(globalRels, { name: "_rels/.rels" });
+    let wbRels = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`;
+    for (const sheet of this.sheetList) {
+      wbRels += `<Relationship Id="${sheet.rId}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/${sheet.nameInArchive}"/>`;
+    }
+    let nextId = this.sheetList.length + 1;
+    wbRels += `<Relationship Id="rId${nextId++}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`;
+    wbRels += `<Relationship Id="rId${nextId++}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`;
+    wbRels += `</Relationships>`;
+    this.archive.append(wbRels, { name: "xl/_rels/workbook.xml.rels" });
+  }
+};
+
+// src/XlsxUpdater.ts
+var fs3 = __toESM(require("fs"));
+var import_adm_zip2 = __toESM(require("adm-zip"));
+var XlsxUpdater = class {
+  /**
+   * @param path Path to an existing `.xlsx` file.
+   */
+  constructor(path2) {
+    this.sheetNameToPath = /* @__PURE__ */ new Map();
+    this.pivotCacheDefs = [];
+    this.pivotTableDefPaths = [];
+    this.sharedStringsXml = null;
+    this.sharedStringsValues = [];
+    this.sharedStringsOriginalLength = 0;
+    this.sharedStringsCount = 0;
+    this.stringIndexMap = /* @__PURE__ */ new Map();
+    this.sourcePath = path2;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    if (!fs3.existsSync(path2)) {
+      throw new Error(`XlsxUpdater: file not found: ${path2}`);
+    }
+    this.zip = new import_adm_zip2.default(path2);
+    if (this.zip.getEntry("xl/workbook.bin")) {
+      throw new Error(
+        "XlsxUpdater: XLSB files are not supported yet. Convert the workbook to XLSX first."
+      );
+    }
+    if (!this.zip.getEntry("xl/workbook.xml")) {
+      throw new Error("XlsxUpdater: not a valid XLSX workbook (xl/workbook.xml missing).");
+    }
+    this._loadWorkbookStructure();
+  }
+  /** Worksheet names in workbook order. */
+  getSheetNames() {
+    return [...this.sheetNameToPath.keys()];
+  }
+  /**
+   * Clear the entire cell data of the target sheet and write new rows in its place.
+   * All other parts of the workbook (pivot tables, other sheets, styles, …) are preserved.
+   *
+   * @param sheetName Name of the worksheet to replace.
+   * @param rows New data rows (`CellValue` cells; null/undefined = blank).
+   * @param options See {@link ReplaceSheetDataOptions}.
+   */
+  replaceSheetData(sheetName, rows, options = {}) {
+    const { headers, styleFallback = "inherit" } = options;
+    rows = trimTrailingEmptyRows(rows);
+    const sheetPath = this.sheetNameToPath.get(sheetName);
+    if (!sheetPath) {
+      throw new Error(`XlsxUpdater: sheet "${sheetName}" not found in the workbook.`);
+    }
+    const entry = this.zip.getEntry(sheetPath);
+    if (!entry) {
+      throw new Error(`XlsxUpdater: worksheet part missing for sheet "${sheetName}".`);
+    }
+    const sheetXml = entry.getData().toString("utf8");
+    this._ensureSharedStringsLoaded();
+    let colStyles = /* @__PURE__ */ new Map();
+    let headerStyles = /* @__PURE__ */ new Map();
+    let dateStyle = null;
+    if (styleFallback !== "general") {
+      const collected = this._collectExistingStyles(sheetXml);
+      colStyles = collected.dataStyles;
+      headerStyles = collected.headerStyles;
+      dateStyle = this._findDateStyleIndex();
+    }
+    const lastCol = Math.max(rows.reduce((m, r) => Math.max(m, r.length), 0), (headers == null ? void 0 : headers.length) ?? 0) - 1;
+    const totalRows = rows.length + (headers ? 1 : 0);
+    const newSheetData = this._buildSheetData(rows, headers, colStyles, headerStyles, dateStyle);
+    const newXml = this._patchSheetXml(sheetXml, newSheetData, totalRows, lastCol);
+    this.zip.updateFile(sheetPath, Buffer.from(newXml, "utf8"));
+    if (this.sharedStringsXml !== null) {
+      this._commitSharedStrings();
+    }
+    const dimRef = totalRows > 0 && lastCol >= 0 ? `A1:${columnIndexToLetter(lastCol)}${totalRows}` : "A1";
+    this._updatePivotCaches(sheetName, dimRef, rows.length);
+    this._addRefreshOnLoadToPivotTables();
+  }
+  /**
+   * Write the updated workbook to disk.
+   * @param outputPath Destination path; defaults to the source file (overwrites in place).
+   */
+  save(outputPath) {
+    const target = outputPath ?? this.sourcePath;
+    fs3.writeFileSync(target, this.zip.toBuffer());
+  }
+  /** The updated workbook as an in-memory ZIP buffer. */
+  toBuffer() {
+    return this.zip.toBuffer();
+  }
+  // ------------------------------------------------------------------
+  // Workbook structure
+  // ------------------------------------------------------------------
+  _loadWorkbookStructure() {
+    const relsEntry = this.zip.getEntry("xl/_rels/workbook.xml.rels");
+    const rIdToTarget = {};
+    if (relsEntry) {
+      const rels = relsEntry.getData().toString("utf8");
+      const relRegex = /<Relationship[^>]*Id="([^"]*)"[^>]*Target="([^"]*)"/g;
+      let match2;
+      while ((match2 = relRegex.exec(rels)) !== null) {
+        rIdToTarget[match2[1]] = match2[2];
+      }
+    }
+    const wbEntry = this.zip.getEntry("xl/workbook.xml");
+    const wbXml = wbEntry ? wbEntry.getData().toString("utf8") : "";
+    const sheetRe = /<sheet\b[^>]*>/g;
+    let match;
+    while ((match = sheetRe.exec(wbXml)) !== null) {
+      const tag = match[0];
+      const nameMatch = /name="([^"]*)"/.exec(tag);
+      const rIdMatch = /r:id="([^"]*)"/.exec(tag);
+      if (!nameMatch || !rIdMatch) continue;
+      const name = nameMatch[1].replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+      const target = rIdToTarget[rIdMatch[1]] ?? "";
+      let fullPath = target;
+      if (fullPath.startsWith("/")) {
+        fullPath = fullPath.substring(1);
+      } else if (!fullPath.startsWith("xl/")) {
+        fullPath = "xl/" + fullPath;
+      }
+      if (fullPath) {
+        this.sheetNameToPath.set(name, fullPath);
+      }
+    }
+    for (const entry of this.zip.getEntries()) {
+      const name = entry.entryName;
+      if (/^xl\/pivotCache\/pivotCacheDefinition\d*\.xml$/.test(name)) {
+        this.pivotCacheDefs.push({ path: name, xml: entry.getData().toString("utf8") });
+      } else if (/^xl\/pivotTables\/pivotTable\d*\.xml$/.test(name)) {
+        this.pivotTableDefPaths.push(name);
+      }
+    }
+  }
+  // ------------------------------------------------------------------
+  // Shared strings
+  // ------------------------------------------------------------------
+  _ensureSharedStringsLoaded() {
+    if (this.stringIndexMap.size > 0 || this.sharedStringsXml !== null) {
+      return;
+    }
+    const entry = this.zip.getEntry("xl/sharedStrings.xml");
+    if (!entry) {
+      this.sharedStringsXml = null;
+      return;
+    }
+    this.sharedStringsXml = entry.getData().toString("utf8");
+    this.sharedStringsValues = parseSharedStringsXml(this.sharedStringsXml);
+    const countMatch = /<sst\b[^>]*>/.exec(this.sharedStringsXml);
+    const countAttr = countMatch ? /count="(\d+)"/.exec(countMatch[0]) : null;
+    this.sharedStringsCount = countAttr ? parseInt(countAttr[1], 10) : 0;
+    this.sharedStringsValues.forEach((value, index) => {
+      if (!this.stringIndexMap.has(value)) {
+        this.stringIndexMap.set(value, index);
+      }
+    });
+    this.sharedStringsOriginalLength = this.sharedStringsValues.length;
+  }
+  _commitSharedStrings() {
+    if (this.sharedStringsXml === null || this.sharedStringsValues.length === this.sharedStringsOriginalLength) {
+      return;
+    }
+    let xml = this.sharedStringsXml;
+    const sstStart = xml.indexOf("<sst");
+    const sstTagEnd = xml.indexOf(">", sstStart);
+    if (sstStart !== -1 && sstTagEnd !== -1) {
+      const tag = xml.substring(sstStart, sstTagEnd + 1);
+      const newTag = tag.replace(/count="\d+"/, `count="${this.sharedStringsCount}"`).replace(/uniqueCount="\d+"/, `uniqueCount="${this.sharedStringsValues.length}"`);
+      xml = xml.substring(0, sstStart) + newTag + xml.substring(sstTagEnd + 1);
+    }
+    const sstEnd = xml.lastIndexOf("</sst>");
+    if (sstEnd === -1) {
+      return;
+    }
+    let appended = "";
+    for (let i = this.sharedStringsOriginalLength; i < this.sharedStringsValues.length; i++) {
+      const txt = this.sharedStringsValues[i];
+      const clean = escapeXmlText(txt);
+      const preserve = clean.length > 0 && (clean[0] === " " || clean[clean.length - 1] === " " || /[\t\n\r]/.test(clean));
+      appended += preserve ? `<si><t xml:space="preserve">${clean}</t></si>` : `<si><t>${clean}</t></si>`;
+    }
+    xml = xml.substring(0, sstEnd) + appended + xml.substring(sstEnd);
+    this.zip.updateFile("xl/sharedStrings.xml", Buffer.from(xml, "utf8"));
+  }
+  // ------------------------------------------------------------------
+  // Styles
+  // ------------------------------------------------------------------
+  _collectExistingStyles(sheetXml) {
+    const dataCounts = /* @__PURE__ */ new Map();
+    const headerStyles = /* @__PURE__ */ new Map();
+    const sdStart = sheetXml.indexOf("<sheetData>");
+    if (sdStart === -1) return { dataStyles: /* @__PURE__ */ new Map(), headerStyles };
+    const sdEnd = sheetXml.indexOf("</sheetData>", sdStart);
+    if (sdEnd === -1) return { dataStyles: /* @__PURE__ */ new Map(), headerStyles };
+    const region = sheetXml.substring(sdStart, sdEnd);
+    const cellRe = /<c\b[^>]*>/g;
+    let m;
+    while ((m = cellRe.exec(region)) !== null) {
+      const tag = m[0];
+      const rMatch = /r="([A-Z]+)(\d+)"/.exec(tag);
+      if (!rMatch) continue;
+      const col = columnLetterToIndex(rMatch[1]);
+      const row = parseInt(rMatch[2], 10);
+      const sMatch = /s="(\d+)"/.exec(tag);
+      if (!sMatch) continue;
+      const s = parseInt(sMatch[1], 10);
+      if (s <= 0) continue;
+      if (row === 1) {
+        if (!headerStyles.has(col)) headerStyles.set(col, s);
+        continue;
+      }
+      let colCounts = dataCounts.get(col);
+      if (!colCounts) {
+        colCounts = /* @__PURE__ */ new Map();
+        dataCounts.set(col, colCounts);
+      }
+      colCounts.set(s, (colCounts.get(s) ?? 0) + 1);
+    }
+    const dataStyles = /* @__PURE__ */ new Map();
+    for (const [col, colCounts] of dataCounts) {
+      let best = 0;
+      let bestCount = -1;
+      for (const [s, count] of colCounts) {
+        if (count > bestCount) {
+          best = s;
+          bestCount = count;
+        }
+      }
+      if (bestCount > 0) dataStyles.set(col, best);
+    }
+    return { dataStyles, headerStyles };
+  }
+  _findDateStyleIndex() {
+    const entry = this.zip.getEntry("xl/styles.xml");
+    if (!entry) return null;
+    const xml = entry.getData().toString("utf8");
+    const customDateFormats = /* @__PURE__ */ new Set();
+    const numFmtRe = /<numFmt\s+[^>]*numFmtId="(\d+)"[^>]*formatCode="([^"]*)"/g;
+    let m;
+    while ((m = numFmtRe.exec(xml)) !== null) {
+      const id = parseInt(m[1], 10);
+      const code = m[2].toLowerCase();
+      if (code.includes("yy") || code.includes("mm") || code.includes("dd") || code.includes("h:mm")) {
+        customDateFormats.add(id);
+      }
+    }
+    const cellXfsStart = xml.indexOf("<cellXfs");
+    if (cellXfsStart === -1) return null;
+    const cellXfsEnd = xml.indexOf("</cellXfs>", cellXfsStart);
+    if (cellXfsEnd === -1) return null;
+    const cellXfsContent = xml.substring(cellXfsStart, cellXfsEnd);
+    const xfRe = /<xf\b[^>]*>/g;
+    let index = 0;
+    while ((m = xfRe.exec(cellXfsContent)) !== null) {
+      const nfMatch = /numFmtId="(\d+)"/.exec(m[0]);
+      const nfId = nfMatch ? parseInt(nfMatch[1], 10) : 0;
+      const isDate = nfId >= 14 && nfId <= 22 || nfId >= 45 && nfId <= 47 || customDateFormats.has(nfId);
+      if (isDate) return index;
+      index++;
+    }
+    return null;
+  }
+  // ------------------------------------------------------------------
+  // Cell / row serialization
+  // ------------------------------------------------------------------
+  _buildSheetData(rows, headers, colStyles, headerStyles, dateStyle) {
+    let out = "";
+    let rowNum = 0;
+    if (headers) {
+      rowNum = 1;
+      out += '<row r="1">';
+      for (let c = 0; c < headers.length; c++) {
+        const style = headerStyles.get(c) ?? 0;
+        out += this._stringCell(headers[c], c, rowNum, style);
+      }
+      out += "</row>";
+    }
+    for (const row of rows) {
+      rowNum++;
+      out += `<row r="${rowNum}">`;
+      for (let c = 0; c < row.length; c++) {
+        const raw = row[c];
+        if (raw === null || raw === void 0) continue;
+        out += this._valueCell(raw, c, rowNum, colStyles, dateStyle);
+      }
+      out += "</row>";
+    }
+    return out;
+  }
+  _valueCell(raw, col, rowNum, colStyles, dateStyle) {
+    const colRef = columnIndexToLetter(col);
+    const fmtString = getFormat(raw);
+    const val = fmtString !== null ? unwrapCell(raw) : raw;
+    const colStyle = colStyles.get(col) ?? 0;
+    if (typeof val === "number") {
+      if (Number.isFinite(val)) {
+        return `<c r="${colRef}${rowNum}"${colStyle > 0 ? ` s="${colStyle}"` : ""}><v>${val}</v></c>`;
+      }
+      return this._stringCell(val.toString(), col, rowNum, colStyle);
+    }
+    if (typeof val === "bigint") {
+      return this._stringCell(val.toString(), col, rowNum, colStyle);
+    }
+    if (typeof val === "boolean") {
+      return `<c r="${colRef}${rowNum}" t="b"${colStyle > 0 ? ` s="${colStyle}"` : ""}><v>${val ? 1 : 0}</v></c>`;
+    }
+    if (val instanceof Date) {
+      const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+      if (Number.isFinite(oaDate)) {
+        const style = colStyle > 0 ? colStyle : dateStyle !== null ? dateStyle : 0;
+        return `<c r="${colRef}${rowNum}"${style > 0 ? ` s="${style}"` : ""}><v>${oaDate}</v></c>`;
+      }
+      return this._stringCell(val.toString(), col, rowNum, colStyle);
+    }
+    if (val !== null && val !== void 0) {
+      return this._stringCell(String(val), col, rowNum, colStyle);
+    }
+    return "";
+  }
+  _stringCell(text, col, rowNum, style) {
+    const colRef = columnIndexToLetter(col);
+    const styleAttr = style > 0 ? ` s="${style}"` : "";
+    if (this.sharedStringsXml === null) {
+      const clean = escapeXmlText(text);
+      const preserve = clean.length > 0 && (clean[0] === " " || clean[clean.length - 1] === " " || /[\t\n\r]/.test(clean));
+      const tAttr = preserve ? ' xml:space="preserve"' : "";
+      return `<c r="${colRef}${rowNum}" t="inlineStr"${styleAttr}><is><t${tAttr}>${clean}</t></is></c>`;
+    }
+    let index = this.stringIndexMap.get(text);
+    if (index === void 0) {
+      index = this.sharedStringsValues.length;
+      this.sharedStringsValues.push(text);
+      this.stringIndexMap.set(text, index);
+    }
+    this.sharedStringsCount++;
+    return `<c r="${colRef}${rowNum}" t="s"${styleAttr}><v>${index}</v></c>`;
+  }
+  // ------------------------------------------------------------------
+  // Worksheet XML patching
+  // ------------------------------------------------------------------
+  _patchSheetXml(sheetXml, newSheetData, totalRows, lastCol) {
+    let xml = sheetXml;
+    const dimRef = totalRows > 0 && lastCol >= 0 ? `A1:${columnIndexToLetter(lastCol)}${totalRows}` : "A1";
+    const dimRe = /<dimension\b[^>]*>/;
+    const dimMatch = dimRe.exec(xml);
+    if (dimMatch) {
+      xml = xml.substring(0, dimMatch.index) + dimMatch[0].replace(/ref="[^"]*"/, `ref="${dimRef}"`) + xml.substring(dimMatch.index + dimMatch[0].length);
+    } else {
+      const rootRe = /<worksheet\b[^>]*>/;
+      const rootMatch = rootRe.exec(xml);
+      if (rootMatch) {
+        const insertAt = rootMatch.index + rootMatch[0].length;
+        xml = xml.substring(0, insertAt) + `<dimension ref="${dimRef}"/>` + xml.substring(insertAt);
+      }
+    }
+    const sdOpen = "<sheetData>";
+    const sdStart = xml.indexOf(sdOpen);
+    if (sdStart === -1) {
+      const selfClosing = /<sheetData\s*\/\s*>/;
+      const scMatch = selfClosing.exec(xml);
+      if (scMatch) {
+        xml = xml.substring(0, scMatch.index) + "<sheetData>" + newSheetData + "</sheetData>" + xml.substring(scMatch.index + scMatch[0].length);
+        return xml;
+      }
+      throw new Error("XlsxUpdater: <sheetData> element not found in worksheet XML.");
+    }
+    const sdEnd = xml.indexOf("</sheetData>", sdStart);
+    if (sdEnd === -1) {
+      throw new Error("XlsxUpdater: <sheetData> element not closed in worksheet XML.");
+    }
+    xml = xml.substring(0, sdStart + sdOpen.length) + newSheetData + xml.substring(sdEnd);
+    const afRe = /<autoFilter\b[^>]*>/;
+    const afMatch = afRe.exec(xml);
+    if (afMatch && totalRows > 0 && lastCol >= 0 && afMatch[0].includes("ref=")) {
+      xml = xml.substring(0, afMatch.index) + afMatch[0].replace(/ref="[^"]*"/, `ref="${dimRef}"`) + xml.substring(afMatch.index + afMatch[0].length);
+    }
+    return xml;
+  }
+  // ------------------------------------------------------------------
+  // Pivot table integration
+  // ------------------------------------------------------------------
+  _updatePivotCaches(sheetName, dimRef, recordCount) {
+    for (const cache of this.pivotCacheDefs) {
+      const wsRe = /<worksheetSource\b[^>]*>/;
+      const wsMatch = wsRe.exec(cache.xml);
+      if (!wsMatch) continue;
+      const wsTag = wsMatch[0];
+      const sheetAttr = /sheet="([^"]*)"/.exec(wsTag);
+      if (!sheetAttr || sheetAttr[1] !== sheetName) continue;
+      let xml = cache.xml;
+      xml = xml.substring(0, wsMatch.index) + wsTag.replace(/ref="[^"]*"/, `ref="${dimRef}"`) + xml.substring(wsMatch.index + wsTag.length);
+      const rootRe = /<pivotCacheDefinition\b[^>]*>/;
+      const rootMatch = rootRe.exec(xml);
+      if (rootMatch) {
+        let rootTag = rootMatch[0];
+        if (/recordCount="\d+"/.test(rootTag)) {
+          rootTag = rootTag.replace(/recordCount="\d+"/, `recordCount="${recordCount}"`);
+        } else if (!/\/>$/.test(rootTag)) {
+          rootTag = rootTag.replace(/>$/, ` recordCount="${recordCount}">`);
+        }
+        xml = xml.substring(0, rootMatch.index) + rootTag + xml.substring(rootMatch.index + rootMatch[0].length);
+      }
+      this.zip.updateFile(cache.path, Buffer.from(xml, "utf8"));
+    }
+  }
+  _addRefreshOnLoadToPivotTables() {
+    for (const path2 of this.pivotTableDefPaths) {
+      const entry = this.zip.getEntry(path2);
+      if (!entry) continue;
+      let xml = entry.getData().toString("utf8");
+      const rootRe = /<pivotTableDefinition\b[^>]*>/;
+      const rootMatch = rootRe.exec(xml);
+      if (!rootMatch || rootMatch[0].includes("refreshOnLoad")) continue;
+      const newTag = rootMatch[0].replace(/(\/?>)$/, ' refreshOnLoad="1"$1');
+      xml = xml.substring(0, rootMatch.index) + newTag + xml.substring(rootMatch.index + rootMatch[0].length);
+      this.zip.updateFile(path2, Buffer.from(xml, "utf8"));
+    }
+  }
+};
+
+// src/XlsbUpdater.ts
+var fs4 = __toESM(require("fs"));
+var import_adm_zip3 = __toESM(require("adm-zip"));
+
+// src/biff12Utils.ts
+function readVlq(buf, pos) {
+  let value = 0;
+  let shift = 0;
+  let byte;
+  do {
+    byte = buf[pos++];
+    value |= (byte & 127) << shift;
+    shift += 7;
+  } while ((byte & 128) !== 0);
+  return { value, nextPos: pos };
+}
+function vlqBytes(value) {
+  const out = [];
+  while (value >= 128) {
+    out.push(value & 127 | 128);
+    value >>>= 7;
+  }
+  out.push(value & 127);
+  return out;
+}
+function readRecord(buf, pos, rec) {
+  const idRes = readVlq(buf, pos);
+  if (idRes.nextPos > buf.length) return false;
+  const lenRes = readVlq(buf, idRes.nextPos);
+  if (lenRes.nextPos + lenRes.value > buf.length) return false;
+  rec.headerStart = pos;
+  rec.dataStart = lenRes.nextPos;
+  rec.dataEnd = lenRes.nextPos + lenRes.value;
+  rec.id = idRes.value;
+  rec.len = lenRes.value;
+  return true;
+}
+function buildRecord(id, payload) {
+  const idBytes = vlqBytes(id);
+  const lenBytes = vlqBytes(payload.length);
+  const header = Buffer.alloc(idBytes.length + lenBytes.length);
+  idBytes.forEach((b, i) => header[i] = b);
+  lenBytes.forEach((b, i) => header[idBytes.length + i] = b);
+  return Buffer.concat([header, payload]);
+}
+function readUtf16(buf, start, charCount) {
+  const end = start + charCount * 2;
+  if (end > buf.length) return "";
+  return buf.toString("utf16le", start, end);
+}
+function parseSharedStringsBin(buf) {
+  const values = [];
+  let total = 0;
+  let unique = 0;
+  let endSstOffset = buf.length;
+  const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+  let pos = 0;
+  while (readRecord(buf, pos, rec)) {
+    pos = rec.dataEnd;
+    if (rec.id === 159) {
+      total = buf.readUInt32LE(rec.dataStart);
+      unique = buf.readUInt32LE(rec.dataStart + 4);
+    } else if (rec.id === 19) {
+      const cch = buf.readUInt32LE(rec.dataStart + 1);
+      values.push(readUtf16(buf, rec.dataStart + 5, cch));
+    } else if (rec.id === 160) {
+      endSstOffset = rec.headerStart;
+    }
+  }
+  return { values, total, unique, endSstOffset };
+}
+
+// src/XlsbUpdater.ts
+var CELL_RECORDS = /* @__PURE__ */ new Set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
+var RK_INT_LOWER = -1 << 29;
+var RK_INT_UPPER = (1 << 29) - 1;
+var XlsbUpdater = class {
+  /**
+   * @param path Path to an existing `.xlsb` file.
+   */
+  constructor(path2) {
+    this.sheetNameToPath = /* @__PURE__ */ new Map();
+    this.pivotCacheDefPaths = [];
+    this.sharedStringsBuf = null;
+    this.sharedStringsValues = [];
+    this.sharedStringsTotal = 0;
+    this.sharedStringsUnique = 0;
+    this.sharedStringsEndSst = 0;
+    this.stringIndexMap = /* @__PURE__ */ new Map();
+    // ------------------------------------------------------------------
+    // Shared strings
+    // ------------------------------------------------------------------
+    this._appendCount = 0;
+    this.sourcePath = path2;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    if (!fs4.existsSync(path2)) {
+      throw new Error(`XlsbUpdater: file not found: ${path2}`);
+    }
+    this.zip = new import_adm_zip3.default(path2);
+    if (!this.zip.getEntry("xl/workbook.bin")) {
+      throw new Error(
+        "XlsbUpdater: not an XLSB workbook (xl/workbook.bin missing). Convert the file to XLSB first."
+      );
+    }
+    this._loadWorkbookStructure();
+  }
+  /** Worksheet names in workbook order. */
+  getSheetNames() {
+    return [...this.sheetNameToPath.keys()];
+  }
+  /**
+   * Clear the entire cell data of the target sheet and write new rows in its place.
+   * All other parts of the workbook (pivot tables, other sheets, styles, …) are preserved.
+   *
+   * @param sheetName Name of the worksheet to replace.
+   * @param rows New data rows (`CellValue` cells; null/undefined = blank).
+   * @param options See {@link ReplaceSheetDataOptions}.
+   */
+  replaceSheetData(sheetName, rows, options = {}) {
+    const { headers, styleFallback = "inherit" } = options;
+    rows = trimTrailingEmptyRows(rows);
+    const sheetPath = this.sheetNameToPath.get(sheetName);
+    if (!sheetPath) {
+      throw new Error(`XlsbUpdater: sheet "${sheetName}" not found in the workbook.`);
+    }
+    const entry = this.zip.getEntry(sheetPath);
+    if (!entry) {
+      throw new Error(`XlsbUpdater: worksheet part missing for sheet "${sheetName}".`);
+    }
+    const sheetBuf = entry.getData();
+    this._ensureSharedStringsLoaded();
+    let dataStyles = /* @__PURE__ */ new Map();
+    let headerStyles = /* @__PURE__ */ new Map();
+    let dateXf = null;
+    if (styleFallback !== "general") {
+      const collected = this._collectStyles(sheetBuf);
+      dataStyles = collected.dataStyles;
+      headerStyles = collected.headerStyles;
+      dateXf = this._findDateXf();
+    }
+    const lastCol = Math.max(0, Math.max(
+      rows.reduce((m, r) => Math.max(m, r.length), 0),
+      (headers == null ? void 0 : headers.length) ?? 0
+    ) - 1);
+    const newRows = this._buildRows(rows, headers, dataStyles, headerStyles, dateXf);
+    const { rowsStart, rowsEnd, autoFilterRanges } = this._findRowsRegion(sheetBuf);
+    const newSheet = Buffer.alloc(sheetBuf.length - (rowsEnd - rowsStart) + newRows.length);
+    sheetBuf.copy(newSheet, 0, 0, rowsStart);
+    newRows.copy(newSheet, rowsStart);
+    sheetBuf.copy(newSheet, rowsStart + newRows.length, rowsEnd);
+    const lastRowIdx = rows.length + (headers ? 1 : 0) - 1;
+    const delta = newRows.length - (rowsEnd - rowsStart);
+    for (const af of autoFilterRanges) {
+      const newAf = af + delta;
+      newSheet.writeInt32LE(lastCol, newAf + 12);
+      newSheet.writeInt32LE(lastRowIdx, newAf + 4);
+    }
+    this._patchDimension(newSheet, lastRowIdx, lastCol);
+    this.zip.updateFile(sheetPath, newSheet);
+    if (this.sharedStringsBuf !== null && this._appendCount > 0) {
+      this._commitSharedStrings();
+    }
+    const rwLast = Math.max(0, rows.length + (headers ? 1 : 0) - 1);
+    const colLast = lastCol;
+    this._patchPivotCaches(sheetName, rwLast, colLast);
+  }
+  /**
+   * Write the updated workbook to disk.
+   * @param outputPath Destination path; defaults to the source file (overwrites in place).
+   */
+  save(outputPath) {
+    const target = outputPath ?? this.sourcePath;
+    fs4.writeFileSync(target, this.zip.toBuffer());
+  }
+  /** The updated workbook as an in-memory ZIP buffer. */
+  toBuffer() {
+    return this.zip.toBuffer();
+  }
+  // ------------------------------------------------------------------
+  // Workbook structure
+  // ------------------------------------------------------------------
+  _loadWorkbookStructure() {
+    const relsEntry = this.zip.getEntry("xl/_rels/workbook.bin.rels");
+    const rIdToTarget = {};
+    if (relsEntry) {
+      const rels = relsEntry.getData().toString("utf8");
+      const relRegex = /<Relationship[^>]*Id="([^"]*)"[^>]*Target="([^"]*)"/g;
+      let match;
+      while ((match = relRegex.exec(rels)) !== null) {
+        rIdToTarget[match[1]] = match[2];
+      }
+    }
+    const wbEntry = this.zip.getEntry("xl/workbook.bin");
+    if (wbEntry) {
+      const wbBuf = wbEntry.getData();
+      const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+      let pos = 0;
+      while (readRecord(wbBuf, pos, rec)) {
+        pos = rec.dataEnd;
+        if (rec.id !== 156 || rec.len < 8) continue;
+        let o = rec.dataStart + 8;
+        const rIdLen = wbBuf.readUInt32LE(o);
+        o += 4;
+        const rId = readUtf16(wbBuf, o, rIdLen);
+        o += rIdLen * 2;
+        const nameLen = wbBuf.readUInt32LE(o);
+        o += 4;
+        const name = readUtf16(wbBuf, o, nameLen);
+        let target = rIdToTarget[rId] ?? "";
+        if (target.startsWith("/")) target = target.substring(1);
+        else if (!target.startsWith("xl/")) target = "xl/" + target;
+        if (target) {
+          this.sheetNameToPath.set(name, target);
+        }
+      }
+    }
+    for (const e of this.zip.getEntries()) {
+      if (/^xl\/pivotCache\/pivotCacheDefinition\d*\.bin$/.test(e.entryName)) {
+        this.pivotCacheDefPaths.push(e.entryName);
+      }
+    }
+  }
+  _ensureSharedStringsLoaded() {
+    if (this.stringIndexMap.size > 0 || this.sharedStringsBuf !== null) {
+      return;
+    }
+    const entry = this.zip.getEntry("xl/sharedStrings.bin");
+    if (!entry) {
+      this.sharedStringsBuf = null;
+      return;
+    }
+    this.sharedStringsBuf = entry.getData();
+    const parsed = parseSharedStringsBin(this.sharedStringsBuf);
+    this.sharedStringsValues = parsed.values;
+    this.sharedStringsTotal = parsed.total;
+    this.sharedStringsUnique = parsed.unique;
+    this.sharedStringsEndSst = parsed.endSstOffset;
+    this.sharedStringsValues.forEach((value, index) => {
+      if (!this.stringIndexMap.has(value)) {
+        this.stringIndexMap.set(value, index);
+      }
+    });
+    this._appendCount = 0;
+  }
+  _commitSharedStrings() {
+    if (this.sharedStringsBuf === null || this._appendCount === 0) return;
+    const originalValuesLength = this.sharedStringsValues.length - this._appendCount;
+    let newItems = Buffer.alloc(0);
+    for (let i = originalValuesLength; i < this.sharedStringsValues.length; i++) {
+      const text = this.sharedStringsValues[i];
+      const payload = Buffer.alloc(1 + 4 + text.length * 2);
+      payload[0] = 0;
+      payload.writeUInt32LE(text.length, 1);
+      payload.write(text, 5, text.length * 2, "utf16le");
+      newItems = Buffer.concat([newItems, buildRecord(19, payload)]);
+    }
+    const out = Buffer.alloc(this.sharedStringsBuf.length + newItems.length);
+    this.sharedStringsBuf.copy(out, 0, 0, this.sharedStringsEndSst);
+    newItems.copy(out, this.sharedStringsEndSst);
+    this.sharedStringsBuf.copy(out, this.sharedStringsEndSst + newItems.length, this.sharedStringsEndSst);
+    const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+    let pos = 0;
+    while (readRecord(out, pos, rec)) {
+      if (rec.id === 159) {
+        out.writeUInt32LE(this.sharedStringsTotal, rec.dataStart);
+        out.writeUInt32LE(this.sharedStringsUnique, rec.dataStart + 4);
+        break;
+      }
+      pos = rec.dataEnd;
+    }
+    this.zip.updateFile("xl/sharedStrings.bin", out);
+  }
+  // ------------------------------------------------------------------
+  // Styles
+  // ------------------------------------------------------------------
+  _collectStyles(sheetBuf) {
+    const dataCounts = /* @__PURE__ */ new Map();
+    const headerStyles = /* @__PURE__ */ new Map();
+    const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+    let pos = 0;
+    let row = -1;
+    while (readRecord(sheetBuf, pos, rec)) {
+      pos = rec.dataEnd;
+      if (rec.id === 0) {
+        row = sheetBuf.readInt32LE(rec.dataStart);
+        continue;
+      }
+      if (!CELL_RECORDS.has(rec.id) || rec.len < 8) continue;
+      const col = sheetBuf.readUInt32LE(rec.dataStart);
+      const xf = sheetBuf.readUInt32LE(rec.dataStart + 4) & 16777215;
+      if (xf <= 0) continue;
+      if (row === 0) {
+        if (!headerStyles.has(col)) headerStyles.set(col, xf);
+        continue;
+      }
+      let colCounts = dataCounts.get(col);
+      if (!colCounts) {
+        colCounts = /* @__PURE__ */ new Map();
+        dataCounts.set(col, colCounts);
+      }
+      colCounts.set(xf, (colCounts.get(xf) ?? 0) + 1);
+    }
+    const dataStyles = /* @__PURE__ */ new Map();
+    for (const [col, colCounts] of dataCounts) {
+      let best = 0;
+      let bestCount = -1;
+      for (const [xf, count] of colCounts) {
+        if (count > bestCount) {
+          best = xf;
+          bestCount = count;
+        }
+      }
+      if (bestCount > 0) dataStyles.set(col, best);
+    }
+    return { dataStyles, headerStyles };
+  }
+  _findDateXf() {
+    const entry = this.zip.getEntry("xl/styles.bin");
+    if (!entry) return null;
+    const stylesBuf = entry.getData();
+    const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+    let pos = 0;
+    let inCellXfs = false;
+    let xfIndex = 0;
+    while (readRecord(stylesBuf, pos, rec)) {
+      pos = rec.dataEnd;
+      if (rec.id === 617) {
+        inCellXfs = true;
+        xfIndex = 0;
+        continue;
+      }
+      if (rec.id === 618) {
+        inCellXfs = false;
+        continue;
+      }
+      if (inCellXfs && rec.id === 47 && rec.len >= 4) {
+        const numFmtId = stylesBuf.readUInt16LE(rec.dataStart + 2);
+        const isDate = numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47;
+        if (isDate) return xfIndex;
+        xfIndex++;
+      }
+    }
+    return null;
+  }
+  // ------------------------------------------------------------------
+  // Row / cell serialization
+  // ------------------------------------------------------------------
+  _buildRows(rows, headers, dataStyles, headerStyles, dateXf) {
+    const chunks = [];
+    const maxCol = Math.max(rows.reduce((m, r) => Math.max(m, r.length), 0), (headers == null ? void 0 : headers.length) ?? 0, 0);
+    const colLast = Math.max(0, maxCol - 1);
+    const pushRow = (rowNum2, cellBytes) => {
+      const header = Buffer.alloc(27);
+      header[0] = 0;
+      header[1] = 25;
+      header.writeInt32LE(rowNum2, 2);
+      header[10] = 44;
+      header[11] = 1;
+      header[15] = 1;
+      header.writeInt32LE(0, 19);
+      header.writeInt32LE(colLast, 23);
+      chunks.push(header);
+      for (const cell of cellBytes) {
+        chunks.push(cell);
+      }
+    };
+    if (headers) {
+      const cells = [];
+      for (let c = 0; c < headers.length; c++) {
+        const style = headerStyles.get(c) ?? 0;
+        cells.push(this._stringCellBytes(c, style, headers[c]));
+      }
+      pushRow(0, cells);
+    }
+    let rowNum = headers ? 1 : 0;
+    for (const row of rows) {
+      const cells = [];
+      for (let c = 0; c < row.length; c++) {
+        const raw = row[c];
+        if (raw === null || raw === void 0) continue;
+        cells.push(this._valueCellBytes(raw, c, dataStyles, dateXf));
+      }
+      pushRow(rowNum, cells);
+      rowNum++;
+    }
+    return Buffer.concat(chunks);
+  }
+  _valueCellBytes(raw, col, dataStyles, dateXf) {
+    const fmtString = getFormat(raw);
+    const val = fmtString !== null ? unwrapCell(raw) : raw;
+    const colStyle = dataStyles.get(col) ?? 0;
+    if (typeof val === "number") {
+      if (Number.isFinite(val) && Number.isInteger(val) && val >= RK_INT_LOWER && val <= RK_INT_UPPER) {
+        const payload = Buffer.alloc(12);
+        payload.writeUInt32LE(col, 0);
+        payload.writeUInt32LE(colStyle, 4);
+        payload.writeInt32LE(val << 2 | 2, 8);
+        return buildRecord(2, payload);
+      }
+      if (Number.isFinite(val)) {
+        const payload = Buffer.alloc(16);
+        payload.writeUInt32LE(col, 0);
+        payload.writeUInt32LE(colStyle, 4);
+        payload.writeDoubleLE(val, 8);
+        return buildRecord(5, payload);
+      }
+      return this._stringCellBytes(col, colStyle, val.toString());
+    }
+    if (typeof val === "bigint") {
+      return this._stringCellBytes(col, colStyle, val.toString());
+    }
+    if (typeof val === "boolean") {
+      const payload = Buffer.alloc(9);
+      payload.writeUInt32LE(col, 0);
+      payload.writeUInt32LE(colStyle, 4);
+      payload[8] = val ? 1 : 0;
+      return buildRecord(4, payload);
+    }
+    if (val instanceof Date) {
+      const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+      if (Number.isFinite(oaDate)) {
+        const style = colStyle > 0 ? colStyle : dateXf !== null ? dateXf : 0;
+        const payload = Buffer.alloc(16);
+        payload.writeUInt32LE(col, 0);
+        payload.writeUInt32LE(style, 4);
+        payload.writeDoubleLE(oaDate, 8);
+        return buildRecord(5, payload);
+      }
+      return this._stringCellBytes(col, colStyle, val.toString());
+    }
+    if (val !== null && val !== void 0) {
+      return this._stringCellBytes(col, colStyle, String(val));
+    }
+    return this._stringCellBytes(col, colStyle, "");
+  }
+  _stringCellBytes(col, style, text) {
+    if (this.sharedStringsBuf === null) {
+      const payload2 = Buffer.alloc(12 + text.length * 2);
+      payload2.writeUInt32LE(col, 0);
+      payload2.writeUInt32LE(style, 4);
+      payload2.writeUInt32LE(text.length, 8);
+      payload2.write(text, 12, text.length * 2, "utf16le");
+      return buildRecord(6, payload2);
+    }
+    let index = this.stringIndexMap.get(text);
+    if (index === void 0) {
+      index = this.sharedStringsValues.length;
+      this.sharedStringsValues.push(text);
+      this.stringIndexMap.set(text, index);
+      this.sharedStringsUnique++;
+      this._appendCount++;
+    }
+    this.sharedStringsTotal++;
+    const payload = Buffer.alloc(12);
+    payload.writeUInt32LE(col, 0);
+    payload.writeUInt32LE(style, 4);
+    payload.writeUInt32LE(index, 8);
+    return buildRecord(7, payload);
+  }
+  // ------------------------------------------------------------------
+  // Rows region detection
+  // ------------------------------------------------------------------
+  _findRowsRegion(sheetBuf) {
+    const autoFilterRanges = [];
+    let rowsStart = -1;
+    let lastCellEnd = -1;
+    let lastW25 = -1;
+    const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+    let pos = 0;
+    while (readRecord(sheetBuf, pos, rec)) {
+      if (rec.id === 0) {
+        if (rowsStart === -1) rowsStart = rec.headerStart;
+      } else if (rec.id >= 1 && rec.id <= 11) {
+        lastCellEnd = rec.dataEnd;
+      } else if (rec.id === 37 && rec.len === 6) {
+        lastW25 = rec.headerStart;
+      } else if (rec.id === 161 && rec.len >= 16) {
+        autoFilterRanges.push(rec.dataStart);
+      }
+      pos = rec.dataEnd;
+    }
+    if (rowsStart === -1) {
+      const insertAt = lastW25 >= 0 ? lastW25 : sheetBuf.length;
+      return { rowsStart: insertAt, rowsEnd: insertAt, autoFilterRanges };
+    }
+    const rowsEnd = lastCellEnd >= 0 ? lastCellEnd : lastW25 >= 0 ? lastW25 : sheetBuf.length;
+    return { rowsStart, rowsEnd, autoFilterRanges };
+  }
+  /**
+   * Keep the sheet dimension record (0x98) in sync with the new data.
+   * Excel uses its rwLast (payload offset 24) and colLast (payload offset 32)
+   * fields to read the full row range; stale values make the last written row
+   * invisible to Excel (and drop it from pivot refreshes).
+   */
+  _patchDimension(sheetBuf, lastRowIdx, lastCol) {
+    const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+    let pos = 0;
+    while (readRecord(sheetBuf, pos, rec)) {
+      if (rec.id === 152 && rec.len >= 36) {
+        sheetBuf.writeInt32LE(lastRowIdx, rec.dataStart + 24);
+        sheetBuf.writeInt32LE(lastCol, rec.dataStart + 32);
+        return;
+      }
+      pos = rec.dataEnd;
+    }
+  }
+  // ------------------------------------------------------------------
+  // Pivot cache integration
+  // ------------------------------------------------------------------
+  _patchPivotCaches(sheetName, rwLast, colLast) {
+    for (const path2 of this.pivotCacheDefPaths) {
+      const entry = this.zip.getEntry(path2);
+      if (!entry) continue;
+      const buf = Buffer.from(entry.getData());
+      const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+      let pos = 0;
+      let patched = false;
+      let refreshXfPatched = false;
+      while (readRecord(buf, pos, rec)) {
+        pos = rec.dataEnd;
+        if (rec.id === 179 && rec.len >= 4 && !refreshXfPatched) {
+          if (rec.dataStart + 4 <= buf.length) {
+            const v = buf[rec.dataStart + 3];
+            if ((v & 4) === 0) {
+              buf[rec.dataStart + 3] = v | 4;
+              patched = true;
+            }
+          }
+          refreshXfPatched = true;
+        }
+        if (rec.id === 187 && rec.len >= 23) {
+          const cch = buf.readUInt32LE(rec.dataStart + 3);
+          const nameStart = rec.dataStart + 7;
+          const refStart = nameStart + cch * 2;
+          const name = readUtf16(buf, nameStart, cch);
+          if (name === sheetName && refStart + 16 <= buf.length) {
+            buf.writeInt32LE(rwLast, refStart + 4);
+            buf.writeInt32LE(colLast, refStart + 12);
+            patched = true;
+          }
+        }
+      }
+      if (patched) {
+        this.zip.updateFile(path2, buf);
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BiffReaderWriter,
+  BigBuffer,
+  ExcelReaderAbstract,
+  F,
+  INVALID_SHEET_NAME_CHARS,
+  ReaderFactory,
+  StreamingSheetState,
+  XlsbReader,
+  XlsbUpdater,
+  XlsbWriter,
+  XlsxReader,
+  XlsxUpdater,
+  XlsxWriter,
+  applyHeaderWidths,
+  defaultColWidth,
+  getFormat,
+  initColWidths,
+  isFormattedCell,
+  sanitizeSheetName,
+  unwrapCell,
+  updateColWidthsFromRows
+});
+//# sourceMappingURL=index.js.map