@devmm/puredocs-excel 1.0.4 → 1.0.5

package/dist/index.cjs

@@ -310,19 +310,26 @@ var CONTENT_TYPES = {
 };
 
 // src/io/ooxml-templates.ts
-function buildContentTypes(sheetCount, extraOverrides = []) {
+function buildContentTypes(sheetCount, extraOverrides = [], extraDefaults = []) {
   const overrides = Array.from(
     { length: sheetCount },
     (_, i) => `  <Override PartName="/xl/worksheets/sheet${i + 1}.xml" ContentType="${CONTENT_TYPES.worksheet}"/>`
   );
-  for (const { partName, contentType } of extraOverrides) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const { partName, contentType } of [...extraOverrides].reverse()) {
+    if (seen.has(partName)) continue;
+    seen.add(partName);
     overrides.push(`  <Override PartName="${partName}" ContentType="${contentType}"/>`);
   }
+  const defaults = extraDefaults.map(
+    ({ extension, contentType }) => `  <Default Extension="${extension}" ContentType="${contentType}"/>`
+  );
   return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Types xmlns="${"http://schemas.openxmlformats.org/package/2006/content-types"}">
   <Default Extension="rels" ContentType="${CONTENT_TYPES.relationships}"/>
   <Default Extension="xml" ContentType="application/xml"/>
-  <Override PartName="/xl/workbook.xml" ContentType="${CONTENT_TYPES.workbook}"/>
+${defaults.length > 0 ? `${defaults.join("\n")}
+` : ""}  <Override PartName="/xl/workbook.xml" ContentType="${CONTENT_TYPES.workbook}"/>
   <Override PartName="/xl/styles.xml" ContentType="${CONTENT_TYPES.styles}"/>
   <Override PartName="/xl/sharedStrings.xml" ContentType="${CONTENT_TYPES.sharedStrings}"/>
 ${overrides.join("\n")}
@@ -401,6 +408,94 @@ ${relationships.join("\n")}
 </Relationships>`;
 }
 
+// src/io/preserved-parts.ts
+function isCoreOwned(path) {
+  return path === "[Content_Types].xml" || path === "_rels/.rels" || path === "xl/workbook.xml" || path === "xl/_rels/workbook.xml.rels" || path === "xl/styles.xml" || path === "xl/sharedStrings.xml" || path.startsWith("xl/worksheets/");
+}
+function collectPreservedParts(entries) {
+  const preserved = /* @__PURE__ */ new Map();
+  for (const [path, bytes] of entries) {
+    if (!isCoreOwned(path)) preserved.set(path, bytes);
+  }
+  return preserved;
+}
+function parseContentTypes(xml2) {
+  const defaults = /* @__PURE__ */ new Map();
+  const overrides = /* @__PURE__ */ new Map();
+  for (const m of xml2.matchAll(/<Default\s+[^>]*\/?>/g)) {
+    const ext = /Extension="([^"]*)"/.exec(m[0])?.[1];
+    const ct = /ContentType="([^"]*)"/.exec(m[0])?.[1];
+    if (ext && ct) defaults.set(ext.toLowerCase(), ct);
+  }
+  for (const m of xml2.matchAll(/<Override\s+[^>]*\/?>/g)) {
+    const part = /PartName="([^"]*)"/.exec(m[0])?.[1];
+    const ct = /ContentType="([^"]*)"/.exec(m[0])?.[1];
+    if (part && ct) overrides.set(part, ct);
+  }
+  return { defaults, overrides };
+}
+function resolveTarget(target, baseDir) {
+  if (target.startsWith("/")) return target.slice(1);
+  const segments = baseDir.split("/").filter(Boolean);
+  for (const seg of target.split("/")) {
+    if (seg === "." || seg === "") continue;
+    if (seg === "..") segments.pop();
+    else segments.push(seg);
+  }
+  return segments.join("/");
+}
+function parseRelationships(relsXml, ownerPath) {
+  const baseDir = ownerPath.slice(0, ownerPath.lastIndexOf("/"));
+  const rels = [];
+  for (const m of relsXml.matchAll(/<Relationship\s+[^>]*\/?>/g)) {
+    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 external = /TargetMode="External"/.test(tag);
+    rels.push({
+      id,
+      type,
+      target,
+      resolved: external ? void 0 : resolveTarget(target, baseDir),
+      external
+    });
+  }
+  return rels;
+}
+function collectSubtree(parts, startPath) {
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [startPath];
+  while (queue.length > 0) {
+    const path = queue.pop();
+    if (seen.has(path) || !parts.has(path)) continue;
+    seen.add(path);
+    const dir = path.slice(0, path.lastIndexOf("/"));
+    const file = path.slice(path.lastIndexOf("/") + 1);
+    const relsPath = `${dir}/_rels/${file}.rels`;
+    const relsBytes = parts.get(relsPath);
+    if (!relsBytes) continue;
+    seen.add(relsPath);
+    for (const rel of parseRelationships(decodeUtf8(relsBytes), path)) {
+      if (rel.resolved) queue.push(rel.resolved);
+    }
+  }
+  return seen;
+}
+var PRESERVED_TAIL_TAGS = ["drawing", "legacyDrawing", "legacyDrawingHF", "picture"];
+function parseTailElements(worksheetXml) {
+  const found = [];
+  for (const tag of PRESERVED_TAIL_TAGS) {
+    const re = new RegExp(`<(?:\\w+:)?${tag}\\s[^>]*?/>|<(?:\\w+:)?${tag}\\s[^>]*?>\\s*</(?:\\w+:)?${tag}>`, "g");
+    for (const m of worksheetXml.matchAll(re)) {
+      const relId = /r:id="([^"]*)"/.exec(m[0])?.[1];
+      if (relId) found.push({ tag, relId, xml: m[0] });
+    }
+  }
+  return found;
+}
+
 // src/model/shared-string-manager.ts
 var _stringToIndex, _indexToString;
 var SharedStringManager = class {
@@ -1550,6 +1645,129 @@ function escAttr(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 
+// src/style/number-format-renderer.ts
+function splitSections(code) {
+  const sections = [];
+  let current = "";
+  let inQuote = false;
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i];
+    if (ch === '"') {
+      inQuote = !inQuote;
+      current += ch;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < code.length) {
+      current += ch + code[++i];
+      continue;
+    }
+    if (ch === ";" && !inQuote) {
+      sections.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  sections.push(current);
+  return sections;
+}
+function isUnsupported(section) {
+  if (/\[[<>=]/.test(section)) return true;
+  if (/[?]/.test(section)) return true;
+  if (/[Ee][+-]/.test(section)) return true;
+  return false;
+}
+function parseSection(section) {
+  const stripped = section.replace(
+    /\[(\$([^\]-]*)[^\]]*|[^\]]*)\]/g,
+    (_m, _all, currency) => typeof currency === "string" ? currency : ""
+  );
+  let prefix = "";
+  let suffix = "";
+  let pattern = "";
+  let seenPattern = false;
+  let percentScale = 1;
+  for (let i = 0; i < stripped.length; i++) {
+    const ch = stripped[i];
+    if (ch === '"') {
+      const end = stripped.indexOf('"', i + 1);
+      const literal = stripped.slice(i + 1, end < 0 ? void 0 : end);
+      if (seenPattern) suffix += literal;
+      else prefix += literal;
+      i = end < 0 ? stripped.length : end;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < stripped.length) {
+      const literal = stripped[++i];
+      if (seenPattern) suffix += literal;
+      else prefix += literal;
+      continue;
+    }
+    if (ch === "_" || ch === "*") {
+      i++;
+      continue;
+    }
+    if (ch === "#" || ch === "0" || ch === "." || ch === ",") {
+      pattern += ch;
+      seenPattern = true;
+      continue;
+    }
+    if (ch === "%") {
+      percentScale *= 100;
+      if (seenPattern) suffix += ch;
+      else prefix += ch;
+      continue;
+    }
+    if (seenPattern) suffix += ch;
+    else prefix += ch;
+  }
+  const dot = pattern.indexOf(".");
+  const intPart = dot < 0 ? pattern : pattern.slice(0, dot);
+  const fracPart = dot < 0 ? "" : pattern.slice(dot + 1);
+  return {
+    literalOnly: !seenPattern,
+    prefix,
+    suffix,
+    minIntDigits: (intPart.match(/0/g) ?? []).length,
+    decimals: (fracPart.match(/[#0]/g) ?? []).length,
+    useGrouping: intPart.includes(","),
+    percentScale
+  };
+}
+function renderNumber(value, p) {
+  if (p.literalOnly) return p.prefix + p.suffix;
+  const scaled = value * p.percentScale;
+  const fixed = scaled.toFixed(p.decimals);
+  let [intDigits = "0", fracDigits = ""] = fixed.split(".");
+  if (intDigits.length < p.minIntDigits) {
+    intDigits = intDigits.padStart(p.minIntDigits, "0");
+  }
+  if (p.useGrouping) {
+    intDigits = intDigits.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  }
+  return p.prefix + intDigits + (fracDigits ? `.${fracDigits}` : "") + p.suffix;
+}
+function formatNumberWithCode(value, formatCode) {
+  if (!Number.isFinite(value)) return null;
+  if (!formatCode || formatCode === "General") return null;
+  if (formatCode === "@") return String(value);
+  const sections = splitSections(formatCode);
+  const negative = sections[1];
+  const zero = sections[2];
+  let section;
+  let magnitude = value;
+  if (value === 0 && zero !== void 0) {
+    section = zero;
+  } else if (value < 0 && negative !== void 0) {
+    section = negative;
+    magnitude = Math.abs(value);
+  } else {
+    section = sections[0];
+  }
+  if (section === void 0 || isUnsupported(section)) return null;
+  return renderNumber(magnitude, parseSection(section));
+}
+
 // src/model/cell-reference.ts
 function parseCellRef(cellReference) {
   if (!cellReference) {
@@ -1749,6 +1967,9 @@ var Cell = class {
   }
   /**
    * Returns the display text of the cell value (always a string).
+   *
+   * Numbers are returned unformatted; use {@link getFormattedText} to apply the
+   * cell's number format.
    */
   getText() {
     const val = this.getValue();
@@ -1756,6 +1977,21 @@ var Cell = class {
     if (val instanceof Date) return val.toLocaleDateString();
     return String(val);
   }
+  /**
+   * 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`.
+   *
+   * 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.
+   */
+  getFormattedText() {
+    const val = this.getValue();
+    if (typeof val !== "number") 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();
+  }
   // ── Formula API ────────────────────────────────────────────────────────────
   /**
    * Sets a formula. The leading '=' is optional.
@@ -2084,7 +2320,7 @@ forEach_fn = function(action) {
 };
 
 // src/model/worksheet.ts
-var _sharedStrings2, _styles2, _name, _rows, _cols, _mergeCells, _pane, _autoFilter, _dataValidations, _visibility, _drawings, _Worksheet_instances, buildColsXml_fn, buildSheetDataXml_fn, buildMergeCellsXml_fn, buildDataValidationsXml_fn, buildSheetViewXml_fn, getOrCreateRow_fn;
+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 Worksheet = class {
   /** @internal */
   constructor(name, sharedStrings, styles) {
@@ -2100,6 +2336,12 @@ var Worksheet = class {
     __privateAdd(this, _dataValidations, []);
     __privateAdd(this, _visibility, "visible");
     __privateAdd(this, _drawings, []);
+    // 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, []);
     __privateSet(this, _name, name);
     __privateSet(this, _sharedStrings2, sharedStrings);
     __privateSet(this, _styles2, styles);
@@ -2179,6 +2421,16 @@ var Worksheet = class {
     __privateGet(this, _cols).push({ min: columnIndex, max: columnIndex, width, customWidth: true });
     __privateGet(this, _cols).sort((a, b) => a.min - b.min);
   }
+  /**
+   * Returns the explicit width of a column (1-based index), or `undefined` when
+   * the column uses the sheet default. Counterpart to {@link setColumnWidth};
+   * widths parsed from an existing file are visible here too, so column layout
+   * can be round-tripped.
+   */
+  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;
+  }
   /** Auto-fits column width based on content (approximate). */
   autoFitColumn(columnIndex) {
     if (columnIndex < 1) throw new RangeError("Column index must be >= 1.");
@@ -2202,6 +2454,14 @@ var Worksheet = class {
     row.height = height;
     row.customHeight = true;
   }
+  /**
+   * Returns the explicit height of a row (1-based index), or `undefined` when
+   * the row uses the sheet default. Counterpart to {@link setRowHeight}.
+   */
+  getRowHeight(rowIndex) {
+    if (rowIndex < 1) throw new RangeError("Row index must be >= 1.");
+    return __privateGet(this, _rows).get(rowIndex)?.height;
+  }
   /** 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.");
@@ -2220,6 +2480,14 @@ var Worksheet = class {
   unmergeCells(rangeReference) {
     __privateSet(this, _mergeCells, __privateGet(this, _mergeCells).filter((m) => m.ref !== rangeReference));
   }
+  /**
+   * All merged ranges on this sheet, in the order they were added (or parsed).
+   * Includes merges read from an existing file, so callers never need to track
+   * their own copy of the list.
+   */
+  get merges() {
+    return __privateGet(this, _mergeCells).map((m) => m.ref);
+  }
   /**
    * Freezes rows and/or columns.
    * @param row    Number of rows to freeze (0 = none)
@@ -2258,6 +2526,18 @@ var Worksheet = class {
   addDrawingProvider(provider) {
     __privateGet(this, _drawings).push(provider);
   }
+  /**
+   * Detaches every drawing from this worksheet — both providers added in memory
+   * and any drawing preserved from the file the workbook was opened from.
+   *
+   * Call before re-adding charts when exporting the same in-memory workbook
+   * repeatedly, otherwise each export appends another copy; call on its own to
+   * deliberately drop a chart that came from the source file.
+   */
+  clearDrawings() {
+    __privateSet(this, _drawings, []);
+    __privateSet(this, _preservedTail, __privateGet(this, _preservedTail).filter((t) => t.tag !== "drawing"));
+  }
   /** True when this worksheet has at least one drawing to serialise. */
   get hasDrawings() {
     return __privateGet(this, _drawings).length > 0;
@@ -2266,6 +2546,44 @@ var Worksheet = class {
   get drawingProviders() {
     return __privateGet(this, _drawings);
   }
+  // ── Round-trip preservation (internal) ───────────────────────────────────────
+  /**
+   * @internal Relationships carried over from the source file, minus any whose
+   * leaf element is no longer emitted (a drawing replaced by live providers, or
+   * cleared outright). The save pipeline writes these into the sheet's rels.
+   */
+  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));
+  }
+  /**
+   * @internal Package paths of relationships that were preserved at load time
+   * but are no longer referenced — a drawing replaced by live providers, or one
+   * cleared outright. The save pipeline prunes these parts so the output has no
+   * orphans.
+   */
+  get droppedPreservedTargets() {
+    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) && r.resolved !== void 0).map((r) => r.resolved);
+  }
+  /**
+   * @internal Relationship id for a drawing built from live providers. Chosen to
+   * 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 `rId${max + 1}`;
+  }
+  /** @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, _preservedTail, parseTailElements(worksheetXml).filter((t) => known.has(t.relId)));
+  }
   // ── XML serialisation ──────────────────────────────────────────────────────
   /** Builds the xl/worksheets/sheetN.xml string. */
   buildXml() {
@@ -2275,12 +2593,13 @@ var Worksheet = class {
     const filterXml = __privateGet(this, _autoFilter) ? `<autoFilter ref="${__privateGet(this, _autoFilter).ref}"/>` : "";
     const validXml = __privateMethod(this, _Worksheet_instances, buildDataValidationsXml_fn).call(this);
     const sheetViewXml = __privateMethod(this, _Worksheet_instances, buildSheetViewXml_fn).call(this);
-    const drawingXml = this.hasDrawings ? `<drawing r:id="${WORKSHEET_DRAWING_REL_ID}"/>` : "";
+    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"?>
 <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}${drawingXml}
+${colsXml}${sheetDataXml}${filterXml}${mergeXml}${validXml}${preservedTailXml}${drawingXml}
 </worksheet>`;
   }
   /** Parses xl/worksheets/sheetN.xml and loads cells into memory. */
@@ -2361,7 +2680,17 @@ _autoFilter = new WeakMap();
 _dataValidations = new WeakMap();
 _visibility = new WeakMap();
 _drawings = new WeakMap();
+_preservedTail = new WeakMap();
+_preservedRels = new WeakMap();
 _Worksheet_instances = new WeakSet();
+/**
+ * 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));
+};
 // ── Private XML builders ───────────────────────────────────────────────────
 buildColsXml_fn = function() {
   if (__privateGet(this, _cols).length === 0) return "";
@@ -2486,7 +2815,7 @@ indexOf_fn = function(name, scope) {
 };
 
 // src/model/workbook.ts
-var _sharedStrings3, _styles3, _sheets, _definedNames, _closed, _Workbook_instances, assertOpen_fn, buildZipEntries_fn;
+var _sharedStrings3, _styles3, _sheets, _definedNames, _closed, _preservedParts, _preservedContentTypes, _orphanedTargets, _Workbook_instances, assertOpen_fn, seedPreservedParts_fn, preservedContentTypeDeclarations_fn, buildZipEntries_fn;
 var _Workbook = class _Workbook {
   constructor(sharedStrings, styles) {
     __privateAdd(this, _Workbook_instances);
@@ -2495,6 +2824,11 @@ var _Workbook = class _Workbook {
     __privateAdd(this, _sheets, []);
     __privateAdd(this, _definedNames, new DefinedNameManager());
     __privateAdd(this, _closed, false);
+    /** Parts carried over verbatim from the file this workbook was opened from. */
+    __privateAdd(this, _preservedParts, /* @__PURE__ */ new Map());
+    __privateAdd(this, _preservedContentTypes);
+    /** Preserved targets whose referring worksheet has been removed. */
+    __privateAdd(this, _orphanedTargets, []);
     __privateSet(this, _sharedStrings3, sharedStrings);
     __privateSet(this, _styles3, styles);
   }
@@ -2535,8 +2869,19 @@ var _Workbook = class _Workbook {
       const ws = new Worksheet(name, ss, sm);
       if (state) ws.setVisibility(state);
       ws.loadFromXml(wsXml);
+      if (wsPath) {
+        const dir = wsPath.slice(0, wsPath.lastIndexOf("/"));
+        const file = wsPath.slice(wsPath.lastIndexOf("/") + 1);
+        const wsRelsXml = readXmlEntry(entries, `${dir}/_rels/${file}.rels`);
+        if (wsRelsXml) {
+          ws.loadPreservedState(wsXml, parseRelationships(wsRelsXml, wsPath));
+        }
+      }
       __privateGet(wb, _sheets).push({ worksheet: ws, sheetId, relId });
     }
+    __privateSet(wb, _preservedParts, collectPreservedParts(entries));
+    const ctXml = readXmlEntry(entries, "[Content_Types].xml");
+    if (ctXml) __privateSet(wb, _preservedContentTypes, parseContentTypes(ctXml));
     for (const dn of getElementsByTagName(wbRoot, "definedName")) {
       const name = getAttr(dn, "name");
       if (!name) continue;
@@ -2586,6 +2931,30 @@ var _Workbook = class _Workbook {
     __privateGet(this, _sheets).push({ worksheet: ws, sheetId, relId });
     return ws;
   }
+  /**
+   * Removes the worksheet with the given name, along with any defined names
+   * scoped to it. Throws if the sheet does not exist or is the last remaining
+   * one — a workbook must always keep at least one sheet.
+   *
+   * Sheet ids and relationship ids are re-derived from document order on save,
+   * so the remaining sheets stay consistent after a removal.
+   */
+  removeWorksheet(name) {
+    __privateMethod(this, _Workbook_instances, assertOpen_fn).call(this);
+    const idx = __privateGet(this, _sheets).findIndex((e) => e.worksheet.name === name);
+    if (idx < 0) throw new Error(`Worksheet "${name}" not found.`);
+    if (__privateGet(this, _sheets).length === 1) {
+      throw new Error("Cannot remove the last worksheet; a workbook must have at least one.");
+    }
+    const removed = __privateGet(this, _sheets)[idx].worksheet;
+    for (const rel of removed.preservedRelationships) {
+      if (rel.resolved) __privateGet(this, _orphanedTargets).push(rel.resolved);
+    }
+    __privateGet(this, _sheets).splice(idx, 1);
+    for (const dn of [...__privateGet(this, _definedNames).all]) {
+      if (dn.scope === name) __privateGet(this, _definedNames).remove(dn.name, dn.scope);
+    }
+  }
   /**
    * Returns a worksheet by name. Throws if not found.
    */
@@ -2670,19 +3039,72 @@ _styles3 = new WeakMap();
 _sheets = new WeakMap();
 _definedNames = new WeakMap();
 _closed = new WeakMap();
+_preservedParts = new WeakMap();
+_preservedContentTypes = new WeakMap();
+_orphanedTargets = new WeakMap();
 _Workbook_instances = new WeakSet();
 // ── Private helpers ────────────────────────────────────────────────────────
 assertOpen_fn = function() {
   if (__privateGet(this, _closed)) throw new Error("Workbook has been closed.");
 };
+/**
+ * Copies preserved source parts into the output, minus those that are now
+ * orphaned. A part is dropped when the only relationship pointing at it has
+ * gone (a drawing replaced by live providers, a sheet removed, an explicit
+ * `clearDrawings()`) and nothing else still reaches it.
+ *
+ * @returns the set of paths written, so later steps can avoid colliding with
+ *   them when naming newly generated parts.
+ */
+seedPreservedParts_fn = function(entries) {
+  if (__privateGet(this, _preservedParts).size === 0) return /* @__PURE__ */ new Set();
+  const retained = /* @__PURE__ */ new Set();
+  for (const { worksheet } of __privateGet(this, _sheets)) {
+    for (const rel of worksheet.preservedRelationships) {
+      if (rel.resolved) {
+        for (const p of collectSubtree(__privateGet(this, _preservedParts), rel.resolved)) retained.add(p);
+      }
+    }
+  }
+  const candidates = [
+    ...__privateGet(this, _sheets).flatMap((e) => [...e.worksheet.droppedPreservedTargets]),
+    ...__privateGet(this, _orphanedTargets)
+  ];
+  const dropped = /* @__PURE__ */ new Set();
+  for (const target of candidates) {
+    for (const p of collectSubtree(__privateGet(this, _preservedParts), target)) {
+      if (!retained.has(p)) dropped.add(p);
+    }
+  }
+  const written = /* @__PURE__ */ new Set();
+  for (const [path, bytes] of __privateGet(this, _preservedParts)) {
+    if (dropped.has(path)) continue;
+    entries.set(path, bytes);
+    written.add(path);
+  }
+  return written;
+};
+/**
+ * Content-type declarations for preserved parts. `<Default>` entries are kept
+ * wholesale — they are extension-scoped and are what types binary parts such
+ * as images — while `<Override>` entries are filtered to parts that survived.
+ */
+preservedContentTypeDeclarations_fn = function(preservedPaths) {
+  const ct = __privateGet(this, _preservedContentTypes);
+  if (!ct) return { defaults: [], overrides: [] };
+  const defaults = [...ct.defaults].filter(([ext]) => ext !== "rels" && ext !== "xml").map(([extension, contentType]) => ({ extension, contentType }));
+  const overrides = [...ct.overrides].filter(([partName]) => preservedPaths.has(partName.replace(/^\//, ""))).map(([partName, contentType]) => ({ partName, contentType }));
+  return { defaults, overrides };
+};
 buildZipEntries_fn = function() {
   const entries = /* @__PURE__ */ new Map();
   const sheetCount = __privateGet(this, _sheets).length;
+  const preservedPaths = __privateMethod(this, _Workbook_instances, seedPreservedParts_fn).call(this, entries);
   entries.set("_rels/.rels", ROOT_RELS);
-  const sheetMetas = __privateGet(this, _sheets).map((e) => ({
+  const sheetMetas = __privateGet(this, _sheets).map((e, i) => ({
     name: e.worksheet.name,
-    sheetId: e.sheetId,
-    relationshipId: e.relId,
+    sheetId: i + 1,
+    relationshipId: `rId${i + 1}`,
     state: e.worksheet.visibility !== "visible" ? e.worksheet.visibility : void 0
   }));
   const definedNameMetas = __privateGet(this, _definedNames).all.map((dn) => {
@@ -2705,34 +3127,48 @@ buildZipEntries_fn = function() {
   let partCounter = 0;
   for (let i = 0; i < __privateGet(this, _sheets).length; i++) {
     const ws = __privateGet(this, _sheets)[i].worksheet;
-    if (!ws.hasDrawings) continue;
-    drawingCounter++;
-    const drawingPath = `xl/drawings/drawing${drawingCounter}.xml`;
-    const anchors = [];
-    const drawingRels = [];
-    ws.drawingProviders.forEach((provider, idx) => {
-      const relId = `rId${idx + 1}`;
-      anchors.push(provider.buildAnchorXml(relId));
-      partCounter++;
-      const part = provider.buildPart(partCounter);
-      entries.set(part.path, part.content);
-      extraOverrides.push({ partName: `/${part.path}`, contentType: part.contentType });
-      const target = `../${part.path.slice("xl/".length)}`;
-      drawingRels.push(
-        `  <Relationship Id="${relId}" Type="${part.relType}" Target="${target}"/>`
-      );
-    });
-    entries.set(drawingPath, buildDrawingXml(anchors.join("")));
-    entries.set(`xl/drawings/_rels/drawing${drawingCounter}.xml.rels`, buildRelsXml(drawingRels));
-    extraOverrides.push({ partName: `/${drawingPath}`, contentType: CONTENT_TYPES.drawing });
-    entries.set(
-      `xl/worksheets/_rels/sheet${i + 1}.xml.rels`,
-      buildRelsXml([
-        `  <Relationship Id="${WORKSHEET_DRAWING_REL_ID}" Type="${REL_TYPES.drawing}" Target="../drawings/drawing${drawingCounter}.xml"/>`
-      ])
+    const sheetRels = ws.preservedRelationships.map(
+      (r) => `  <Relationship Id="${r.id}" Type="${r.type}" Target="${r.target}"${r.external ? ' TargetMode="External"' : ""}/>`
     );
+    if (ws.hasDrawings) {
+      do {
+        drawingCounter++;
+      } while (preservedPaths.has(`xl/drawings/drawing${drawingCounter}.xml`));
+      const drawingPath = `xl/drawings/drawing${drawingCounter}.xml`;
+      const anchors = [];
+      const drawingRels = [];
+      ws.drawingProviders.forEach((provider, idx) => {
+        const relId = `rId${idx + 1}`;
+        anchors.push(provider.buildAnchorXml(relId));
+        let part = provider.buildPart(++partCounter);
+        while (preservedPaths.has(part.path)) part = provider.buildPart(++partCounter);
+        entries.set(part.path, part.content);
+        extraOverrides.push({ partName: `/${part.path}`, contentType: part.contentType });
+        const target = `../${part.path.slice("xl/".length)}`;
+        drawingRels.push(
+          `  <Relationship Id="${relId}" Type="${part.relType}" Target="${target}"/>`
+        );
+      });
+      entries.set(drawingPath, buildDrawingXml(anchors.join("")));
+      entries.set(`xl/drawings/_rels/drawing${drawingCounter}.xml.rels`, buildRelsXml(drawingRels));
+      extraOverrides.push({ partName: `/${drawingPath}`, contentType: CONTENT_TYPES.drawing });
+      sheetRels.push(
+        `  <Relationship Id="${ws.drawingRelId}" Type="${REL_TYPES.drawing}" Target="../drawings/drawing${drawingCounter}.xml"/>`
+      );
+    }
+    if (sheetRels.length > 0) {
+      entries.set(`xl/worksheets/_rels/sheet${i + 1}.xml.rels`, buildRelsXml(sheetRels));
+    }
   }
-  entries.set("[Content_Types].xml", buildContentTypes(sheetCount, extraOverrides));
+  const preservedCt = __privateMethod(this, _Workbook_instances, preservedContentTypeDeclarations_fn).call(this, preservedPaths);
+  entries.set(
+    "[Content_Types].xml",
+    buildContentTypes(
+      sheetCount,
+      [...preservedCt.overrides, ...extraOverrides],
+      preservedCt.defaults
+    )
+  );
   return entries;
 };
 var Workbook = _Workbook;
@@ -2785,6 +3221,7 @@ exports.columnNumber = columnNumber;
 exports.decodeUtf8 = decodeUtf8;
 exports.encodeUtf8 = encodeUtf8;
 exports.escapeXml = escapeXml;
+exports.formatNumberWithCode = formatNumberWithCode;
 exports.fromOADate = fromOADate;
 exports.getAttr = getAttr;
 exports.getElementsByTagName = getElementsByTagName;