@devmm/puredocs-excel 1.0.5 → 1.0.7

package/dist/index.cjs

@@ -50,10 +50,10 @@ function parseMinimal(xmlString) {
   }
   function parseAttributes(raw) {
     const attrs = {};
-    const re = /(\S+?)\s*=\s*["']([^"']*)["']/g;
+    const re = /([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
     let m;
     while ((m = re.exec(raw)) !== null) {
-      attrs[m[1]] = m[2].replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+      attrs[m[1]] = decodeXmlEntities(m[2] ?? m[3] ?? "");
     }
     return attrs;
   }
@@ -107,7 +107,7 @@ function parseMinimal(xmlString) {
     } else {
       const textStart = pos;
       skipUntil("<");
-      const text = xmlString.slice(textStart, pos).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+      const text = decodeXmlEntities(xmlString.slice(textStart, pos));
       if (stack.length > 0 && text.trim()) {
         stack[stack.length - 1].textContent += text;
       }
@@ -116,6 +116,10 @@ function parseMinimal(xmlString) {
   if (!root) throw new Error("XML parse error: empty document.");
   return root;
 }
+function decodeXmlEntities(value) {
+  if (value.indexOf("&") === -1) return value;
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
 function parseXml(xmlString) {
   if (typeof DOMParser !== "undefined") {
     return parseDom(xmlString);
@@ -192,6 +196,124 @@ function listEntries(entries, prefix) {
   }
   return results.sort();
 }
+
+// src/io/zip-container.ts
+var LOCAL_HEADER = 67324752;
+var CENTRAL_HEADER = 33639248;
+var END_OF_CENTRAL_DIR = 101010256;
+var DOS_DATE = 33;
+var DOS_TIME = 0;
+var MAX_ENTRIES = 65535;
+var MAX_BYTES = 4294967295;
+var CRC_TABLE = (() => {
+  const table = new Int32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[i] = c;
+  }
+  return table;
+})();
+function crc32(data) {
+  let c = -1;
+  for (let i = 0; i < data.length; i++) {
+    c = c >>> 8 ^ CRC_TABLE[(c ^ data[i]) & 255];
+  }
+  return (c ^ -1) >>> 0;
+}
+function exceedsZipLimits(parts) {
+  if (parts.length > MAX_ENTRIES) return true;
+  let total = 0;
+  for (const p of parts) {
+    total += 30 + utf8Length(p.name) * 2 + 46 + p.deflated.length;
+    if (total > MAX_BYTES || p.rawSize > MAX_BYTES) return true;
+  }
+  return false;
+}
+function buildZipContainer(parts) {
+  const names = parts.map((p) => encodeName(p.name));
+  let localSize = 0;
+  let centralSize = 0;
+  for (let i = 0; i < parts.length; i++) {
+    localSize += 30 + names[i].bytes.length + parts[i].deflated.length;
+    centralSize += 46 + names[i].bytes.length;
+  }
+  const out = new Uint8Array(localSize + centralSize + 22);
+  const view = new DataView(out.buffer);
+  const offsets = [];
+  let at = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const name = names[i];
+    offsets.push(at);
+    view.setUint32(at, LOCAL_HEADER, true);
+    view.setUint16(at + 4, 20, true);
+    view.setUint16(at + 6, name.utf8Flag, true);
+    view.setUint16(at + 8, 8, true);
+    view.setUint16(at + 10, DOS_TIME, true);
+    view.setUint16(at + 12, DOS_DATE, true);
+    view.setUint32(at + 14, part.crc, true);
+    view.setUint32(at + 18, part.deflated.length, true);
+    view.setUint32(at + 22, part.rawSize, true);
+    view.setUint16(at + 26, name.bytes.length, true);
+    view.setUint16(at + 28, 0, true);
+    at += 30;
+    out.set(name.bytes, at);
+    at += name.bytes.length;
+    out.set(part.deflated, at);
+    at += part.deflated.length;
+  }
+  const centralStart = at;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const name = names[i];
+    view.setUint32(at, CENTRAL_HEADER, true);
+    view.setUint16(at + 4, 20, true);
+    view.setUint16(at + 6, 20, true);
+    view.setUint16(at + 8, name.utf8Flag, true);
+    view.setUint16(at + 10, 8, true);
+    view.setUint16(at + 12, DOS_TIME, true);
+    view.setUint16(at + 14, DOS_DATE, true);
+    view.setUint32(at + 16, part.crc, true);
+    view.setUint32(at + 20, part.deflated.length, true);
+    view.setUint32(at + 24, part.rawSize, true);
+    view.setUint16(at + 28, name.bytes.length, true);
+    view.setUint16(at + 30, 0, true);
+    view.setUint16(at + 32, 0, true);
+    view.setUint16(at + 34, 0, true);
+    view.setUint16(at + 36, 0, true);
+    view.setUint32(at + 38, 0, true);
+    view.setUint32(at + 42, offsets[i], true);
+    at += 46;
+    out.set(name.bytes, at);
+    at += name.bytes.length;
+  }
+  view.setUint32(at, END_OF_CENTRAL_DIR, true);
+  view.setUint16(at + 4, 0, true);
+  view.setUint16(at + 6, 0, true);
+  view.setUint16(at + 8, parts.length, true);
+  view.setUint16(at + 10, parts.length, true);
+  view.setUint32(at + 12, at - centralStart, true);
+  view.setUint32(at + 16, centralStart, true);
+  view.setUint16(at + 20, 0, true);
+  return out;
+}
+function encodeName(name) {
+  const bytes = new TextEncoder().encode(name);
+  let ascii = true;
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] > 127) {
+      ascii = false;
+      break;
+    }
+  }
+  return { bytes, utf8Flag: ascii ? 0 : 2048 };
+}
+function utf8Length(name) {
+  return new TextEncoder().encode(name).length;
+}
+
+// src/io/zip-writer.ts
 function zipXlsx(entries) {
   const zippable = {};
   for (const [path, content] of entries) {
@@ -206,6 +328,95 @@ function zipXlsx(entries) {
     );
   }
 }
+var ASYNC_MIN_BYTES = 512 * 1024;
+function createDeflateCache() {
+  return /* @__PURE__ */ new Map();
+}
+function compress(name, source, bytes) {
+  return {
+    name,
+    source,
+    deflated: fflate.deflateSync(bytes, { level: 6 }),
+    crc: crc32(bytes),
+    rawSize: bytes.length
+  };
+}
+function zipXlsxCached(entries, cache) {
+  const parts = collectParts(entries, cache);
+  pruneCache(entries, cache);
+  return exceedsZipLimits(parts) ? zipXlsx(entries) : buildZipContainer(parts);
+}
+async function zipXlsxCachedAsync(entries, cache) {
+  const order = [];
+  const ready = /* @__PURE__ */ new Map();
+  const jobs = [];
+  const todo = [];
+  let todoBytes = 0;
+  for (const [path, content] of entries) {
+    order.push(path);
+    const cached = cache.get(path);
+    if (cached && cached.source === content) {
+      ready.set(path, cached);
+      continue;
+    }
+    const bytes = typeof content === "string" ? encodeUtf8(content) : content;
+    todo.push({ path, content, bytes });
+    todoBytes += bytes.length;
+  }
+  if (todoBytes <= ASYNC_MIN_BYTES) {
+    for (const { path, content, bytes } of todo) {
+      const compressed = compress(path, content, bytes);
+      cache.set(path, compressed);
+      ready.set(path, compressed);
+    }
+  } else {
+    for (const { path, content, bytes } of todo) {
+      jobs.push(deflateAsync(bytes).then((deflated) => ({
+        name: path,
+        source: content,
+        deflated,
+        crc: crc32(bytes),
+        rawSize: bytes.length
+      })));
+    }
+  }
+  for (const part of await Promise.all(jobs)) {
+    cache.set(part.name, part);
+    ready.set(part.name, part);
+  }
+  pruneCache(entries, cache);
+  const parts = order.map((path) => ready.get(path));
+  return exceedsZipLimits(parts) ? zipXlsx(entries) : buildZipContainer(parts);
+}
+function deflateAsync(bytes) {
+  return new Promise((resolve, reject) => {
+    fflate.deflate(bytes, { level: 6 }, (err, data) => {
+      if (err) reject(new Error(`Failed to create xlsx: ${err.message}`));
+      else resolve(data);
+    });
+  });
+}
+function collectParts(entries, cache) {
+  const parts = [];
+  for (const [path, content] of entries) {
+    const cached = cache.get(path);
+    if (cached && cached.source === content) {
+      parts.push(cached);
+      continue;
+    }
+    const bytes = typeof content === "string" ? encodeUtf8(content) : content;
+    const part = compress(path, content, bytes);
+    cache.set(path, part);
+    parts.push(part);
+  }
+  return parts;
+}
+function pruneCache(entries, cache) {
+  if (cache.size === entries.size) return;
+  for (const path of [...cache.keys()]) {
+    if (!entries.has(path)) cache.delete(path);
+  }
+}
 function setXmlEntry(entries, path, xml2) {
   entries.set(path, xml2);
 }
@@ -296,7 +507,10 @@ var REL_TYPES = {
   styles: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
   chart: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
   drawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
-  hyperlink: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+  hyperlink: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+  comments: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+  vmlDrawing: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing",
+  calcChain: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain"
 };
 var CONTENT_TYPES = {
   workbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
@@ -306,7 +520,10 @@ var CONTENT_TYPES = {
   drawing: "application/vnd.openxmlformats-officedocument.drawing+xml",
   chart: "application/vnd.openxmlformats-officedocument.drawingml.chart+xml",
   relationships: "application/vnd.openxmlformats-package.relationships+xml",
-  coreProperties: "application/vnd.openxmlformats-package.core-properties+xml"
+  coreProperties: "application/vnd.openxmlformats-package.core-properties+xml",
+  comments: "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml",
+  vmlDrawing: "application/vnd.openxmlformats-officedocument.vmlDrawing",
+  calcChain: "application/vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml"
 };
 
 // src/io/ooxml-templates.ts
@@ -339,18 +556,20 @@ var ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
   <Relationship Id="rId1" Type="${REL_TYPES.officeDocument}" Target="xl/workbook.xml"/>
 </Relationships>`;
-function buildWorkbookRels(sheetCount) {
+function buildWorkbookRels(sheetCount, includeCalcChain = false) {
   const sheetRels = Array.from(
     { length: sheetCount },
     (_, i) => `  <Relationship Id="rId${i + 1}" Type="${REL_TYPES.worksheet}" Target="worksheets/sheet${i + 1}.xml"/>`
   ).join("\n");
   const stylesId = sheetCount + 1;
   const sharedId = sheetCount + 2;
+  const calcChainRel = includeCalcChain ? `
+  <Relationship Id="rId${sheetCount + 3}" Type="${REL_TYPES.calcChain}" Target="calcChain.xml"/>` : "";
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
 ${sheetRels}
   <Relationship Id="rId${stylesId}" Type="${REL_TYPES.styles}" Target="styles.xml"/>
-  <Relationship Id="rId${sharedId}" Type="${REL_TYPES.sharedStrings}" Target="sharedStrings.xml"/>
+  <Relationship Id="rId${sharedId}" Type="${REL_TYPES.sharedStrings}" Target="sharedStrings.xml"/>${calcChainRel}
 </Relationships>`;
 }
 function buildWorkbookXml(sheets, definedNames = []) {
@@ -451,8 +670,9 @@ function parseRelationships(relsXml, ownerPath) {
     const tag = m[0];
     const id = /\bId="([^"]*)"/.exec(tag)?.[1];
     const type = /\bType="([^"]*)"/.exec(tag)?.[1];
