@devmm/puredocs-excel 1.0.5 → 1.0.6

package/dist/index.js

@@ -48,10 +48,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;
   }
@@ -105,7 +105,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;
       }
@@ -114,6 +114,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);
@@ -294,7 +298,9 @@ 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"
 };
 var CONTENT_TYPES = {
   workbook: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",
@@ -304,7 +310,9 @@ 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"
 };
 
 // src/io/ooxml-templates.ts
@@ -449,8 +457,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,
@@ -1669,10 +1678,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) {
@@ -1766,12 +1780,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) {
@@ -1817,6 +1996,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) {
@@ -1977,18 +2161,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 ────────────────────────────────────────────────────────────
   /**
@@ -2173,8 +2359,269 @@ function escXml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
+// 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
+    };
+  }
+  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++;
+    }
+    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;
+      }
+    }
+    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/range.ts
-var _sheet, _startRow, _startColumn, _endRow, _endColumn, _address, _Range_instances, forEach_fn;
+var _sheet, _startRow, _startColumn, _endRow, _endColumn, _address, _Range_instances, forEach_fn, forEachExisting_fn;
 var Range = class {
   constructor(sheet, rangeReference) {
     __privateAdd(this, _Range_instances);
@@ -2223,26 +2670,63 @@ var Range = class {
    * 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 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();
       }
-      result.push(row);
-    }
+    );
     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. */
@@ -2316,9 +2800,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, _Worksheet_instances, 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, 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) {
@@ -2334,6 +2866,26 @@ 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
@@ -2353,8 +2905,15 @@ 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) {
@@ -2364,10 +2923,17 @@ var Worksheet = class {
     return new Cell(cellData, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2));
   }
   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));
@@ -2392,10 +2958,83 @@ var Worksheet = class {
   getSpillRange(reference) {
     return this.tryGetCell(reference)?.getArrayRef() ?? 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)));
+      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)), 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) {
+    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;
@@ -2404,7 +3043,7 @@ var Worksheet = class {
       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;
+        const col = columnFromRef(ref, refSplit(ref));
         if (col > columnCount) columnCount = col;
       }
     }
@@ -2415,9 +3054,41 @@ var Worksheet = class {
   setColumnWidth(columnIndex, width) {
     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) {
+    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) {
+    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
@@ -2427,22 +3098,28 @@ 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;
-      }
+    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) {
+    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) {
@@ -2460,6 +3137,19 @@ 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) {
+    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) {
     if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
@@ -2469,6 +3159,137 @@ 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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
     if (!rangeReference) throw new Error("Range reference cannot be empty.");
@@ -2515,6 +3336,119 @@ var Worksheet = class {
   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) {
+    __privateSet(this, _protection, { ...PROTECTION_DEFAULTS, ...options });
+  }
+  /** Turns off sheet protection, discarding any password read from a file. */
+  unprotect() {
+    __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).");
+    }
+    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) {
+    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) {
+    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) {
+    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.
@@ -2552,7 +3486,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
@@ -2569,35 +3508,86 @@ 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));
+    __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 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}"/>` : "";
+    const linksXml = __privateMethod(this, _Worksheet_instances, buildHyperlinksXml_fn).call(this, rels.hyperlinks);
+    const tailXml = __privateMethod(this, _Worksheet_instances, buildTailXml_fn).call(this, rels);
     return `<?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>`;
   }
   /** Parses xl/worksheets/sheetN.xml and loads cells into memory. */
@@ -2608,12 +3598,17 @@ ${colsXml}${sheetDataXml}${filterXml}${mergeXml}${validXml}${preservedTailXml}${
     __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"
       });
