@justybase/spreadsheet-tasks 2.2.0 → 3.0.0

package/dist/esm/index.js

@@ -112,6 +112,143 @@ var BigBuffer = class {
   }
 };
 
+// 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 OA_EPOCH_1900 = Date.UTC(1899, 11, 30);
+var MARCH_1_1900 = Date.UTC(1900, 2, 1);
+function oaDateToTime(oaDate, epochMs) {
+  let serial = oaDate;
+  if (epochMs === OA_EPOCH_1900 && serial >= 1 && serial < 60) {
+    serial += 1;
+  }
+  return Math.round(serial * 864e5) + epochMs;
+}
+function timeToOaDate(timeMs, epochMs) {
+  let serial = (timeMs - epochMs) / 864e5;
+  if (epochMs === OA_EPOCH_1900 && timeMs < MARCH_1_1900) {
+    serial -= 1;
+  }
+  return serial;
+}
+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;
+}
+var MAX_ROWS = 1048576;
+var MAX_COLS = 16384;
+var MAX_CELL_CHARS = 32767;
+function assertCellTextLength(text) {
+  if (text.length > MAX_CELL_CHARS) {
+    throw new Error(
+      `Excel cell text exceeds ${MAX_CELL_CHARS} UTF-16 code units (got ${text.length}).`
+    );
+  }
+}
+function assertColumnCount(columnCount) {
+  if (!Number.isInteger(columnCount) || columnCount < 1 || columnCount > MAX_COLS) {
+    throw new Error(
+      `Excel column count must be 1..${MAX_COLS} (got ${columnCount}).`
+    );
+  }
+}
+function assertRowFitsColumns(kind, length, columnCount) {
+  if (length > columnCount) {
+    throw new Error(
+      `Excel ${kind} length ${length} exceeds columnCount ${columnCount}.`
+    );
+  }
+}
+function assertRowCount(totalRows) {
+  if (totalRows > MAX_ROWS) {
+    throw new Error(
+      `Excel row count exceeds ${MAX_ROWS} (got ${totalRows}).`
+    );
+  }
+}
+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/ExcelReaderAbstract.ts
 var ExcelReaderAbstract = class {
   constructor() {
@@ -126,8 +263,7 @@ var ExcelReaderAbstract = class {
   dispose() {
   }
   getDateTimeFromOaDate(oaDate) {
-    const ms = oaDate * 864e5 + this._oaEpoch;
-    return new Date(ms);
+    return new Date(oaDateToTime(oaDate, this._oaEpoch));
   }
 };
 
@@ -387,6 +523,208 @@ var BiffReaderWriter = class {
 
 // src/XlsbReader.ts
 import AdmZip from "adm-zip";
+
+// 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|lt|gt|quot|apos|#\d+|#x[0-9a-fA-F]+);/g, (entity) => {
+    switch (entity) {
+      case "&amp;":
+        return "&";
+      case "&lt;":
+        return "<";
+      case "&gt;":
+        return ">";
+      case "&quot;":
+        return '"';
+      case "&apos;":
+        return "'";
+      default: {
+        if (entity[1] === "#") {
+          const body = entity.slice(2, -1);
+          const code = body[0] === "x" || body[0] === "X" ? parseInt(body.slice(1), 16) : parseInt(body, 10);
+          if (Number.isFinite(code)) {
+            try {
+              return String.fromCodePoint(code);
+            } catch {
+              return entity;
+            }
+          }
+        }
+        return entity;
+      }
+    }
+  });
+}
+function parseTagAttributes(tag) {
+  const attrs = {};
+  const re = /([A-Za-z_][\w.:-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+  let m;
+  while ((m = re.exec(tag)) !== null) {
+    const name = m[1];
+    const value = m[3] !== void 0 ? m[3] : m[4];
+    attrs[name] = value;
+    const colon = name.indexOf(":");
+    if (colon !== -1) {
+      const local = name.slice(colon + 1);
+      if (!(local in attrs)) attrs[local] = value;
+    }
+  }
+  return attrs;
+}
+function resolveRelTarget(target) {
+  if (!target) return target;
+  if (target.startsWith("/")) return target.slice(1);
+  if (target.startsWith("xl/")) return target;
+  return "xl/" + target;
+}
+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 = [];
+  const itemRegex = /<(?:(?:[A-Za-z_][\w.-]*):)?si\b[^>]*>([\s\S]*?)<\/(?:(?:[A-Za-z_][\w.-]*):)?si\s*>|<(?:(?:[A-Za-z_][\w.-]*):)?si\b[^>]*\/>/gi;
+  let itemMatch;
+  while ((itemMatch = itemRegex.exec(xml)) !== null) {
+    const full = itemMatch[0];
+    if (full.endsWith("/>") && itemMatch[1] === void 0) {
+      result.push("");
+      continue;
+    }
+    let content = itemMatch[1] ?? "";
+    content = content.replace(/<(?:(?:[A-Za-z_][\w.-]*):)?rPh\b[^>]*>[\s\S]*?<\/(?:(?:[A-Za-z_][\w.-]*):)?rPh\s*>/gi, "");
+    content = content.replace(/<(?:(?:[A-Za-z_][\w.-]*):)?rPh\b[^>]*\/>/gi, "");
+    const textRegex = /<(?:(?:[A-Za-z_][\w.-]*):)?t\b[^>]*>([\s\S]*?)<\/(?:(?:[A-Za-z_][\w.-]*):)?t\s*>/gi;
+    let value = "";
+    let textMatch;
+    while ((textMatch = textRegex.exec(content)) !== null) {
+      value += textMatch[1];
+    }
+    result.push(unescapeXml(value));
+  }
+  return result;
+}
+
+// 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/XlsbReader.ts
 var XlsbReader = class extends ExcelReaderAbstract {
   constructor() {
     super();
@@ -398,12 +736,29 @@ var XlsbReader = class extends ExcelReaderAbstract {
     this._reader = null;
     this._currentRow = [];
     this._pendingRowIndex = -1;
+    this._nextExpectedRow = 0;
     this._eof = false;
     this.xfIdToNumFmtId = [];
     this.customDateFormats = null;
   }
-  async open(path7, readSharedStrings = true) {
-    this.zip = new AdmZip(path7);
+  async open(path9, readSharedStrings = true) {
+    await this.close();
+    this.sheetNames = [];
+    this.sheets = [];
+    this.sharedStrings = [];
+    this.xfIdToNumFmtId = [];
+    this.customDateFormats = /* @__PURE__ */ new Set();
+    this.fieldCount = 0;
+    this.resultsCount = 0;
+    this.actualSheetName = "";
+    this._currentSheetIndex = -1;
+    this._currentRow = [];
+    this._pendingRowIndex = -1;
+    this._nextExpectedRow = 0;
+    this._eof = false;
+    this._reader = null;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    this.zip = new AdmZip(path9);
     const wbEntry = this.zip.getEntry("xl/workbook.bin");
     if (wbEntry) {
       const buf = wbEntry.getData();
@@ -420,20 +775,39 @@ var XlsbReader = class extends ExcelReaderAbstract {
     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 relTagRe = /<Relationship\b[^>]*>/g;
+      let tagMatch;
       const rIdToTarget = {};
-      while ((match = relRegex.exec(xml)) !== null) {
-        rIdToTarget[match[1]] = match[2];
+      while ((tagMatch = relTagRe.exec(xml)) !== null) {
+        const attrs = parseTagAttributes(tagMatch[0]);
+        const id = attrs["Id"] ?? attrs["id"];
+        const target = attrs["Target"] ?? attrs["target"];
+        if (id !== void 0 && target !== void 0) {
+          rIdToTarget[id] = target;
+        }
       }
       for (const sheet of this.sheets) {
-        let target = rIdToTarget[sheet.rId];
+        const target = rIdToTarget[sheet.rId];
         if (target) {
-          if (target.startsWith("/")) target = target.substring(1);
-          if (!target.startsWith("xl/")) target = "xl/" + target;
-          sheet.path = target;
+          sheet.path = resolveRelTarget(target);
+        }
+      }
+    }
+    try {
+      const raw = wbEntry ? wbEntry.getData() : null;
+      if (raw) {
+        const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+        let pos = 0;
+        while (readRecord(raw, pos, rec)) {
+          if (rec.id === 153 && rec.len >= 4) {
+            const is1904 = (raw[rec.dataStart] & 1) !== 0;
+            this._oaEpoch = is1904 ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+            break;
+          }
+          pos = rec.dataEnd;
         }
       }
+    } catch {
     }
     if (readSharedStrings) {
       const ssPath = "xl/sharedStrings.bin";
@@ -448,8 +822,8 @@ var XlsbReader = class extends ExcelReaderAbstract {
     this.resultsCount = this.sheets.length;
     this._currentSheetIndex = -1;
   }
-  _readSharedStrings(path7) {
-    const entry = this.zip.getEntry(path7);
+  _readSharedStrings(path9) {
+    const entry = this.zip.getEntry(path9);
     if (!entry) return;
     const reader = new BiffReaderWriter(entry.getData());
     while (reader.readSharedStrings()) {
@@ -458,8 +832,8 @@ var XlsbReader = class extends ExcelReaderAbstract {
       }
     }
   }
-  _readStyles(path7) {
-    const entry = this.zip.getEntry(path7);
+  _readStyles(path9) {
+    const entry = this.zip.getEntry(path9);
     if (!entry) return;
     const reader = new BiffReaderWriter(entry.getData());
     while (reader.readStyles()) {
@@ -470,21 +844,54 @@ var XlsbReader = class extends ExcelReaderAbstract {
   getSheetNames() {
     return this.sheetNames;
   }
+  async selectSheet(nameOrIndex) {
+    let index = -1;
+    if (typeof nameOrIndex === "number") {
+      index = nameOrIndex;
+    } else {
+      index = this.sheetNames.indexOf(nameOrIndex);
+      if (index === -1) throw new Error(`Sheet '${nameOrIndex}' not found`);
+    }
+    if (index < 0 || index >= this.sheets.length) {
+      throw new Error(`Sheet index ${String(nameOrIndex)} out of range`);
+    }
+    this._currentSheetIndex = index;
+    if (!this._initSheet(index)) {
+      throw new Error(`XlsbReader: worksheet part missing for sheet '${this.sheetNames[index]}'.`);
+    }
+  }
+  async nextResult() {
+    const next = this._currentSheetIndex + 1;
+    if (next >= this.sheets.length) return false;
+    this._currentSheetIndex = next;
+    if (!this._initSheet(next)) {
+      throw new Error(`XlsbReader: worksheet part missing for sheet '${this.sheetNames[next]}'.`);
+    }
+    return true;
+  }
   async read() {
     if (this._currentSheetIndex === -1) {
       this._currentSheetIndex = 0;
       if (!this._initSheet(0)) return false;
     }
     if (this._eof) return false;
+    if (this._pendingRowIndex > this._nextExpectedRow && this._pendingRowIndex < MAX_ROWS) {
+      this._currentRow = [];
+      this._nextExpectedRow++;
+      return true;
+    }
     this._currentRow = [];
     while (true) {
       const hasRecord = this._reader.readWorksheet();
       if (!hasRecord) {
         this._eof = true;
+        this._nextExpectedRow = this._pendingRowIndex + 1;
         return true;
       }
       if (this._reader._rowIndex !== -1 && this._reader._rowIndex !== this._pendingRowIndex) {
+        const completed = this._pendingRowIndex;
         this._pendingRowIndex = this._reader._rowIndex;
+        this._nextExpectedRow = completed + 1;
         return true;
       }
       if (this._reader._readCell) {
@@ -525,13 +932,17 @@ var XlsbReader = class extends ExcelReaderAbstract {
     }
   }
   _initSheet(index) {
-    if (index >= this.sheets.length) return false;
+    if (index < 0 || index >= this.sheets.length) return false;
     const sheet = this.sheets[index];
-    const entry = this.zip.getEntry(sheet.path);
+    const entry = sheet.path ? this.zip.getEntry(sheet.path) : void 0;
     if (!entry) return false;
     this._reader = new BiffReaderWriter(entry.getData());
     this._eof = false;
     this._pendingRowIndex = -1;
+    this._nextExpectedRow = 0;
+    this._currentRow = [];
+    this.fieldCount = 0;
+    this.actualSheetName = sheet.name;
     while (this._reader.readWorksheet()) {
       if (this._reader._rowIndex !== -1) {
         this._pendingRowIndex = this._reader._rowIndex;
@@ -539,7 +950,7 @@ var XlsbReader = class extends ExcelReaderAbstract {
       }
     }
     this._eof = true;
-    return false;
+    return true;
   }
   getValue(i) {
     if (i < 0 || i >= this._currentRow.length) return null;
@@ -549,84 +960,15 @@ 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(/&#x([0-9a-f]+);/gi, (_match, hex) => String.fromCodePoint(parseInt(hex, 16))).replace(/&#(\d+);/g, (_match, decimal) => String.fromCodePoint(parseInt(decimal, 10))).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 = [];
-  const itemRegex = /<(?:(?:[A-Za-z_][\w.-]*):)?si\b[^>]*>([\s\S]*?)<\/(?:(?:[A-Za-z_][\w.-]*):)?si\s*>/gi;
-  let itemMatch;
-  while ((itemMatch = itemRegex.exec(xml)) !== null) {
-    const content = itemMatch[1];
-    const textRegex = /<(?:(?:[A-Za-z_][\w.-]*):)?t\b[^>]*>([\s\S]*?)<\/(?:(?:[A-Za-z_][\w.-]*):)?t\s*>/gi;
-    let value = "";
-    let textMatch;
-    while ((textMatch = textRegex.exec(content)) !== null) {
-      value += textMatch[1];
-    }
-    result.push(unescapeXml(value));
-  }
-  return result;
+function parseIsoDateUtc(value) {
+  let text = value.trim().replace(" ", "T");
+  if (!text) return null;
+  if (!/z$|[+-]\d{2}:?\d{2}$/i.test(text) && text.includes("T")) {
+    text += "Z";
+  }
+  const date = new Date(text);
+  return Number.isNaN(date.getTime()) ? null : date;
 }
-
-// src/XlsxReader.ts
 var XlsxReader = class extends ExcelReaderAbstract {
   constructor() {
     super();
@@ -638,13 +980,34 @@ var XlsxReader = class extends ExcelReaderAbstract {
     this._currentSheetIndex = -1;
     this._sheetXml = null;
     this._xmlPos = 0;
+    /** End of the sheetData element; row tags must not be searched past it. */
+    this._xmlEnd = 0;
     this._currentRow = [];
+    this._expectedRowNum = 1;
+    this._pendingEmptyCount = 0;
     this.xfIdToNumFmtId = [];
     this.customDateFormats = /* @__PURE__ */ new Set();
   }
-  async open(path7, readSharedStrings = true) {
-    return new Promise((resolve4, reject) => {
-      yauzl.open(path7, { lazyEntries: true, autoClose: false }, async (err, zipfile) => {
+  async open(path9, readSharedStrings = true) {
+    await this.close();
+    this.sheetNames = [];
+    this.sheets = [];
+    this.sharedStrings = [];
+    this.xfIdToNumFmtId = [];
+    this.customDateFormats = /* @__PURE__ */ new Set();
+    this.fieldCount = 0;
+    this.resultsCount = 0;
+    this.actualSheetName = "";
+    this._currentSheetIndex = -1;
+    this._sheetXml = null;
+    this._xmlPos = 0;
+    this._xmlEnd = 0;
+    this._currentRow = [];
+    this._expectedRowNum = 1;
+    this._pendingEmptyCount = 0;
+    this._oaEpoch = Date.UTC(1899, 11, 30);
+    return new Promise((resolve6, reject) => {
+      yauzl.open(path9, { lazyEntries: true, autoClose: false }, async (err, zipfile) => {
         if (err) return reject(err);
         this.zipfile = zipfile;
         this.entries = /* @__PURE__ */ new Map();
@@ -657,28 +1020,40 @@ var XlsxReader = class extends ExcelReaderAbstract {
             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 relTagRe = /<Relationship\b[^>]*>/g;
+              let tagMatch;
+              while ((tagMatch = relTagRe.exec(wbRelsContent)) !== null) {
+                const attrs = parseTagAttributes(tagMatch[0]);
+                const id = attrs["Id"] ?? attrs["id"];
+                const target = attrs["Target"] ?? attrs["target"];
+                if (id !== void 0 && target !== void 0) {
+                  rIdToTarget[id] = target;
+                }
               }
             }
             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 sheetTagRe = /<sheet\b[^>]*>/g;
+              let tagMatch;
+              while ((tagMatch = sheetTagRe.exec(wbContent)) !== null) {
+                const attrs = parseTagAttributes(tagMatch[0]);
+                const rawName = attrs["name"];
+                const sheetId = attrs["sheetId"] ?? "";
+                const rId = attrs["r:id"] ?? attrs["id"] ?? attrs["rId"];
+                if (rawName === void 0 || rId === void 0) continue;
+                const name = unescapeXml(rawName);
                 const target = rIdToTarget[rId];
-                let fullPath = target;
-                if (!fullPath.startsWith("xl/")) {
-                  fullPath = "xl/" + fullPath;
-                }
+                if (!target) continue;
+                const fullPath = resolveRelTarget(target);
                 this.sheetNames.push(name);
                 this.sheets.push({ name, sheetId, rId, path: fullPath });
               }
+              const wbPrMatch = /<workbookPr\b[^>]*>/i.exec(wbContent);
+              if (wbPrMatch) {
+                const wbPrAttrs = parseTagAttributes(wbPrMatch[0]);
+                const v = (wbPrAttrs["date1904"] ?? "").trim().toLowerCase();
+                this._oaEpoch = v === "1" || v === "true" ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+              }
             }
             if (readSharedStrings) {
               const ssContent = await this._readZipEntryContent("xl/sharedStrings.xml");
@@ -692,7 +1067,7 @@ var XlsxReader = class extends ExcelReaderAbstract {
             }
             this.resultsCount = this.sheets.length;
             this._currentSheetIndex = -1;
-            resolve4();
+            resolve6();
           } catch (e) {
             reject(e);
           }
@@ -706,16 +1081,16 @@ var XlsxReader = class extends ExcelReaderAbstract {
       this.zipfile.close();
     }
   }
-  async _readZipEntryContent(path7) {
-    const entry = this.entries.get(path7);
+  async _readZipEntryContent(path9) {
+    const entry = this.entries.get(path9);
     if (!entry) return null;
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
       this.zipfile.openReadStream(entry, (err, readStream) => {
         if (err) return reject(err);
         const chunks = [];
         readStream.on("data", (chunk) => chunks.push(chunk));
         readStream.on("end", () => {
-          resolve4(Buffer.concat(chunks).toString("utf8"));
+          resolve6(Buffer.concat(chunks).toString("utf8"));
         });
         readStream.on("error", reject);
       });
@@ -763,6 +1138,27 @@ var XlsxReader = class extends ExcelReaderAbstract {
       return false;
     }
   }
+  async selectSheet(nameOrIndex) {
+    let index = -1;
+    if (typeof nameOrIndex === "number") {
+      index = nameOrIndex;
+    } else {
+      index = this.sheetNames.indexOf(nameOrIndex);
+      if (index === -1) throw new Error(`Sheet '${nameOrIndex}' not found`);
+    }
+    if (index < 0 || index >= this.sheets.length) {
+      throw new Error(`Sheet index ${String(nameOrIndex)} out of range`);
+    }
+    this._currentSheetIndex = index;
+    await this._initSheet(index);
+  }
+  async nextResult() {
+    const next = this._currentSheetIndex + 1;
+    if (next >= this.sheets.length) return false;
+    this._currentSheetIndex = next;
+    await this._initSheet(next);
+    return true;
+  }
   async _initSheet(index) {
     if (index >= this.sheets.length) return;
     const sheet = this.sheets[index];
@@ -772,23 +1168,106 @@ var XlsxReader = class extends ExcelReaderAbstract {
       this._sheetXml = "";
     }
     this._xmlPos = 0;
+    this._xmlEnd = this._sheetXml.length;
+    this._expectedRowNum = 1;
+    this._pendingEmptyCount = 0;
+    this._currentRow = [];
+    this.fieldCount = 0;
     const sd = this._sheetXml.indexOf("<sheetData>");
-    if (sd !== -1) this._xmlPos = sd + 11;
+    if (sd !== -1) {
+      this._xmlPos = sd + 11;
+      const se = this._sheetXml.indexOf("</sheetData>", this._xmlPos);
+      if (se !== -1) this._xmlEnd = se;
+    } else {
+      const m = /<(?:[A-Za-z_][\w.-]*:)?sheetData\b[^>]*>/i.exec(this._sheetXml);
+      if (m && m.index !== void 0) {
+        this._xmlPos = m.index + m[0].length;
+        if (/\/>\s*$/.test(m[0])) {
+          this._xmlEnd = this._xmlPos;
+        } else {
+          const se = this._sheetXml.indexOf("</sheetData>", this._xmlPos);
+          if (se !== -1) this._xmlEnd = se;
+        }
+      }
+    }
   }
   _readNextRow() {
     if (!this._sheetXml) return false;
-    const rowStart = this._sheetXml.indexOf("<row", this._xmlPos);
+    if (this._pendingEmptyCount > 0) {
+      this._pendingEmptyCount--;
+      this._currentRow = [];
+      this._expectedRowNum++;
+      return true;
+    }
+    const rowStart = this._findRowTagStart(this._xmlPos);
     if (rowStart === -1) return false;
+    const rowTagEnd = this._sheetXml.indexOf(">", rowStart);
+    if (rowTagEnd === -1) return false;
+    const rowTag = this._sheetXml.substring(rowStart, rowTagEnd + 1);
+    const isSelfClosing = this._sheetXml.charCodeAt(rowTagEnd - 1) === 47;
+    const rowAttrs = parseTagAttributes(rowTag);
+    const rRaw = rowAttrs["r"];
+    let rowNum = this._expectedRowNum;
+    if (rRaw !== void 0) {
+      const parsed = parseInt(rRaw, 10);
+      if (Number.isFinite(parsed) && parsed >= 1 && parsed <= MAX_ROWS) rowNum = parsed;
+    }
+    if (rowNum > this._expectedRowNum) {
+      const gap = rowNum - this._expectedRowNum;
+      this._pendingEmptyCount = gap - 1;
+      this._currentRow = [];
+      this._expectedRowNum++;
+      return true;
+    }
+    if (rowNum < this._expectedRowNum) {
+      if (isSelfClosing) {
+        this._xmlPos = rowTagEnd + 1;
+        this._currentRow = [];
+        return true;
+      }
+      const rowEnd2 = this._sheetXml.indexOf("</row>", rowStart);
+      if (rowEnd2 === -1) return false;
+      this._xmlPos = rowEnd2 + 6;
+      this._parseRowByIndex(rowStart, rowEnd2);
+      this._expectedRowNum = Math.max(this._expectedRowNum + 1, rowNum + 1);
+      return true;
+    }
+    if (isSelfClosing) {
+      this._xmlPos = rowTagEnd + 1;
+      this._currentRow = [];
+      this._expectedRowNum = rowNum + 1;
+      return true;
+    }
     const rowEnd = this._sheetXml.indexOf("</row>", rowStart);
     if (rowEnd === -1) return false;
     this._xmlPos = rowEnd + 6;
     this._parseRowByIndex(rowStart, rowEnd);
+    this._expectedRowNum = rowNum + 1;
     return true;
   }
+  /**
+   * Find the next `<row …>` start, ignoring similarly named elements such as
+   * `<rowBreaks>` that follow `</sheetData>`.
+   */
+  _findRowTagStart(from) {
+    const xml = this._sheetXml;
+    let pos = from;
+    while (pos < this._xmlEnd) {
+      const idx = xml.indexOf("<row", pos);
+      if (idx === -1 || idx >= this._xmlEnd) return -1;
+      const next = xml.charCodeAt(idx + 4);
+      if (next === 62 || next === 47 || next === 32 || next === 9 || next === 10 || next === 13) {
+        return idx;
+      }
+      pos = idx + 4;
+    }
+    return -1;
+  }
   _parseRowByIndex(rowStart, rowEnd) {
     this._currentRow = [];
     const xml = this._sheetXml;
     let pos = xml.indexOf(">", rowStart) + 1;
+    let nextCol = 0;
     while (pos < rowEnd) {
       const cStart = xml.indexOf("<c", pos);
       if (cStart === -1 || cStart >= rowEnd) break;
@@ -822,6 +1301,7 @@ var XlsxReader = class extends ExcelReaderAbstract {
         }
       }
       let val = null;
+      let inlineVals = null;
       if (xml.charCodeAt(nextTagClose - 1) === 47) {
         pos = nextTagClose + 1;
       } else {
@@ -836,20 +1316,28 @@ var XlsxReader = class extends ExcelReaderAbstract {
           }
         } else {
           if (type === "inlineStr") {
-            const tStart = xml.indexOf("<t", nextTagClose);
-            if (tStart !== -1 && tStart < cellContentEnd) {
-              const tContentStart = xml.indexOf(">", tStart) + 1;
+            inlineVals = [];
+            let tSearch = nextTagClose;
+            while (true) {
+              const tStart = xml.indexOf("<t", tSearch);
+              if (tStart === -1 || tStart >= cellContentEnd) break;
+              const tClose = xml.indexOf(">", tStart);
+              if (tClose === -1 || tClose >= cellContentEnd) break;
+              const tContentStart = tClose + 1;
               const tEnd = xml.indexOf("</t>", tContentStart);
-              if (tEnd !== -1 && tEnd < cellContentEnd) {
-                val = xml.substring(tContentStart, tEnd);
-              }
+              if (tEnd === -1 || tEnd > cellContentEnd) break;
+              inlineVals.push(xml.substring(tContentStart, tEnd));
+              tSearch = tEnd + 4;
             }
+            if (inlineVals.length === 0) inlineVals = null;
           }
         }
         pos = cellContentEnd + 4;
       }
       let finalVal = null;
-      if (val !== null) {
+      if (inlineVals !== null) {
+        finalVal = unescapeXml(inlineVals.join(""));
+      } else if (val !== null) {
         if (type === "s") {
           const idx = parseInt(val, 10);
           finalVal = this.sharedStrings[idx];
@@ -857,6 +1345,12 @@ var XlsxReader = class extends ExcelReaderAbstract {
           finalVal = val === "1" || val === "true";
         } else if (type === "inlineStr") {
           finalVal = unescapeXml(val);
+        } else if (type === "str") {
+          finalVal = unescapeXml(val);
+        } else if (type === "e") {
+          finalVal = unescapeXml(val);
+        } else if (type === "d") {
+          finalVal = parseIsoDateUtc(val) ?? unescapeXml(val);
         } else if (type === "n" || type === "") {
           finalVal = parseFloat(val);
           if (styleIndex > 0 && this.xfIdToNumFmtId) {
@@ -874,10 +1368,10 @@ var XlsxReader = class extends ExcelReaderAbstract {
           }
         }
       }
-      if (colIndex !== -1) {
-        this._currentRow[colIndex] = finalVal;
-        if (colIndex >= this.fieldCount) this.fieldCount = colIndex + 1;
-      }
+      if (colIndex === -1) colIndex = nextCol;
+      nextCol = colIndex + 1;
+      this._currentRow[colIndex] = finalVal;
+      if (colIndex >= this.fieldCount) this.fieldCount = colIndex + 1;
     }
   }
   getValue(i) {
@@ -907,99 +1401,11 @@ var ReaderFactory = class {
 
 // src/XlsbWriter.ts
 import * as fs from "fs";
+import * as path2 from "path";
+import { randomUUID } from "crypto";
 import archiver from "archiver";
 import { Readable } from "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() {
@@ -1052,6 +1458,8 @@ var XlsbWriter = class _XlsbWriter {
    * @param filePath Destination `.xlsb` path on disk.
    */
   constructor(filePath) {
+    this._outputError = null;
+    this._finalized = false;
     this.sheetCount = 0;
     this.sheetList = [];
     this.sstDic = /* @__PURE__ */ new Map();
@@ -1062,8 +1470,20 @@ var XlsbWriter = class _XlsbWriter {
     this._nextXfIdx = 4;
     this._stFmtRecords = /* @__PURE__ */ new Map();
     this.stream = new StreamingSheetState();
-    this.output = fs.createWriteStream(filePath);
+    this._targetPath = path2.resolve(filePath);
+    fs.mkdirSync(path2.dirname(this._targetPath), { recursive: true });
+    this._tempPath = path2.join(
+      path2.dirname(this._targetPath),
+      `.${path2.basename(this._targetPath)}.${randomUUID()}.tmp`
+    );
+    this.output = fs.createWriteStream(this._tempPath);
+    this.output.on("error", (err) => {
+      this._outputError = err;
+    });
     this.archive = archiver("zip");
+    this.archive.on("error", (err) => {
+      this._outputError = err;
+    });
     this.archive.pipe(this.output);
     this._oaEpoch = Date.UTC(1899, 11, 30);
     this._sheet1Bytes = Buffer.from([
@@ -2933,6 +3353,11 @@ var XlsbWriter = class _XlsbWriter {
    * @param options Optional settings (hidden, doAutofilter)
    */
   startSheet(sheetName, columnCount, headers, options = {}) {
+    assertColumnCount(columnCount);
+    if (headers !== void 0) {
+      assertRowFitsColumns("header", headers.length, columnCount);
+      for (const h of headers) assertCellTextLength(h);
+    }
     const { hidden = false, doAutofilter = true, sampleRows } = options;
     this.addSheet(sheetName, hidden);
     this.stream.begin(columnCount, doAutofilter && headers !== void 0, new BigBuffer());
@@ -2998,6 +3423,7 @@ var XlsbWriter = class _XlsbWriter {
         `Row length mismatch. Expected ${this.stream.endCol - this.stream.startCol} columns, got ${row.length}`
       );
     }
+    assertRowCount(this.stream.rowNum + 1);
     this.createRowHeader(bigBuf, this.stream.rowNum, this.stream.startCol, this.stream.endCol);
     for (let c = 0; c < row.length; c++) {
       const raw = row[c];
@@ -3020,7 +3446,7 @@ var XlsbWriter = class _XlsbWriter {
       } else if (typeof val === "boolean") {
         this.writeBool(bigBuf, val, c);
       } else if (val instanceof Date) {
-        const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+        const oaDate = timeToOaDate(val.getTime(), this._oaEpoch);
         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);
@@ -3077,6 +3503,16 @@ var XlsbWriter = class _XlsbWriter {
     } else if (headers) {
       columnCount = headers.length;
     }
+    if (columnCount > 0) assertColumnCount(columnCount);
+    const totalRowsCheck = rows.length + (headers ? 1 : 0);
+    assertRowCount(totalRowsCheck);
+    if (headers) {
+      assertRowFitsColumns("header", headers.length, columnCount);
+      for (const h of headers) assertCellTextLength(h);
+    }
+    for (let r = 0; r < rows.length; r++) {
+      assertRowFitsColumns("row", rows[r].length, columnCount);
+    }
     const colWidths = initColWidths(columnCount);
     if (headers) {
       applyHeaderWidths(colWidths, headers, columnCount);
@@ -3152,7 +3588,7 @@ var XlsbWriter = class _XlsbWriter {
         } else if (typeof val === "boolean") {
           this.writeBool(bigBuf, val, c);
         } else if (val instanceof Date) {
-          const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+          const oaDate = timeToOaDate(val.getTime(), this._oaEpoch);
           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);
@@ -3235,13 +3671,14 @@ var XlsbWriter = class _XlsbWriter {
     bigBuf.writeUnsafeByte(val ? 1 : 0);
   }
   writeDateTime(bigBuf, date, colNum) {
-    const oaDate = (date.getTime() - this._oaEpoch) / 864e5;
+    const oaDate = timeToOaDate(date.getTime(), this._oaEpoch);
     this.writeDouble(bigBuf, oaDate, colNum, 1);
   }
   _getDateWidth(_date) {
     return 19;
   }
   writeString(bigBuf, val, colNum, bolded = false, styleOverride) {
+    assertCellTextLength(val);
     let index;
     if (this.sstDic.has(val)) {
       index = this.sstDic.get(val);
@@ -3267,8 +3704,8 @@ var XlsbWriter = class _XlsbWriter {
     bigBuf.writeByte(159);
     bigBuf.writeByte(1);
     bigBuf.writeByte(8);
-    bigBuf.writeInt32LE(this.sstCntUnique);
     bigBuf.writeInt32LE(this.sstCntAll);
+    bigBuf.writeInt32LE(this.sstCntUnique);
     for (const [txt] of this.sstDic) {
       const txtLen = txt.length;
       bigBuf.writeByte(19);
@@ -3321,8 +3758,61 @@ var XlsbWriter = class _XlsbWriter {
    * Must be awaited before the file is fully written.
    */
   finalize() {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
+      if (this._finalized) {
+        reject(new Error("XlsbWriter: already finalized"));
+        return;
+      }
+      this._finalized = true;
+      let settled = false;
+      const cleanupTemp = () => {
+        try {
+          if (fs.existsSync(this._tempPath)) fs.rmSync(this._tempPath);
+        } catch {
+        }
+      };
+      const fail = (err) => {
+        if (settled) return;
+        settled = true;
+        try {
+          this.archive.abort();
+        } catch {
+        }
+        try {
+          this.output.destroy();
+        } catch {
+        }
+        cleanupTemp();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      const succeed = () => {
+        if (settled) return;
+        if (this._outputError) {
+          fail(this._outputError);
+          return;
+        }
+        settled = true;
+        try {
+          const fd = fs.openSync(this._tempPath, "r+");
+          try {
+            fs.fsyncSync(fd);
+          } finally {
+            fs.closeSync(fd);
+          }
+          try {
+            const existing = fs.statSync(this._targetPath);
+            fs.chmodSync(this._tempPath, existing.mode & 511);
+          } catch {
+          }
+          fs.renameSync(this._tempPath, this._targetPath);
+          resolve6();
+        } catch (err) {
+          cleanupTemp();
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      };
       try {
+        if (this._outputError) throw this._outputError;
         this.saveSst();
         this.archive.append(this._buildStylesBin(), { name: "xl/styles.bin" });
         const wbBuffers = [];
@@ -3419,11 +3909,12 @@ var XlsbWriter = class _XlsbWriter {
 </Relationships>`;
           this.archive.append(wsRels, { name: `xl/worksheets/_rels/${sheet.nameInArchive}.rels` });
         }
-        this.output.on("close", () => resolve4());
-        this.archive.on("error", (err) => reject(err));
+        this.output.once("close", succeed);
+        this.output.once("error", fail);
+        this.archive.once("error", fail);
         this.archive.finalize();
       } catch (err) {
-        reject(err);
+        fail(err);
       }
     });
   }
@@ -3431,27 +3922,17 @@ var XlsbWriter = class _XlsbWriter {
 
 // src/XlsxWriter.ts
 import * as fs2 from "fs";
+import * as path3 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 import archiver2 from "archiver";
 import { Readable as Readable2 } from "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._outputError = null;
+    this._finalized = false;
     this.sheetCount = 0;
     this.sheetList = [];
     this.sstArray = [];
@@ -3465,13 +3946,25 @@ var XlsxWriter = class {
     this._nextXfIndex = 4;
     this.stream = new StreamingSheetState();
     this.currentColLetters = [];
-    this.output = fs2.createWriteStream(filePath);
+    this._targetPath = path3.resolve(filePath);
+    fs2.mkdirSync(path3.dirname(this._targetPath), { recursive: true });
+    this._tempPath = path3.join(
+      path3.dirname(this._targetPath),
+      `.${path3.basename(this._targetPath)}.${randomUUID2()}.tmp`
+    );
+    this.output = fs2.createWriteStream(this._tempPath);
+    this.output.on("error", (err) => {
+      this._outputError = err;
+    });
     this.archive = archiver2("zip");
+    this.archive.on("error", (err) => {
+      this._outputError = err;
+    });
     this.archive.pipe(this.output);
     this._oaEpoch = Date.UTC(1899, 11, 30);
   }
   _getColumnLetter(colIndex) {
-    return colIndex < COLUMN_LETTERS.length ? COLUMN_LETTERS[colIndex] : "A";
+    return columnIndexToLetter(colIndex);
   }
   /** @deprecated Internal; kept for unit-test access. Prefer sanitizeSheetName(). */
   _sanitizeSheetName(name) {
@@ -3523,6 +4016,11 @@ var XlsxWriter = class {
    * Start streaming a sheet. Call `writeRow` for each row, then `endSheet`.
    */
   startSheet(sheetName, columnCount, headers, options = {}) {
+    assertColumnCount(columnCount);
+    if (headers !== void 0) {
+      assertRowFitsColumns("header", headers.length, columnCount);
+      for (const h of headers) assertCellTextLength(h);
+    }
     const { hidden = false, doAutofilter = true, sampleRows } = options;
     this.addSheet(sheetName, hidden);
     this.stream.begin(columnCount, doAutofilter && headers !== void 0, new BigBuffer());
@@ -3579,6 +4077,7 @@ var XlsxWriter = class {
       );
     }
     this.stream.rowNum++;
+    assertRowCount(this.stream.rowNum);
     bigBuf.writeString(`<row r="${this.stream.rowNum}">`);
     for (let c = 0; c < row.length; c++) {
       const raw = row[c];
@@ -3642,6 +4141,16 @@ var XlsxWriter = class {
     } else if (headers) {
       columnCount = headers.length;
     }
+    if (columnCount > 0) assertColumnCount(columnCount);
+    const totalRows = rows.length + (headers ? 1 : 0);
+    assertRowCount(totalRows);
+    if (headers) {
+      assertRowFitsColumns("header", headers.length, columnCount);
+      for (const h of headers) assertCellTextLength(h);
+    }
+    for (let r = 0; r < rows.length; r++) {
+      assertRowFitsColumns("row", rows[r].length, columnCount);
+    }
     const colWidths = initColWidths(columnCount);
     const colLetters = new Array(columnCount);
     for (let i = 0; i < columnCount; i++) {
@@ -3653,7 +4162,6 @@ var XlsxWriter = class {
     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 {
@@ -3739,6 +4247,7 @@ var XlsxWriter = class {
     });
   }
   _writeStringCell(bigBuf, val, colRef, rowNum, styleOverride) {
+    assertCellTextLength(val);
     let index = this.sstMap.get(val);
     if (index === void 0) {
       index = this.sstArray.length;
@@ -3760,29 +4269,79 @@ var XlsxWriter = class {
     return xfIndex;
   }
   _toOADate(date) {
-    return (date.getTime() - this._oaEpoch) / 864e5;
+    return timeToOaDate(date.getTime(), this._oaEpoch);
   }
   _getDateWidth(_date) {
     return 19;
   }
   /** Finalize the ZIP package and close the output stream. */
   finalize() {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve6, reject) => {
+      if (this._finalized) {
+        reject(new Error("XlsxWriter: already finalized"));
+        return;
+      }
+      this._finalized = true;
+      let settled = false;
+      const cleanupTemp = () => {
+        try {
+          if (fs2.existsSync(this._tempPath)) fs2.rmSync(this._tempPath);
+        } catch {
+        }
+      };
+      const fail = (err) => {
+        if (settled) return;
+        settled = true;
+        try {
+          this.archive.abort();
+        } catch {
+        }
+        try {
+          this.output.destroy();
+        } catch {
+        }
+        cleanupTemp();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      };
+      const succeed = () => {
+        if (settled) return;
+        if (this._outputError) {
+          fail(this._outputError);
+          return;
+        }
+        settled = true;
+        try {
+          const fd = fs2.openSync(this._tempPath, "r+");
+          try {
+            fs2.fsyncSync(fd);
+          } finally {
+            fs2.closeSync(fd);
+          }
+          try {
+            const existing = fs2.statSync(this._targetPath);
+            fs2.chmodSync(this._tempPath, existing.mode & 511);
+          } catch {
+          }
+          fs2.renameSync(this._tempPath, this._targetPath);
+          resolve6();
+        } catch (err) {
+          cleanupTemp();
+          reject(err instanceof Error ? err : new Error(String(err)));
+        }
+      };
       try {
+        if (this._outputError) throw this._outputError;
         this._writeSharedStrings();
         this._writeStyles();
         this._writeWorkbook();
         this._writeContentTypes();
         this._writeRels();
-        this.output.on("close", () => {
-          resolve4();
-        });
-        this.archive.on("error", (err) => {
-          reject(err);
-        });
+        this.output.once("close", succeed);
+        this.output.once("error", fail);
+        this.archive.once("error", fail);
         this.archive.finalize();
       } catch (err) {
-        reject(err);
+        fail(err);
       }
     });
   }
@@ -3914,13 +4473,13 @@ ${xfEntries.join("\n")}
 // src/XlsxUpdater.ts
 import * as fs5 from "fs";
 import * as os from "os";
-import * as path4 from "path";
+import * as path6 from "path";
 import AdmZip2 from "adm-zip";
 
 // src/atomicFile.ts
 import * as fs3 from "fs";
-import * as path2 from "path";
-import { randomUUID } from "crypto";
+import * as path4 from "path";
+import { randomUUID as randomUUID3 } from "crypto";
 var realFileOperations = {
   exists: (filePath) => fs3.existsSync(filePath),
   rename: (sourcePath, destinationPath) => fs3.renameSync(sourcePath, destinationPath),
@@ -3943,7 +4502,7 @@ function readDestinationMode(target) {
   }
 }
 function installTemporaryOutput(temporaryPath, destinationPath, overwrite, operations = realFileOperations) {
-  const backupPath = `${destinationPath}.${randomUUID()}.replacement-backup`;
+  const backupPath = `${destinationPath}.${randomUUID3()}.replacement-backup`;
   let backupCreated = false;
   let installed = false;
   if (operations.exists(destinationPath)) {
@@ -3991,11 +4550,11 @@ function installTemporaryOutput(temporaryPath, destinationPath, overwrite, opera
   }
 }
 function writeBufferAtomically(buffer, destinationPath) {
-  const target = path2.resolve(destinationPath);
-  fs3.mkdirSync(path2.dirname(target), { recursive: true });
-  const temporaryPath = path2.join(
-    path2.dirname(target),
-    `.${path2.basename(target)}.${randomUUID()}.tmp`
+  const target = path4.resolve(destinationPath);
+  fs3.mkdirSync(path4.dirname(target), { recursive: true });
+  const temporaryPath = path4.join(
+    path4.dirname(target),
+    `.${path4.basename(target)}.${randomUUID3()}.tmp`
   );
   const destinationMode = readDestinationMode(target);
   try {
@@ -4031,8 +4590,8 @@ function writeBufferAtomically(buffer, destinationPath) {
 
 // src/streamingZip.ts
 import * as fs4 from "fs";
-import * as path3 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+import * as path5 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
 import { finished } from "stream/promises";
 import { Readable as Readable3 } from "stream";
 import archiver3 from "archiver";
@@ -4044,8 +4603,8 @@ function readDestinationMode2(target) {
     return void 0;
   }
 }
-function appendAndWait(archive, source, name) {
-  return new Promise((resolve4, reject) => {
+function appendAndWait(archive, source, name, output) {
+  return new Promise((resolve6, reject) => {
     const cleanup = () => {
       archive.off("entry", onEntry);
       archive.off("error", onError);
@@ -4053,10 +4612,13 @@ function appendAndWait(archive, source, name) {
       if (typeof maybeEmitter2.off === "function") {
         maybeEmitter2.off("error", onError);
       }
+      if (output) {
+        output.off("error", onError);
+      }
     };
     const onEntry = () => {
       cleanup();
-      resolve4();
+      resolve6();
     };
     const onError = (error) => {
       cleanup();
@@ -4064,6 +4626,9 @@ function appendAndWait(archive, source, name) {
     };
     archive.once("entry", onEntry);
     archive.once("error", onError);
+    if (output) {
+      output.once("error", onError);
+    }
     const maybeEmitter = source;
     if (typeof maybeEmitter.once === "function") {
       maybeEmitter.once("error", onError);
@@ -4077,11 +4642,11 @@ function appendAndWait(archive, source, name) {
   });
 }
 async function writeAdmZipStreaming(zip, stagedParts, destinationPath) {
-  const target = path3.resolve(destinationPath);
-  fs4.mkdirSync(path3.dirname(target), { recursive: true });
-  const temporaryPath = path3.join(
-    path3.dirname(target),
-    `.${path3.basename(target)}.${randomUUID2()}.tmp`
+  const target = path5.resolve(destinationPath);
+  fs4.mkdirSync(path5.dirname(target), { recursive: true });
+  const temporaryPath = path5.join(
+    path5.dirname(target),
+    `.${path5.basename(target)}.${randomUUID4()}.tmp`
   );
   const destinationMode = readDestinationMode2(target);
   let output = null;
@@ -4091,18 +4656,32 @@ async function writeAdmZipStreaming(zip, stagedParts, destinationPath) {
       temporaryPath,
       destinationMode !== void 0 ? { mode: destinationMode } : {}
     );
+    let outputError = null;
+    output.on("error", (err) => {
+      outputError = err;
+      try {
+        archive == null ? void 0 : archive.abort();
+      } catch {
+      }
+    });
     archive = archiver3("zip");
+    archive.on("error", (err) => {
+      outputError = err;
+    });
     archive.pipe(output);
     for (const entry of zip.getEntries()) {
+      if (outputError) throw outputError;
       const stagedPath = stagedParts.get(entry.entryName);
       if (stagedPath) {
-        await appendAndWait(archive, fs4.createReadStream(stagedPath), entry.entryName);
+        await appendAndWait(archive, fs4.createReadStream(stagedPath), entry.entryName, output);
       } else {
-        await appendAndWait(archive, Readable3.from([entry.getData()]), entry.entryName);
+        await appendAndWait(archive, Readable3.from([entry.getData()]), entry.entryName, output);
       }
     }
+    if (outputError) throw outputError;
     await archive.finalize();
     await finished(output);
+    if (outputError) throw outputError;
     if (destinationMode !== void 0) {
       try {
         fs4.chmodSync(temporaryPath, destinationMode);
@@ -4136,6 +4715,23 @@ async function writeAdmZipStreaming(zip, stagedParts, destinationPath) {
 }
 
 // src/XlsxUpdater.ts
+function parseCellRange(ref) {
+  const m = /^\$?([A-Za-z]+)\$?(\d+)(?::\$?([A-Za-z]+)\$?(\d+))?$/.exec(ref.trim());
+  if (!m) return null;
+  const c1 = columnLetterToIndex(m[1].toUpperCase());
+  const r1 = parseInt(m[2], 10);
+  const c2 = m[3] ? columnLetterToIndex(m[3].toUpperCase()) : c1;
+  const r2 = m[4] ? parseInt(m[4], 10) : r1;
+  if (!Number.isFinite(c1) || !Number.isFinite(r1) || !Number.isFinite(c2) || !Number.isFinite(r2)) {
+    return null;
+  }
+  return {
+    c1: Math.min(c1, c2),
+    r1: Math.min(r1, r2),
+    c2: Math.max(c1, c2),
+    r2: Math.max(r1, r2)
+  };
+}
 var XlsxUpdater = class _XlsxUpdater {
   /**
    * @param path Path to an existing `.xlsx` file.
@@ -4222,6 +4818,8 @@ var XlsxUpdater = class _XlsxUpdater {
     const dimRef = totalRows > 0 && lastCol >= 0 ? `A1:${columnIndexToLetter(lastCol)}${totalRows}` : "A1";
     this._updatePivotCaches(sheetName, dimRef, rows.length);
     this._addRefreshOnLoadToPivotTables();
+    this._removeCalcChain();
+    this._updateTableRefs(sheetName, dimRef);
   }
   /**
    * Replace worksheet rows from a one-pass source without materialising the
@@ -4294,10 +4892,10 @@ var XlsxUpdater = class _XlsxUpdater {
         if (outputError) throw outputError;
         writtenBytes += data.length;
         if (rowOutput.write(data)) return;
-        await new Promise((resolve4, reject) => {
+        await new Promise((resolve6, reject) => {
           const onDrain = () => {
             cleanup();
-            resolve4();
+            resolve6();
           };
           const onError = (error) => {
             cleanup();
@@ -4337,8 +4935,8 @@ var XlsxUpdater = class _XlsxUpdater {
           lastKeptEnd = writtenBytes;
         }
       }
-      await new Promise((resolve4, reject) => {
-        rowOutput.once("close", resolve4);
+      await new Promise((resolve6, reject) => {
+        rowOutput.once("close", resolve6);
         rowOutput.once("error", reject);
         rowOutput.end();
       });
@@ -4357,6 +4955,8 @@ var XlsxUpdater = class _XlsxUpdater {
       this._commitSharedStrings();
       this._updatePivotCaches(sheetName, dimRef, keptDataRows);
       this._addRefreshOnLoadToPivotTables();
+      this._removeCalcChain();
+      this._updateTableRefs(sheetName, dimRef);
       if (oldStage && oldStage !== outputPath) {
         this._removeTemporaryFile(oldStage);
       }
@@ -4430,7 +5030,7 @@ var XlsxUpdater = class _XlsxUpdater {
   }
   _ensureTemporaryDirectory() {
     if (this.temporaryDirectory === null) {
-      this.temporaryDirectory = fs5.mkdtempSync(path4.join(os.tmpdir(), "spreadsheet-updater-"));
+      this.temporaryDirectory = fs5.mkdtempSync(path6.join(os.tmpdir(), "spreadsheet-updater-"));
     } else {
       try {
         fs5.mkdirSync(this.temporaryDirectory, { recursive: true });
@@ -4440,7 +5040,7 @@ var XlsxUpdater = class _XlsxUpdater {
     return this.temporaryDirectory;
   }
   _temporaryPath(suffix) {
-    return path4.join(this._ensureTemporaryDirectory(), `part-${Date.now()}-${Math.random().toString(16).slice(2)}${suffix}`);
+    return path6.join(this._ensureTemporaryDirectory(), `part-${Date.now()}-${Math.random().toString(16).slice(2)}${suffix}`);
   }
   _removeTemporaryFile(filePath) {
     try {
@@ -4480,10 +5080,15 @@ var XlsxUpdater = class _XlsxUpdater {
     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 relTagRe = /<Relationship\b[^>]*>/g;
+      let tagMatch;
+      while ((tagMatch = relTagRe.exec(rels)) !== null) {
+        const attrs = parseTagAttributes(tagMatch[0]);
+        const id = attrs["Id"] ?? attrs["id"];
+        const target = attrs["Target"] ?? attrs["target"];
+        if (id !== void 0 && target !== void 0) {
+          rIdToTarget[id] = target;
+        }
       }
     }
     const wbEntry = this.zip.getEntry("xl/workbook.xml");
@@ -4492,21 +5097,23 @@ var XlsxUpdater = class _XlsxUpdater {
     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;
-      }
+      const attrs = parseTagAttributes(tag);
+      const rawName = attrs["name"];
+      const rId = attrs["r:id"] ?? attrs["id"] ?? attrs["rId"];
+      if (rawName === void 0 || rId === void 0) continue;
+      const name = unescapeXml(rawName);
+      const target = rIdToTarget[rId] ?? "";
+      const fullPath = resolveRelTarget(target);
       if (fullPath) {
         this.sheetNameToPath.set(name, fullPath);
       }
     }
+    const wbPrMatch = /<workbookPr\b[^>]*>/i.exec(wbXml);
+    if (wbPrMatch) {
+      const wbPrAttrs = parseTagAttributes(wbPrMatch[0]);
+      const v = (wbPrAttrs["date1904"] ?? "").trim().toLowerCase();
+      this._oaEpoch = v === "1" || v === "true" ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+    }
     for (const entry of this.zip.getEntries()) {
       const name = entry.entryName;
       if (/^xl\/pivotCache\/pivotCacheDefinition\d*\.xml$/.test(name)) {
@@ -4701,7 +5308,7 @@ var XlsxUpdater = class _XlsxUpdater {
       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;
+      const oaDate = timeToOaDate(val.getTime(), this._oaEpoch);
       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>`;
@@ -4918,8 +5525,8 @@ var XlsxUpdater = class _XlsxUpdater {
     }
   }
   _addRefreshOnLoadToPivotTables() {
-    for (const path7 of this.pivotTableDefPaths) {
-      const entry = this.zip.getEntry(path7);
+    for (const path9 of this.pivotTableDefPaths) {
+      const entry = this.zip.getEntry(path9);
       if (!entry) continue;
       let xml = entry.getData().toString("utf8");
       const rootRe = /<pivotTableDefinition\b[^>]*>/;
@@ -4927,7 +5534,233 @@ var XlsxUpdater = class _XlsxUpdater {
       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(path7, Buffer.from(xml, "utf8"));
+      this.zip.updateFile(path9, Buffer.from(xml, "utf8"));
+    }
+  }
+  /**
+   * Remove the stale calculation chain (xl/calcChain.xml). Excel rebuilds it
+   * on open; keeping stale <c> entries for the replaced sheet would force a
+   * repair prompt. Removes the part, its Content_Types override and its
+   * workbook rels entry (xlspy parity).
+   */
+  _removeCalcChain() {
+    const calcPath = "xl/calcChain.xml";
+    if (!this.zip.getEntry(calcPath) && !this.stagedParts.has(calcPath)) {
+      this._ensureCalcPrFullCalc();
+      return;
+    }
+    try {
+      this.zip.deleteFile(calcPath);
+    } catch {
+    }
+    const stagedCalc = this.stagedParts.get(calcPath);
+    if (stagedCalc) {
+      this.stagedParts.delete(calcPath);
+      try {
+        fs5.rmSync(stagedCalc, { force: true });
+      } catch {
+      }
+    }
+    const ctEntry = this.zip.getEntry("[Content_Types].xml");
+    if (ctEntry || this.stagedParts.has("[Content_Types].xml")) {
+      try {
+        let ct = this._entryData("[Content_Types].xml").toString("utf8");
+        const before = ct;
+        ct = ct.replace(/<Override\b[^>]*PartName="\/xl\/calcChain\.xml"[^>]*\/?>/gi, "");
+        if (ct !== before) {
+          this._writePartText("[Content_Types].xml", ct);
+        }
+      } catch {
+      }
+    }
+    const relsPath = "xl/_rels/workbook.xml.rels";
+    if (this.zip.getEntry(relsPath) || this.stagedParts.has(relsPath)) {
+      try {
+        const rels = this._entryData(relsPath).toString("utf8");
+        const relTagRe = /<Relationship\b[^>]*>/g;
+        let m;
+        let out = "";
+        let last = 0;
+        let changed = false;
+        while ((m = relTagRe.exec(rels)) !== null) {
+          const attrs = parseTagAttributes(m[0]);
+          const type = attrs["Type"] ?? attrs["type"] ?? "";
+          const target = attrs["Target"] ?? attrs["target"] ?? "";
+          const isCalcChain = type.endsWith("/calcChain") && resolveRelTarget(target) === "xl/calcChain.xml";
+          if (isCalcChain) {
+            out += rels.substring(last, m.index);
+            last = m.index + m[0].length;
+            changed = true;
+          }
+        }
+        if (changed) {
+          out += rels.substring(last);
+          this._writePartText(relsPath, out);
+        }
+      } catch {
+      }
+    }
+    this._ensureCalcPrFullCalc();
+  }
+  _writePartText(name, text) {
+    if (this.stagedParts.has(name)) {
+      fs5.writeFileSync(this.stagedParts.get(name), text, "utf8");
+    } else {
+      this.zip.updateFile(name, Buffer.from(text, "utf8"));
+    }
+  }
+  _ensureCalcPrFullCalc() {
+    try {
+      const wbPath = "xl/workbook.xml";
+      if (!this.zip.getEntry(wbPath) && !this.stagedParts.has(wbPath)) return;
+      let xml = this._entryData(wbPath).toString("utf8");
+      const calcPrRe = /<(?:[A-Za-z_][\w.-]*:)?calcPr\b[^>]*>/i;
+      const match = calcPrRe.exec(xml);
+      if (match && match.index !== void 0) {
+        const newTag = _XlsxUpdater._replaceOrAddXmlAttribute(match[0], "fullCalcOnLoad", "1");
+        xml = xml.substring(0, match.index) + newTag + xml.substring(match.index + match[0].length);
+      } else {
+        const insertAt = _XlsxUpdater._calcPrInsertPosition(xml);
+        if (insertAt < 0) return;
+        xml = xml.substring(0, insertAt) + '<calcPr fullCalcOnLoad="1"/>' + xml.substring(insertAt);
+      }
+      this._writePartText(wbPath, xml);
+    } catch {
+    }
+  }
+  /**
+   * Insertion offset for a missing `<calcPr>`. The element follows
+   * sheets/externalReferences/definedNames in the workbook schema, so insert
+   * after the last of those that exists instead of right after `<workbook>`.
+   */
+  static _calcPrInsertPosition(xml) {
+    const prefixed = "(?:[A-Za-z_][\\w.-]*:)?";
+    const candidates = [
+      new RegExp(`</${prefixed}sheets\\s*>`, "i"),
+      new RegExp(`<${prefixed}externalReferences\\b[^>]*/>`, "i"),
+      new RegExp(`<${prefixed}externalReferences\\b[^>]*>[\\s\\S]*?</${prefixed}externalReferences\\s*>`, "i"),
+      new RegExp(`<${prefixed}definedNames\\b[^>]*/>`, "i"),
+      new RegExp(`<${prefixed}definedNames\\b[^>]*>[\\s\\S]*?</${prefixed}definedNames\\s*>`, "i")
+    ];
+    let insertAt = -1;
+    for (const re of candidates) {
+      const m = re.exec(xml);
+      if (m && m.index !== void 0) {
+        insertAt = Math.max(insertAt, m.index + m[0].length);
+      }
+    }
+    if (insertAt >= 0) return insertAt;
+    const close = new RegExp(`</${prefixed}workbook\\s*>`, "i").exec(xml);
+    if (close && close.index !== void 0) return close.index;
+    const root = new RegExp(`<${prefixed}workbook\\b[^>]*>`, "i").exec(xml);
+    if (!root || root.index === void 0) return -1;
+    return root.index + root[0].length;
+  }
+  /**
+   * Update ListObject table ranges (xl/tables/*.xml) for the replaced sheet.
+   * Only tables anchored at A1 are updated to the new dimension; tables
+   * elsewhere are left untouched (moving them would corrupt the sheet).
+   * Empty replacements (dimRef "A1") do not shrink multi-column tables.
+   */
+  _updateTableRefs(sheetName, dimRef) {
+    const sheetPath = this.sheetNameToPath.get(sheetName);
+    if (!sheetPath) return;
+    const slash = sheetPath.lastIndexOf("/");
+    const dir = slash >= 0 ? sheetPath.substring(0, slash + 1) : "";
+    const base = slash >= 0 ? sheetPath.substring(slash + 1) : sheetPath;
+    const sheetRelsPath = `${dir}_rels/${base}.rels`;
+    const sheetRelsEntry = this.zip.getEntry(sheetRelsPath);
+    const hasStagedRels = this.stagedParts.has(sheetRelsPath);
+    if (!sheetRelsEntry && !hasStagedRels) return;
+    const tableTargets = [];
+    try {
+      const relsXml = this._entryData(sheetRelsPath).toString("utf8");
+      const relTagRe = /<Relationship\b[^>]*>/g;
+      let m;
+      while ((m = relTagRe.exec(relsXml)) !== null) {
+        const attrs = parseTagAttributes(m[0]);
+        const type = attrs["Type"] ?? attrs["type"] ?? "";
+        const target = attrs["Target"] ?? attrs["target"] ?? "";
+        if (!type.includes("/table") || !target) continue;
+        let tablePath;
+        if (target.startsWith("/")) {
+          tablePath = resolveRelTarget(target);
+        } else {
+          const combined = dir + target;
+          const parts = [];
+          for (const seg of combined.split("/")) {
+            if (seg === "..") parts.pop();
+            else if (seg !== "." && seg !== "") parts.push(seg);
+          }
+          tablePath = parts.join("/");
+        }
+        tableTargets.push(tablePath);
+      }
+    } catch {
+      return;
+    }
+    if (tableTargets.length === 0) return;
+    const tables = [];
+    for (const tablePath of tableTargets) {
+      try {
+        const hasEntry = !!this.zip.getEntry(tablePath);
+        const hasStaged = this.stagedParts.has(tablePath);
+        if (!hasEntry && !hasStaged) continue;
+        const xml = this._entryData(tablePath).toString("utf8");
+        const tableTagRe = /<(?:[A-Za-z_][\w.-]*:)?table\b[^>]*>/i;
+        const tableMatch = tableTagRe.exec(xml);
+        if (!tableMatch || tableMatch.index === void 0) continue;
+        const refMatch = /\bref\s*=\s*("([^"]*)"|'([^']*)')/i.exec(tableMatch[0]);
+        const ref = refMatch ? refMatch[2] ?? refMatch[3] ?? "" : "";
+        tables.push({
+          path: tablePath,
+          xml,
+          tag: tableMatch[0],
+          tagIndex: tableMatch.index,
+          ref,
+          range: parseCellRange(ref),
+          staged: hasStaged
+        });
+      } catch {
+      }
+    }
+    if (tables.length === 0) return;
+    const dimRange = parseCellRange(dimRef);
+    if (!dimRange) return;
+    for (const table of tables) {
+      try {
+        const origRange = table.range;
+        if (!origRange) continue;
+        if (origRange.r1 !== 1 || origRange.c1 !== 0) continue;
+        if (dimRef === "A1" && !/^A1$/i.test(table.ref)) continue;
+        const origCols = origRange.c2 - origRange.c1 + 1;
+        const newCols = dimRange.c2 - dimRange.c1 + 1;
+        if (newCols !== origCols) continue;
+        let lastRow = dimRange.r2;
+        for (const other of tables) {
+          if (other === table || !other.range) continue;
+          if (other.range.r1 <= 1) continue;
+          if (other.range.c1 > origRange.c2 || other.range.c2 < origRange.c1) continue;
+          lastRow = Math.min(lastRow, other.range.r1 - 1);
+        }
+        if (lastRow < 1) continue;
+        const newRef = origRange.c2 === 0 && lastRow === 1 ? "A1" : `A1:${columnIndexToLetter(origRange.c2)}${lastRow}`;
+        let xml = table.xml;
+        const newTag = _XlsxUpdater._replaceOrAddXmlAttribute(table.tag, "ref", newRef);
+        xml = xml.substring(0, table.tagIndex) + newTag + xml.substring(table.tagIndex + table.tag.length);
+        const afRe = /<(?:[A-Za-z_][\w.-]*:)?autoFilter\b[^>]*>/i;
+        const afMatch = afRe.exec(xml);
+        if (afMatch && afMatch.index !== void 0) {
+          const newAf = _XlsxUpdater._replaceOrAddXmlAttribute(afMatch[0], "ref", newRef);
+          xml = xml.substring(0, afMatch.index) + newAf + xml.substring(afMatch.index + afMatch[0].length);
+        }
+        if (table.staged) {
+          fs5.writeFileSync(this.stagedParts.get(table.path), xml, "utf8");
+        } else {
+          this.zip.updateFile(table.path, Buffer.from(xml, "utf8"));
+        }
+      } catch {
+      }
     }
   }
 };
@@ -4935,78 +5768,8 @@ var XlsxUpdater = class _XlsxUpdater {
 // src/XlsbUpdater.ts
 import * as fs6 from "fs";
 import * as os2 from "os";
-import * as path5 from "path";
+import * as path7 from "path";
 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;
@@ -5110,6 +5873,7 @@ var XlsbUpdater = class {
     const rwLast = Math.max(0, rows.length + (headers ? 1 : 0) - 1);
     const colLast = lastCol;
     this._patchPivotCaches(sheetName, rwLast, colLast);
+    this._removeCalcChain();
   }
   /** Replace worksheet rows from a one-pass source. */
   async replaceSheetDataStream(sheetName, rows, options = {}) {
@@ -5177,10 +5941,10 @@ var XlsbUpdater = class {
         if (outputError) throw outputError;
         writtenBytes += data.length;
         if (rowOutput.write(data)) return;
-        await new Promise((resolve4, reject) => {
+        await new Promise((resolve6, reject) => {
           const onDrain = () => {
             cleanup();
-            resolve4();
+            resolve6();
           };
           const onError = (error) => {
             cleanup();
@@ -5231,8 +5995,8 @@ var XlsbUpdater = class {
           lastKeptEnd = writtenBytes;
         }
       }
-      await new Promise((resolve4, reject) => {
-        rowOutput.once("close", resolve4);
+      await new Promise((resolve6, reject) => {
+        rowOutput.once("close", resolve6);
         rowOutput.once("error", reject);
         rowOutput.end();
       });
@@ -5295,6 +6059,7 @@ var XlsbUpdater = class {
         Math.max(0, keptDataRows + (headers !== void 0 ? 1 : 0) - 1),
         lastCol
       );
+      this._removeCalcChain();
       if (oldStage && oldStage !== outputPath) this._removeTemporaryFile(oldStage);
       createdParts.splice(createdParts.indexOf(outputPath), 1);
     } catch (error) {
@@ -5365,7 +6130,7 @@ var XlsbUpdater = class {
   }
   _ensureTemporaryDirectory() {
     if (this.temporaryDirectory === null) {
-      this.temporaryDirectory = fs6.mkdtempSync(path5.join(os2.tmpdir(), "spreadsheet-updater-"));
+      this.temporaryDirectory = fs6.mkdtempSync(path7.join(os2.tmpdir(), "spreadsheet-updater-"));
     } else {
       try {
         fs6.mkdirSync(this.temporaryDirectory, { recursive: true });
@@ -5375,7 +6140,7 @@ var XlsbUpdater = class {
     return this.temporaryDirectory;
   }
   _temporaryPath(suffix) {
-    return path5.join(this._ensureTemporaryDirectory(), `part-${Date.now()}-${Math.random().toString(16).slice(2)}${suffix}`);
+    return path7.join(this._ensureTemporaryDirectory(), `part-${Date.now()}-${Math.random().toString(16).slice(2)}${suffix}`);
   }
   _removeTemporaryFile(filePath) {
     try {
@@ -5415,10 +6180,15 @@ var XlsbUpdater = class {
     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 relTagRe = /<Relationship\b[^>]*>/g;
+      let tagMatch;
+      while ((tagMatch = relTagRe.exec(rels)) !== null) {
+        const attrs = parseTagAttributes(tagMatch[0]);
+        const id = attrs["Id"] ?? attrs["id"];
+        const target = attrs["Target"] ?? attrs["target"];
+        if (id !== void 0 && target !== void 0) {
+          rIdToTarget[id] = target;
+        }
       }
     }
     const wbEntry = this.zip.getEntry("xl/workbook.bin");
@@ -5438,12 +6208,24 @@ var XlsbUpdater = class {
         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;
+        target = resolveRelTarget(target);
         if (target) {
           this.sheetNameToPath.set(name, target);
         }
       }
+      try {
+        const rec1904 = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
+        let p1904 = 0;
+        while (readRecord(wbBuf, p1904, rec1904)) {
+          if (rec1904.id === 153 && rec1904.len >= 4) {
+            const is1904 = (wbBuf[rec1904.dataStart] & 1) !== 0;
+            this._oaEpoch = is1904 ? Date.UTC(1904, 0, 1) : Date.UTC(1899, 11, 30);
+            break;
+          }
+          p1904 = rec1904.dataEnd;
+        }
+      } catch {
+      }
     }
     for (const e of this.zip.getEntries()) {
       if (/^xl\/pivotCache\/pivotCacheDefinition\d*\.bin$/.test(e.entryName)) {
@@ -5552,27 +6334,15 @@ var XlsbUpdater = class {
   _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++;
+    const reader = new BiffReaderWriter(entry.getData());
+    while (reader.readStyles()) {
+    }
+    const numFmtIds = reader._xfIndexToNumFmtId;
+    const customDates = reader._customNumFmts;
+    for (let i = 0; i < numFmtIds.length; i++) {
+      const numFmtId = numFmtIds[i];
+      if (numFmtId >= 14 && numFmtId <= 22 || numFmtId >= 45 && numFmtId <= 47 || customDates.has(numFmtId)) {
+        return i;
       }
     }
     return null;
@@ -5652,7 +6422,7 @@ var XlsbUpdater = class {
       return buildRecord(4, payload);
     }
     if (val instanceof Date) {
-      const oaDate = (val.getTime() - this._oaEpoch) / 864e5;
+      const oaDate = timeToOaDate(val.getTime(), this._oaEpoch);
       if (Number.isFinite(oaDate)) {
         const style = colStyle > 0 ? colStyle : dateXf !== null ? dateXf : 0;
         const payload = Buffer.alloc(16);
@@ -5719,10 +6489,10 @@ var XlsbUpdater = class {
       const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
       let pos = 0;
       while (readRecord(originalSheet, pos, rec)) {
-        if (rec.id === 152 && rec.len >= 36) {
+        if (rec.id === 148 && rec.len >= 16) {
           const shift = rec.dataStart >= rowsEnd ? delta : 0;
-          patchInt32(rec.dataStart + shift + 24, lastRowIdx);
-          patchInt32(rec.dataStart + shift + 32, lastCol);
+          patchInt32(rec.dataStart + shift + 4, lastRowIdx);
+          patchInt32(rec.dataStart + shift + 12, lastCol);
           break;
         }
         pos = rec.dataEnd;
@@ -5761,8 +6531,8 @@ var XlsbUpdater = class {
     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)
+   * Keep the sheet dimension record (0x94) in sync with the new data.
+   * Excel uses its rwLast (payload offset 4) and colLast (payload offset 12)
    * fields to read the full row range; stale values make the last written row
    * invisible to Excel (and drop it from pivot refreshes).
    */
@@ -5770,9 +6540,9 @@ var XlsbUpdater = class {
     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);
+      if (rec.id === 148 && rec.len >= 16) {
+        sheetBuf.writeInt32LE(lastRowIdx, rec.dataStart + 4);
+        sheetBuf.writeInt32LE(lastCol, rec.dataStart + 12);
         return;
       }
       pos = rec.dataEnd;
@@ -5782,8 +6552,8 @@ var XlsbUpdater = class {
   // Pivot cache integration
   // ------------------------------------------------------------------
   _patchPivotCaches(sheetName, rwLast, colLast) {
-    for (const path7 of this.pivotCacheDefPaths) {
-      const entry = this.zip.getEntry(path7);
+    for (const path9 of this.pivotCacheDefPaths) {
+      const entry = this.zip.getEntry(path9);
       if (!entry) continue;
       const buf = Buffer.from(entry.getData());
       const rec = { headerStart: 0, dataStart: 0, dataEnd: 0, id: 0, len: 0 };
@@ -5815,16 +6585,84 @@ var XlsbUpdater = class {
         }
       }
       if (patched) {
-        this.zip.updateFile(path7, buf);
+        this.zip.updateFile(path9, buf);
+      }
+    }
+  }
+  /**
+   * Remove the stale calculation chain (xl/calcChain.bin). Excel rebuilds it
+   * on open. Removes the part, its Content_Types override and its workbook
+   * rels entry. XLSB tables are not patched (documented limitation).
+   */
+  _removeCalcChain() {
+    const calcPath = "xl/calcChain.bin";
+    if (!this.zip.getEntry(calcPath) && !this.stagedParts.has(calcPath)) return;
+    try {
+      this.zip.deleteFile(calcPath);
+    } catch {
+    }
+    const stagedCalc = this.stagedParts.get(calcPath);
+    if (stagedCalc) {
+      this.stagedParts.delete(calcPath);
+      try {
+        fs6.rmSync(stagedCalc, { force: true });
+      } catch {
+      }
+    }
+    const ctPath = "[Content_Types].xml";
+    if (this.zip.getEntry(ctPath) || this.stagedParts.has(ctPath)) {
+      try {
+        const ct = this._entryData(ctPath).toString("utf8");
+        const updated = ct.replace(
+          /<Override\b[^>]*PartName="\/xl\/calcChain\.bin"[^>]*\/?>/gi,
+          ""
+        );
+        if (updated !== ct) this._writePartText(ctPath, updated);
+      } catch {
+      }
+    }
+    const relsPath = "xl/_rels/workbook.bin.rels";
+    if (this.zip.getEntry(relsPath) || this.stagedParts.has(relsPath)) {
+      try {
+        const rels = this._entryData(relsPath).toString("utf8");
+        const relTagRe = /<Relationship\b[^>]*>/g;
+        let m;
+        let out = "";
+        let last = 0;
+        let changed = false;
+        while ((m = relTagRe.exec(rels)) !== null) {
+          const attrs = parseTagAttributes(m[0]);
+          const type = attrs["Type"] ?? attrs["type"] ?? "";
+          const target = attrs["Target"] ?? attrs["target"] ?? "";
+          if (type.endsWith("/calcChain") && resolveRelTarget(target) === "xl/calcChain.bin") {
+            out += rels.substring(last, m.index);
+            last = m.index + m[0].length;
+            changed = true;
+          }
+        }
+        if (changed) {
+          out += rels.substring(last);
+          this._writePartText(relsPath, out);
+        }
+      } catch {
       }
     }
   }
+  /** Write an XML/text part to its staged file when present, else into the ZIP. */
+  _writePartText(name, text) {
+    const stagedPath = this.stagedParts.get(name);
+    if (stagedPath) {
+      fs6.writeFileSync(stagedPath, text, "utf8");
+    } else {
+      this.zip.updateFile(name, Buffer.from(text, "utf8"));
+    }
+  }
 };
 
 // src/ExcelConverter.ts
 import * as fs7 from "fs";
-import * as path6 from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import * as path8 from "path";
+import { randomUUID as randomUUID5 } from "crypto";
 import { spawn } from "child_process";
 var POWERSHELL_CONVERSION_SCRIPT = `
 $ErrorActionPreference = 'Stop'
@@ -5870,14 +6708,14 @@ function errorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function validateConversionPaths(inputPath, outputPath, inputExtension, outputExtension, overwrite) {
-  const input = path6.resolve(inputPath);
-  const output = path6.resolve(outputPath);
-  if (path6.extname(input).toLowerCase() !== inputExtension) {
+  const input = path8.resolve(inputPath);
+  const output = path8.resolve(outputPath);
+  if (path8.extname(input).toLowerCase() !== inputExtension) {
     throw new Error(
       `Excel conversion: source must have the ${inputExtension} extension: ${inputPath}`
     );
   }
-  if (path6.extname(output).toLowerCase() !== outputExtension) {
+  if (path8.extname(output).toLowerCase() !== outputExtension) {
     throw new Error(
       `Excel conversion: destination must have the ${outputExtension} extension: ${outputPath}`
     );
@@ -5888,8 +6726,8 @@ function validateConversionPaths(inputPath, outputPath, inputExtension, outputEx
   if (!fs7.statSync(input).isFile()) {
     throw new Error(`Excel conversion: source path is not a file: ${inputPath}`);
   }
-  if (!fs7.existsSync(path6.dirname(output))) {
-    throw new Error(`Excel conversion: destination directory not found: ${path6.dirname(output)}`);
+  if (!fs7.existsSync(path8.dirname(output))) {
+    throw new Error(`Excel conversion: destination directory not found: ${path8.dirname(output)}`);
   }
   if (fs7.existsSync(output)) {
     if (fs7.statSync(output).isDirectory()) {
@@ -5914,7 +6752,7 @@ function runPowerShellConversion(inputPath, outputPath, fileFormat) {
     JUSTYBASE_EXCEL_OUTPUT: outputPath,
     JUSTYBASE_EXCEL_FORMAT: String(fileFormat)
   };
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve6, reject) => {
     var _a, _b, _c, _d;
     let stdout = "";
     let stderr = "";
@@ -5949,7 +6787,7 @@ function runPowerShellConversion(inputPath, outputPath, fileFormat) {
       if (settled) return;
       settled = true;
       if (code === 0) {
-        resolve4();
+        resolve6();
         return;
       }
       const details = (stderr || stdout).replace(/\s+/g, " ").trim();
@@ -5970,9 +6808,9 @@ async function convertExcelFile(inputPath, outputPath, inputExtension, outputExt
   if (process.platform !== "win32") {
     throw new Error("Excel conversion requires Windows with desktop Microsoft Excel and COM automation.");
   }
-  const temporaryOutput = path6.join(
-    path6.dirname(output),
-    `.${path6.basename(output, outputExtension)}.${randomUUID3()}.conversion${outputExtension}`
+  const temporaryOutput = path8.join(
+    path8.dirname(output),
+    `.${path8.basename(output, outputExtension)}.${randomUUID5()}.conversion${outputExtension}`
   );
   try {
     await runPowerShellConversion(input, temporaryOutput, fileFormat);
@@ -6003,6 +6841,9 @@ export {
   ExcelReaderAbstract,
   F,
   INVALID_SHEET_NAME_CHARS,
+  MAX_CELL_CHARS,
+  MAX_COLS,
+  MAX_ROWS,
   ReaderFactory,
   StreamingSheetState,
   XlsbReader,
@@ -6013,13 +6854,25 @@ export {
   XlsxUpdater,
   XlsxWriter,
   applyHeaderWidths,
+  assertCellTextLength,
+  assertColumnCount,
+  assertRowCount,
+  assertRowFitsColumns,
+  columnIndexToLetter,
+  columnLetterToIndex,
   convertXlsbToXlsx,
   convertXlsxToXlsb,
   defaultColWidth,
+  escapeXmlText,
   getFormat,
   initColWidths,
   isFormattedCell,
+  parseSharedStringsXml,
+  parseTagAttributes,
+  resolveRelTarget,
   sanitizeSheetName,
+  trimTrailingEmptyRows,
+  unescapeXml,
   unwrapCell,
   updateColWidthsFromRows
 };