-    const target = /\bTarget="([^"]*)"/.exec(tag)?.[1];
-    if (!id || !type || target === void 0) continue;
+    const rawTarget = /\bTarget="([^"]*)"/.exec(tag)?.[1];
+    if (!id || !type || rawTarget === void 0) continue;
+    const target = decodeXmlEntities(rawTarget);
     const external = /TargetMode="External"/.test(tag);
     rels.push({
       id,
@@ -954,8 +1174,12 @@ var ExcelBorderEdge = class _ExcelBorderEdge {
   cacheKey() {
     return `${this.style}:${this.color?.toString() ?? "null"}`;
   }
+  /** An independent copy. ExcelColor is immutable, so it is shared. */
+  clone() {
+    return new _ExcelBorderEdge(this.style, this.color);
+  }
 };
-var _ExcelBorder = class _ExcelBorder {
+var ExcelBorder = class _ExcelBorder {
   constructor() {
     this.left = new ExcelBorderEdge();
     this.right = new ExcelBorderEdge();
@@ -995,6 +1219,33 @@ var _ExcelBorder = class _ExcelBorder {
     b.right = new ExcelBorderEdge(style, color);
     return b;
   }
+  /**
+   * A border with no edges set.
+   *
+   * A fresh instance per access, not a shared singleton. `ExcelBorder` is mutable
+   * (`border.left.style = …` is the normal way to use it), so a shared instance
+   * handed to two styles let an edit through one of them reach the other — and,
+   * once anything had assigned `none` and then modified it, every later
+   * `ExcelBorder.none` came back already carrying that edge.
+   */
+  static get none() {
+    return new _ExcelBorder();
+  }
+  /**
+   * A deep copy: the edges are new objects, so mutating the copy cannot reach the
+   * original. {@link CellStyle.clone} relies on this.
+   */
+  clone() {
+    const b = new _ExcelBorder();
+    b.left = this.left.clone();
+    b.right = this.right.clone();
+    b.top = this.top.clone();
+    b.bottom = this.bottom.clone();
+    b.diagonal = this.diagonal.clone();
+    b.diagonalDown = this.diagonalDown;
+    b.diagonalUp = this.diagonalUp;
+    return b;
+  }
   // ── Serialisation ─────────────────────────────────────────────────────────
   toXml() {
     const dd = this.diagonalDown ? ' diagonalDown="1"' : "";
@@ -1040,8 +1291,6 @@ var _ExcelBorder = class _ExcelBorder {
     ].join("|");
   }
 };
-_ExcelBorder.none = new _ExcelBorder();
-var ExcelBorder = _ExcelBorder;
 
 // src/style/excel-alignment.ts
 var ExcelHorizontalAlignment = /* @__PURE__ */ ((ExcelHorizontalAlignment3) => {
@@ -1334,7 +1583,7 @@ var _CellStyle = class _CellStyle {
     const s = new _CellStyle();
     if (this.font) s.font = this.font.clone();
     s.fill = this.fill;
-    s.border = this.border;
+    s.border = this.border?.clone();
     s.alignment = this.alignment ? Object.assign(new ExcelAlignment(), this.alignment) : void 0;
     s.numberFormat = this.numberFormat;
     s.isLocked = this.isLocked;
@@ -1357,8 +1606,46 @@ ensureAlignment_fn = function() {
 };
 var CellStyle = _CellStyle;
 
+// src/model/oa-date.ts
+var OA_EPOCH_MS = Date.UTC(1899, 11, 30, 0, 0, 0, 0);
+var MS_PER_DAY = 864e5;
+function toOADate(date) {
+  const utcMs = Date.UTC(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds(),
+    date.getMilliseconds()
+  );
+  return (utcMs - OA_EPOCH_MS) / MS_PER_DAY;
+}
+function fromOADate(oaDate) {
+  const ms = OA_EPOCH_MS + oaDate * MS_PER_DAY;
+  const d = new Date(ms);
+  return new Date(
+    d.getUTCFullYear(),
+    d.getUTCMonth(),
+    d.getUTCDate(),
+    d.getUTCHours(),
+    d.getUTCMinutes(),
+    d.getUTCSeconds(),
+    d.getUTCMilliseconds()
+  );
+}
+var DATE_FORMAT_IDS = /* @__PURE__ */ new Set([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47]);
+function isDateFormatId(formatId) {
+  return DATE_FORMAT_IDS.has(formatId);
+}
+function isDateFormatCode(formatCode) {
+  const lower = formatCode.toLowerCase();
+  return lower.includes("y") || lower.includes("d") || lower.includes("m") && !lower.includes("mm:") || // m = month unless part of mm:ss
+  lower.includes("h") || lower.includes("am") || lower.includes("pm");
+}
+
 // src/style/style-manager.ts
-var _StyleManager_instances, initDefaults_fn, getOrCreateFont_fn, getOrCreateFill_fn, getOrCreateBorder_fn, getOrCreateNumFmt_fn, cellFormatKey_fn, cfToXml_fn;
+var _numFmtMapCache, _dateStyleMemo, _StyleManager_instances, numFmtMap_fn, invalidateFormatCaches_fn, initDefaults_fn, getOrCreateFont_fn, getOrCreateFill_fn, getOrCreateBorder_fn, getOrCreateNumFmt_fn, cellFormatKey_fn, cfToXml_fn;
 var StyleManager = class {
   constructor() {
     __privateAdd(this, _StyleManager_instances);
@@ -1377,6 +1664,21 @@ var StyleManager = class {
     this.cellXfCache = /* @__PURE__ */ new Map();
     this.nextCustomNumFmtId = 164;
     this.isDirty = false;
+    /**
+     * `numFmtId` → format code for the custom (≥164) formats, materialised once.
+     * Rebuilding it per lookup made every numeric cell read O(custom formats),
+     * and reading a cell's value has to consult it to tell dates from numbers.
+     * Invalidated whenever `numFmts` changes — see {@link #invalidateFormatCaches}.
+     */
+    __privateAdd(this, _numFmtMapCache);
+    /**
+     * cellXf index → does its number format render a date? Memoised because
+     * {@link Cell.getValue} asks this for every numeric cell, and answering it
+     * from scratch reconstructs a whole CellStyle. Entries stay valid because
+     * `cellXfs` and `numFmts` are append-only: an existing index never changes
+     * meaning.
+     */
+    __privateAdd(this, _dateStyleMemo, /* @__PURE__ */ new Map());
     __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
   }
   // ── Public API ─────────────────────────────────────────────────────────────
@@ -1428,10 +1730,7 @@ var StyleManager = class {
     const borderEntry = this.borders[cf.borderId];
     if (borderEntry && cf.applyBorder) s.border = borderEntry.border;
     if (cf.applyNumFmt) {
-      const customMap = new Map(
-        this.numFmts.map((n) => [n.id, n.code])
-      );
-      s.numberFormat = ExcelNumberFormat.fromFormatId(cf.numFmtId, customMap);
+      s.numberFormat = ExcelNumberFormat.fromFormatId(cf.numFmtId, __privateMethod(this, _StyleManager_instances, numFmtMap_fn).call(this));
     }
     if (cf.alignment && cf.applyAlign) s.alignment = cf.alignment;
     if (cf.applyProt) {
@@ -1440,6 +1739,29 @@ var StyleManager = class {
     }
     return s;
   }
+  /**
+   * Whether the cellXf at `styleIndex` formats its value as a date. This is the
+   * one style question the value-reading path has to ask, so it is answered
+   * without reconstructing a CellStyle: the result is derived from the stored
+   * format id/code and memoised per index.
+   *
+   * Equivalent to `getCellStyle(i).numberFormat` being date-like, by
+   * construction — both read the same `applyNumFmt`/`numFmtId` pair through
+   * {@link ExcelNumberFormat.fromFormatId}.
+   */
+  isDateStyle(styleIndex) {
+    const memo = __privateGet(this, _dateStyleMemo).get(styleIndex);
+    if (memo !== void 0) return memo;
+    const cf = this.cellXfs[styleIndex];
+    if (!cf) return false;
+    let isDate = false;
+    if (cf.applyNumFmt) {
+      const fmt = ExcelNumberFormat.fromFormatId(cf.numFmtId, __privateMethod(this, _StyleManager_instances, numFmtMap_fn).call(this));
+      isDate = isDateFormatId(fmt.formatId) || isDateFormatCode(fmt.formatCode);
+    }
+    __privateGet(this, _dateStyleMemo).set(styleIndex, isDate);
+    return isDate;
+  }
   // ── XML serialisation ──────────────────────────────────────────────────────
   /** Builds the complete xl/styles.xml string. */
   buildStylesXml() {
@@ -1469,6 +1791,7 @@ ${cellXfsXml}
     this.numFmtCache.clear();
     this.cellXfCache.clear();
     this.nextCustomNumFmtId = 164;
+    __privateMethod(this, _StyleManager_instances, invalidateFormatCaches_fn).call(this);
     const root = parseXml(stylesXml);
     for (const el of getElementsByTagName(root, "numFmt")) {
       const id = parseInt(getAttr(el, "numFmtId") ?? "0", 10);
@@ -1527,9 +1850,23 @@ ${cellXfsXml}
     }
     if (this.fonts.length === 0) __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
     if (this.cellXfs.length === 0) __privateMethod(this, _StyleManager_instances, initDefaults_fn).call(this);
+    __privateMethod(this, _StyleManager_instances, invalidateFormatCaches_fn).call(this);
   }
 };
+_numFmtMapCache = new WeakMap();
+_dateStyleMemo = new WeakMap();
 _StyleManager_instances = new WeakSet();
+numFmtMap_fn = function() {
+  if (!__privateGet(this, _numFmtMapCache)) {
+    __privateSet(this, _numFmtMapCache, new Map(this.numFmts.map((n) => [n.id, n.code])));
+  }
+  return __privateGet(this, _numFmtMapCache);
+};
+/** Drops the derived format caches after `numFmts` or `cellXfs` changed. */
+invalidateFormatCaches_fn = function() {
+  __privateSet(this, _numFmtMapCache, void 0);
+  __privateGet(this, _dateStyleMemo).clear();
+};
 // ── Private helpers ────────────────────────────────────────────────────────
 initDefaults_fn = function() {
   const defaultFont = new ExcelFont({ name: "Calibri", size: 11 });
@@ -1602,6 +1939,7 @@ getOrCreateNumFmt_fn = function(fmt) {
   const id = this.nextCustomNumFmtId++;
   this.numFmts.push({ id, code: fmt.formatCode });
   this.numFmtCache.set(fmt.formatCode, id);
+  __privateMethod(this, _StyleManager_instances, invalidateFormatCaches_fn).call(this);
   this.isDirty = true;
   return id;
 };
@@ -1671,10 +2009,15 @@ function splitSections(code) {
   sections.push(current);
   return sections;
 }
+function hasDateTokens(section) {
+  const bare = section.replace(/"[^"]*"/g, "").replace(/\\./g, "").replace(/\[[^\]]*\]/g, "");
+  return /[ymdhsYMDHS]/.test(bare);
+}
 function isUnsupported(section) {
   if (/\[[<>=]/.test(section)) return true;
   if (/[?]/.test(section)) return true;
   if (/[Ee][+-]/.test(section)) return true;
+  if (hasDateTokens(section)) return true;
   return false;
 }
 function parseSection(section) {
@@ -1768,12 +2111,177 @@ function formatNumberWithCode(value, formatCode) {
   return renderNumber(magnitude, parseSection(section));
 }
 
+// src/style/date-format-renderer.ts
+var MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function firstSection(code) {
+  let inQuote = false;
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i];
+    if (ch === '"') inQuote = !inQuote;
+    else if (ch === ";" && !inQuote) return code.slice(0, i);
+  }
+  return code;
+}
+function tokenize(section) {
+  const tokens = [];
+  let i = 0;
+  const n = section.length;
+  while (i < n) {
+    const ch = section[i];
+    if (ch === '"') {
+      let j = i + 1;
+      let text = "";
+      while (j < n && section[j] !== '"') text += section[j++];
+      tokens.push({ kind: "literal", text });
+      i = j + 1;
+      continue;
+    }
+    if (ch === "\\") {
+      tokens.push({ kind: "literal", text: section[i + 1] ?? "" });
+      i += 2;
+      continue;
+    }
+    if (ch === "[") {
+      const close = section.indexOf("]", i);
+      if (close === -1) return null;
+      const inner = section.slice(i + 1, close);
+      if (/^[hmsHMS]+$/.test(inner)) return null;
+      i = close + 1;
+      continue;
+    }
+    const rest = section.slice(i);
+    const ampm = /^(AM\/PM|A\/P|am\/pm|a\/p)/.exec(rest);
+    if (ampm) {
+      tokens.push({ kind: "ampm", text: ampm[1] });
+      i += ampm[1].length;
+      continue;
+    }
+    const lower = ch.toLowerCase();
+    if ("ymdhs".includes(lower)) {
+      let j = i;
+      while (j < n && section[j].toLowerCase() === lower) j++;
+      tokens.push({ kind: lower, text: section.slice(i, j) });
+      i = j;
+      if (lower === "s" && section[i] === "." && /\d|0/.test(section[i + 1] ?? "")) return null;
+      continue;
+    }
+    if (/[a-zA-Z]/.test(ch)) return null;
+    tokens.push({ kind: "literal", text: ch });
+    i++;
+  }
+  return tokens;
+}
+function resolveMonthVsMinute(tokens) {
+  const dateKinds = /* @__PURE__ */ new Set(["y", "m", "d", "h", "s"]);
+  for (let t = 0; t < tokens.length; t++) {
+    const token = tokens[t];
+    if (token.kind !== "m" || token.text.length > 2) continue;
+    let prev;
+    for (let p = t - 1; p >= 0; p--) {
+      if (dateKinds.has(tokens[p].kind)) {
+        prev = tokens[p];
+        break;
+      }
+    }
+    let next;
+    for (let q = t + 1; q < tokens.length; q++) {
+      if (dateKinds.has(tokens[q].kind)) {
+        next = tokens[q];
+        break;
+      }
+    }
+    if (prev?.kind === "h" || next?.kind === "s") token.kind = "minute";
+  }
+}
+var pad = (v, len) => String(v).padStart(len, "0");
+function formatDateCode(date, formatCode) {
+  if (!formatCode || formatCode === "General") return null;
+  const tokens = tokenize(firstSection(formatCode));
+  if (!tokens) return null;
+  if (!tokens.some((t) => "ymdhs".includes(t.kind))) return null;
+  resolveMonthVsMinute(tokens);
+  const twelveHour = tokens.some((t) => t.kind === "ampm");
+  const hours24 = date.getHours();
+  const hours12 = hours24 % 12 === 0 ? 12 : hours24 % 12;
+  let out = "";
+  for (const t of tokens) {
+    switch (t.kind) {
+      case "literal":
+        out += t.text;
+        break;
+      case "y":
+        out += t.text.length <= 2 ? pad(date.getFullYear() % 100, 2) : String(date.getFullYear());
+        break;
+      case "m": {
+        const month = date.getMonth();
+        if (t.text.length === 1) out += String(month + 1);
+        else if (t.text.length === 2) out += pad(month + 1, 2);
+        else if (t.text.length === 3) out += MONTHS[month].slice(0, 3);
+        else if (t.text.length === 5) out += MONTHS[month][0];
+        else out += MONTHS[month];
+        break;
+      }
+      case "minute":
+        out += t.text.length === 1 ? String(date.getMinutes()) : pad(date.getMinutes(), 2);
+        break;
+      case "d": {
+        const day = date.getDate();
+        if (t.text.length === 1) out += String(day);
+        else if (t.text.length === 2) out += pad(day, 2);
+        else if (t.text.length === 3) out += DAYS[date.getDay()].slice(0, 3);
+        else out += DAYS[date.getDay()];
+        break;
+      }
+      case "h": {
+        const h = twelveHour ? hours12 : hours24;
+        out += t.text.length === 1 ? String(h) : pad(h, 2);
+        break;
+      }
+      case "s":
+        out += t.text.length === 1 ? String(date.getSeconds()) : pad(date.getSeconds(), 2);
+        break;
+      case "ampm": {
+        const isAm = hours24 < 12;
+        if (t.text === "a/p") out += isAm ? "a" : "p";
+        else if (t.text === "A/P") out += isAm ? "A" : "P";
+        else if (t.text === "am/pm") out += isAm ? "am" : "pm";
+        else out += isAm ? "AM" : "PM";
+        break;
+      }
+    }
+  }
+  return out;
+}
+
 // src/model/cell-reference.ts
+var EXCEL_MAX_ROWS = 1048576;
+var EXCEL_MAX_COLUMNS = 16384;
+function needsNormalizing(ref) {
+  for (let i = 0; i < ref.length; i++) {
+    const code = ref.charCodeAt(i);
+    if (code === 36 || code >= 97 && code <= 122) return true;
+  }
+  return false;
+}
 function parseCellRef(cellReference) {
   if (!cellReference) {
     throw new Error("Cell reference cannot be null or empty.");
   }
-  const ref = cellReference.replace(/\$/g, "").toUpperCase();
+  const ref = needsNormalizing(cellReference) ? cellReference.replace(/\$/g, "").toUpperCase() : cellReference;
   let i = 0;
   let column = 0;
   while (i < ref.length && ref.charCodeAt(i) >= 65 && ref.charCodeAt(i) <= 90) {
@@ -1819,6 +2327,11 @@ function columnNumber(letters) {
   }
   return col;
 }
+function formatRangeRef(startRow, startColumn, endRow, endColumn) {
+  const start = cellRefFromRowCol(startRow, startColumn);
+  if (startRow === endRow && startColumn === endColumn) return start;
+  return `${start}:${cellRefFromRowCol(endRow, endColumn)}`;
+}
 function parseRangeRef(rangeReference) {
   const parts = rangeReference.split(":");
   if (parts.length !== 2) {
@@ -1839,56 +2352,54 @@ function parseRangeRef(rangeReference) {
   };
 }
 
-// src/model/oa-date.ts
-var OA_EPOCH_MS = Date.UTC(1899, 11, 30, 0, 0, 0, 0);
-var MS_PER_DAY = 864e5;
-function toOADate(date) {
-  const utcMs = Date.UTC(
-    date.getFullYear(),
-    date.getMonth(),
-    date.getDate(),
-    date.getHours(),
-    date.getMinutes(),
-    date.getSeconds(),
-    date.getMilliseconds()
-  );
-  return (utcMs - OA_EPOCH_MS) / MS_PER_DAY;
-}
-function fromOADate(oaDate) {
-  const ms = OA_EPOCH_MS + oaDate * MS_PER_DAY;
-  const d = new Date(ms);
-  return new Date(
-    d.getUTCFullYear(),
-    d.getUTCMonth(),
-    d.getUTCDate(),
-    d.getUTCHours(),
-    d.getUTCMinutes(),
-    d.getUTCSeconds(),
-    d.getUTCMilliseconds()
-  );
-}
-var DATE_FORMAT_IDS = /* @__PURE__ */ new Set([14, 15, 16, 17, 18, 19, 20, 21, 22, 45, 46, 47]);
-function isDateFormatId(formatId) {
-  return DATE_FORMAT_IDS.has(formatId);
+// src/model/cell.ts
+function readCellValue(data, sharedStrings, styles) {
+  const raw = data.rawValue;
+  if (raw === void 0 || raw === "") return null;
+  switch (data.dataType) {
+    case "s": {
+      const idx = parseInt(raw, 10);
+      return sharedStrings.tryGetString(idx) ?? raw;
+    }
+    case "b":
+      return raw === "1";
+    case "str":
+      return raw;
+    default: {
+      const num = parseFloat(raw);
+      if (isNaN(num)) return raw;
+      if (styles.isDateStyle(data.styleIndex)) {
+        try {
+          return fromOADate(num);
+        } catch {
+          return num;
+        }
+      }
+      return num;
+    }
+  }
 }
-function isDateFormatCode(formatCode) {
-  const lower = formatCode.toLowerCase();
-  return lower.includes("y") || lower.includes("d") || lower.includes("m") && !lower.includes("mm:") || // m = month unless part of mm:ss
-  lower.includes("h") || lower.includes("am") || lower.includes("pm");
+function buildCellXml(data) {
+  const style = data.styleIndex > 0 ? ` s="${data.styleIndex}"` : "";
+  const formulaXml = data.formula ? data.arrayRef ? `<f t="array" ref="${data.arrayRef}" aca="1" ca="1">${escXml(data.formula)}</f>` : `<f>${escXml(data.formula)}</f>` : "";
+  const valueXml = data.rawValue !== void 0 && data.rawValue !== "" ? `<v>${escXml(data.rawValue)}</v>` : "";
+  const type = data.dataType && (formulaXml || valueXml) ? ` t="${data.dataType}"` : "";
+  if (!formulaXml && !valueXml && data.styleIndex === 0) return "";
+  return `<c r="${data.reference}"${style}${type}>${formulaXml}${valueXml}</c>`;
 }
-
-// src/model/cell.ts
-var _data, _sharedStrings, _styles, _Cell_instances, isDateStyle_fn;
+var _data, _sharedStrings, _styles, _version, _Cell_instances, touch_fn;
 var Cell = class {
   /** @internal */
-  constructor(data, sharedStrings, styles) {
+  constructor(data, sharedStrings, styles, version) {
     __privateAdd(this, _Cell_instances);
     __privateAdd(this, _data);
     __privateAdd(this, _sharedStrings);
     __privateAdd(this, _styles);
+    __privateAdd(this, _version);
     __privateSet(this, _data, data);
     __privateSet(this, _sharedStrings, sharedStrings);
     __privateSet(this, _styles, styles);
+    __privateSet(this, _version, version);
   }
   // ── Identity ───────────────────────────────────────────────────────────────
   /** Cell reference string e.g. "A1". */
@@ -1904,6 +2415,7 @@ var Cell = class {
     return parseCellRef(__privateGet(this, _data).reference).column;
   }
   setValue(value) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).formula = void 0;
     if (value === null || value === void 0) {
       __privateGet(this, _data).dataType = void 0;
@@ -1941,29 +2453,7 @@ var Cell = class {
    * Date detection is based on the cell's number format.
    */
   getValue() {
-    if (__privateGet(this, _data).rawValue === void 0 || __privateGet(this, _data).rawValue === "") return null;
-    switch (__privateGet(this, _data).dataType) {
-      case "s": {
-        const idx = parseInt(__privateGet(this, _data).rawValue, 10);
-        return __privateGet(this, _sharedStrings).tryGetString(idx) ?? __privateGet(this, _data).rawValue;
-      }
-      case "b":
-        return __privateGet(this, _data).rawValue === "1";
-      case "str":
-        return __privateGet(this, _data).rawValue;
-      default: {
-        const num = parseFloat(__privateGet(this, _data).rawValue);
-        if (isNaN(num)) return __privateGet(this, _data).rawValue;
-        if (__privateMethod(this, _Cell_instances, isDateStyle_fn).call(this)) {
-          try {
-            return fromOADate(num);
-          } catch {
-            return num;
-          }
-        }
-        return num;
-      }
-    }
+    return readCellValue(__privateGet(this, _data), __privateGet(this, _sharedStrings), __privateGet(this, _styles));
   }
   /**
    * Returns the display text of the cell value (always a string).
@@ -1979,18 +2469,20 @@ var Cell = class {
   }
   /**
    * Returns the display text with the cell's number format applied, e.g. a
-   * value of 4.5 under `$#,##0.00` renders as `$4.50`.
+   * value of 4.5 under `$#,##0.00` renders as `$4.50`, and a date under
+   * `dd/mm/yyyy` as `31/01/2025`.
    *
-   * Falls back to {@link getText} for non-numeric values and for format codes
-   * outside the supported subset (fractions, scientific notation, conditional
-   * sections) — so the result is never a misleading rendering.
+   * Falls back to {@link getText} for values with no format and for format
+   * codes outside the supported subset (fractions, scientific notation,
+   * conditional sections, elapsed time) — so the result is never a misleading
+   * rendering.
    */
   getFormattedText() {
     const val = this.getValue();
-    if (typeof val !== "number") return this.getText();
+    if (typeof val !== "number" && !(val instanceof Date)) return this.getText();
     const format = __privateGet(this, _styles).getCellStyle(__privateGet(this, _data).styleIndex).numberFormat;
     if (!format) return this.getText();
-    return formatNumberWithCode(val, format.formatCode) ?? this.getText();
+    return val instanceof Date ? formatDateCode(val, format.formatCode) ?? this.getText() : formatNumberWithCode(val, format.formatCode) ?? this.getText();
   }
   // ── Formula API ────────────────────────────────────────────────────────────
   /**
@@ -1999,6 +2491,7 @@ var Cell = class {
    */
   setFormula(formula) {
     if (!formula) throw new Error("Formula cannot be empty.");
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).formula = formula.startsWith("=") ? formula.slice(1) : formula;
     __privateGet(this, _data).rawValue = void 0;
     __privateGet(this, _data).dataType = void 0;
@@ -2011,6 +2504,7 @@ var Cell = class {
    * plain scalar formula. Serialises as `<f t="array" ref="…">`.
    */
   setArrayRef(spillRef) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).arrayRef = spillRef ?? void 0;
     return this;
   }
@@ -2028,6 +2522,7 @@ var Cell = class {
    * added to the shared-string table.
    */
   setComputedValue(value) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     if (value === null || value === void 0) {
       __privateGet(this, _data).dataType = void 0;
       __privateGet(this, _data).rawValue = void 0;
@@ -2067,6 +2562,7 @@ var Cell = class {
   }
   /** Replaces the entire cell style. */
   set style(value) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).styleIndex = __privateGet(this, _styles).getOrCreateCellFormatIndex(value);
   }
   /**
@@ -2077,6 +2573,7 @@ var Cell = class {
    * cell.applyStyle(s => s.setBold(true).setFontColor(ExcelColor.red))
    */
   applyStyle(action) {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     const s = __privateGet(this, _styles).getCellStyle(__privateGet(this, _data).styleIndex).clone();
     action(s);
     __privateGet(this, _data).styleIndex = __privateGet(this, _styles).getOrCreateCellFormatIndex(s);
@@ -2119,6 +2616,7 @@ var Cell = class {
   // ── Clear ──────────────────────────────────────────────────────────────────
   /** Clears the cell value and formula, preserving style. */
   clear() {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     __privateGet(this, _data).rawValue = void 0;
     __privateGet(this, _data).dataType = void 0;
     __privateGet(this, _data).formula = void 0;
@@ -2126,19 +2624,14 @@ var Cell = class {
   }
   /** Clears the cell value, formula, AND style. */
   clearAll() {
+    __privateMethod(this, _Cell_instances, touch_fn).call(this);
     this.clear();
     __privateGet(this, _data).styleIndex = 0;
   }
   // ── XML serialisation ──────────────────────────────────────────────────────
   /** @internal Builds the <c> XML element string for this cell. */
   toXml() {
-    const ref = __privateGet(this, _data).reference;
-    const style = __privateGet(this, _data).styleIndex > 0 ? ` s="${__privateGet(this, _data).styleIndex}"` : "";
-    const formulaXml = __privateGet(this, _data).formula ? __privateGet(this, _data).arrayRef ? `<f t="array" ref="${__privateGet(this, _data).arrayRef}" aca="1" ca="1">${escXml(__privateGet(this, _data).formula)}</f>` : `<f>${escXml(__privateGet(this, _data).formula)}</f>` : "";
-    const valueXml = __privateGet(this, _data).rawValue !== void 0 && __privateGet(this, _data).rawValue !== "" ? `<v>${escXml(__privateGet(this, _data).rawValue)}</v>` : "";
-    const type = __privateGet(this, _data).dataType && (formulaXml || valueXml) ? ` t="${__privateGet(this, _data).dataType}"` : "";
-    if (!formulaXml && !valueXml && __privateGet(this, _data).styleIndex === 0) return "";
-    return `<c r="${ref}"${style}${type}>${formulaXml}${valueXml}</c>`;
+    return buildCellXml(__privateGet(this, _data));
   }
   /** @internal Parses a <c> XML element into CellData. */
   static fromXmlElement(el, ref) {
@@ -2147,105 +2640,622 @@ var Cell = class {
     let rawValue;
     let formula;
     let arrayRef;
+    let sharedIndex;
     for (const child of el.children) {
       const tag = child.tagName.replace(/^.*:/, "");
       if (tag === "v") rawValue = child.textContent;
       if (tag === "f") {
         formula = child.textContent;
-        if (child.attributes && child.attributes["t"] === "array" && child.attributes["ref"]) {
-          arrayRef = child.attributes["ref"];
+        const attrs = child.attributes;
+        const type = attrs?.["t"];
+        if (type === "array" && attrs?.["ref"]) {
+          arrayRef = attrs["ref"];
+        }
+        if (type === "shared" && attrs?.["si"] !== void 0) {
+          const si = parseInt(attrs["si"], 10);
+          if (!Number.isNaN(si)) sharedIndex = si;
         }
       }
     }
-    return { reference: ref, dataType, rawValue, formula, arrayRef, styleIndex };
+    if (formula === "") formula = void 0;
+    return { reference: ref, dataType, rawValue, formula, arrayRef, styleIndex, sharedIndex };
   }
 };
 _data = new WeakMap();
 _sharedStrings = new WeakMap();
 _styles = new WeakMap();
+_version = new WeakMap();
 _Cell_instances = new WeakSet();
-// ── Private helpers ────────────────────────────────────────────────────────
-isDateStyle_fn = function() {
-  const style = __privateGet(this, _styles).getCellStyle(__privateGet(this, _data).styleIndex);
-  if (!style.numberFormat) return false;
-  if (isDateFormatId(style.numberFormat.formatId)) return true;
-  return isDateFormatCode(style.numberFormat.formatCode);
+/** Records that this cell's stored data changed. */
+touch_fn = function() {
+  if (__privateGet(this, _version)) __privateGet(this, _version).v++;
 };
 function escXml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
-// src/model/range.ts
-var _sheet, _startRow, _startColumn, _endRow, _endColumn, _address, _Range_instances, forEach_fn;
-var Range = class {
-  constructor(sheet, rangeReference) {
-    __privateAdd(this, _Range_instances);
-    __privateAdd(this, _sheet);
-    __privateAdd(this, _startRow);
-    __privateAdd(this, _startColumn);
-    __privateAdd(this, _endRow);
-    __privateAdd(this, _endColumn);
-    __privateAdd(this, _address);
-    __privateSet(this, _sheet, sheet);
-    __privateSet(this, _address, rangeReference.toUpperCase());
-    const { startRow, startColumn, endRow, endColumn } = parseRangeRef(rangeReference);
-    __privateSet(this, _startRow, startRow);
-    __privateSet(this, _startColumn, startColumn);
-    __privateSet(this, _endRow, endRow);
-    __privateSet(this, _endColumn, endColumn);
-  }
-  /** The range address e.g. "A1:B10". */
-  get address() {
-    return __privateGet(this, _address);
-  }
-  /** Number of rows in the range. */
-  get rowCount() {
-    return __privateGet(this, _endRow) - __privateGet(this, _startRow) + 1;
-  }
-  /** Number of columns in the range. */
-  get columnCount() {
-    return __privateGet(this, _endColumn) - __privateGet(this, _startColumn) + 1;
+// src/model/ref-shift.ts
+function shiftIndex(index, shift) {
+  if (shift.kind === "insert") {
+    return index >= shift.at ? index + shift.count : index;
+  }
+  const bandEnd = shift.at + shift.count - 1;
+  if (index < shift.at) return index;
+  if (index <= bandEnd) return null;
+  return index - shift.count;
+}
+function shiftSpan(start, end, shift) {
+  if (shift.kind === "insert") {
+    return {
+      start: start >= shift.at ? start + shift.count : start,
+      end: end >= shift.at ? end + shift.count : end
+    };
   }
-  // ── Value bulk operations ──────────────────────────────────────────────────
-  /**
-   * Sets values from a 2D array.
-   * Values that exceed the range boundary are silently ignored.
-   */
-  setValues(values) {
-    for (let r = 0; r < values.length && __privateGet(this, _startRow) + r <= __privateGet(this, _endRow); r++) {
-      const rowValues = values[r];
-      for (let c = 0; c < rowValues.length && __privateGet(this, _startColumn) + c <= __privateGet(this, _endColumn); c++) {
-        const cell = __privateGet(this, _sheet).getCell(__privateGet(this, _startRow) + r, __privateGet(this, _startColumn) + c);
-        const val = rowValues[c];
-        cell.setValue(val);
+  const bandEnd = shift.at + shift.count - 1;
+  const newStart = start < shift.at ? start : start <= bandEnd ? shift.at : start - shift.count;
+  const newEnd = end < shift.at ? end : end <= bandEnd ? shift.at - 1 : end - shift.count;
+  return newEnd < newStart ? null : { start: newStart, end: newEnd };
+}
+function shiftRangeRef(ref, shift) {
+  const [startRef, endRef] = ref.split(":");
+  const start = parseCellRef(startRef);
+  const end = endRef !== void 0 ? parseCellRef(endRef) : start;
+  const rows = shift.dim === "row" ? shiftSpan(start.row, end.row, shift) : { start: start.row, end: end.row };
+  const cols = shift.dim === "col" ? shiftSpan(start.column, end.column, shift) : { start: start.column, end: end.column };
+  if (!rows || !cols) return null;
+  const startOut = cellRefFromRowCol(rows.start, cols.start);
+  if (endRef === void 0) return startOut;
+  return `${startOut}:${cellRefFromRowCol(rows.end, cols.end)}`;
+}
+function shiftSqref(sqref, shift) {
+  const surviving = sqref.split(/\s+/).filter(Boolean).map((part) => shiftRangeRef(part, shift)).filter((part) => part !== null);
+  return surviving.length > 0 ? surviving.join(" ") : null;
+}
+
+// src/model/formula-ref-shift.ts
+var MAX_ROW = EXCEL_MAX_ROWS;
+var MAX_COL = EXCEL_MAX_COLUMNS;
+function isWordChar(code) {
+  return code >= 65 && code <= 90 || // A-Z
+  code >= 97 && code <= 122 || // a-z
+  code >= 48 && code <= 57 || // 0-9
+  code === 95 || // _
+  code === 46 || // .
+  code === 36;
+}
+function parseCellComponent(word) {
+  const m = /^(\$?)([A-Za-z]{1,3})(\$?)(\d+)$/.exec(word);
+  if (!m) return null;
+  const col = columnNumber(m[2]);
+  const row = parseInt(m[4], 10);
+  if (col > MAX_COL || row < 1 || row > MAX_ROW) return null;
+  return { colAbs: m[1] === "$", col, rowAbs: m[3] === "$", row };
+}
+function parseColComponent(word) {
+  const m = /^(\$?)([A-Za-z]{1,3})$/.exec(word);
+  if (!m) return null;
+  const col = columnNumber(m[2]);
+  if (col > MAX_COL) return null;
+  return { abs: m[1] === "$", col };
+}
+function parseRowComponent(word) {
+  const m = /^(\$?)(\d+)$/.exec(word);
+  if (!m) return null;
+  const row = parseInt(m[2], 10);
+  if (row < 1 || row > MAX_ROW) return null;
+  return { abs: m[1] === "$", row };
+}
+function emitCell(c, row, col) {
+  return `${c.colAbs ? "$" : ""}${columnLetter(col)}${c.rowAbs ? "$" : ""}${row}`;
+}
+function shiftFormulaRefs(formula, shift, formulaSheet) {
+  const n = formula.length;
+  const editedSheet = shift.sheetName.toUpperCase();
+  const unqualifiedRewritable = formulaSheet.toUpperCase() === editedSheet;
+  const isRowShift = shift.dim === "row";
+  let out = "";
+  let flushed = 0;
+  let changed = false;
+  let hasRefError = false;
+  let i = 0;
+  const replace = (start, text) => {
+    if (text.length === i - start && formula.startsWith(text, start)) return;
+    out += formula.slice(flushed, start) + text;
+    flushed = i;
+    changed = true;
+  };
+  const readWord = () => {
+    let j = i;
+    while (j < n && isWordChar(formula.charCodeAt(j))) j++;
+    const w = formula.slice(i, j);
+    i = j;
+    return w;
+  };
+  const readQuoted = () => {
+    let j = i + 1;
+    while (j < n) {
+      if (formula[j] === "'") {
+        if (formula[j + 1] === "'") {
+          j += 2;
+          continue;
+        }
+        j++;
+        break;
       }
+      j++;
     }
-  }
-  /**
-   * Gets all cell values as a 2D array (row-major order).
-   */
-  getValues() {
-    const result = [];
-    for (let r = 0; r < this.rowCount; r++) {
-      const row = [];
-      for (let c = 0; c < this.columnCount; c++) {
-        const cell = __privateGet(this, _sheet).tryGetCell(__privateGet(this, _startRow) + r, __privateGet(this, _startColumn) + c);
-        row.push(cell ? cell.getValue() : null);
+    const q = formula.slice(i, j);
+    i = j;
+    return q;
+  };
+  const consumeRef = (refStart, rewritable) => {
+    const first = readWord();
+    let firstCell = parseCellComponent(first);
+    let firstCol = firstCell ? null : parseColComponent(first);
+    let firstRow = firstCell || firstCol ? null : parseRowComponent(first);
+    let second = null;
+    let secondCell = null;
+    let secondCol = null;
+    let secondRow = null;
+    if (formula[i] === ":" && i + 1 < n && isWordChar(formula.charCodeAt(i + 1))) {
+      const save = i;
+      i++;
+      const w = readWord();
+      if (firstCell) secondCell = parseCellComponent(w);
+      else if (firstCol) secondCol = parseColComponent(w);
+      else if (firstRow) secondRow = parseRowComponent(w);
+      if (secondCell || secondCol || secondRow) {
+        second = w;
+      } else {
+        i = save;
       }
-      result.push(row);
     }
-    return result;
+    if (second === null && formula[i] === "(") return;
+    const dead = () => {
+      if (formula[i] === "#") i++;
+      replace(refStart, "#REF!");
+      hasRefError = true;
+    };
+    if (second !== null) {
+      if (!rewritable) return;
+      if (firstCell && secondCell) {
+        const a = firstCell, b = secondCell;
+        const rows = isRowShift ? shiftSpan(a.row, b.row, shift) : { start: a.row, end: b.row };
+        const cols = isRowShift ? { start: a.col, end: b.col } : shiftSpan(a.col, b.col, shift);
+        if (!rows || !cols) {
+          dead();
+          return;
+        }
+        replace(refStart, `${emitCell(a, rows.start, cols.start)}:${emitCell(b, rows.end, cols.end)}`);
+        return;
+      }
+      if (firstCol && secondCol) {
+        if (isRowShift) return;
+        const span = shiftSpan(firstCol.col, secondCol.col, shift);
+        if (!span) {
+          dead();
+          return;
+        }
+        const a = firstCol.abs ? "$" : "";
+        const b = secondCol.abs ? "$" : "";
+        replace(refStart, `${a}${columnLetter(span.start)}:${b}${columnLetter(span.end)}`);
+        return;
+      }
+      if (firstRow && secondRow) {
+        if (!isRowShift) return;
+        const span = shiftSpan(firstRow.row, secondRow.row, shift);
+        if (!span) {
+          dead();
+          return;
+        }
+        const a = firstRow.abs ? "$" : "";
+        const b = secondRow.abs ? "$" : "";
+        replace(refStart, `${a}${span.start}:${b}${span.end}`);
+        return;
+      }
+      return;
+    }
+    if (!firstCell || !rewritable) return;
+    const row = isRowShift ? shiftIndex(firstCell.row, shift) : firstCell.row;
+    const col = isRowShift ? firstCell.col : shiftIndex(firstCell.col, shift);
+    if (row === null || col === null) {
+      dead();
+      return;
+    }
+    replace(refStart, emitCell(firstCell, row, col));
+  };
+  while (i < n) {
+    const ch = formula[i];
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < n) {
+        if (formula[j] === '"') {
+          if (formula[j + 1] === '"') {
+            j += 2;
+            continue;
+          }
+          j++;
+          break;
+        }
+        j++;
+      }
+      i = j;
+      continue;
+    }
+    if (ch === "'") {
+      const quoted = readQuoted();
+      if (formula[i] === "!") {
+        i++;
+        const name = quoted.slice(1, -1);
+        const rewritable = name.indexOf(":") === -1 && (name.indexOf("''") === -1 ? name : name.replace(/''/g, "'")).toUpperCase() === editedSheet;
+        consumeRef(i, rewritable);
+      }
+      continue;
+    }
+    if (isWordChar(formula.charCodeAt(i))) {
+      const start = i;
+      const word = readWord();
+      if (formula[i] === "!") {
+        i++;
+        consumeRef(i, word.toUpperCase() === editedSheet);
+        continue;
+      }
+      if (formula[i] === ":") {
+        const save = i;
+        i++;
+        const w2 = i < n && isWordChar(formula.charCodeAt(i)) ? readWord() : "";
+        if (w2 && formula[i] === "!") {
+          i++;
+          consumeRef(i, false);
+          continue;
+        }
+        i = save;
+      }
+      if (formula[i] === "[") {
+        let depth = 0;
+        let j = i;
+        while (j < n) {
+          if (formula[j] === "[") depth++;
+          else if (formula[j] === "]" && --depth === 0) {
+            j++;
+            break;
+          }
+          j++;
+        }
+        i = j;
+        continue;
+      }
+      i = start;
+      consumeRef(start, unqualifiedRewritable);
+      continue;
+    }
+    i++;
+  }
+  if (!changed) return { text: formula, changed: false, hasRefError };
+  return { text: out + formula.slice(flushed), changed: true, hasRefError };
+}
+
+// src/model/formula-ref-translate.ts
+function isWordChar2(code) {
+  return code >= 65 && code <= 90 || // A-Z
+  code >= 97 && code <= 122 || // a-z
+  code >= 48 && code <= 57 || // 0-9
+  code === 95 || // _
+  code === 46 || // .
+  code === 36;
+}
+function parseCellComponent2(word) {
+  const m = /^(\$?)([A-Za-z]{1,3})(\$?)(\d+)$/.exec(word);
+  if (!m) return null;
+  const col = columnNumber(m[2]);
+  const row = parseInt(m[4], 10);
+  if (col > EXCEL_MAX_COLUMNS || row < 1 || row > EXCEL_MAX_ROWS) return null;
+  return { colAbs: m[1] === "$", col, rowAbs: m[3] === "$", row };
+}
+function parseColComponent2(word) {
+  const m = /^(\$?)([A-Za-z]{1,3})$/.exec(word);
+  if (!m) return null;
+  const col = columnNumber(m[2]);
+  return col > EXCEL_MAX_COLUMNS ? null : { abs: m[1] === "$", col };
+}
+function parseRowComponent2(word) {
+  const m = /^(\$?)(\d+)$/.exec(word);
+  if (!m) return null;
+  const row = parseInt(m[2], 10);
+  return row < 1 || row > EXCEL_MAX_ROWS ? null : { abs: m[1] === "$", row };
+}
+function move(index, delta, abs, max) {
+  if (abs || delta === 0) return index;
+  const moved = index + delta;
+  return moved < 1 || moved > max ? null : moved;
+}
+function translateFormulaRefs(formula, dRow, dCol) {
+  if (dRow === 0 && dCol === 0) return { text: formula, hasRefError: false };
+  const n = formula.length;
+  let out = "";
+  let flushed = 0;
+  let hasRefError = false;
+  let i = 0;
+  const replace = (start, text) => {
+    if (text.length === i - start && formula.startsWith(text, start)) return;
+    out += formula.slice(flushed, start) + text;
+    flushed = i;
+  };
+  const readWord = () => {
+    let j = i;
+    while (j < n && isWordChar2(formula.charCodeAt(j))) j++;
+    const w = formula.slice(i, j);
+    i = j;
+    return w;
+  };
+  const readQuoted = () => {
+    let j = i + 1;
+    while (j < n) {
+      if (formula[j] === "'") {
+        if (formula[j + 1] === "'") {
+          j += 2;
+          continue;
+        }
+        j++;
+        break;
+      }
+      j++;
+    }
+    const q = formula.slice(i, j);
+    i = j;
+    return q;
+  };
+  const emitCell2 = (c, row, col) => `${c.colAbs ? "$" : ""}${columnLetter(col)}${c.rowAbs ? "$" : ""}${row}`;
+  const consumeRef = (refStart, rewrite = true) => {
+    const first = readWord();
+    const firstCell = parseCellComponent2(first);
+    const firstCol = firstCell ? null : parseColComponent2(first);
+    const firstRow = firstCell || firstCol ? null : parseRowComponent2(first);
+    if (!firstCell && !firstCol && !firstRow) return;
+    let secondCell = null;
+    let secondCol = null;
+    let secondRow = null;
+    let isRange = false;
+    if (formula[i] === ":" && i + 1 < n && isWordChar2(formula.charCodeAt(i + 1))) {
+      const save = i;
+      i++;
+      const w = readWord();
+      if (firstCell) secondCell = parseCellComponent2(w);
+      else if (firstCol) secondCol = parseColComponent2(w);
+      else if (firstRow) secondRow = parseRowComponent2(w);
+      if (secondCell || secondCol || secondRow) isRange = true;
+      else i = save;
+    }
+    if (!isRange && formula[i] === "(") return;
+    if (!rewrite) {
+      if (formula[i] === "#") i++;
+      return;
+    }
+    const dead = () => {
+      if (formula[i] === "#") i++;
+      replace(refStart, "#REF!");
+      hasRefError = true;
+    };
+    if (isRange) {
+      if (firstCell && secondCell) {
+        const r1 = move(firstCell.row, dRow, firstCell.rowAbs, EXCEL_MAX_ROWS);
+        const c1 = move(firstCell.col, dCol, firstCell.colAbs, EXCEL_MAX_COLUMNS);
+        const r2 = move(secondCell.row, dRow, secondCell.rowAbs, EXCEL_MAX_ROWS);
+        const c2 = move(secondCell.col, dCol, secondCell.colAbs, EXCEL_MAX_COLUMNS);
+        if (r1 === null || c1 === null || r2 === null || c2 === null) {
+          dead();
+          return;
+        }
+        replace(refStart, `${emitCell2(firstCell, r1, c1)}:${emitCell2(secondCell, r2, c2)}`);
+        return;
+      }
+      if (firstCol && secondCol) {
+        const c1 = move(firstCol.col, dCol, firstCol.abs, EXCEL_MAX_COLUMNS);
+        const c2 = move(secondCol.col, dCol, secondCol.abs, EXCEL_MAX_COLUMNS);
+        if (c1 === null || c2 === null) {
+          dead();
+          return;
+        }
+        replace(refStart, `${firstCol.abs ? "$" : ""}${columnLetter(c1)}:${secondCol.abs ? "$" : ""}${columnLetter(c2)}`);
+        return;
+      }
+      if (firstRow && secondRow) {
+        const r1 = move(firstRow.row, dRow, firstRow.abs, EXCEL_MAX_ROWS);
+        const r2 = move(secondRow.row, dRow, secondRow.abs, EXCEL_MAX_ROWS);
+        if (r1 === null || r2 === null) {
+          dead();
+          return;
+        }
+        replace(refStart, `${firstRow.abs ? "$" : ""}${r1}:${secondRow.abs ? "$" : ""}${r2}`);
+        return;
+      }
+      return;
+    }
+    if (!firstCell) return;
+    const row = move(firstCell.row, dRow, firstCell.rowAbs, EXCEL_MAX_ROWS);
+    const col = move(firstCell.col, dCol, firstCell.colAbs, EXCEL_MAX_COLUMNS);
+    if (row === null || col === null) {
+      dead();
+      return;
+    }
+    replace(refStart, emitCell2(firstCell, row, col));
+  };
+  while (i < n) {
+    const ch = formula[i];
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < n) {
+        if (formula[j] === '"') {
+          if (formula[j + 1] === '"') {
+            j += 2;
+            continue;
+          }
+          j++;
+          break;
+        }
+        j++;
+      }
+      i = j;
+      continue;
+    }
+    if (ch === "'") {
+      readQuoted();
+      if (formula[i] === "!") {
+        i++;
+        consumeRef(i);
+      }
+      continue;
+    }
+    if (isWordChar2(formula.charCodeAt(i))) {
+      const start = i;
+      readWord();
+      if (formula[i] === "!") {
+        i++;
+        consumeRef(i);
+        continue;
+      }
+      if (formula[i] === ":") {
+        const save = i;
+        i++;
+        const w2 = i < n && isWordChar2(formula.charCodeAt(i)) ? readWord() : "";
+        if (w2 && formula[i] === "!") {
+          i++;
+          consumeRef(i, false);
+          continue;
+        }
+        i = save;
+      }
+      if (formula[i] === "[") {
+        let depth = 0;
+        let j = i;
+        while (j < n) {
+          if (formula[j] === "[") depth++;
+          else if (formula[j] === "]" && --depth === 0) {
+            j++;
+            break;
+          }
+          j++;
+        }
+        i = j;
+        continue;
+      }
+      i = start;
+      consumeRef(start);
+      continue;
+    }
+    i++;
+  }
+  return { text: out + formula.slice(flushed), hasRefError };
+}
+
+// src/model/range.ts
+var _sheet, _startRow, _startColumn, _endRow, _endColumn, _address, _Range_instances, forEach_fn, forEachExisting_fn;
+var Range = class {
+  constructor(sheet, rangeReference) {
+    __privateAdd(this, _Range_instances);
+    __privateAdd(this, _sheet);
+    __privateAdd(this, _startRow);
+    __privateAdd(this, _startColumn);
+    __privateAdd(this, _endRow);
+    __privateAdd(this, _endColumn);
+    __privateAdd(this, _address);
+    __privateSet(this, _sheet, sheet);
+    __privateSet(this, _address, rangeReference.toUpperCase());
+    const { startRow, startColumn, endRow, endColumn } = parseRangeRef(rangeReference);
+    __privateSet(this, _startRow, startRow);
+    __privateSet(this, _startColumn, startColumn);
+    __privateSet(this, _endRow, endRow);
+    __privateSet(this, _endColumn, endColumn);
+  }
+  /** The range address e.g. "A1:B10". */
+  get address() {
+    return __privateGet(this, _address);
+  }
+  /** Number of rows in the range. */
+  get rowCount() {
+    return __privateGet(this, _endRow) - __privateGet(this, _startRow) + 1;
+  }
+  /** Number of columns in the range. */
+  get columnCount() {
+    return __privateGet(this, _endColumn) - __privateGet(this, _startColumn) + 1;
+  }
+  // ── Value bulk operations ──────────────────────────────────────────────────
+  /**
+   * Sets values from a 2D array.
+   * Values that exceed the range boundary are silently ignored.
+   */
+  setValues(values) {
+    for (let r = 0; r < values.length && __privateGet(this, _startRow) + r <= __privateGet(this, _endRow); r++) {
+      const rowValues = values[r];
+      for (let c = 0; c < rowValues.length && __privateGet(this, _startColumn) + c <= __privateGet(this, _endColumn); c++) {
+        const cell = __privateGet(this, _sheet).getCell(__privateGet(this, _startRow) + r, __privateGet(this, _startColumn) + c);
+        const val = rowValues[c];
+        cell.setValue(val);
+      }
+    }
+  }
+  /**
+   * Gets all cell values as a 2D array (row-major order).
+   */
+  getValues() {
+    const rowCount = this.rowCount;
+    const columnCount = this.columnCount;
+    const result = new Array(rowCount);
+    for (let r = 0; r < rowCount; r++) result[r] = new Array(columnCount).fill(null);
+    const startRow = __privateGet(this, _startRow);
+    const startColumn = __privateGet(this, _startColumn);
+    __privateGet(this, _sheet).forEachCellIn(
+      startRow,
+      startColumn,
+      __privateGet(this, _endRow),
+      __privateGet(this, _endColumn),
+      (cell, row, column) => {
+        result[row - startRow][column - startColumn] = cell.getValue();
+      }
+    );
+    return result;
   }
   /** Clears all cells in the range (values only, preserves style). */
   clear() {
-    __privateMethod(this, _Range_instances, forEach_fn).call(this, (cell) => cell.clear());
+    __privateMethod(this, _Range_instances, forEachExisting_fn).call(this, (cell) => cell.clear());
   }
-  /** Auto-fits all columns in the range. */
-  autoFit() {
-    for (let col = __privateGet(this, _startColumn); col <= __privateGet(this, _endColumn); col++) {
-      __privateGet(this, _sheet).autoFitColumn(col);
+  /** Clears values AND styles of all cells in the range. */
+  clearAll() {
+    __privateMethod(this, _Range_instances, forEachExisting_fn).call(this, (cell) => cell.clearAll());
+  }
+  /**
+   * Moves the whole range so its top-left cell lands on `destTopLeft`,
+   * carrying values, formulas, styles and spill anchors. The vacated cells
+   * are cleared and the destination block is fully replaced (empty source
+   * cells clear their destination). Overlapping source/destination is safe.
+   * Formula text is NOT adjusted for the new position.
+   *
+   * @example
+   * ws.getRange('A1:B3').moveTo('D1');
+   */
+  moveTo(destTopLeft) {
+    const dest = parseCellRef(destTopLeft.replace(/\$/g, "").toUpperCase());
+    const deltaRow = dest.row - __privateGet(this, _startRow);
+    const deltaCol = dest.column - __privateGet(this, _startColumn);
+    if (deltaRow === 0 && deltaCol === 0) return;
+    if (__privateGet(this, _endRow) + deltaRow > EXCEL_MAX_ROWS || __privateGet(this, _endColumn) + deltaCol > EXCEL_MAX_COLUMNS) {
+      throw new RangeError("Destination extends past the sheet limits.");
+    }
+    const rowOrder = deltaRow > 0 ? { from: __privateGet(this, _endRow), to: __privateGet(this, _startRow), step: -1 } : { from: __privateGet(this, _startRow), to: __privateGet(this, _endRow), step: 1 };
+    const colOrder = deltaCol > 0 ? { from: __privateGet(this, _endColumn), to: __privateGet(this, _startColumn), step: -1 } : { from: __privateGet(this, _startColumn), to: __privateGet(this, _endColumn), step: 1 };
+    for (let r = rowOrder.from; deltaRow > 0 ? r >= rowOrder.to : r <= rowOrder.to; r += rowOrder.step) {
+      for (let c = colOrder.from; deltaCol > 0 ? c >= colOrder.to : c <= colOrder.to; c += colOrder.step) {
+        __privateGet(this, _sheet).moveCellRC(r, c, r + deltaRow, c + deltaCol);
+      }
     }
   }
+  /**
+   * Auto-fits all columns in the range. Measures every column in one sparse
+   * sweep rather than re-scanning the sheet per column.
+   */
+  autoFit() {
+    __privateGet(this, _sheet).autoFitColumns(__privateGet(this, _startColumn), __privateGet(this, _endColumn));
+  }
   // ── Style bulk operations ──────────────────────────────────────────────────
   /** Applies a CellStyle to all cells in the range. Returns this for chaining. */
   setStyle(style) {
@@ -2318,9 +3328,57 @@ forEach_fn = function(action) {
     }
   }
 };
+/**
+ * Like #forEach but only visits cells that already exist — used by the
+ * clearing operations so they never materialise empty cells, and so the cost
+ * tracks the populated cells rather than the area of the range.
+ */
+forEachExisting_fn = function(action) {
+  __privateGet(this, _sheet).forEachCellIn(
+    __privateGet(this, _startRow),
+    __privateGet(this, _startColumn),
+    __privateGet(this, _endRow),
+    __privateGet(this, _endColumn),
+    (cell) => action(cell)
+  );
+};
 
 // src/model/worksheet.ts
-var _sharedStrings2, _styles2, _name, _rows, _cols, _mergeCells, _pane, _autoFilter, _dataValidations, _visibility, _drawings, _preservedTail, _preservedRels, _Worksheet_instances, activeTail_fn, buildColsXml_fn, buildSheetDataXml_fn, buildMergeCellsXml_fn, buildDataValidationsXml_fn, buildSheetViewXml_fn, getOrCreateRow_fn;
+var PROTECTION_DEFAULTS = {
+  allowSelectLockedCells: true,
+  allowSelectUnlockedCells: true,
+  allowFormatCells: false,
+  allowFormatColumns: false,
+  allowFormatRows: false,
+  allowInsertRows: false,
+  allowInsertColumns: false,
+  allowInsertHyperlinks: false,
+  allowDeleteRows: false,
+  allowDeleteColumns: false,
+  allowSort: false,
+  allowAutoFilter: false,
+  allowPivotTables: false,
+  allowEditObjects: false,
+  allowEditScenarios: false
+};
+var PROTECTION_ATTRS = [
+  ["allowSelectLockedCells", "selectLockedCells"],
+  ["allowSelectUnlockedCells", "selectUnlockedCells"],
+  ["allowFormatCells", "formatCells"],
+  ["allowFormatColumns", "formatColumns"],
+  ["allowFormatRows", "formatRows"],
+  ["allowInsertRows", "insertRows"],
+  ["allowInsertColumns", "insertColumns"],
+  ["allowInsertHyperlinks", "insertHyperlinks"],
+  ["allowDeleteRows", "deleteRows"],
+  ["allowDeleteColumns", "deleteColumns"],
+  ["allowSort", "sort"],
+  ["allowAutoFilter", "autoFilter"],
+  ["allowPivotTables", "pivotTables"],
+  ["allowEditObjects", "objects"],
+  ["allowEditScenarios", "scenarios"]
+];
+var _sharedStrings2, _styles2, _name, _rows, _cols, _mergeCells, _pane, _autoFilter, _dataValidations, _visibility, _drawings, _protection, _protectionCredentials, _hyperlinks, _comments, _commentsDirty, _pendingHyperlinkRels, _preservedTail, _preservedRels, _version2, _usedBoundsMemo, _xmlMemo, _Worksheet_instances, touch_fn2, findCellData_fn, computeUsedBounds_fn, takeCellData_fn, takeCellDataAt_fn, deleteCellData_fn, applyStructural_fn, shiftRowsAndCells_fn, shiftRows_fn, shiftColumns_fn, maxPopulatedRow_fn, shiftSpillRanges_fn, shiftSpillRange_fn, rewriteFormulas_fn, shiftMerges_fn, shiftAutoFilter_fn, shiftValidations_fn, shiftHyperlinks_fn, shiftComments_fn, shiftColDefs_fn, relIdBase_fn, activeTail_fn, buildTailXml_fn, buildSheetProtectionXml_fn, buildHyperlinksXml_fn, resolveSharedFormulas_fn, buildColsXml_fn, buildSheetDataXml_fn, buildMergeCellsXml_fn, buildDataValidationsXml_fn, buildSheetViewXml_fn, splitColSpan_fn, insertColDef_fn, findColDefIndex_fn, findColDef_fn, pruneColDefs_fn, getOrCreateRow_fn;
 var Worksheet = class {
   /** @internal */
   constructor(name, sharedStrings, styles) {
@@ -2336,16 +3394,52 @@ var Worksheet = class {
     __privateAdd(this, _dataValidations, []);
     __privateAdd(this, _visibility, "visible");
     __privateAdd(this, _drawings, []);
+    __privateAdd(this, _protection);
+    /**
+     * Password/hash attributes of a protection element read from a file, kept
+     * verbatim so a protected sheet round-trips with its password intact. This
+     * library never creates them: see {@link protect}.
+     */
+    __privateAdd(this, _protectionCredentials, "");
+    /** Hyperlinks keyed by their normalised ref, in insertion order. */
+    __privateAdd(this, _hyperlinks, /* @__PURE__ */ new Map());
+    /** Comments keyed by their normalised cell ref, in insertion order. */
+    __privateAdd(this, _comments, /* @__PURE__ */ new Map());
+    /**
+     * True once the comment set has been modified through the API. Until then a
+     * sheet loaded from a file keeps its original comments and VML parts verbatim,
+     * so untouched files round-trip byte-for-byte; from then on this sheet owns
+     * them and regenerates both. See {@link setComment}.
+     */
+    __privateAdd(this, _commentsDirty, false);
+    /** Hyperlink ref → relationship id, awaiting resolution against the rels part. */
+    __privateAdd(this, _pendingHyperlinkRels, /* @__PURE__ */ new Map());
     // Round-trip state captured when this sheet was loaded from a file: the
     // relationship-bearing leaf elements of the worksheet part, and the sheet's
     // original relationships. Re-emitted on save so drawings, images and legacy
     // comment anchors survive open→save. See io/preserved-parts.ts.
     __privateAdd(this, _preservedTail, []);
     __privateAdd(this, _preservedRels, []);
+    /**
+     * Mutation counter for this sheet, shared with every {@link Cell} view it
+     * hands out (a Cell writes directly into the stored CellData). Everything
+     * derived from the sheet's contents — the used-range memo, the cached
+     * worksheet XML — is keyed on it, so every mutator must bump it. The test
+     * `worksheet-version.test.ts` walks the public surface to keep that true.
+     */
+    __privateAdd(this, _version2, { v: 0 });
+    /** Memoised {@link usedBounds}, valid while `#version.v` is unchanged. */
+    __privateAdd(this, _usedBoundsMemo);
+    /** Memoised {@link buildXml} output, valid while `#version.v` is unchanged. */
+    __privateAdd(this, _xmlMemo);
     __privateSet(this, _name, name);
     __privateSet(this, _sharedStrings2, sharedStrings);
     __privateSet(this, _styles2, styles);
   }
+  /** @internal Current mutation count — see {@link #version}. */
+  get version() {
+    return __privateGet(this, _version2).v;
+  }
   // ── Identity ───────────────────────────────────────────────────────────────
   get name() {
     return __privateGet(this, _name);
@@ -2355,24 +3449,39 @@ var Worksheet = class {
     __privateSet(this, _name, value);
   }
   getCell(refOrRow, column) {
-    const ref = typeof refOrRow === "string" ? refOrRow.replace(/\$/g, "").toUpperCase() : cellRefFromRowCol(refOrRow, column);
-    const { row } = parseCellRef(ref);
+    let ref;
+    let row;
+    if (typeof refOrRow === "string") {
+      ref = normalizeRefFast(refOrRow);
+      row = parseCellRef(ref).row;
+    } else {
+      ref = cellRefFromRowCol(refOrRow, column);
+      row = refOrRow;
+    }
     const rowData = __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, row);
     let cellData = rowData.cells.get(ref);
     if (!cellData) {
+      __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
       cellData = { reference: ref, styleIndex: 0 };
       rowData.cells.set(ref, cellData);
     }
-    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
+    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2), __privateGet(this, _version2));
   }
   tryGetCell(refOrRow, column) {
-    const ref = typeof refOrRow === "string" ? refOrRow.replace(/\$/g, "").toUpperCase() : cellRefFromRowCol(refOrRow, column);
-    const { row } = parseCellRef(ref);
-    const rowData = __privateGet(this, _rows).get(row);
-    if (!rowData) return null;
+    let rowData;
+    let ref;
+    if (typeof refOrRow === "string") {
+      ref = normalizeRefFast(refOrRow);
+      rowData = __privateGet(this, _rows).get(parseCellRef(ref).row);
+      if (!rowData) return null;
+    } else {
+      rowData = __privateGet(this, _rows).get(refOrRow);
+      if (!rowData) return null;
+      ref = cellRefFromRowCol(refOrRow, column);
+    }
     const cellData = rowData.cells.get(ref);
     if (!cellData) return null;
-    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
+    return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2), __privateGet(this, _version2));
   }
   cell(refOrRow, column) {
     return typeof refOrRow === "string" ? this.getCell(refOrRow) : this.getCell(refOrRow, column);
@@ -2384,42 +3493,158 @@ var Worksheet = class {
   }
   /** Gets the raw value of a cell (for formula evaluation). */
   getCellValue(reference) {
-    return this.tryGetCell(reference)?.getValue() ?? null;
+    const cd = __privateMethod(this, _Worksheet_instances, findCellData_fn).call(this, reference);
+    return cd ? readCellValue(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)) : null;
+  }
+  /**
+   * Value of a cell addressed by 1-based row/column. The reference-string
+   * overload has to build (and the callee re-parse) a string per cell; a range
+   * read walking a rectangle already knows the coordinates, and on a real
+   * workbook that is tens of millions of strings per recalculation.
+   */
+  getCellValueAt(row, column) {
+    const rowData = __privateGet(this, _rows).get(row);
+    if (!rowData) return null;
+    const cd = rowData.cells.get(cellRefFromRowCol(row, column));
+    return cd ? readCellValue(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)) : null;
   }
   /** Formula text (without leading '=') of a cell, or null if it has none. */
   getCellFormula(reference) {
-    return this.tryGetCell(reference)?.getFormula() ?? null;
+    return __privateMethod(this, _Worksheet_instances, findCellData_fn).call(this, reference)?.formula ?? null;
   }
   /** Spill range (e.g. "A1:A3") of a dynamic-array anchor, or null. Supports A1#. */
   getSpillRange(reference) {
-    return this.tryGetCell(reference)?.getArrayRef() ?? null;
+    return __privateMethod(this, _Worksheet_instances, findCellData_fn).call(this, reference)?.arrayRef ?? null;
+  }
+  /**
+   * Iterates the populated rows of the sheet in ascending row order, yielding
+   * each row's 1-based index and its cells (left to right). Rows and cells
+   * that were never written are skipped, so a sparse sheet iterates in
+   * O(populated cells) regardless of its bounds.
+   *
+   * @example
+   * for (const { rowIndex, cells } of ws.rows()) {
+   *   for (const cell of cells) console.log(rowIndex, cell.reference, cell.getValue());
+   * }
+   */
+  *rows() {
+    const populated = [...__privateGet(this, _rows).values()].filter((row) => row.cells.size > 0).sort((a, b) => a.rowIndex - b.rowIndex);
+    for (const row of populated) {
+      const cells = [...row.cells.values()].map((cd) => ({ cd, col: columnFromRef(cd.reference, refSplit(cd.reference)) })).sort((a, b) => a.col - b.col).map(({ cd }) => new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2), __privateGet(this, _version2)));
+      yield { rowIndex: row.rowIndex, cells };
+    }
+  }
+  /**
+   * Iterates every populated cell of the sheet in row-major order. Sparse
+   * counterpart to scanning {@link usedBounds} with {@link tryGetCell}.
+   *
+   * @example
+   * for (const cell of ws.cells()) console.log(cell.reference, cell.getValue());
+   */
+  *cells() {
+    for (const { cells } of this.rows()) yield* cells;
+  }
+  /**
+   * @internal Visits the populated cells inside a rectangle, passing the
+   * coordinates it already knows so the callback never has to parse a
+   * reference. Backs the Range operations that must not create cells; probing
+   * every coordinate would cost O(area) even on an empty sheet.
+   */
+  forEachCellIn(startRow, startColumn, endRow, endColumn, action) {
+    const visit = (row) => {
+      for (const cd of row.cells.values()) {
+        const col = columnFromRef(cd.reference, refSplit(cd.reference));
+        if (col < startColumn || col > endColumn) continue;
+        action(new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2), __privateGet(this, _version2)), row.rowIndex, col);
+      }
+    };
+    if (endRow - startRow + 1 <= __privateGet(this, _rows).size) {
+      for (let r = startRow; r <= endRow; r++) {
+        const row = __privateGet(this, _rows).get(r);
+        if (row) visit(row);
+      }
+      return;
+    }
+    for (const row of __privateGet(this, _rows).values()) {
+      if (row.rowIndex >= startRow && row.rowIndex <= endRow) visit(row);
+    }
+  }
+  /**
+   * @internal Moves a cell by coordinates, skipping the reference parsing that
+   * the public {@link moveCell} has to do. Used by bulk range moves.
+   */
+  moveCellRC(fromRow, fromColumn, toRow, toColumn) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    if (fromRow === toRow && fromColumn === toColumn) return;
+    const fromRef = cellRefFromRowCol(fromRow, fromColumn);
+    const toRef = cellRefFromRowCol(toRow, toColumn);
+    const src = __privateMethod(this, _Worksheet_instances, takeCellDataAt_fn).call(this, fromRow, fromRef);
+    if (!src) {
+      __privateMethod(this, _Worksheet_instances, takeCellDataAt_fn).call(this, toRow, toRef);
+      return;
+    }
+    const moved = { ...src, reference: toRef };
+    if (moved.arrayRef) {
+      moved.arrayRef = translateRangeRef(moved.arrayRef, toRow - fromRow, toColumn - fromColumn);
+    }
+    __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, toRow).cells.set(toRef, moved);
   }
   /**
    * Returns the 1-based extent of populated cells (largest row and column that
    * contain data). Returns zeros for an empty sheet. Useful for snapshotting a
-   * sheet into a dense 2D array.
+   * sheet into a dense 2D array — though {@link rows} and {@link cells} are
+   * cheaper when a dense shape is not actually required.
    */
   get usedBounds() {
-    let rowCount = 0;
-    let columnCount = 0;
-    for (const row of __privateGet(this, _rows).values()) {
-      if (row.cells.size === 0) continue;
-      if (row.rowIndex > rowCount) rowCount = row.rowIndex;
-      for (const ref of row.cells.keys()) {
-        const col = parseCellRef(ref).column;
-        if (col > columnCount) columnCount = col;
-      }
-    }
-    return { rowCount, columnCount };
+    const memo = __privateGet(this, _usedBoundsMemo);
+    if (memo && memo.at === __privateGet(this, _version2).v) return memo.value;
+    const value = __privateMethod(this, _Worksheet_instances, computeUsedBounds_fn).call(this);
+    __privateSet(this, _usedBoundsMemo, { at: __privateGet(this, _version2).v, value });
+    return value;
   }
   // ── Layout ─────────────────────────────────────────────────────────────────
   /** Sets the width of a column (1-based index). */
   setColumnWidth(columnIndex, width) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
     if (width <= 0) throw new RangeError("Width must be > 0.");
-    __privateSet(this, _cols, __privateGet(this, _cols).filter((c) => !(c.min <= columnIndex && c.max >= columnIndex)));
-    __privateGet(this, _cols).push({ min: columnIndex, max: columnIndex, width, customWidth: true });
-    __privateGet(this, _cols).sort((a, b) => a.min - b.min);
+    const def = __privateMethod(this, _Worksheet_instances, splitColSpan_fn).call(this, columnIndex) ?? __privateMethod(this, _Worksheet_instances, insertColDef_fn).call(this, { min: columnIndex, max: columnIndex, customWidth: false });
+    def.width = width;
+    def.customWidth = true;
+  }
+  /**
+   * Removes the explicit width of a column so it falls back to the sheet
+   * default. Counterpart to {@link setColumnWidth}; afterwards
+   * {@link getColumnWidth} returns `undefined`. A hidden column stays hidden.
+   */
+  resetColumnWidth(columnIndex) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
+    const def = __privateMethod(this, _Worksheet_instances, splitColSpan_fn).call(this, columnIndex);
+    if (!def) return;
+    def.width = void 0;
+    def.customWidth = false;
+    __privateMethod(this, _Worksheet_instances, pruneColDefs_fn).call(this);
+  }
+  /**
+   * Shows or hides a column (1-based index). Hidden columns round-trip to the
+   * file as `<col hidden="1">` and keep any explicit width.
+   */
+  setColumnHidden(columnIndex, hidden = true) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
+    const def = __privateMethod(this, _Worksheet_instances, splitColSpan_fn).call(this, columnIndex);
+    if (def) {
+      def.hidden = hidden;
+      __privateMethod(this, _Worksheet_instances, pruneColDefs_fn).call(this);
+    } else if (hidden) {
+      __privateMethod(this, _Worksheet_instances, insertColDef_fn).call(this, { min: columnIndex, max: columnIndex, customWidth: false, hidden: true });
+    }
+  }
+  /** True if the given 1-based column is hidden. */
+  isColumnHidden(columnIndex) {
+    if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
+    return __privateMethod(this, _Worksheet_instances, findColDef_fn).call(this, columnIndex)?.hidden === true;
   }
   /**
    * Returns the explicit width of a column (1-based index), or `undefined` when
@@ -2429,25 +3654,34 @@ var Worksheet = class {
    */
   getColumnWidth(columnIndex) {
     if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
-    return __privateGet(this, _cols).find((c) => c.min <= columnIndex && c.max >= columnIndex)?.width;
+    return __privateMethod(this, _Worksheet_instances, findColDef_fn).call(this, columnIndex)?.width;
   }
   /** Auto-fits column width based on content (approximate). */
   autoFitColumn(columnIndex) {
-    if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
-    let maxLen = 8;
-    for (const row of __privateGet(this, _rows).values()) {
-      const ref = cellRefFromRowCol(row.rowIndex, columnIndex);
-      const cellData = row.cells.get(ref);
-      if (cellData) {
-        const cell = new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
-        const textLen = cell.getText().length;
-        if (textLen > maxLen) maxLen = textLen;
-      }
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    this.autoFitColumns(columnIndex, columnIndex);
+  }
+  /**
+   * Auto-fits an inclusive span of columns (1-based) in a single pass over the
+   * populated cells, instead of re-scanning the sheet once per column.
+   */
+  autoFitColumns(firstColumn, lastColumn) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    if (firstColumn < 1) throw new RangeError("Column index must be >= 1.");
+    if (lastColumn < firstColumn) return;
+    const maxLen = /* @__PURE__ */ new Map();
+    this.forEachCellIn(1, firstColumn, EXCEL_MAX_ROWS, lastColumn, (cell, _row, column) => {
+      const len = cell.getText().length;
+      if (len > (maxLen.get(column) ?? 0)) maxLen.set(column, len);
+    });
+    for (let col = firstColumn; col <= lastColumn; col++) {
+      const len = Math.max(maxLen.get(col) ?? 0, 8);
+      this.setColumnWidth(col, Math.min(len * 1.2 + 2, 255));
     }
-    this.setColumnWidth(columnIndex, Math.min(maxLen * 1.2 + 2, 255));
   }
   /** Sets the height of a row (1-based index). */
   setRowHeight(rowIndex, height) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
     if (height <= 0) throw new RangeError("Height must be > 0.");
     const row = __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, rowIndex);
@@ -2462,8 +3696,23 @@ var Worksheet = class {
     if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
     return __privateGet(this, _rows).get(rowIndex)?.height;
   }
+  /**
+   * Removes the explicit height of a row so it falls back to the sheet
+   * default. Counterpart to {@link setRowHeight}; afterwards
+   * {@link getRowHeight} returns `undefined`. A hidden row stays hidden.
+   */
+  resetRowHeight(rowIndex) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
+    const row = __privateGet(this, _rows).get(rowIndex);
+    if (!row) return;
+    row.height = void 0;
+    row.customHeight = void 0;
+    if (row.cells.size === 0 && !row.hidden) __privateGet(this, _rows).delete(rowIndex);
+  }
   /** Shows or hides a row (1-based index). Hidden rows affect SUBTOTAL(101-111). */
   setRowHidden(rowIndex, hidden = true) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
     __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, rowIndex).hidden = hidden;
   }
@@ -2471,13 +3720,153 @@ var Worksheet = class {
   isRowHidden(rowIndex) {
     return __privateGet(this, _rows).get(rowIndex)?.hidden === true;
   }
+  /**
+   * The 1-based indices of every hidden row, ascending. Sparse counterpart to
+   * probing {@link isRowHidden} across {@link usedBounds}.
+   */
+  get hiddenRows() {
+    const result = [];
+    for (const row of __privateGet(this, _rows).values()) {
+      if (row.hidden) result.push(row.rowIndex);
+    }
+    return result.sort((a, b) => a - b);
+  }
+  /**
+   * The 1-based indices of every hidden column, ascending. Counterpart to
+   * {@link isColumnHidden}, in the same spirit as {@link hiddenRows}.
+   */
+  get hiddenColumns() {
+    const result = [];
+    for (const def of __privateGet(this, _cols)) {
+      if (!def.hidden) continue;
+      for (let c = def.min; c <= def.max; c++) result.push(c);
+    }
+    return result.sort((a, b) => a - b);
+  }
+  // ── Structural editing ─────────────────────────────────────────────────────
+  /**
+   * Inserts `count` empty rows starting at row `at` (1-based). Everything at
+   * or below `at` moves down: cell values, formulas (references are rewritten
+   * the way Excel does), styles, row heights, hidden flags, merges,
+   * autofilter and data-validation ranges.
+   *
+   * Frozen panes are a view property and stay put. Drawing/chart anchors
+   * preserved from a loaded file are opaque XML and do NOT shift — images
+   * keep their absolute position (known limitation).
+   *
+   * When formulas on OTHER sheets reference this sheet, use the
+   * Workbook-level counterpart so they are rewritten too, or call
+   * `applyExternalShift` on each sheet yourself. If a RecalcEngine is
+   * attached, notify it afterwards (e.g. `engine.onRowsInserted(...)`).
+   *
+   * @example
+   * ws.insertRows(3, 2); // pushes row 3 and below down by two rows
+   */
+  insertRows(at, count = 1) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    return __privateMethod(this, _Worksheet_instances, applyStructural_fn).call(this, "row", "insert", at, count);
+  }
+  /**
+   * Deletes `count` rows starting at row `at` (1-based). Rows below move up;
+   * formulas referencing the deleted band get `#REF!` (fully inside) or
+   * shrink (partially inside), exactly like Excel. See {@link insertRows}
+   * for the shifting rules and known limitations.
+   */
+  deleteRows(at, count = 1) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    return __privateMethod(this, _Worksheet_instances, applyStructural_fn).call(this, "row", "delete", at, count);
+  }
+  /**
+   * Inserts `count` empty columns starting at column `at` (1-based).
+   * Column-level counterpart to {@link insertRows}; widths and hidden flags
+   * shift with the columns.
+   */
+  insertColumns(at, count = 1) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    return __privateMethod(this, _Worksheet_instances, applyStructural_fn).call(this, "col", "insert", at, count);
+  }
+  /**
+   * Deletes `count` columns starting at column `at` (1-based).
+   * Column-level counterpart to {@link deleteRows}.
+   */
+  deleteColumns(at, count = 1) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    return __privateMethod(this, _Worksheet_instances, applyStructural_fn).call(this, "col", "delete", at, count);
+  }
+  /**
+   * @internal Rewrites formulas on THIS sheet after a structural edit on a
+   * DIFFERENT sheet (named by `shift.sheetName`), so qualified references
+   * like `'Data'!A5` stay correct. Cell positions here do not change.
+   */
+  applyExternalShift(shift) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    return { refErrors: __privateMethod(this, _Worksheet_instances, rewriteFormulas_fn).call(this, shift) };
+  }
+  /**
+   * Moves a cell's full contents — value, formula, style and spill anchor —
+   * to another cell, overwriting the destination and clearing the source.
+   * A missing source clears the destination. This is a literal move: formula
+   * text is NOT adjusted for the new position.
+   *
+   * @example
+   * ws.moveCell('A1', 'C5');
+   */
+  moveCell(from, to) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    const fromRef = normalizeRef(from);
+    const toRef = normalizeRef(to);
+    if (fromRef === toRef) return;
+    const src = __privateMethod(this, _Worksheet_instances, takeCellData_fn).call(this, fromRef);
+    if (!src) {
+      __privateMethod(this, _Worksheet_instances, deleteCellData_fn).call(this, toRef);
+      return;
+    }
+    const fromPos = parseCellRef(fromRef);
+    const toPos = parseCellRef(toRef);
+    const moved = { ...src, reference: toRef };
+    if (moved.arrayRef) {
+      moved.arrayRef = translateRangeRef(
+        moved.arrayRef,
+        toPos.row - fromPos.row,
+        toPos.column - fromPos.column
+      );
+    }
+    __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, toPos.row).cells.set(toRef, moved);
+  }
+  /**
+   * Copies a cell's value, formula and style to another cell, overwriting the
+   * destination and leaving the source untouched. A missing source clears the
+   * destination. This is a literal copy: formula references are NOT adjusted,
+   * and the spill anchor (`arrayRef`) is not copied — a recalc engine
+   * re-establishes it.
+   *
+   * @example
+   * ws.copyCell('A1', 'C5');
+   */
+  copyCell(from, to) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    const fromRef = normalizeRef(from);
+    const toRef = normalizeRef(to);
+    if (fromRef === toRef) return;
+    const srcRow = __privateGet(this, _rows).get(parseCellRef(fromRef).row);
+    const src = srcRow?.cells.get(fromRef);
+    if (!src) {
+      __privateMethod(this, _Worksheet_instances, deleteCellData_fn).call(this, toRef);
+      return;
+    }
+    const toPos = parseCellRef(toRef);
+    const copied = { ...src, reference: toRef, arrayRef: void 0 };
+    __privateMethod(this, _Worksheet_instances, getOrCreateRow_fn).call(this, toPos.row).cells.set(toRef, copied);
+  }
   /** Merges cells in the given range (e.g. "A1:B2"). */
   mergeCells(rangeReference) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (!rangeReference) throw new Error("Range reference cannot be empty.");
     __privateGet(this, _mergeCells).push({ ref: rangeReference });
   }
   /** Removes a merge for the given range reference. */
   unmergeCells(rangeReference) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _mergeCells, __privateGet(this, _mergeCells).filter((m) => m.ref !== rangeReference));
   }
   /**
@@ -2494,12 +3883,14 @@ var Worksheet = class {
    * @param column Number of columns to freeze (0 = none)
    */
   freezePanes(row, column) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     if (row < 0) throw new RangeError("Row must be >= 0.");
     if (column < 0) throw new RangeError("Column must be >= 0.");
     __privateSet(this, _pane, row === 0 && column === 0 ? void 0 : { row, column });
   }
   /** Sets auto-filter on the given range. */
   setAutoFilter(rangeReference) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _autoFilter, { ref: rangeReference });
   }
   /**
@@ -2508,15 +3899,136 @@ var Worksheet = class {
    * @param listFormula Formula for the dropdown list (e.g. "'Sheet2'!$A$1:$A$10")
    */
   addDropdownValidation(cellRange, listFormula) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateGet(this, _dataValidations).push({ sqref: cellRange, formula: listFormula });
   }
   /** Sets the visibility state of this worksheet. */
   setVisibility(state) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _visibility, state);
   }
   get visibility() {
     return __privateGet(this, _visibility);
   }
