@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/esm/modules/excel/xlsx/xform/comment/threaded-comments-xform.js

@@ -0,0 +1,213 @@
+/**
+ * Reader/writer for Office 365 "threaded comments" (`<ThreadedComments>`
+ * XML root) and the workbook-level person directory (`<personList>`).
+ *
+ * Threaded comments live in a separate part tree from classic VML
+ * comments:
+ *
+ *   - `xl/threadedComments/threadedComment{N}.xml` — one per sheet
+ *     that has threaded comments; referenced from the sheet rels
+ *   - `xl/persons/person.xml` — workbook-level person directory;
+ *     referenced from the workbook rels
+ *
+ * The schema lives in Microsoft's extension namespace
+ * `http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments`
+ * (for comments) and the older `…/2018/threadedcomments` for persons
+ * (identical URI tag-shared).
+ *
+ * This module is intentionally free of runtime xform plumbing —
+ * threaded comments are a discrete part with only text content, so
+ * two small render/parse functions suffice and plug directly into
+ * `xlsx.browser.ts` and `workbook.browser.ts`.
+ */
+import { synthGuid } from "../../../utils/guid.js";
+import { findChild, findChildren, parseXml, textContent } from "../../../../xml/dom.js";
+import { xmlEncode, xmlEncodeAttr } from "../../../../xml/encode.js";
+const TC_NAMESPACE = "http://schemas.microsoft.com/office/spreadsheetml/2018/threadedcomments";
+/**
+ * Render the threaded-comment part for a single worksheet.
+ *
+ * Input is a list of `(cellRef, comment)` pairs — the cell ref is
+ * stored as the `ref` attribute on each `<threadedComment>`, not on
+ * the public {@link ThreadedComment} type (which doesn't carry it so
+ * the same structure can be shared between the public API and the
+ * XForm).
+ *
+ * Input order is preserved — Excel relies on parent-child ordering
+ * when rendering conversation threads, so callers must keep replies
+ * after their parents.
+ */
+export function renderThreadedComments(entries) {
+    const parts = [];
+    parts.push('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>');
+    parts.push(`<ThreadedComments xmlns="${TC_NAMESPACE}">`);
+    for (const { ref, comment: c } of entries) {
+        const id = c.id ?? `{${synthGuid()}}`;
+        const attrs = [`ref="${escapeAttr(ref)}"`];
+        if (c.date) {
+            attrs.push(`dT="${escapeAttr(c.date)}"`);
+        }
+        attrs.push(`personId="${escapeAttr(c.personId)}"`);
+        attrs.push(`id="${escapeAttr(id)}"`);
+        if (c.parentId) {
+            attrs.push(`parentId="${escapeAttr(c.parentId)}"`);
+        }
+        if (c.done !== undefined) {
+            attrs.push(`done="${c.done ? "1" : "0"}"`);
+        }
+        parts.push(`<threadedComment ${attrs.join(" ")}>`);
+        parts.push(`<text>${escapeXml(c.text)}</text>`);
+        if (c.mentions && c.mentions.length > 0) {
+            parts.push("<mentions>");
+            for (const m of c.mentions) {
+                // `startIndex` and `length` are `xsd:unsignedInt` per the
+                // threaded-comments schema — negative, non-integer, or
+                // non-finite values produce XML that strict validators (and
+                // Excel's own reader) reject. Fail loud with a descriptive
+                // error rather than ship a broken comment part.
+                if (!isNonNegativeInt(m.startIndex)) {
+                    throw new Error(`Threaded comment mention.startIndex must be a non-negative integer; got ${m.startIndex}.`);
+                }
+                if (!isNonNegativeInt(m.length)) {
+                    throw new Error(`Threaded comment mention.length must be a non-negative integer; got ${m.length}.`);
+                }
+                const mAttrs = [
+                    `mentionpersonId="${escapeAttr(m.mentionPersonId)}"`,
+                    `mentionId="${escapeAttr(m.mentionId ?? `{${synthGuid()}}`)}"`,
+                    `startIndex="${m.startIndex}"`,
+                    `length="${m.length}"`
+                ];
+                parts.push(`<mention ${mAttrs.join(" ")}/>`);
+            }
+            parts.push("</mentions>");
+        }
+        parts.push(`</threadedComment>`);
+    }
+    parts.push(`</ThreadedComments>`);
+    return parts.join("");
+}
+/**
+ * Parse a `xl/threadedComments/threadedComment{N}.xml` payload into
+ * structured per-cell entries. Returns an empty array on malformed
+ * input — the caller can silently drop threaded comments rather than
+ * failing the entire workbook load.
+ */
+export function parseThreadedComments(rawXml) {
+    let root;
+    try {
+        root = parseXml(rawXml).root;
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    for (const el of findChildren(root, "threadedComment")) {
+        const ref = el.attributes.ref;
+        if (!ref) {
+            continue;
+        }
+        const personId = el.attributes.personId;
+        if (!personId) {
+            continue;
+        }
+        const textEl = findChild(el, "text");
+        const mentionsEl = findChild(el, "mentions");
+        const mentions = mentionsEl
+            ? findChildren(mentionsEl, "mention").map(m => ({
+                mentionId: m.attributes.mentionId,
+                mentionPersonId: m.attributes.mentionpersonId ?? "",
+                startIndex: parseInt(m.attributes.startIndex ?? "0", 10),
+                length: parseInt(m.attributes.length ?? "0", 10)
+            }))
+            : [];
+        const comment = {
+            personId,
+            text: textEl ? textContent(textEl) : "",
+            ...(el.attributes.id ? { id: el.attributes.id } : {}),
+            ...(el.attributes.parentId ? { parentId: el.attributes.parentId } : {}),
+            ...(el.attributes.dT ? { date: el.attributes.dT } : {}),
+            ...(el.attributes.done !== undefined ? { done: el.attributes.done === "1" } : {}),
+            ...(mentions.length > 0 ? { mentions } : {})
+        };
+        result.push({ ref, comment });
+    }
+    return result;
+}
+/**
+ * Render the workbook-level `xl/persons/person.xml` part.
+ */
+export function renderPersonList(persons) {
+    const parts = [];
+    parts.push('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>');
+    parts.push(`<personList xmlns="${TC_NAMESPACE}">`);
+    for (const p of persons) {
+        const attrs = [
+            `displayName="${escapeAttr(p.displayName)}"`,
+            `id="${escapeAttr(p.id)}"`
+        ];
+        if (p.userId !== undefined) {
+            attrs.push(`userId="${escapeAttr(p.userId)}"`);
+        }
+        if (p.providerId !== undefined) {
+            attrs.push(`providerId="${escapeAttr(p.providerId)}"`);
+        }
+        parts.push(`<person ${attrs.join(" ")}/>`);
+    }
+    parts.push(`</personList>`);
+    return parts.join("");
+}
+/**
+ * Parse `xl/persons/person.xml` into a {@link ThreadedCommentPerson}
+ * list. Missing ids are auto-generated so downstream parts that
+ * reference the list don't accidentally collide.
+ */
+export function parsePersonList(rawXml) {
+    let root;
+    try {
+        root = parseXml(rawXml).root;
+    }
+    catch {
+        return [];
+    }
+    return findChildren(root, "person")
+        .map(el => {
+        const id = el.attributes.id ?? `{${synthGuid()}}`;
+        const displayName = el.attributes.displayName ?? "";
+        if (!displayName) {
+            return undefined;
+        }
+        const entry = { id, displayName };
+        if (el.attributes.userId !== undefined) {
+            entry.userId = el.attributes.userId;
+        }
+        if (el.attributes.providerId !== undefined) {
+            entry.providerId = el.attributes.providerId;
+        }
+        return entry;
+    })
+        .filter((x) => x !== undefined);
+}
+function escapeXml(value) {
+    // Route through the canonical encoder so the writer strips
+    // XML-illegal control characters / lone surrogates in user-supplied
+    // comment text. The previous manual `.replace` chain only handled
+    // `& < >` and left every other hazard untouched — e.g. a pasted
+    // `\u0008` corrupted the whole `<ThreadedComments>` part on save.
+    return xmlEncode(value);
+}
+function escapeAttr(value) {
+    // Attribute values additionally need `\t \n \r` encoded as
+    // numeric character references so XML attribute-value normalisation
+    // doesn't collapse them to literal spaces; a threaded comment
+    // `personId` / `id` GUID shouldn't ever contain whitespace but the
+    // `ref` / `displayName` attributes can carry user input.
+    return xmlEncodeAttr(value);
+}
+/**
+ * Whether `v` is a finite non-negative integer suitable for the
+ * `xsd:unsignedInt` attributes used by the threaded-comments schema.
+ * Rejects `NaN`, `±Infinity`, negative numbers, and fractional values.
+ */
+function isNonNegativeInt(v) {
+    return typeof v === "number" && Number.isFinite(v) && v >= 0 && Math.floor(v) === v;
+}

package/dist/esm/modules/excel/xlsx/xform/core/content-types-xform.js

@@ -1,4 +1,4 @@
-import { OOXML_PATHS, commentsPathFromName, ctrlPropPath, drawingPath, externalLinkPath, pivotCacheDefinitionPath, pivotCacheRecordsPath, pivotTablePath, tablePath, toContentTypesPartName, worksheetPath } from "../../../utils/ooxml-paths.js";
+import { OOXML_PATHS, chartsheetPath, commentsPathFromName, ctrlPropPath, drawingPath, externalLinkPath, chartPath, chartUserShapesPath, chartExPath, chartStylePath, chartColorsPath, chartExStylePath, chartExColorsPath, pivotCacheDefinitionPath, pivotCacheRecordsPath, pivotTablePath, tablePath, toContentTypesPartName, worksheetPath } from "../../../utils/ooxml-paths.js";
 import { BaseXform } from "../base-xform.js";
 import { StdDocAttributes } from "../../../../xml/writer.js";
 // used for rendering the [Content_Types].xml file
@@ -35,6 +35,14 @@ class ContentTypesXform extends BaseXform {
                 ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"
             });
         });