@@ -2665,6 +3660,75 @@ ${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) {
+    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();
@@ -2678,23 +3742,263 @@ _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();
 _Worksheet_instances = new WeakSet();
+/** 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) : this.usedBounds.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>`;
 };
 // ── 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>`;
 };
@@ -2704,12 +4008,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 }) => new Cell(cd, __privateGet(this, _sharedStrings2), __privateGet(this, _styles2)).toXml()).filter(Boolean).join("");
     if (!cellsXml && !ht && !hidden) return "";
     return `<row r="${row.rowIndex}"${ht}${hidden}>${cellsXml}</row>`;
   }).filter(Boolean).join("");
@@ -2738,6 +4038,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) {
@@ -2746,9 +4101,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;
@@ -2813,7 +4223,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, _preservedParts, _preservedContentTypes, _orphanedTargets, _Workbook_instances, structuralEdit_fn, assertOpen_fn, seedPreservedParts_fn, preservedContentTypeDeclarations_fn, buildZipEntries_fn;
 var _Workbook = class _Workbook {
   constructor(sharedStrings, styles) {
     __privateAdd(this, _Workbook_instances);
@@ -2873,6 +4283,11 @@ 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 });
@@ -2961,6 +4376,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.
@@ -3041,6 +4482,23 @@ _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 };
+};
 // ── Private helpers ────────────────────────────────────────────────────────
 assertOpen_fn = function() {
   if (__privateGet(this, _closed)) throw new Error("Workbook has been closed.");
@@ -3121,13 +4579,40 @@ buildZipEntries_fn = function() {
     entries.set(`xl/worksheets/sheet${i + 1}.xml`, __privateGet(this, _sheets)[i].worksheet.buildXml());
   }
   const extraOverrides = [];
+  const extraDefaults = [];
   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++;
@@ -3164,7 +4649,7 @@ buildZipEntries_fn = function() {
     buildContentTypes(
       sheetCount,
       [...preservedCt.overrides, ...extraOverrides],
-      preservedCt.defaults
+      [...preservedCt.defaults, ...extraDefaults]
     )
   );
   return entries;
@@ -3185,6 +4670,6 @@ function resolveWorksheetPath(relsXml, relId) {
   return void 0;
 }
 
-export { CONTENT_TYPES, Cell, CellStyle, DefinedNameManager, ExcelAlignment, ExcelBorder, ExcelBorderEdge, ExcelBorderStyle, ExcelColor, ExcelFill, ExcelFont, ExcelHorizontalAlignment, ExcelNumberFormat, ExcelPatternType, ExcelReadingOrder, ExcelUnderline, ExcelVerticalAlignRun, ExcelVerticalAlignment, NS, REL_TYPES, Range, StyleManager, WORKSHEET_DRAWING_REL_ID, Workbook, Worksheet, XmlBuilder, buildDrawingXml, buildRelsXml, cellRefFromRowCol, columnLetter, columnNumber, decodeUtf8, encodeUtf8, escapeXml, formatNumberWithCode, fromOADate, getAttr, getElementsByTagName, isDateFormatCode, isDateFormatId, listEntries, parseCellRef, parseRangeRef, parseXml, readXmlEntry, requireXmlEntry, setBinaryEntry, setXmlEntry, toOADate, unzipXlsx, xml, zipXlsx };
+export { CONTENT_TYPES, Cell, CellStyle, DefinedNameManager, EXCEL_MAX_COLUMNS, EXCEL_MAX_ROWS, ExcelAlignment, ExcelBorder, ExcelBorderEdge, ExcelBorderStyle, ExcelColor, ExcelFill, ExcelFont, ExcelHorizontalAlignment, ExcelNumberFormat, ExcelPatternType, ExcelReadingOrder, ExcelUnderline, ExcelVerticalAlignRun, ExcelVerticalAlignment, NS, REL_TYPES, Range, StyleManager, WORKSHEET_DRAWING_REL_ID, Workbook, Worksheet, XmlBuilder, buildDrawingXml, buildRelsXml, cellRefFromRowCol, columnLetter, columnNumber, decodeUtf8, decodeXmlEntities, encodeUtf8, escapeXml, formatDateCode, formatNumberWithCode, formatRangeRef, fromOADate, getAttr, getElementsByTagName, isDateFormatCode, isDateFormatId, listEntries, parseCellRef, parseRangeRef, parseXml, readXmlEntry, requireXmlEntry, setBinaryEntry, setXmlEntry, shiftFormulaRefs, shiftIndex, shiftRangeRef, shiftSpan, shiftSqref, toOADate, unzipXlsx, xml, zipXlsx };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map