+  // ── Sheet protection ───────────────────────────────────────────────────────
+  /**
+   * Turns on sheet protection, optionally relaxing individual permissions.
+   * Cells are locked by default in Excel, so protecting a sheet makes all of
+   * them read-only; clear a cell style's `locked` flag to leave a cell editable.
+   *
+   * Excel's sheet protection is a UI guard, **not** security: the contents stay
+   * readable to anything that opens the file. This library therefore never
+   * creates a protection password. A password read from an existing file is
+   * preserved so the sheet round-trips unchanged.
+   *
+   * @example
+   * ws.protect();                                  // lock everything
+   * ws.protect({ allowSort: true, allowAutoFilter: true });
+   */
+  protect(options) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    __privateSet(this, _protection, { ...PROTECTION_DEFAULTS, ...options });
+  }
+  /** Turns off sheet protection, discarding any password read from a file. */
+  unprotect() {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    __privateSet(this, _protection, void 0);
+    __privateSet(this, _protectionCredentials, "");
+  }
+  /** True when this sheet is protected. */
+  get isProtected() {
+    return __privateGet(this, _protection) !== void 0;
+  }
+  /** The active permissions, or `undefined` when the sheet is not protected. */
+  get protection() {
+    return __privateGet(this, _protection) ? { ...__privateGet(this, _protection) } : void 0;
+  }
+  // ── Hyperlinks ─────────────────────────────────────────────────────────────
+  /**
+   * Attaches a hyperlink to a cell or range. Give `target` for an external
+   * destination or `location` for one inside the workbook; passing both keeps
+   * the external target and uses the location as its fragment, which is how
+   * Excel links to an anchor within a document.
+   *
+   * A cell's displayed text still comes from its own value — set that
+   * separately; `display` only overrides what Excel shows in the edit bar.
+   *
+   * @example
+   * ws.getCell('A1').setValue('Anthropic');
+   * ws.setHyperlink('A1', { target: 'https://anthropic.com', tooltip: 'Open site' });
+   * ws.setHyperlink('B1', { location: "'Sheet2'!A1" });
+   */
+  setHyperlink(ref, link) {
+    if (!link.target && !link.location) {
+      throw new Error("A hyperlink needs a target (external) or a location (in-workbook).");
+    }
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    const normalized = normalizeRangeRef(ref);
+    __privateGet(this, _hyperlinks).set(normalized, { ref: normalized, ...link });
+  }
+  /** The hyperlink covering exactly this ref, or undefined. */
+  getHyperlink(ref) {
+    return __privateGet(this, _hyperlinks).get(normalizeRangeRef(ref));
+  }
+  /** Removes the hyperlink on this ref. Returns true if one was there. */
+  removeHyperlink(ref) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    return __privateGet(this, _hyperlinks).delete(normalizeRangeRef(ref));
+  }
+  /** Every hyperlink on the sheet, including ones read from a file. */
+  get hyperlinks() {
+    return [...__privateGet(this, _hyperlinks).values()];
+  }
+  // ── Comments (notes) ───────────────────────────────────────────────────────
+  /**
+   * Attaches a comment (a "note" in current Excel versions) to a cell,
+   * replacing any comment already there.
+   *
+   * Note that writing comments makes this sheet regenerate its comment and
+   * legacy-drawing parts on save. If the file was opened with other legacy
+   * drawing content on the same sheet — form controls, for instance — that
+   * content is not reproduced. Reading comments has no such effect.
+   *
+   * @example
+   * ws.setComment('B4', 'Check this figure', { author: 'Bill' });
+   */
+  setComment(ref, text, options) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    const normalized = normalizeRef(ref);
+    __privateGet(this, _comments).set(normalized, {
+      ref: normalized,
+      text,
+      author: options?.author ?? ""
+    });
+    __privateSet(this, _commentsDirty, true);
+  }
+  /** The comment on a cell, or undefined. */
+  getComment(ref) {
+    return __privateGet(this, _comments).get(normalizeRef(ref));
+  }
+  /** Removes the comment on a cell. Returns true if one was there. */
+  removeComment(ref) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    const removed = __privateGet(this, _comments).delete(normalizeRef(ref));
+    if (removed) __privateSet(this, _commentsDirty, true);
+    return removed;
+  }
+  /** Every comment on the sheet, including ones read from a file. */
+  get comments() {
+    return [...__privateGet(this, _comments).values()];
+  }
+  /** @internal True when this sheet must write its own comment parts. */
+  get ownsCommentParts() {
+    return __privateGet(this, _commentsDirty) && __privateGet(this, _comments).size > 0;
+  }
+  /**
+   * @internal True when the sheet took over its comment parts and any preserved
+   * originals must be dropped — including the case where every comment was
+   * deleted and nothing replaces them.
+   */
+  get commentPartsReplaced() {
+    return __privateGet(this, _commentsDirty);
+  }
   // ── Drawings (charts, images …) ──────────────────────────────────────────────
   /**
    * Attaches a drawing provider (e.g. a chart) to this worksheet.
@@ -2524,6 +4036,7 @@ var Worksheet = class {
    * save pipeline turns registered providers into valid OOXML drawing/chart parts.
    */
   addDrawingProvider(provider) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateGet(this, _drawings).push(provider);
   }
   /**
@@ -2535,6 +4048,7 @@ var Worksheet = class {
    * deliberately drop a chart that came from the source file.
    */
   clearDrawings() {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateSet(this, _drawings, []);
     __privateSet(this, _preservedTail, __privateGet(this, _preservedTail).filter((t) => t.tag !== "drawing"));
   }