+        if (model.chartsheets) {
+            model.chartsheets.forEach((cs) => {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(chartsheetPath(cs.sheetNo)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml"
+                });
+            });
+        }
         if ((model.pivotTables ?? []).length) {
             // R9-B6: Deduplicate cache content types by cacheId. When multiple pivot tables
             // share the same cache, the cache definition/records files are written only once.
@@ -122,11 +130,105 @@ class ContentTypesXform extends BaseXform {
                 });
             });
         }
-        // VML extension is needed for comments, form controls, or header watermarks
+        if (model.chartEntries) {
+            for (const [n, entry] of Object.entries(model.chartEntries)) {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(chartPath(n)),
+                    ContentType: "application/vnd.openxmlformats-officedocument.drawingml.chart+xml"
+                });
+                if (entry?.userShapesXml) {
+                    // `c:userShapes` overlay drawings use the same DrawingML
+                    // content type as worksheet drawings — Excel distinguishes
+                    // them via the relationship type, not the content-type.
+                    xmlStream.leafNode("Override", {
+                        PartName: toContentTypesPartName(chartUserShapesPath(n)),
+                        ContentType: "application/vnd.openxmlformats-officedocument.drawing+xml"
+                    });
+                }
+            }
+        }
+        // Track every ChartEx PartName already emitted so the structured
+        // and raw entry loops can't duplicate an Override. Open Packaging
+        // mandates at most one `<Override>` per PartName — a duplicate
+        // surfaces as the "damaged workbook" dialog in Excel. Using an
+        // explicit Set also guards against any future drift in the key
+        // shape between `chartExEntries` and `chartExStructuredEntries`.
+        const chartExPartNamesEmitted = new Set();
+        if (model.chartExEntries) {
+            for (const n of Object.keys(model.chartExEntries)) {
+                const partName = toContentTypesPartName(chartExPath(n));
+                if (chartExPartNamesEmitted.has(partName)) {
+                    continue;
+                }
+                chartExPartNamesEmitted.add(partName);
+                xmlStream.leafNode("Override", {
+                    PartName: partName,
+                    // Microsoft's canonical content type for ChartEx parts is
+                    // `application/vnd.ms-office.chartex+xml` — ALL lowercase.
+                    // Earlier versions of this library emitted the camel-cased
+                    // `chartEx+xml` variant; Excel 2016+ is strict about this and
+                    // drops any chartEx whose content-type doesn't match exactly,
+                    // which cascades into "Removed Part: /xl/drawings/drawingN.xml
+                    // (Drawing shape)" because the parent drawing's r:id pointer
+                    // is left dangling.
+                    ContentType: "application/vnd.ms-office.chartex+xml"
+                });
+            }
+        }
+        if (model.chartExStructuredEntries) {
+            for (const n of Object.keys(model.chartExStructuredEntries)) {
+                const partName = toContentTypesPartName(chartExPath(n));
+                if (chartExPartNamesEmitted.has(partName)) {
+                    continue;
+                }
+                chartExPartNamesEmitted.add(partName);
+                xmlStream.leafNode("Override", {
+                    PartName: partName,
+                    ContentType: "application/vnd.ms-office.chartex+xml"
+                });
+            }
+        }
+        if (model.chartStyles) {
+            for (const n of Object.keys(model.chartStyles)) {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(chartStylePath(n)),
+                    ContentType: "application/vnd.ms-office.chartstyle+xml"
+                });
+            }
+        }
+        if (model.chartColors) {
+            for (const n of Object.keys(model.chartColors)) {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(chartColorsPath(n)),
+                    ContentType: "application/vnd.ms-office.chartcolorstyle+xml"
+                });
+            }
+        }
+        if (model.chartExStyles) {
+            for (const n of Object.keys(model.chartExStyles)) {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(chartExStylePath(n)),
+                    ContentType: "application/vnd.ms-office.chartstyle+xml"
+                });
+            }
+        }
+        if (model.chartExColors) {
+            for (const n of Object.keys(model.chartExColors)) {
+                xmlStream.leafNode("Override", {
+                    PartName: toContentTypesPartName(chartExColorsPath(n)),
+                    ContentType: "application/vnd.ms-office.chartcolorstyle+xml"
+                });
+            }
+        }
+        // VML extension is needed for comments, form controls, header
+        // watermarks, OR any chartsheet that carries a `<legacyDrawing>`
+        // reference — that last case pins a VML part body through the
+        // package without the worksheet loop declaring the extension.
         const hasComments = model.commentRefs && model.commentRefs.length > 0;
         const hasFormControls = model.formControlRefs && model.formControlRefs.length > 0;
         const hasHeaderWatermark = model.hasHeaderWatermark === true;
