@justybase/spreadsheet-tasks 2.0.0 → 2.1.1

package/dist/esm/index.js

@@ -402,8 +402,8 @@ var XlsbReader = class extends ExcelReaderAbstract {
     this.xfIdToNumFmtId = [];
     this.customDateFormats = null;
   }
-  async open(path2, readSharedStrings = true) {
-    this.zip = new AdmZip(path2);
+  async open(path3, readSharedStrings = true) {
+    this.zip = new AdmZip(path3);
     const wbEntry = this.zip.getEntry("xl/workbook.bin");
     if (wbEntry) {
       const buf = wbEntry.getData();
@@ -448,8 +448,8 @@ var XlsbReader = class extends ExcelReaderAbstract {
     this.resultsCount = this.sheets.length;
     this._currentSheetIndex = -1;
   }
-  _readSharedStrings(path2) {
-    const entry = this.zip.getEntry(path2);
+  _readSharedStrings(path3) {
+    const entry = this.zip.getEntry(path3);
     if (!entry) return;
     const reader = new BiffReaderWriter(entry.getData());
     while (reader.readSharedStrings()) {
@@ -458,8 +458,8 @@ var XlsbReader = class extends ExcelReaderAbstract {
       }
     }
   }
-  _readStyles(path2) {
-    const entry = this.zip.getEntry(path2);
+  _readStyles(path3) {
+    const entry = this.zip.getEntry(path3);
     if (!entry) return;
     const reader = new BiffReaderWriter(entry.getData());
     while (reader.readStyles()) {
@@ -549,6 +549,93 @@ var XlsbReader = class extends ExcelReaderAbstract {
 
 // src/XlsxReader.ts
 import yauzl from "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();
@@ -564,9 +651,9 @@ var XlsxReader = class extends ExcelReaderAbstract {
     this.xfIdToNumFmtId = [];
     this.customDateFormats = /* @__PURE__ */ new Set();
   }
-  async open(path2, readSharedStrings = true) {
-    return new Promise((resolve, reject) => {
-      yauzl.open(path2, { lazyEntries: true, autoClose: false }, async (err, zipfile) => {
+  async open(path3, readSharedStrings = true) {
+    return new Promise((resolve2, reject) => {
+      yauzl.open(path3, { lazyEntries: true, autoClose: false }, async (err, zipfile) => {
         if (err) return reject(err);
         this.zipfile = zipfile;
         this.entries = /* @__PURE__ */ new Map();
@@ -590,7 +677,7 @@ var XlsxReader = class extends ExcelReaderAbstract {
               const sheetRegex = /<sheet[^>]*name="([^"]*)"[^>]*sheetId="([^"]*)"[^>]*r:id="([^"]*)"/g;
               let match;
               while ((match = sheetRegex.exec(wbContent)) !== null) {
-                const name = this._unescapeXml(match[1]);
+                const name = unescapeXml(match[1]);
                 const sheetId = match[2];
                 const rId = match[3];
                 const target = rIdToTarget[rId];
@@ -614,7 +701,7 @@ var XlsxReader = class extends ExcelReaderAbstract {
             }
             this.resultsCount = this.sheets.length;
             this._currentSheetIndex = -1;
-            resolve();
+            resolve2();
           } catch (e) {
             reject(e);
           }
@@ -628,48 +715,23 @@ var XlsxReader = class extends ExcelReaderAbstract {
       this.zipfile.close();
     }
   }
-  async _readZipEntryContent(path2) {
-    const entry = this.entries.get(path2);
+  async _readZipEntryContent(path3) {
+    const entry = this.entries.get(path3);
     if (!entry) return null;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, 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"));
+          resolve2(Buffer.concat(chunks).toString("utf8"));
         });
         readStream.on("error", reject);
       });
     });
   }
-  _unescapeXml(str) {
-    if (!str) return "";
-    if (str.indexOf("&") === -1) return str;
-    return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'");
-  }
   _parseSharedStrings(xml) {
-    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;
-      }
-      this.sharedStrings.push(this._unescapeXml(val));
-      pos = siEnd + 5;
-    }
+    this.sharedStrings = parseSharedStringsXml(xml);
   }
   _parseStyles(xml) {
     const numFmtRegex = /<numFmt\s+[^>]*numFmtId="(\d+)"[^>]*formatCode="([^"]*)"/g;
@@ -760,7 +822,7 @@ var XlsxReader = class extends ExcelReaderAbstract {
           if (key === "r") {
             let letterLen = 0;
             while (letterLen < val2.length && val2.charCodeAt(letterLen) >= 65) letterLen++;
-            colIndex = this._columnLetterToIndex(val2.substring(0, letterLen));
+            colIndex = columnLetterToIndex(val2.substring(0, letterLen));
           } else if (key === "t") {
             type = val2;
           } else if (key === "s") {
@@ -803,7 +865,7 @@ var XlsxReader = class extends ExcelReaderAbstract {
         } else if (type === "b") {
           finalVal = val === "1" || val === "true";
         } else if (type === "inlineStr") {
-          finalVal = this._unescapeXml(val);
+          finalVal = unescapeXml(val);
         } else if (type === "n" || type === "") {
           finalVal = parseFloat(val);
           if (styleIndex > 0 && this.xfIdToNumFmtId) {
@@ -827,14 +889,6 @@ var XlsxReader = class extends ExcelReaderAbstract {
       }
     }
   }
-  _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;
-  }
   getValue(i) {
     if (i < 0 || i >= this._currentRow.length) return null;
     return this._currentRow[i];
@@ -3276,7 +3330,7 @@ var XlsbWriter = class _XlsbWriter {
    * Must be awaited before the file is fully written.
    */
   finalize() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       try {
         this.saveSst();
         this.archive.append(this._buildStylesBin(), { name: "xl/styles.bin" });
@@ -3374,7 +3428,7 @@ var XlsbWriter = class _XlsbWriter {
 </Relationships>`;
           this.archive.append(wsRels, { name: `xl/worksheets/_rels/${sheet.nameInArchive}.rels` });
         }
-        this.output.on("close", () => resolve());
+        this.output.on("close", () => resolve2());
         this.archive.on("error", (err) => reject(err));
         this.archive.finalize();
       } catch (err) {
@@ -3722,7 +3776,7 @@ var XlsxWriter = class {
   }
   /** Finalize the ZIP package and close the output stream. */
   finalize() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       try {
         this._writeSharedStrings();
         this._writeStyles();
@@ -3730,7 +3784,7 @@ var XlsxWriter = class {
         this._writeContentTypes();
         this._writeRels();
         this.output.on("close", () => {
-          resolve();
+          resolve2();
         });
         this.archive.on("error", (err) => {
           reject(err);
@@ -3865,6 +3919,1219 @@ ${xfEntries.join("\n")}
     this.archive.append(wbRels, { name: "xl/_rels/workbook.xml.rels" });
   }
 };
+
+// src/XlsxUpdater.ts
+import * as fs3 from "fs";
+import AdmZip2 from "adm-zip";
+var XlsxUpdater = class {
+  /**
+   * @param path Path to an existing `.xlsx` file.
+   */
+  constructor(path3) {
+    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 = path3;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    if (!fs3.existsSync(path3)) {
+      throw new Error(`XlsxUpdater: file not found: ${path3}`);
+    }
+    this.zip = new AdmZip2(path3);
+    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 path3 of this.pivotTableDefPaths) {
+      const entry = this.zip.getEntry(path3);
+      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(path3, Buffer.from(xml, "utf8"));
+    }
+  }
+};
+
+// src/XlsbUpdater.ts
+import * as fs4 from "fs";
+import AdmZip3 from "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(path3) {
+    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 = path3;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    if (!fs4.existsSync(path3)) {
+      throw new Error(`XlsbUpdater: file not found: ${path3}`);
+    }
+    this.zip = new AdmZip3(path3);
+    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 path3 of this.pivotCacheDefPaths) {
+      const entry = this.zip.getEntry(path3);
+      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(path3, buf);
+      }
+    }
+  }
+};
+
+// src/ExcelConverter.ts
+import * as fs6 from "fs";
+import * as path2 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import { spawn } from "child_process";
+
+// src/atomicFile.ts
+import * as fs5 from "fs";
+import { randomUUID } from "crypto";
+var realFileOperations = {
+  exists: (filePath) => fs5.existsSync(filePath),
+  rename: (sourcePath, destinationPath) => fs5.renameSync(sourcePath, destinationPath),
+  remove: (filePath) => fs5.rmSync(filePath)
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function destinationExistsError(destinationPath) {
+  return new Error(
+    `Excel conversion: destination already exists (pass { overwrite: true } to replace it): ${destinationPath}`
+  );
+}
+function installTemporaryOutput(temporaryPath, destinationPath, overwrite, operations = realFileOperations) {
+  const backupPath = `${destinationPath}.${randomUUID()}.replacement-backup`;
+  let backupCreated = false;
+  let installed = false;
+  if (operations.exists(destinationPath)) {
+    if (!overwrite) {
+      throw destinationExistsError(destinationPath);
+    }
+    operations.rename(destinationPath, backupPath);
+    backupCreated = true;
+  }
+  try {
+    try {
+      operations.rename(temporaryPath, destinationPath);
+      installed = true;
+    } catch (error) {
+      if (overwrite && !backupCreated && operations.exists(destinationPath)) {
+        operations.rename(destinationPath, backupPath);
+        backupCreated = true;
+        operations.rename(temporaryPath, destinationPath);
+        installed = true;
+      } else {
+        throw error;
+      }
+    }
+    if (backupCreated) {
+      operations.remove(backupPath);
+    }
+  } catch (error) {
+    if (backupCreated && !installed) {
+      if (!operations.exists(destinationPath)) {
+        try {
+          operations.rename(backupPath, destinationPath);
+          backupCreated = false;
+        } catch (rollbackError) {
+          throw new Error(
+            `Excel conversion: final destination install failed (${errorMessage(error)}), and restoring the original destination also failed (${errorMessage(rollbackError)}). Original file remains at ${backupPath}.`
+          );
+        }
+      } else {
+        throw new Error(
+          `Excel conversion: final destination install failed (${errorMessage(error)}). A concurrent destination was preserved; the original file remains at ${backupPath}.`
+        );
+      }
+    }
+    throw error;
+  }
+}
+
+// src/ExcelConverter.ts
+var POWERSHELL_CONVERSION_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+$inputPath = [Environment]::GetEnvironmentVariable('JUSTYBASE_EXCEL_INPUT')
+$outputPath = [Environment]::GetEnvironmentVariable('JUSTYBASE_EXCEL_OUTPUT')
+$fileFormat = [int][Environment]::GetEnvironmentVariable('JUSTYBASE_EXCEL_FORMAT')
+$excel = $null
+$workbook = $null
+$exitCode = 0
+
+try {
+    $excel = New-Object -ComObject Excel.Application
+    $excel.Visible = $false
+    $excel.DisplayAlerts = $false
+    $excel.ScreenUpdating = $false
+
+    # Open read-only so the source workbook is never changed by the conversion.
+    $workbook = $excel.Workbooks.Open($inputPath, 0, $true)
+    if ($null -eq $workbook) {
+        throw 'Excel did not return a workbook when opening the source file.'
+    }
+
+    $workbook.SaveAs($outputPath, $fileFormat)
+} catch {
+    $exitCode = 1
+    [Console]::Error.WriteLine($_.Exception.ToString())
+} finally {
+    if ($null -ne $workbook) {
+        try { $workbook.Close($false) } catch { }
+        try { [System.Runtime.InteropServices.Marshal]::ReleaseComObject($workbook) | Out-Null } catch { }
+    }
+    if ($null -ne $excel) {
+        try { $excel.Quit() } catch { }
+        try { [System.Runtime.InteropServices.Marshal]::ReleaseComObject($excel) | Out-Null } catch { }
+    }
+    [GC]::Collect()
+    [GC]::WaitForPendingFinalizers()
+}
+
+exit $exitCode
+`;
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function validateConversionPaths(inputPath, outputPath, inputExtension, outputExtension, overwrite) {
+  const input = path2.resolve(inputPath);
+  const output = path2.resolve(outputPath);
+  if (path2.extname(input).toLowerCase() !== inputExtension) {
+    throw new Error(
+      `Excel conversion: source must have the ${inputExtension} extension: ${inputPath}`
+    );
+  }
+  if (path2.extname(output).toLowerCase() !== outputExtension) {
+    throw new Error(
+      `Excel conversion: destination must have the ${outputExtension} extension: ${outputPath}`
+    );
+  }
+  if (!fs6.existsSync(input)) {
+    throw new Error(`Excel conversion: source file not found: ${inputPath}`);
+  }
+  if (!fs6.statSync(input).isFile()) {
+    throw new Error(`Excel conversion: source path is not a file: ${inputPath}`);
+  }
+  if (!fs6.existsSync(path2.dirname(output))) {
+    throw new Error(`Excel conversion: destination directory not found: ${path2.dirname(output)}`);
+  }
+  if (fs6.existsSync(output)) {
+    if (fs6.statSync(output).isDirectory()) {
+      throw new Error(`Excel conversion: destination path is a directory: ${outputPath}`);
+    }
+    if (!overwrite) {
+      throw new Error(
+        `Excel conversion: destination already exists (pass { overwrite: true } to replace it): ${outputPath}`
+      );
+    }
+  }
+  if (process.platform === "win32" && input.toLowerCase() === output.toLowerCase()) {
+    throw new Error("Excel conversion: source and destination must be different files.");
+  }
+  return { input, output };
+}
+function runPowerShellConversion(inputPath, outputPath, fileFormat) {
+  const encodedCommand = Buffer.from(POWERSHELL_CONVERSION_SCRIPT, "utf16le").toString("base64");
+  const environment = {
+    ...process.env,
+    JUSTYBASE_EXCEL_INPUT: inputPath,
+    JUSTYBASE_EXCEL_OUTPUT: outputPath,
+    JUSTYBASE_EXCEL_FORMAT: String(fileFormat)
+  };
+  return new Promise((resolve2, reject) => {
+    var _a, _b, _c, _d;
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const child = spawn(
+      "powershell.exe",
+      [
+        "-NoLogo",
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-EncodedCommand",
+        encodedCommand
+      ],
+      { env: environment, windowsHide: true }
+    );
+    (_a = child.stdout) == null ? void 0 : _a.setEncoding("utf8");
+    (_b = child.stderr) == null ? void 0 : _b.setEncoding("utf8");
+    (_c = child.stdout) == null ? void 0 : _c.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    (_d = child.stderr) == null ? void 0 : _d.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      reject(new Error(`Excel conversion: unable to start PowerShell/COM: ${error.message}`));
+    });
+    child.once("close", (code) => {
+      if (settled) return;
+      settled = true;
+      if (code === 0) {
+        resolve2();
+        return;
+      }
+      const details = (stderr || stdout).replace(/\s+/g, " ").trim();
+      reject(new Error(
+        `Excel conversion failed (PowerShell exit code ${code ?? "unknown"})${details ? `: ${details}` : "."}`
+      ));
+    });
+  });
+}
+async function convertExcelFile(inputPath, outputPath, inputExtension, outputExtension, fileFormat, options = {}) {
+  const { input, output } = validateConversionPaths(
+    inputPath,
+    outputPath,
+    inputExtension,
+    outputExtension,
+    options.overwrite === true
+  );
+  if (process.platform !== "win32") {
+    throw new Error("Excel conversion requires Windows with desktop Microsoft Excel and COM automation.");
+  }
+  const temporaryOutput = path2.join(
+    path2.dirname(output),
+    `.${path2.basename(output, outputExtension)}.${randomUUID2()}.conversion${outputExtension}`
+  );
+  try {
+    await runPowerShellConversion(input, temporaryOutput, fileFormat);
+    if (!fs6.existsSync(temporaryOutput)) {
+      throw new Error("Excel conversion completed without creating the destination file.");
+    }
+    installTemporaryOutput(temporaryOutput, output, options.overwrite === true);
+  } catch (error) {
+    throw new Error(`Excel conversion ${inputExtension} -> ${outputExtension}: ${errorMessage2(error)}`);
+  } finally {
+    if (fs6.existsSync(temporaryOutput)) {
+      try {
+        fs6.rmSync(temporaryOutput);
+      } catch {
+      }
+    }
+  }
+}
+function convertXlsbToXlsx(inputPath, outputPath, options) {
+  return convertExcelFile(inputPath, outputPath, ".xlsb", ".xlsx", 51, options);
+}
+function convertXlsxToXlsb(inputPath, outputPath, options) {
+  return convertExcelFile(inputPath, outputPath, ".xlsx", ".xlsb", 50, options);
+}
 export {
   BiffReaderWriter,
   BigBuffer,
@@ -3874,10 +5141,14 @@ export {
   ReaderFactory,
   StreamingSheetState,
   XlsbReader,
+  XlsbUpdater,
   XlsbWriter,
   XlsxReader,
+  XlsxUpdater,
   XlsxWriter,
   applyHeaderWidths,
+  convertXlsbToXlsx,
+  convertXlsxToXlsb,
   defaultColWidth,
   getFormat,
   initColWidths,