@@ -2554,7 +4068,12 @@ var Worksheet = class {
    */
   get preservedRelationships() {
     const liveIds = new Set(__privateMethod(this, _Worksheet_instances, activeTail_fn).call(this).map((t) => t.relId));
-    return __privateGet(this, _preservedRels).filter((r) => liveIds.has(r.id));
+    return __privateGet(this, _preservedRels).filter((r) => {
+      if (r.type === REL_TYPES.comments) {
+        return !this.commentPartsReplaced && __privateGet(this, _comments).size > 0;
+      }
+      return liveIds.has(r.id);
+    });
   }
   /**
    * @internal Package paths of relationships that were preserved at load time
@@ -2571,55 +4090,119 @@ var Worksheet = class {
    * clear every preserved id so the two sets cannot collide.
    */
   get drawingRelId() {
-    let max = 0;
-    for (const r of __privateGet(this, _preservedRels)) {
-      const n = /^rId(\d+)$/.exec(r.id);
-      if (n) max = Math.max(max, parseInt(n[1], 10));
+    return this.generatedRels().drawing ?? `rId${__privateMethod(this, _Worksheet_instances, relIdBase_fn).call(this) + 1}`;
+  }
+  /**
+   * @internal Relationship ids for the parts this sheet generates itself.
+   *
+   * Derived purely from the model so the worksheet XML and the sheet's rels part
+   * — which are written by different code — cannot disagree about an id. Order is
+   * fixed: drawing, then external hyperlinks in insertion order, then the
+   * comments part and its legacy VML drawing.
+   */
+  generatedRels() {
+    let next = __privateMethod(this, _Worksheet_instances, relIdBase_fn).call(this);
+    const result = { hyperlinks: /* @__PURE__ */ new Map() };
+    if (this.hasDrawings) result.drawing = `rId${++next}`;
+    for (const link of __privateGet(this, _hyperlinks).values()) {
+      if (link.target) result.hyperlinks.set(link.ref, `rId${++next}`);
     }
-    return `rId${max + 1}`;
+    if (this.ownsCommentParts) {
+      result.comments = `rId${++next}`;
+      result.vmlDrawing = `rId${++next}`;
+    }
+    return result;
   }
   /** @internal Captures round-trip state from the source package. */
   loadPreservedState(worksheetXml, relationships) {
-    __privateSet(this, _preservedRels, [...relationships]);
-    const known = new Set(relationships.map((r) => r.id));
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    __privateSet(this, _preservedRels, relationships.filter((r) => r.type !== REL_TYPES.hyperlink));
+    const known = new Set(__privateGet(this, _preservedRels).map((r) => r.id));
     __privateSet(this, _preservedTail, parseTailElements(worksheetXml).filter((t) => known.has(t.relId)));
+    const byId = new Map(relationships.map((r) => [r.id, r]));
+    for (const [ref, relId] of __privateGet(this, _pendingHyperlinkRels)) {
+      const rel = byId.get(relId);
+      const link = __privateGet(this, _hyperlinks).get(ref);
+      if (!rel || !link) continue;
+      __privateGet(this, _hyperlinks).set(ref, { ...link, target: rel.target });
+    }
+    __privateGet(this, _pendingHyperlinkRels).clear();
+    for (const [ref, link] of [...__privateGet(this, _hyperlinks)]) {
+      if (!link.target && !link.location) __privateGet(this, _hyperlinks).delete(ref);
+    }
+  }
+  /**
+   * @internal Package paths of the comment parts this sheet read at load time.
+   * The save pipeline drops them from the preserved set once the sheet takes
+   * ownership, so they are not written twice.
+   */
+  commentPartPaths() {
+    const paths = [];
+    for (const rel of __privateGet(this, _preservedRels)) {
+      if (!rel.resolved) continue;
+      if (rel.type === REL_TYPES.comments || rel.type === REL_TYPES.vmlDrawing) {
+        paths.push(rel.resolved);
+      }
+    }
+    return paths;
+  }
+  /**
+   * @internal The relationship pointing at this sheet's comments part, if the
+   * sheet was loaded from a file that had one.
+   */
+  commentsPartPath() {
+    return __privateGet(this, _preservedRels).find((r) => r.type === REL_TYPES.comments)?.resolved;
   }
   // ── XML serialisation ──────────────────────────────────────────────────────
   /** Builds the xl/worksheets/sheetN.xml string. */
   buildXml() {
+    const memo = __privateGet(this, _xmlMemo);
+    if (memo && memo.at === __privateGet(this, _version2).v) return memo.xml;
+    const rels = this.generatedRels();
+    const sheetViewXml = __privateMethod(this, _Worksheet_instances, buildSheetViewXml_fn).call(this);
     const colsXml = __privateMethod(this, _Worksheet_instances, buildColsXml_fn).call(this);
     const sheetDataXml = __privateMethod(this, _Worksheet_instances, buildSheetDataXml_fn).call(this);
-    const mergeXml = __privateMethod(this, _Worksheet_instances, buildMergeCellsXml_fn).call(this);
+    const protectionXml = __privateMethod(this, _Worksheet_instances, buildSheetProtectionXml_fn).call(this);
     const filterXml = __privateGet(this, _autoFilter) ? `<autoFilter ref="${__privateGet(this, _autoFilter).ref}"/>` : "";
+    const mergeXml = __privateMethod(this, _Worksheet_instances, buildMergeCellsXml_fn).call(this);
     const validXml = __privateMethod(this, _Worksheet_instances, buildDataValidationsXml_fn).call(this);
-    const sheetViewXml = __privateMethod(this, _Worksheet_instances, buildSheetViewXml_fn).call(this);
-    const preservedTailXml = __privateMethod(this, _Worksheet_instances, activeTail_fn).call(this).map((t) => t.xml).join("");
-    const drawingXml = this.hasDrawings ? `<drawing r:id="${this.drawingRelId}"/>` : "";
-    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+    const linksXml = __privateMethod(this, _Worksheet_instances, buildHyperlinksXml_fn).call(this, rels.hyperlinks);
+    const tailXml = __privateMethod(this, _Worksheet_instances, buildTailXml_fn).call(this, rels);
+    const xml2 = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
            xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
   <sheetViews>${sheetViewXml}</sheetViews>
-${colsXml}${sheetDataXml}${filterXml}${mergeXml}${validXml}${preservedTailXml}${drawingXml}
+${colsXml}${sheetDataXml}${protectionXml}${filterXml}${mergeXml}${validXml}${linksXml}${tailXml}
 </worksheet>`;
+    __privateSet(this, _xmlMemo, { at: __privateGet(this, _version2).v, xml: xml2 });
+    return xml2;
   }
   /** Parses xl/worksheets/sheetN.xml and loads cells into memory. */
   loadFromXml(xml2) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
     __privateGet(this, _rows).clear();
     __privateSet(this, _cols, []);
     __privateSet(this, _mergeCells, []);
     __privateSet(this, _pane, void 0);
     __privateSet(this, _autoFilter, void 0);
     __privateSet(this, _dataValidations, []);
+    __privateSet(this, _protection, void 0);
+    __privateSet(this, _protectionCredentials, "");
+    __privateGet(this, _hyperlinks).clear();
+    __privateGet(this, _pendingHyperlinkRels).clear();
     const root = parseXml(xml2);
     for (const colEl of getElementsByTagName(root, "col")) {
+      const widthAttr = getAttr(colEl, "width");
       __privateGet(this, _cols).push({
         min: parseInt(getAttr(colEl, "min") ?? "1", 10),
         max: parseInt(getAttr(colEl, "max") ?? "1", 10),
-        width: parseFloat(getAttr(colEl, "width") ?? "8"),
+        width: widthAttr !== void 0 ? parseFloat(widthAttr) : void 0,
         customWidth: getAttr(colEl, "customWidth") === "1",
         hidden: getAttr(colEl, "hidden") === "1"
       });
     }
+    const sharedMasters = /* @__PURE__ */ new Map();
+    const sharedInstances = [];
     for (const rowEl of getElementsByTagName(root, "row")) {
       const rowIndex = parseInt(getAttr(rowEl, "r") ?? "0", 10);
       if (rowIndex < 1) continue;
@@ -2640,9 +4223,17 @@ ${colsXml}${sheetDataXml}${filterXml}${mergeXml}${validXml}${preservedTailXml}${
           ref.toUpperCase()
         );
         rowData.cells.set(ref.toUpperCase(), cellData);
+        if (cellData.sharedIndex !== void 0) {
+          if (cellData.formula !== void 0) {
+            sharedMasters.set(cellData.sharedIndex, { formula: cellData.formula, ref: cellData.reference });
+          } else {
+            sharedInstances.push(cellData);
+          }
+        }
       }
       __privateGet(this, _rows).set(rowIndex, rowData);
     }
+    __privateMethod(this, _Worksheet_instances, resolveSharedFormulas_fn).call(this, sharedMasters, sharedInstances);
     for (const mcEl of getElementsByTagName(root, "mergeCell")) {
       const ref = getAttr(mcEl, "ref");
       if (ref) __privateGet(this, _mergeCells).push({ ref });
@@ -2667,6 +4258,76 @@ ${colsXml}${sheetDataXml}${filterXml}${mergeXml}${validXml}${preservedTailXml}${
       const formula = f1Els[0]?.textContent ?? "";
       if (sqref && formula) __privateGet(this, _dataValidations).push({ sqref, formula });
     }
+    const protEl = getElementsByTagName(root, "sheetProtection")[0];
+    if (protEl && getAttr(protEl, "sheet") === "1") {
+      const protection = { ...PROTECTION_DEFAULTS };
+      for (const [key, attr] of PROTECTION_ATTRS) {
+        const raw = getAttr(protEl, attr);
+        if (raw !== void 0) protection[key] = raw !== "1";
+      }
+      __privateSet(this, _protection, protection);
+      let credentials = "";
+      for (const attr of ["password", "algorithmName", "hashValue", "saltValue", "spinCount"]) {
+        const raw = getAttr(protEl, attr);
+        if (raw !== void 0) credentials += ` ${attr}="${escXmlAttr(raw)}"`;
+      }
+      __privateSet(this, _protectionCredentials, credentials);
+    }
+    for (const hlEl of getElementsByTagName(root, "hyperlink")) {
+      const ref = getAttr(hlEl, "ref");
+      if (!ref) continue;
+      const normalized = normalizeRangeRef(ref);
+      __privateGet(this, _hyperlinks).set(normalized, {
+        ref: normalized,
+        location: getAttr(hlEl, "location"),
+        display: getAttr(hlEl, "display"),
+        tooltip: getAttr(hlEl, "tooltip")
+      });
+      const relId = getAttr(hlEl, "r:id") ?? getAttr(hlEl, "id");
+      if (relId) __privateGet(this, _pendingHyperlinkRels).set(normalized, relId);
+    }
+  }
+  /** @internal Parses an `xl/comments*.xml` part into this sheet's comments. */
+  loadCommentsXml(xml2) {
+    __privateMethod(this, _Worksheet_instances, touch_fn2).call(this);
+    const root = parseXml(xml2);
+    const authors = getElementsByTagName(root, "author").map((a) => a.textContent);
+    for (const cEl of getElementsByTagName(root, "comment")) {
+      const ref = getAttr(cEl, "ref");
+      if (!ref) continue;
+      const authorId = parseInt(getAttr(cEl, "authorId") ?? "0", 10);
+      const text = getElementsByTagName(cEl, "t").map((t) => t.textContent).join("");
+      const normalized = normalizeRef(ref);
+      __privateGet(this, _comments).set(normalized, {
+        ref: normalized,
+        text,
+        author: authors[authorId] ?? ""
+      });
+    }
+    __privateSet(this, _commentsDirty, false);
+  }
+  /** @internal The comments part content, when this sheet owns it. */
+  buildCommentsXml() {
+    const authors = [...new Set([...__privateGet(this, _comments).values()].map((c) => c.author))];
+    const authorsXml = authors.map((a) => `<author>${escXml2(a)}</author>`).join("");
+    const listXml = [...__privateGet(this, _comments).values()].map(
+      (c) => `<comment ref="${c.ref}" authorId="${authors.indexOf(c.author)}"><text><r><t xml:space="preserve">${escXml2(c.text)}</t></r></text></comment>`
+    ).join("");
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<comments xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><authors>${authorsXml}</authors><commentList>${listXml}</commentList></comments>`;
+  }
+  /**
+   * @internal The legacy VML drawing that positions the comment boxes. Excel
+   * needs it to draw the note indicator and popup; the comments part alone
+   * carries only the text.
+   */
+  buildCommentsVml() {
+    const shapes = [...__privateGet(this, _comments).values()].map((c, idx) => {
+      const { row, column } = parseCellRef(c.ref);
+      const anchor = `${column}, 15, ${row - 1}, 10, ${column + 2}, 15, ${row + 3}, 4`;
+      return `<v:shape id="_x0000_s${1025 + idx}" type="#_x0000_t202" style="position:absolute;margin-left:60pt;margin-top:5pt;width:108pt;height:60pt;z-index:${idx + 1};visibility:hidden" fillcolor="#ffffe1" o:insetmode="auto"><v:fill color2="#ffffe1"/><v:shadow on="t" color="black" obscured="t"/><v:path o:connecttype="none"/><v:textbox style="mso-direction-alt:auto"><div style="text-align:left"/></v:textbox><x:ClientData ObjectType="Note"><x:MoveWithCells/><x:SizeWithCells/><x:Anchor>${anchor}</x:Anchor><x:AutoFill>False</x:AutoFill><x:Row>${row - 1}</x:Row><x:Column>${column - 1}</x:Column></x:ClientData></v:shape>`;
+    }).join("");
+    return `<xml xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:x="urn:schemas-microsoft-com:office:excel"><o:shapelayout v:ext="edit"><o:idmap v:ext="edit" data="1"/></o:shapelayout><v:shapetype id="_x0000_t202" coordsize="21600,21600" o:spt="202" path="m,l,21600r21600,l21600,xe"><v:stroke joinstyle="miter"/><v:path gradientshapeok="t" o:connecttype="rect"/></v:shapetype>${shapes}</xml>`;
   }
 };
 _sharedStrings2 = new WeakMap();
@@ -2680,23 +4341,331 @@ _autoFilter = new WeakMap();
 _dataValidations = new WeakMap();
 _visibility = new WeakMap();
 _drawings = new WeakMap();
+_protection = new WeakMap();
+_protectionCredentials = new WeakMap();
+_hyperlinks = new WeakMap();
+_comments = new WeakMap();
+_commentsDirty = new WeakMap();
+_pendingHyperlinkRels = new WeakMap();
 _preservedTail = new WeakMap();
 _preservedRels = new WeakMap();
+_version2 = new WeakMap();
+_usedBoundsMemo = new WeakMap();
+_xmlMemo = new WeakMap();
 _Worksheet_instances = new WeakSet();
+/** Records a change to this sheet's contents or layout. */
+touch_fn2 = function() {
+  __privateGet(this, _version2).v++;
+};
+/**
+ * The stored record for a cell, without creating it — the read paths below
+ * work on this directly instead of wrapping it in a {@link Cell}. Formula
+ * evaluation reads far more cells than it writes, and one wrapper per read is
+ * pure garbage.
+ */
+findCellData_fn = function(reference) {
+  const ref = normalizeRefFast(reference);
+  return __privateGet(this, _rows).get(parseCellRef(ref).row)?.cells.get(ref);
+};
+/**
+ * The extent, computed without touching the memo.
+ *
+ * Internal callers must use this. A mutator bumps the version once, at its
+ * start, and then does its work; if it read the memoised getter part-way
+ * through, the half-finished extent would be cached against the *new* version
+ * and served as current for the rest of that version's life. That is precisely
+ * how `insertColumns` came to report the extent it had before the insert —
+ * caught by the round-trip fuzz test, not by any of the hand-written ones.
+ */
+computeUsedBounds_fn = function() {
+  let rowCount = 0;
+  let columnCount = 0;
+  for (const row of __privateGet(this, _rows).values()) {
+    if (row.cells.size === 0) continue;
+    if (row.rowIndex > rowCount) rowCount = row.rowIndex;
+    for (const ref of row.cells.keys()) {
+      const col = columnFromRef(ref, refSplit(ref));
+      if (col > columnCount) columnCount = col;
+    }
+  }
+  return { rowCount, columnCount };
+};
+/** Removes and returns a cell's data record, pruning an emptied bare row. */
+takeCellData_fn = function(ref) {
+  return __privateMethod(this, _Worksheet_instances, takeCellDataAt_fn).call(this, parseCellRef(ref).row, ref);
+};
+takeCellDataAt_fn = function(row, ref) {
+  const rowData = __privateGet(this, _rows).get(row);
+  const data = rowData?.cells.get(ref);
+  if (rowData && data) {
+    rowData.cells.delete(ref);
+    if (rowData.cells.size === 0 && !rowData.hidden && rowData.height === void 0) {
+      __privateGet(this, _rows).delete(row);
+    }
+  }
+  return data;
+};
+deleteCellData_fn = function(ref) {
+  __privateMethod(this, _Worksheet_instances, takeCellData_fn).call(this, ref);
+};
+applyStructural_fn = function(dim, kind, at, count) {
+  const what = dim === "row" ? "Row" : "Column";
+  if (!Number.isInteger(at) || at < 1) throw new RangeError(`${what} index must be an integer >= 1.`);
+  if (!Number.isInteger(count) || count < 1) throw new RangeError("Count must be an integer >= 1.");
+  const shift = { dim, kind, at, count, sheetName: __privateGet(this, _name) };
+  if (kind === "insert") {
+    const limit = dim === "row" ? EXCEL_MAX_ROWS : EXCEL_MAX_COLUMNS;
+    const used = dim === "row" ? __privateMethod(this, _Worksheet_instances, maxPopulatedRow_fn).call(this) : __privateMethod(this, _Worksheet_instances, computeUsedBounds_fn).call(this).columnCount;
+    if (used >= at && used + count > limit) {
+      throw new RangeError(`Insert would push populated cells past the sheet limit of ${limit}.`);
+    }
+  }
+  __privateMethod(this, _Worksheet_instances, shiftRowsAndCells_fn).call(this, shift);
+  const refErrors = __privateMethod(this, _Worksheet_instances, rewriteFormulas_fn).call(this, shift);
+  __privateMethod(this, _Worksheet_instances, shiftMerges_fn).call(this, shift);
+  __privateMethod(this, _Worksheet_instances, shiftAutoFilter_fn).call(this, shift);
+  __privateMethod(this, _Worksheet_instances, shiftValidations_fn).call(this, shift);
+  __privateMethod(this, _Worksheet_instances, shiftHyperlinks_fn).call(this, shift);
+  __privateMethod(this, _Worksheet_instances, shiftComments_fn).call(this, shift);
+  if (dim === "col") __privateMethod(this, _Worksheet_instances, shiftColDefs_fn).call(this, shift);
+  return { refErrors };
+};
+/**
+ * Re-keys the row map / per-row cell maps and shifts every cell's spill range.
+ *
+ * Rows and columns before the shift boundary keep their keys, their reference
+ * strings and their identity, so an edit near the end of a sheet costs
+ * proportionally little rather than rebuilding the whole model. Spill ranges
+ * are the one thing that must be visited everywhere, since a range belonging
+ * to an unmoved anchor can still span the boundary — but that pass is a bare
+ * property test per cell.
+ */
+shiftRowsAndCells_fn = function(shift) {
+  if (shift.dim === "row") __privateMethod(this, _Worksheet_instances, shiftRows_fn).call(this, shift);
+  else __privateMethod(this, _Worksheet_instances, shiftColumns_fn).call(this, shift);
+};
+shiftRows_fn = function(shift) {
+  const moved = [];
+  for (const row of __privateGet(this, _rows).values()) {
+    if (row.rowIndex < shift.at) {
+      __privateMethod(this, _Worksheet_instances, shiftSpillRanges_fn).call(this, row, shift);
+      continue;
+    }
+    const shifted = shiftIndex(row.rowIndex, shift);
+    __privateGet(this, _rows).delete(row.rowIndex);
+    if (shifted === null) continue;
+    row.rowIndex = shifted;
+    moved.push(row);
+  }
+  for (const row of moved) {
+    const suffix = String(row.rowIndex);
+    const newCells = /* @__PURE__ */ new Map();
+    for (const cd of row.cells.values()) {
+      const ref = cd.reference.slice(0, refSplit(cd.reference)) + suffix;
+      cd.reference = ref;
+      if (cd.arrayRef) cd.arrayRef = shiftRangeRef(cd.arrayRef, shift) ?? void 0;
+      newCells.set(ref, cd);
+    }
+    row.cells = newCells;
+    __privateGet(this, _rows).set(row.rowIndex, row);
+  }
+};
+shiftColumns_fn = function(shift) {
+  for (const row of __privateGet(this, _rows).values()) {
+    let affected;
+    for (const cd of row.cells.values()) {
+      const ref = cd.reference;
+      if (columnFromRef(ref, refSplit(ref)) < shift.at) {
+        __privateMethod(this, _Worksheet_instances, shiftSpillRange_fn).call(this, cd, shift);
+        continue;
+      }
+      (affected ?? (affected = [])).push(cd);
+    }
+    if (!affected) continue;
+    for (const cd of affected) row.cells.delete(cd.reference);
+    for (const cd of affected) {
+      const split = refSplit(cd.reference);
+      const shifted = shiftIndex(columnFromRef(cd.reference, split), shift);
+      if (shifted === null) continue;
+      const ref = columnLetter(shifted) + cd.reference.slice(split);
+      cd.reference = ref;
+      __privateMethod(this, _Worksheet_instances, shiftSpillRange_fn).call(this, cd, shift);
+      row.cells.set(ref, cd);
+    }
+  }
+};
+/** Largest 1-based row index holding a cell, or 0. O(rows), no ref parsing. */
+maxPopulatedRow_fn = function() {
+  let max = 0;
+  for (const row of __privateGet(this, _rows).values()) {
+    if (row.cells.size > 0 && row.rowIndex > max) max = row.rowIndex;
+  }
+  return max;
+};
+shiftSpillRanges_fn = function(row, shift) {
+  for (const cd of row.cells.values()) __privateMethod(this, _Worksheet_instances, shiftSpillRange_fn).call(this, cd, shift);
+};
+shiftSpillRange_fn = function(cd, shift) {
+  if (cd.arrayRef) cd.arrayRef = shiftRangeRef(cd.arrayRef, shift) ?? void 0;
+};
+/** Rewrites every formula on the sheet; returns refs that now hold #REF!. */
+rewriteFormulas_fn = function(shift) {
+  const refErrors = [];
+  for (const row of __privateGet(this, _rows).values()) {
+    for (const cd of row.cells.values()) {
+      if (!cd.formula) continue;
+      const result = shiftFormulaRefs(cd.formula, shift, __privateGet(this, _name));
+      if (result.changed) cd.formula = result.text;
+      if (result.hasRefError) refErrors.push(cd.reference);
+    }
+  }
+  return refErrors;
+};
+shiftMerges_fn = function(shift) {
+  __privateSet(this, _mergeCells, __privateGet(this, _mergeCells).flatMap((m) => {
+    const ref = shiftRangeRef(m.ref, shift);
+    if (!ref) return [];
+    const [a, b] = ref.split(":");
+    if (!b || a === b) return [];
+    return [{ ref }];
+  }));
+};
+shiftAutoFilter_fn = function(shift) {
+  if (!__privateGet(this, _autoFilter)) return;
+  const ref = shiftRangeRef(__privateGet(this, _autoFilter).ref, shift);
+  __privateSet(this, _autoFilter, ref ? { ref } : void 0);
+};
+shiftValidations_fn = function(shift) {
+  __privateSet(this, _dataValidations, __privateGet(this, _dataValidations).flatMap((dv) => {
+    const sqref = shiftSqref(dv.sqref, shift);
+    if (!sqref) return [];
+    const formula = shiftFormulaRefs(dv.formula, shift, __privateGet(this, _name)).text;
+    return [{ sqref, formula }];
+  }));
+};
+shiftHyperlinks_fn = function(shift) {
+  const moved = /* @__PURE__ */ new Map();
+  for (const link of __privateGet(this, _hyperlinks).values()) {
+    const ref = shiftRangeRef(link.ref, shift);
+    if (!ref) continue;
+    moved.set(ref, { ...link, ref });
+  }
+  __privateSet(this, _hyperlinks, moved);
+};
+shiftComments_fn = function(shift) {
+  const moved = /* @__PURE__ */ new Map();
+  let changed = false;
+  for (const comment of __privateGet(this, _comments).values()) {
+    const ref = shiftRangeRef(comment.ref, shift);
+    if (!ref) {
+      changed = true;
+      continue;
+    }
+    if (ref !== comment.ref) changed = true;
+    moved.set(ref, { ...comment, ref });
+  }
+  __privateSet(this, _comments, moved);
+  if (changed) __privateSet(this, _commentsDirty, true);
+};
+shiftColDefs_fn = function(shift) {
+  __privateSet(this, _cols, __privateGet(this, _cols).flatMap((c) => {
+    const span = shiftSpan(c.min, c.max, shift);
+    return span ? [{ ...c, min: span.start, max: span.end }] : [];
+  }));
+};
+/** Highest numeric preserved relationship id, so generated ids clear them all. */
+relIdBase_fn = function() {
+  let max = 0;
+  for (const r of __privateGet(this, _preservedRels)) {
+    const n = RID_PATTERN.exec(r.id);
+    if (n) max = Math.max(max, parseInt(n[1], 10));
+  }
+  return max;
+};
 /**
  * Preserved leaf elements that will actually be emitted. A sheet may only have
  * one `<drawing>`, so live providers suppress a preserved one — every consumer
  * (serialisation, relationships, pruning) must agree on that, hence one helper.
  */
 activeTail_fn = function() {
-  return __privateGet(this, _preservedTail).filter((t) => !(t.tag === "drawing" && this.hasDrawings));
+  return __privateGet(this, _preservedTail).filter((t) => {
+    if (t.tag === "drawing") return !this.hasDrawings;
+    if (t.tag === "legacyDrawing") return !this.commentPartsReplaced;
+    return true;
+  });
+};
+/**
+ * The relationship-bearing leaf elements, in schema order: `drawing`,
+ * `legacyDrawing`, `legacyDrawingHF`, `picture`. A sheet may hold only one of
+ * each, so generated content replaces the preserved element of the same tag —
+ * live drawing providers replace a preserved `<drawing>`, and comments this
+ * sheet now owns replace a preserved `<legacyDrawing>`.
+ */
+buildTailXml_fn = function(rels) {
+  const preserved = __privateMethod(this, _Worksheet_instances, activeTail_fn).call(this);
+  const byTag = (tag) => preserved.filter((t) => t.tag === tag).map((t) => t.xml).join("");
+  const drawing = rels.drawing ? `<drawing r:id="${rels.drawing}"/>` : byTag("drawing");
+  const legacy = rels.vmlDrawing ? `<legacyDrawing r:id="${rels.vmlDrawing}"/>` : byTag("legacyDrawing");
+  return drawing + legacy + byTag("legacyDrawingHF") + byTag("picture");
+};
+buildSheetProtectionXml_fn = function() {
+  if (!__privateGet(this, _protection)) return "";
+  let attrs = ' sheet="1"';
+  for (const [key, attr] of PROTECTION_ATTRS) {
+    const blocked = !__privateGet(this, _protection)[key];
+    const defaultBlocked = !PROTECTION_DEFAULTS[key];
+    if (blocked !== defaultBlocked) attrs += ` ${attr}="${blocked ? 1 : 0}"`;
+  }
+  return `<sheetProtection${__privateGet(this, _protectionCredentials)}${attrs}/>`;
+};
+buildHyperlinksXml_fn = function(relIds) {
+  if (__privateGet(this, _hyperlinks).size === 0) return "";
+  const inner = [...__privateGet(this, _hyperlinks).values()].map((link) => {
+    const relId = relIds.get(link.ref);
+    const parts = [`ref="${link.ref}"`];
+    if (relId) parts.push(`r:id="${relId}"`);
+    if (link.location) parts.push(`location="${escXmlAttr(link.location)}"`);
+    if (link.display) parts.push(`display="${escXmlAttr(link.display)}"`);
+    if (link.tooltip) parts.push(`tooltip="${escXmlAttr(link.tooltip)}"`);
+    return `<hyperlink ${parts.join(" ")}/>`;
+  }).join("");
+  return `<hyperlinks>${inner}</hyperlinks>`;
+};
+/**
+ * Materialises the formula of every shared-formula instance cell.
+ *
+ * Excel writes a fill-down once: the group's master carries the text, the rest
+ * carry `<f t="shared" si="n"/>` and are understood to hold the master's
+ * formula with its relative references moved by the offset between the cells.
+ * Read literally — the way this used to be read — an instance cell has no
+ * formula at all, and the next save turns it into the constant that happened to
+ * be cached in `<v>`. On a real workbook that is tens of thousands of formulas
+ * quietly replaced by numbers.
+ *
+ * Each cell ends up owning its own text, so nothing downstream (evaluation,
+ * structural edits, serialisation) needs to know the group ever existed.
+ */
+resolveSharedFormulas_fn = function(masters, instances) {
+  if (instances.length === 0) return;
+  for (const cd of instances) {
+    const master = masters.get(cd.sharedIndex);
+    if (!master) continue;
+    const from = parseCellRef(master.ref);
+    const to = parseCellRef(cd.reference);
+    cd.formula = translateFormulaRefs(
+      master.formula,
+      to.row - from.row,
+      to.column - from.column
+    ).text;
+  }
 };
 // ── Private XML builders ───────────────────────────────────────────────────
 buildColsXml_fn = function() {
   if (__privateGet(this, _cols).length === 0) return "";
   const inner = __privateGet(this, _cols).map((c) => {
+    const width = c.width !== void 0 ? ` width="${c.width.toFixed(2)}" customWidth="${c.customWidth ? 1 : 0}"` : "";
     const hidden = c.hidden ? ' hidden="1"' : "";
-    return `<col min="${c.min}" max="${c.max}" width="${c.width.toFixed(2)}" customWidth="${c.customWidth ? 1 : 0}"${hidden}/>`;
+    return `<col min="${c.min}" max="${c.max}"${width}${hidden}/>`;
   }).join("");
   return `<cols>${inner}</cols>`;
 };
@@ -2706,12 +4675,8 @@ buildSheetDataXml_fn = function() {
   const rowsXml = sortedRows.map((row) => {
     const ht = row.height !== void 0 && row.customHeight ? ` ht="${row.height}" customHeight="1"` : "";
     const hidden = row.hidden ? ' hidden="1"' : "";
-    const sortedCells = [...row.cells.values()].sort((a, b) => {
-      const ra = parseCellRef(a.reference);
-      const rb = parseCellRef(b.reference);
-      return ra.column - rb.column;
-    });
-    const cellsXml = sortedCells.map((cd) => new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)).toXml()).filter(Boolean).join("");
+    const sortedCells = [...row.cells.values()].map((cd) => ({ cd, col: columnFromRef(cd.reference, refSplit(cd.reference)) })).sort((a, b) => a.col - b.col);
+    const cellsXml = sortedCells.map(({ cd }) => buildCellXml(cd)).filter(Boolean).join("");
     if (!cellsXml && !ht && !hidden) return "";
     return `<row r="${row.rowIndex}"${ht}${hidden}>${cellsXml}</row>`;
   }).filter(Boolean).join("");