-        if (hasComments || hasFormControls || hasHeaderWatermark) {
+        const hasChartsheetVml = model.hasChartsheetVml === true;
+        if (hasComments || hasFormControls || hasHeaderWatermark || hasChartsheetVml) {
             xmlStream.leafNode("Default", {
                 Extension: "vml",
                 ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"
@@ -148,14 +250,51 @@ class ContentTypesXform extends BaseXform {
                 });
             }
         }
-        // Add passthrough content types (charts, etc.)
-        if (model.passthroughContentTypes) {
-            for (const { partName, contentType } of model.passthroughContentTypes) {
-                xmlStream.leafNode("Override", {
-                    PartName: toContentTypesPartName(partName),
-                    ContentType: contentType
-                });
-            }
+        // Office 365 threaded comments: each worksheet that has them gets
+        // its own override, and the workbook-level person directory gets
+        // one more. Writers populate `model.threadedCommentSheetIds` with
+        // the worksheet ids that need parts; absent entry means no
+        // threaded comments on that sheet.
+        const threadedCommentSheetIds = model.threadedCommentSheetIds ?? [];
+        for (const sheetId of threadedCommentSheetIds) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(`xl/threadedComments/threadedComment${sheetId}.xml`),
+                ContentType: "application/vnd.ms-excel.threadedcomments+xml"
+            });
+        }
+        if (model.hasPersons) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName("xl/persons/person.xml"),
+                ContentType: "application/vnd.ms-excel.person+xml"
+            });
+        }
+        // Raw-passthrough parts for slicers / timelines. The path lists
+        // were populated in `prepareModel` from the workbook's captured
+        // raw parts. Content type URIs come from MS-XLSX §2.1.32 and the
+        // 2011 timeline extension addendum.
+        for (const path of model.slicerPartPaths ?? []) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(path),
+                ContentType: "application/vnd.ms-excel.slicer+xml"
+            });
+        }
+        for (const path of model.slicerCachePartPaths ?? []) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(path),
+                ContentType: "application/vnd.ms-excel.slicerCache+xml"
+            });
+        }
+        for (const path of model.timelinePartPaths ?? []) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(path),
+                ContentType: "application/vnd.ms-excel.timeline+xml"
+            });
+        }
+        for (const path of model.timelineCachePartPaths ?? []) {
+            xmlStream.leafNode("Override", {
+                PartName: toContentTypesPartName(path),
+                ContentType: "application/vnd.ms-excel.timelineCache+xml"
+            });
         }
         xmlStream.leafNode("Override", {
             PartName: toContentTypesPartName(OOXML_PATHS.docPropsCore),

package/dist/esm/modules/excel/xlsx/xform/drawing/absolute-anchor-xform.js

@@ -1,6 +1,7 @@
 import { BaseXform } from "../base-xform.js";
 import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
 import { ExtXform } from "./ext-xform.js";
+import { GraphicFrameXform } from "./graphic-frame-xform.js";
 import { PicXform } from "./pic-xform.js";
 import { StaticXform } from "../static-xform.js";
 /** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
@@ -60,6 +61,15 @@ class AbsoluteAnchorXform extends BaseCellAnchorXform {
             "xdr:pos": new PosXform(),
             "xdr:ext": new ExtXform({ tag: "xdr:ext" }),
             "xdr:pic": new PicXform(),
+            // `xdr:graphicFrame` carries the chart / embedded object payload
+            // for absolute-anchor sheet drawings. The oneCell / twoCell
+            // counterparts already handled it; the absolute branch was
+            // pic-only, so a chart authored with an absolute anchor (or
+            // programmatically constructed via `{ pos, ext }`) silently
+            // dropped its graphicFrame on write — the drawing XML emitted
+            // `<xdr:absoluteAnchor><xdr:pos/><xdr:ext/><xdr:clientData/></xdr:absoluteAnchor>`
+            // with no chart reference, so the anchor was ignored on open.
+            "xdr:graphicFrame": new GraphicFrameXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -70,6 +80,9 @@ class AbsoluteAnchorXform extends BaseCellAnchorXform {
         if (model.picture) {
             this.map["xdr:pic"].prepare(model.picture, options);
         }
+        else if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].prepare(model.graphicFrame, options);
+        }
     }
     render(xmlStream, model) {
         xmlStream.openNode(this.tag);
@@ -78,6 +91,9 @@ class AbsoluteAnchorXform extends BaseCellAnchorXform {
         if (model.picture) {
             this.map["xdr:pic"].render(xmlStream, model.picture);
         }
+        else if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
+        }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode();
     }
@@ -93,13 +109,16 @@ class AbsoluteAnchorXform extends BaseCellAnchorXform {
                 this.model.range.pos = this.map["xdr:pos"].model;
                 this.model.range.ext = this.map["xdr:ext"].model;
                 this.model.picture = this.map["xdr:pic"].model;
+                this.model.graphicFrame = this.map["xdr:graphicFrame"].model;
                 return false;
             default:
                 return true;
         }
     }
     reconcile(model, options) {
-        model.medium = this.reconcilePicture(model.picture, options);
+        if (model.picture) {
+            model.medium = this.reconcilePicture(model.picture, options);
+        }
     }
 }
 export { AbsoluteAnchorXform };

package/dist/esm/modules/excel/xlsx/xform/drawing/base-cell-anchor-xform.js

@@ -10,7 +10,7 @@ class BaseCellAnchorXform extends BaseXform {
                 this.reset();
                 this.model = {
                     range: {
-                        editAs: node.attributes.editAs ?? "oneCell"
+                        editAs: node.attributes.editAs
                     }
                 };
                 break;

package/dist/esm/modules/excel/xlsx/xform/drawing/drawing-xform.js

@@ -14,6 +14,15 @@ function getAnchorType(model) {
 class DrawingXform extends BaseXform {
     constructor() {
         super();
+        // mc:AlternateContent parse state
+        this._inAlternateContent = false;
+        this._acDepth = 0;
+        this._inChoice = false;
+        this._inFallback = false;
+        this._fallbackDepth = 0;
+        this._choiceRequires = undefined;
+        /** Number of anchors before entering mc:AlternateContent — used to tag new anchors */
+        this._anchorCountBeforeAC = 0;
         this.map = {
             "xdr:twoCellAnchor": new TwoCellAnchorXform(),
             "xdr:oneCellAnchor": new OneCellAnchorXform(),
@@ -34,7 +43,27 @@ class DrawingXform extends BaseXform {
     render(xmlStream, model) {
         const renderModel = model || this.model;
         xmlStream.openXml(StdDocAttributes);
-        xmlStream.openNode(this.tag, DrawingXform.DRAWING_ATTRIBUTES);
+        // `<xdr:wsDr>` must declare every namespace prefix any descendant
+        // uses. Inline `xmlns:mc=…` declarations on a deeply nested
+        // `<mc:AlternateContent>` are legal XML and strictly sufficient for
+        // the parser, but Microsoft Excel's **drawing validator** walks the
+        // anchor tree ahead of the parser and rejects the whole drawing
+        // when it encounters an element whose prefix was not pre-declared
+        // on the wsDr root ("Removed Part: /xl/drawings/drawingN.xml
+        // part. (Drawing shape)"). Excel's own output for any drawing that
+        // hosts ChartEx content therefore declares all six prefixes —
+        // `xdr`, `a`, `r`, `c`, `mc`, `cx` — at the root.
+        //
+        // Switch to the extended namespace set whenever any anchor carries
+        // `alternateContent` metadata (form-control shapes, ChartEx
+        // charts, and their `cx1` variants all use the same wrapper). The
+        // bare `xdr` + `a` set is correct for "legacy only" drawings and
+        // round-trips byte-for-byte with Excel's output for those files.
+        const needsMcNamespaces = renderModel.anchors.some(a => !!a?.alternateContent);
+        const rootAttrs = needsMcNamespaces
+            ? DrawingXform.DRAWING_ATTRIBUTES_WITH_MC
+            : DrawingXform.DRAWING_ATTRIBUTES;
+        xmlStream.openNode(this.tag, rootAttrs);
         renderModel.anchors.forEach(item => {
             const anchor = this.map[item.anchorType];
             anchor.render(xmlStream, item);
@@ -42,6 +71,12 @@ class DrawingXform extends BaseXform {
         xmlStream.closeNode();
     }
     parseOpen(node) {
+        // Inside mc:Fallback — skip everything
+        if (this._inFallback) {
+            this._fallbackDepth++;
+            return true;
+        }
+        // Delegate to active parser
         if (this.parser) {
             this.parser.parseOpen(node);
             return true;
@@ -49,11 +84,29 @@ class DrawingXform extends BaseXform {
         switch (node.name) {
             case this.tag:
                 this.reset();
-                this.model = {
-                    anchors: []
-                };
+                this.model = { anchors: [] };
+                break;
+            case "mc:AlternateContent":
+                this._acDepth = (this._acDepth ?? 0) + 1;
+                if (this._acDepth === 1) {
+                    this._inAlternateContent = true;
+                    this._anchorCountBeforeAC = this.model.anchors.length;
+                }
+                break;
+            case "mc:Choice":
+                if (this._inAlternateContent) {
+                    this._inChoice = true;
+                    this._choiceRequires = node.attributes?.Requires;
+                }
+                break;
+            case "mc:Fallback":
+                if (this._inAlternateContent) {
+                    this._inFallback = true;
+                    this._fallbackDepth = 1;
+                }
                 break;
             default:
+                // Normal anchor dispatch (works both inside mc:Choice and at top level)
                 this.parser = this.map[node.name];
                 if (this.parser) {
                     this.parser.parseOpen(node);
@@ -63,11 +116,22 @@ class DrawingXform extends BaseXform {
         return true;
     }
     parseText(text) {
+        if (this._inFallback) {
+            return;
+        }
         if (this.parser) {
             this.parser.parseText(text);
         }
     }
     parseClose(name) {
+        // Inside mc:Fallback — skip until closed
+        if (this._inFallback) {
+            this._fallbackDepth--;
+            if (this._fallbackDepth === 0) {
+                this._inFallback = false;
+            }
+            return true;
+        }
         if (this.parser) {
             if (!this.parser.parseClose(name)) {
                 this.model.anchors.push(this.parser.model);
@@ -78,8 +142,26 @@ class DrawingXform extends BaseXform {
         switch (name) {
             case this.tag:
                 return false;
+            case "mc:AlternateContent":
+                this._acDepth = (this._acDepth ?? 0) - 1;
+                if (this._acDepth <= 0) {
+                    // Tag any anchors added during this mc:AlternateContent with alternateContent info
+                    if (this._inAlternateContent && this._choiceRequires) {
+                        const anchors = this.model.anchors;
+                        for (let i = this._anchorCountBeforeAC; i < anchors.length; i++) {
+                            anchors[i].alternateContent = { requires: this._choiceRequires };
+                        }
+                    }
+                    this._inAlternateContent = false;
+                    this._inChoice = false;
+                    this._choiceRequires = undefined;
+                    this._acDepth = 0;
+                }
+                return true;
+            case "mc:Choice":
+                this._inChoice = false;
+                return true;
             default:
-                // could be some unrecognised tags
                 return true;
         }
     }
@@ -101,4 +183,26 @@ DrawingXform.DRAWING_ATTRIBUTES = {
     "xmlns:xdr": "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing",
     "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main"
 };
+/**
+ * Extended namespace set used when the drawing contains anchors
+ * wrapped in `<mc:AlternateContent>` — the ChartEx case. Excel's
+ * strict loader requires the `mc`, `r`, `c`, and `cx` prefixes at
+ * the root of `<xdr:wsDr>` before it will parse `<mc:Choice>` /
+ * `<cx:chart>` descendants. Declaring them only inside the inner
+ * `<mc:AlternateContent>` element (as earlier versions did) made
+ * Excel reject the drawing and report "Removed Part:
+ * /xl/drawings/drawingN.xml (Drawing shape)".
+ *
+ * Mirrors what Excel itself emits when it writes a drawing that
+ * hosts a ChartEx chart — see `__tests__/data/workbook-roundtrip-
+ * chartex.xlsx` (fixtures authored by Excel 2016+).
+ */
+DrawingXform.DRAWING_ATTRIBUTES_WITH_MC = {
+    "xmlns:xdr": "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing",
+    "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main",
+    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+    "xmlns:c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+    "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+    "xmlns:cx": "http://schemas.microsoft.com/office/drawing/2014/chartex"
+};
 export { DrawingXform };