@@ -2740,6 +4705,61 @@ buildSheetViewXml_fn = function() {
   const ySplit = row > 0 ? ` ySplit="${row}"` : "";
   return `<sheetView workbookViewId="0"><pane${xSplit}${ySplit} topLeftCell="${topLeft}" activePane="${activePane}" state="frozen"/></sheetView>`;
 };
+/**
+ * Returns the single-column ColDef covering `columnIndex`, splitting a wider
+ * span into up to three pieces so the other columns keep their width/hidden
+ * state. Returns undefined when no definition covers the column.
+ */
+splitColSpan_fn = function(columnIndex) {
+  const idx = __privateMethod(this, _Worksheet_instances, findColDefIndex_fn).call(this, columnIndex);
+  if (idx === -1) return void 0;
+  const span = __privateGet(this, _cols)[idx];
+  if (span.min === span.max) return span;
+  const pieces = [];
+  if (span.min < columnIndex) pieces.push({ ...span, max: columnIndex - 1 });
+  const target = { ...span, min: columnIndex, max: columnIndex };
+  pieces.push(target);
+  if (span.max > columnIndex) pieces.push({ ...span, min: columnIndex + 1 });
+  __privateGet(this, _cols).splice(idx, 1, ...pieces);
+  return target;
+};
+/**
+ * Inserts a definition keeping `#cols` sorted by `min`. Binary insertion,
+ * because re-sorting the whole array per call makes setting widths for every
+ * column of a wide sheet quadratic.
+ */
+insertColDef_fn = function(def) {
+  let lo = 0;
+  let hi = __privateGet(this, _cols).length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (__privateGet(this, _cols)[mid].min < def.min) lo = mid + 1;
+    else hi = mid;
+  }
+  __privateGet(this, _cols).splice(lo, 0, def);
+  return def;
+};
+/** Index of the definition covering `columnIndex`, or -1. Binary search. */
+findColDefIndex_fn = function(columnIndex) {
+  let lo = 0;
+  let hi = __privateGet(this, _cols).length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const c = __privateGet(this, _cols)[mid];
+    if (columnIndex < c.min) hi = mid - 1;
+    else if (columnIndex > c.max) lo = mid + 1;
+    else return mid;
+  }
+  return -1;
+};
+findColDef_fn = function(columnIndex) {
+  const idx = __privateMethod(this, _Worksheet_instances, findColDefIndex_fn).call(this, columnIndex);
+  return idx === -1 ? void 0 : __privateGet(this, _cols)[idx];
+};
+/** Drops definitions that no longer carry any information. */
+pruneColDefs_fn = function() {
+  __privateSet(this, _cols, __privateGet(this, _cols).filter((c) => c.width !== void 0 || c.customWidth || c.hidden));
+};
 getOrCreateRow_fn = function(rowIndex) {
   let row = __privateGet(this, _rows).get(rowIndex);
   if (!row) {
@@ -2748,9 +4768,64 @@ getOrCreateRow_fn = function(rowIndex) {
   }
   return row;
 };
+var RID_PATTERN = /^rId(\d+)$/;
 function escXml2(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
+function escXmlAttr(s) {
+  return escXml2(s).replace(/"/g, "&quot;");
+}
+function normalizeRef(ref) {
+  const normalized = normalizeRefFast(ref);
+  parseCellRef(normalized);
+  return normalized;
+}
+function normalizeRangeRef(ref) {
+  const normalized = normalizeRefFast(ref);
+  const colon = normalized.indexOf(":");
+  if (colon === -1) {
+    parseCellRef(normalized);
+    return normalized;
+  }
+  parseCellRef(normalized.slice(0, colon));
+  parseCellRef(normalized.slice(colon + 1));
+  return normalized;
+}
+function normalizeRefFast(ref) {
+  return ref.indexOf("$") === -1 ? upperFast(ref) : ref.replace(/\$/g, "").toUpperCase();
+}
+function upperFast(s) {
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code >= 97 && code <= 122) return s.toUpperCase();
+  }
+  return s;
+}
+function refSplit(ref) {
+  let i = 0;
+  while (i < ref.length) {
+    const code = ref.charCodeAt(i);
+    if (code < 65 || code > 90) break;
+    i++;
+  }
+  return i;
+}
+function columnFromRef(ref, split) {
+  let col = 0;
+  for (let i = 0; i < split; i++) col = col * 26 + (ref.charCodeAt(i) - 64);
+  return col;
+}
+function translateRangeRef(ref, deltaRow, deltaCol) {
+  const parts = ref.split(":").map((p) => {
+    const { row, column } = parseCellRef(p);
+    const r = row + deltaRow;
+    const c = column + deltaCol;
+    if (r < 1 || c < 1 || r > EXCEL_MAX_ROWS || c > EXCEL_MAX_COLUMNS) return null;
+    return cellRefFromRowCol(r, c);
+  });
+  if (parts.some((p) => p === null)) return void 0;
+  return parts.join(":");
+}
 
 // src/model/defined-name.ts
 var _names, _DefinedNameManager_instances, indexOf_fn;
@@ -2815,7 +4890,7 @@ indexOf_fn = function(name, scope) {
 };
 
 // src/model/workbook.ts
-var _sharedStrings3, _styles3, _sheets, _definedNames, _closed, _preservedParts, _preservedContentTypes, _orphanedTargets, _Workbook_instances, assertOpen_fn, seedPreservedParts_fn, preservedContentTypeDeclarations_fn, buildZipEntries_fn;
+var _sharedStrings3, _styles3, _sheets, _definedNames, _closed, _calcChain, _calcChainFingerprint, _deflateCache, _preservedParts, _preservedContentTypes, _orphanedTargets, _Workbook_instances, structuralEdit_fn, sheetFingerprint_fn, calcChainStillValid_fn, assertOpen_fn, seedPreservedParts_fn, preservedContentTypeDeclarations_fn, buildZipEntries_fn;
 var _Workbook = class _Workbook {
   constructor(sharedStrings, styles) {
     __privateAdd(this, _Workbook_instances);
@@ -2824,6 +4899,24 @@ var _Workbook = class _Workbook {
     __privateAdd(this, _sheets, []);
     __privateAdd(this, _definedNames, new DefinedNameManager());
     __privateAdd(this, _closed, false);
+    /**
+     * The calculation order Excel stored in `xl/calcChain.xml`, in file order, or
+     * undefined when the source had no such part. Read-only to consumers: it is a
+     * record of what the source file said, not a live view of the model.
+     */
+    __privateAdd(this, _calcChain);
+    /**
+     * Fingerprint of the sheet set taken right after the calc chain was parsed.
+     * The chain is only written back out when this still matches — see
+     * {@link #calcChainStillValid}.
+     */
+    __privateAdd(this, _calcChainFingerprint);
+    /**
+     * Compressed form of each package part from the last save. Compression is where
+     * a save spends its time, and an autosave changes one part, so the rest are
+     * reused verbatim. Keyed on content, so a part rebuilt identically still hits.
+     */
+    __privateAdd(this, _deflateCache, createDeflateCache());
     /** Parts carried over verbatim from the file this workbook was opened from. */
     __privateAdd(this, _preservedParts, /* @__PURE__ */ new Map());
     __privateAdd(this, _preservedContentTypes);
@@ -2848,6 +4941,7 @@ var _Workbook = class _Workbook {
    * Mirrors Workbook.Open(stream) in C#.
    */
   static fromBuffer(buffer) {
+    var _a;
     const entries = unzipXlsx(buffer);
     const ss = new SharedStringManager();
     const sm = new StyleManager();
@@ -2875,10 +4969,20 @@ var _Workbook = class _Workbook {
         const wsRelsXml = readXmlEntry(entries, `${dir}/_rels/${file}.rels`);
         if (wsRelsXml) {
           ws.loadPreservedState(wsXml, parseRelationships(wsRelsXml, wsPath));
+          const commentsPath = ws.commentsPartPath();
+          if (commentsPath) {
+            const commentsXml = readXmlEntry(entries, commentsPath);
+            if (commentsXml) ws.loadCommentsXml(commentsXml);
+          }
         }
       }
       __privateGet(wb, _sheets).push({ worksheet: ws, sheetId, relId });
     }
+    const calcChainXml = readXmlEntry(entries, CALC_CHAIN_PATH);
+    if (calcChainXml) {
+      __privateSet(wb, _calcChain, parseCalcChain(calcChainXml, __privateGet(wb, _sheets)));
+      __privateSet(wb, _calcChainFingerprint, __privateMethod(_a = wb, _Workbook_instances, sheetFingerprint_fn).call(_a));
+    }
     __privateSet(wb, _preservedParts, collectPreservedParts(entries));
     const ctXml = readXmlEntry(entries, "[Content_Types].xml");
     if (ctXml) __privateSet(wb, _preservedContentTypes, parseContentTypes(ctXml));
@@ -2925,8 +5029,8 @@ var _Workbook = class _Workbook {
     if (__privateGet(this, _sheets).some((e) => e.worksheet.name === name)) {
       throw new Error(`Worksheet "${name}" already exists.`);
     }
-    const sheetId = __privateGet(this, _sheets).length + 1;
-    const relId = `rId${sheetId}`;
+    const sheetId = __privateGet(this, _sheets).reduce((max, e) => Math.max(max, e.sheetId), 0) + 1;
+    const relId = `rId${__privateGet(this, _sheets).length + 1}`;
     const ws = new Worksheet(name, __privateGet(this, _sharedStrings3), __privateGet(this, _styles3));
     __privateGet(this, _sheets).push({ worksheet: ws, sheetId, relId });
     return ws;
@@ -2963,6 +5067,32 @@ var _Workbook = class _Workbook {
     if (!entry) throw new Error(`Worksheet "${name}" not found.`);
     return entry.worksheet;
   }
+  // ── Structural editing (workbook-wide) ───────────────────────────────────────
+  /**
+   * Inserts rows on one sheet and keeps the whole workbook consistent:
+   * formulas on OTHER sheets that reference the edited sheet, and defined
+   * names, are rewritten too. Prefer this over `Worksheet.insertRows` in a
+   * multi-sheet workbook.
+   *
+   * @returns The edited sheet's result; `refErrors` additionally includes
+   *          sheet-qualified refs (e.g. `"Other!B2"`) for affected formula
+   *          cells on other sheets.
+   */
+  insertRows(sheetName, at, count = 1) {
+    return __privateMethod(this, _Workbook_instances, structuralEdit_fn).call(this, sheetName, "row", "insert", at, count);
+  }
+  /** Workbook-wide counterpart to `Worksheet.deleteRows`. See {@link insertRows}. */
+  deleteRows(sheetName, at, count = 1) {
+    return __privateMethod(this, _Workbook_instances, structuralEdit_fn).call(this, sheetName, "row", "delete", at, count);
+  }
+  /** Workbook-wide counterpart to `Worksheet.insertColumns`. See {@link insertRows}. */
+  insertColumns(sheetName, at, count = 1) {
+    return __privateMethod(this, _Workbook_instances, structuralEdit_fn).call(this, sheetName, "col", "insert", at, count);
+  }
+  /** Workbook-wide counterpart to `Worksheet.deleteColumns`. See {@link insertRows}. */
+  deleteColumns(sheetName, at, count = 1) {
+    return __privateMethod(this, _Workbook_instances, structuralEdit_fn).call(this, sheetName, "col", "delete", at, count);
+  }
   // ── Defined names (named ranges) ─────────────────────────────────────────────
   /**
    * Defines (or replaces) a named range.
@@ -3009,7 +5139,21 @@ var _Workbook = class _Workbook {
   saveAsBuffer() {
     __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
     const entries = __privateMethod(this, _Workbook_instances, buildZipEntries_fn).call(this);
-    return zipXlsx(entries);
+    return zipXlsxCached(entries, __privateGet(this, _deflateCache));
+  }
+  /**
+   * Same output as {@link saveAsBuffer}, without blocking the calling thread on
+   * compression — for an editor that autosaves, this is the difference between a
+   * visible stall on every save and none.
+   *
+   * The XML for sheets that have not changed since the last save is reused, so a
+   * save after a one-cell edit re-serialises one sheet rather than all of them.
+   * That reuse applies to the synchronous path too; only the compression differs.
+   */
+  async saveAsBufferAsync() {
+    __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
+    const entries = __privateMethod(this, _Workbook_instances, buildZipEntries_fn).call(this);
+    return zipXlsxCachedAsync(entries, __privateGet(this, _deflateCache));
   }
   /**
    * Saves the workbook to a file (Node.js only).
@@ -3017,7 +5161,7 @@ var _Workbook = class _Workbook {
    */
   async saveToFile(filePath) {
     __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
-    const buffer = this.saveAsBuffer();
+    const buffer = await this.saveAsBufferAsync();
     const fs = await import('fs/promises');
     const path = await import('path');
     const dir = path.dirname(filePath);
@@ -3033,16 +5177,72 @@ var _Workbook = class _Workbook {
   [Symbol.dispose]() {
     this.close();
   }
+  // ── Calculation order ──────────────────────────────────────────────────────
+  /**
+   * The calculation order Excel recorded for this workbook, oldest-first as
+   * stored in `xl/calcChain.xml`, or an empty array when the source file had
+   * none (a freshly created workbook, or one saved by a tool that omits it).
+   *
+   * Excel has already done the topological sort that produced this order, so
+   * evaluating in it avoids repeating that work. Treat it as a hint, not a
+   * guarantee: it reflects the file as opened, and edits made since are not
+   * reflected here.
+   */
+  get calcChain() {
+    return __privateGet(this, _calcChain) ?? EMPTY_CALC_CHAIN;
+  }
 };
 _sharedStrings3 = new WeakMap();
 _styles3 = new WeakMap();
 _sheets = new WeakMap();
 _definedNames = new WeakMap();
 _closed = new WeakMap();
+_calcChain = new WeakMap();
+_calcChainFingerprint = new WeakMap();
+_deflateCache = new WeakMap();
 _preservedParts = new WeakMap();
 _preservedContentTypes = new WeakMap();
 _orphanedTargets = new WeakMap();
 _Workbook_instances = new WeakSet();
+structuralEdit_fn = function(sheetName, dim, kind, at, count) {
+  __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
+  const target = this.getWorksheet(sheetName);
+  const result = dim === "row" ? kind === "insert" ? target.insertRows(at, count) : target.deleteRows(at, count) : kind === "insert" ? target.insertColumns(at, count) : target.deleteColumns(at, count);
+  const shift = { dim, kind, at, count, sheetName: target.name };
+  const refErrors = [...result.refErrors];
+  for (const ws of this.worksheets) {
+    if (ws === target) continue;
+    const external = ws.applyExternalShift(shift);
+    for (const ref of external.refErrors) refErrors.push(`${ws.name}!${ref}`);
+  }
+  for (const dn of [...__privateGet(this, _definedNames).all]) {
+    const rewritten = shiftFormulaRefs(dn.refersTo, shift, dn.scope ?? "");
+    if (rewritten.changed) __privateGet(this, _definedNames).define(dn.name, rewritten.text, dn.scope);
+  }
+  return { refErrors };
+};
+/**
+ * Identity of the sheet set: names, durable ids and per-sheet mutation counts.
+ * The calc chain is a statement about exactly this set — which cells hold
+ * formulas, on which sheet, under which id — so any change to it invalidates
+ * the chain wholesale.
+ */
+sheetFingerprint_fn = function() {
+  return __privateGet(this, _sheets).map((e) => `${e.sheetId}:${e.worksheet.name}:${e.worksheet.version}`).join("|");
+};
+/**
+ * Whether the parsed calc chain may be written back out.
+ *
+ * Deliberately conservative: any edit at all (a value, a formula, a sheet
+ * added or removed) and the chain is dropped instead of patched. An absent
+ * calcChain is a documented no-op — Excel rebuilds it on open — whereas a
+ * chain that disagrees with the sheets is the failure mode this whole change
+ * exists to remove. Rebuilding a correct chain would mean redoing Excel's
+ * dependency analysis, which belongs in the formula package, not here.
+ */
+calcChainStillValid_fn = function() {
+  return __privateGet(this, _calcChain) !== void 0 && __privateGet(this, _calcChain).length > 0 && __privateGet(this, _calcChainFingerprint) === __privateMethod(this, _Workbook_instances, sheetFingerprint_fn).call(this);
+};
 // ── Private helpers ────────────────────────────────────────────────────────
 assertOpen_fn = function() {
   if (__privateGet(this, _closed)) throw new Error("Workbook has been closed.");
@@ -3103,7 +5303,7 @@ buildZipEntries_fn = function() {
   entries.set("_rels/.rels", ROOT_RELS);
   const sheetMetas = __privateGet(this, _sheets).map((e, i) => ({
     name: e.worksheet.name,
-    sheetId: i + 1,
+    sheetId: e.sheetId,
     relationshipId: `rId${i + 1}`,
     state: e.worksheet.visibility !== "visible" ? e.worksheet.visibility : void 0
   }));
@@ -3116,20 +5316,58 @@ buildZipEntries_fn = function() {
     return { name: dn.name, refersTo: dn.refersTo, localSheetId };
   });
   entries.set("xl/workbook.xml", buildWorkbookXml(sheetMetas, definedNameMetas));
-  entries.set("xl/_rels/workbook.xml.rels", buildWorkbookRels(sheetCount));
+  const keepCalcChain = __privateMethod(this, _Workbook_instances, calcChainStillValid_fn).call(this);
+  if (keepCalcChain) {
+    const idBySheet = new Map(__privateGet(this, _sheets).map((e) => [e.worksheet.name, e.sheetId]));
+    entries.set(CALC_CHAIN_PATH, buildCalcChainXml(__privateGet(this, _calcChain), idBySheet));
+  } else {
+    entries.delete(CALC_CHAIN_PATH);
+    preservedPaths.delete(CALC_CHAIN_PATH);
+  }
+  entries.set("xl/_rels/workbook.xml.rels", buildWorkbookRels(sheetCount, keepCalcChain));
   entries.set("xl/styles.xml", __privateGet(this, _styles3).buildStylesXml());
   entries.set("xl/sharedStrings.xml", __privateGet(this, _sharedStrings3).buildXml());
   for (let i = 0; i < __privateGet(this, _sheets).length; i++) {
     entries.set(`xl/worksheets/sheet${i + 1}.xml`, __privateGet(this, _sheets)[i].worksheet.buildXml());
   }
   const extraOverrides = [];
+  const extraDefaults = [];
+  if (keepCalcChain) {
+    extraOverrides.push({ partName: `/${CALC_CHAIN_PATH}`, contentType: CONTENT_TYPES.calcChain });
+  }
   let drawingCounter = 0;
   let partCounter = 0;
+  let commentsCounter = 0;
   for (let i = 0; i < __privateGet(this, _sheets).length; i++) {
     const ws = __privateGet(this, _sheets)[i].worksheet;
     const sheetRels = ws.preservedRelationships.map(
-      (r) => `  <Relationship Id="${r.id}" Type="${r.type}" Target="${r.target}"${r.external ? ' TargetMode="External"' : ""}/>`
+      (r) => `  <Relationship Id="${r.id}" Type="${r.type}" Target="${escapeXml(r.target)}"${r.external ? ' TargetMode="External"' : ""}/>`
     );
+    const generated = ws.generatedRels();
+    for (const link of ws.hyperlinks) {
+      const relId = generated.hyperlinks.get(link.ref);
+      if (!relId || !link.target) continue;
+      sheetRels.push(
+        `  <Relationship Id="${relId}" Type="${REL_TYPES.hyperlink}" Target="${escapeXml(link.target)}" TargetMode="External"/>`
+      );
+    }
+    if (generated.comments && generated.vmlDrawing) {
+      do {
+        commentsCounter++;
+      } while (preservedPaths.has(`xl/comments${commentsCounter}.xml`) || preservedPaths.has(`xl/drawings/vmlDrawing${commentsCounter}.vml`));
+      const commentsPath = `xl/comments${commentsCounter}.xml`;
+      const vmlPath = `xl/drawings/vmlDrawing${commentsCounter}.vml`;
+      entries.set(commentsPath, ws.buildCommentsXml());
+      entries.set(vmlPath, ws.buildCommentsVml());
+      extraOverrides.push({ partName: `/${commentsPath}`, contentType: CONTENT_TYPES.comments });
+      if (!extraDefaults.some((d) => d.extension === "vml")) {
+        extraDefaults.push({ extension: "vml", contentType: CONTENT_TYPES.vmlDrawing });
+      }
+      sheetRels.push(
+        `  <Relationship Id="${generated.comments}" Type="${REL_TYPES.comments}" Target="../comments${commentsCounter}.xml"/>`,
+        `  <Relationship Id="${generated.vmlDrawing}" Type="${REL_TYPES.vmlDrawing}" Target="../drawings/vmlDrawing${commentsCounter}.vml"/>`
+      );
+    }
     if (ws.hasDrawings) {
       do {
         drawingCounter++;
@@ -3166,12 +5404,48 @@ buildZipEntries_fn = function() {
     buildContentTypes(
       sheetCount,
       [...preservedCt.overrides, ...extraOverrides],
-      preservedCt.defaults
+      [...preservedCt.defaults, ...extraDefaults]
     )
   );
   return entries;
 };
 var Workbook = _Workbook;
+var CALC_CHAIN_PATH = "xl/calcChain.xml";
+var EMPTY_CALC_CHAIN = [];
+function parseCalcChain(xml2, sheets) {
+  const nameById = new Map(sheets.map((e) => [e.sheetId, e.worksheet.name]));
+  const out = [];
+  let currentId;
+  try {
+    const root = parseXml(xml2);
+    for (const el of getElementsByTagName(root, "c")) {
+      const ref = getAttr(el, "r");
+      if (!ref) continue;
+      const iAttr = getAttr(el, "i");
+      if (iAttr !== void 0) {
+        const parsed = parseInt(iAttr, 10);
+        if (!Number.isNaN(parsed)) currentId = parsed;
+      }
+      if (currentId === void 0) continue;
+      const sheet = nameById.get(currentId);
+      if (sheet === void 0) continue;
+      out.push({ sheet, ref: ref.toUpperCase() });
+    }
+  } catch {
+    return [];
+  }
+  return out;
+}
+function buildCalcChainXml(chain, idBySheet) {
+  const cells = [];
+  for (const { sheet, ref } of chain) {
+    const id = idBySheet.get(sheet);
+    if (id === void 0) continue;
+    cells.push(`<c r="${ref}" i="${id}"/>`);
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<calcChain xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">${cells.join("")}</calcChain>`;
+}
 function resolveWorksheetPath(relsXml, relId) {
   if (!relsXml) return void 0;
   try {
@@ -3191,6 +5465,8 @@ exports.CONTENT_TYPES = CONTENT_TYPES;
 exports.Cell = Cell;
 exports.CellStyle = CellStyle;
 exports.DefinedNameManager = DefinedNameManager;
+exports.EXCEL_MAX_COLUMNS = EXCEL_MAX_COLUMNS;
+exports.EXCEL_MAX_ROWS = EXCEL_MAX_ROWS;
 exports.ExcelAlignment = ExcelAlignment;
 exports.ExcelBorder = ExcelBorder;
 exports.ExcelBorderEdge = ExcelBorderEdge;
@@ -3219,9 +5495,12 @@ exports.cellRefFromRowCol = cellRefFromRowCol;
 exports.columnLetter = columnLetter;
 exports.columnNumber = columnNumber;
 exports.decodeUtf8 = decodeUtf8;
+exports.decodeXmlEntities = decodeXmlEntities;
 exports.encodeUtf8 = encodeUtf8;
 exports.escapeXml = escapeXml;
+exports.formatDateCode = formatDateCode;
 exports.formatNumberWithCode = formatNumberWithCode;
+exports.formatRangeRef = formatRangeRef;
 exports.fromOADate = fromOADate;
 exports.getAttr = getAttr;
 exports.getElementsByTagName = getElementsByTagName;
@@ -3235,6 +5514,11 @@ exports.readXmlEntry = readXmlEntry;
 exports.requireXmlEntry = requireXmlEntry;
 exports.setBinaryEntry = setBinaryEntry;
 exports.setXmlEntry = setXmlEntry;
+exports.shiftFormulaRefs = shiftFormulaRefs;
+exports.shiftIndex = shiftIndex;
+exports.shiftRangeRef = shiftRangeRef;
+exports.shiftSpan = shiftSpan;
+exports.shiftSqref = shiftSqref;
 exports.toOADate = toOADate;
 exports.unzipXlsx = unzipXlsx;
 exports.xml = xml;