@cj-tech-master/excelts 9.4.2 → 9.5.0

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

@@ -0,0 +1,225 @@
+/**
+ * GraphicFrameXform — handles `xdr:graphicFrame` elements in drawing XML.
+ *
+ * A graphicFrame is the container for embedded objects such as charts.
+ * The OOXML structure:
+ *
+ *   <xdr:graphicFrame macro="">
+ *     <xdr:nvGraphicFramePr>
+ *       <xdr:cNvPr id="2" name="Chart 1"/>
+ *       <xdr:cNvGraphicFramePr/>
+ *     </xdr:nvGraphicFramePr>
+ *     <xdr:xfrm>
+ *       <a:off x="0" y="0"/>
+ *       <a:ext cx="0" cy="0"/>
+ *     </xdr:xfrm>
+ *     <a:graphic>
+ *       <a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/chart">
+ *         <c:chart xmlns:c="..." xmlns:r="..." r:id="rId1"/>
+ *       </a:graphicData>
+ *     </a:graphic>
+ *   </xdr:graphicFrame>
+ */
+import { BaseXform } from "../base-xform.js";
+import { uuidV4 } from "../../../../../utils/uuid.js";
+const CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+const CHART_EX_URI = "http://schemas.microsoft.com/office/drawing/2014/chartex";
+// URI identifying the Office `creationId` extension registered on
+// `xdr:cNvPr`. This GUID is the Microsoft-assigned registry value
+// for the extension — every Office-authored drawing carries the
+// same uri on this element.
+const CREATION_ID_EXT_URI = "{FF2B5EF4-FFF2-40B4-BE49-F238E27FC236}";
+class GraphicFrameXform extends BaseXform {
+    constructor() {
+        super(...arguments);
+        // SAX parse state
+        this._inNvPr = false;
+        this._inGraphicData = false;
+        /** Raw XML capture for a:extLst inside xdr:cNvPr */
+        this._extLstCapture = null;
+    }
+    get tag() {
+        return "xdr:graphicFrame";
+    }
+    prepare(model, options) {
+        if (model.index === undefined) {
+            model.index = options.index + 1;
+        }
+    }
+    render(xmlStream, model) {
+        xmlStream.openNode(this.tag, { macro: "" });
+        // Non-visual properties
+        xmlStream.openNode("xdr:nvGraphicFramePr");
+        // Microsoft Excel starts `xdr:cNvPr/@id` at 2 (id 1 is
+        // reserved for the anchor's own non-visual drawing id slot
+        // internal to Office's drawing engine). Mirror the convention
+        // here so freshly-authored drawings round-trip byte-for-byte
+        // against Excel's output. Loaded files retain whatever id they
+        // carried at parse time via `model.index`.
+        const cNvPrId = model.index ?? 2;
+        const cNvPrName = model.name ?? `Chart ${cNvPrId}`;
+        if (model.cNvPrExtLst) {
+            xmlStream.openNode("xdr:cNvPr", {
+                id: cNvPrId,
+                name: cNvPrName
+            });
+            xmlStream.writeRaw(model.cNvPrExtLst);
+            xmlStream.closeNode(); // xdr:cNvPr
+        }
+        else if (model.isChartEx) {
+            // ChartEx drawings — auto-generate Microsoft's standard
+            // `<a:extLst>` with an `<a16:creationId>` extension so
+            // Excel 2019+ can track the drawing across sessions.
+            // Without this extension, strict Excel builds have been
+            // observed to reject the drawing part on load with
+            // "Removed Part: /xl/drawings/drawingN.xml (Drawing shape)"
+            // even when the chartEx reference inside is otherwise
+            // valid. A random UUID suffices — the id only has to be
+            // stable within a given saved file; it isn't a content
+            // address.
+            xmlStream.openNode("xdr:cNvPr", {
+                id: cNvPrId,
+                name: cNvPrName
+            });
+            xmlStream.openNode("a:extLst");
+            xmlStream.openNode("a:ext", { uri: CREATION_ID_EXT_URI });
+            xmlStream.leafNode("a16:creationId", {
+                "xmlns:a16": "http://schemas.microsoft.com/office/drawing/2014/main",
+                id: `{${uuidV4().toUpperCase()}}`
+            });
+            xmlStream.closeNode(); // a:ext
+            xmlStream.closeNode(); // a:extLst
+            xmlStream.closeNode(); // xdr:cNvPr
+        }
+        else {
+            xmlStream.leafNode("xdr:cNvPr", {
+                id: cNvPrId,
+                name: cNvPrName
+            });
+        }
+        xmlStream.leafNode("xdr:cNvGraphicFramePr");
+        xmlStream.closeNode(); // xdr:nvGraphicFramePr
+        // Transform (position/size handled by anchor, so use zeros)
+        xmlStream.openNode("xdr:xfrm");
+        xmlStream.leafNode("a:off", { x: 0, y: 0 });
+        xmlStream.leafNode("a:ext", { cx: 0, cy: 0 });
+        xmlStream.closeNode(); // xdr:xfrm
+        // Graphic
+        xmlStream.openNode("a:graphic");
+        if (model.isChartEx) {
+            xmlStream.openNode("a:graphicData", { uri: CHART_EX_URI });
+            xmlStream.leafNode("cx:chart", {
+                "xmlns:cx": CHART_EX_URI,
+                "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+                "r:id": model.rId
+            });
+        }
+        else {
+            xmlStream.openNode("a:graphicData", {
+                uri: model.graphicDataUri ?? CHART_URI
+            });
+            xmlStream.leafNode("c:chart", {
+                "xmlns:c": "http://schemas.openxmlformats.org/drawingml/2006/chart",
+                "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+                "r:id": model.rId
+            });
+        }
+        xmlStream.closeNode(); // a:graphicData
+        xmlStream.closeNode(); // a:graphic
+        xmlStream.closeNode(); // xdr:graphicFrame
+    }
+    parseOpen(node) {
+        // Raw XML capture mode for extLst
+        if (this._extLstCapture) {
+            const attrs = Object.entries(node.attributes || {})
+                .map(([k, v]) => ` ${k}="${v}"`)
+                .join("");
+            if (node.isSelfClosing) {
+                this._extLstCapture.parts.push(`<${node.name}${attrs}/>`);
+                this._extLstCapture.skipNextClose = true;
+            }
+            else {
+                this._extLstCapture.parts.push(`<${node.name}${attrs}>`);
+                this._extLstCapture.depth++;
+            }
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {};
+                this._extLstCapture = null;
+                break;
+            case "xdr:cNvPr":
+                this._inNvPr = true;
+                this.model.index = parseInt(node.attributes.id, 10) || undefined;
+                this.model.name = node.attributes.name;
+                break;
+            case "a:extLst":
+                if (this._inNvPr) {
+                    // Start capturing raw XML
+                    const attrs = Object.entries(node.attributes || {})
+                        .map(([k, v]) => ` ${k}="${v}"`)
+                        .join("");
+                    this._extLstCapture = {
+                        depth: 1,
+                        parts: [`<a:extLst${attrs}>`],
+                        skipNextClose: false
+                    };
+                    return true;
+                }
+                break;
+            case "a:graphicData":
+                this._inGraphicData = true;
+                this.model.graphicDataUri = node.attributes.uri;
+                break;
+            case "c:chart":
+                if (this._inGraphicData) {
+                    this.model.rId = node.attributes["r:id"];
+                }
+                break;
+            case "cx:chart":
+                if (this._inGraphicData) {
+                    this.model.rId = node.attributes["r:id"];
+                    this.model.isChartEx = true;
+                }
+                break;
+            default:
+                break;
+        }
+        return true;
+    }
+    parseText(text) {
+        if (this._extLstCapture && text) {
+            this._extLstCapture.parts.push(text);
+        }
+    }
+    parseClose(name) {
+        if (this._extLstCapture) {
+            if (this._extLstCapture.skipNextClose) {
+                this._extLstCapture.skipNextClose = false;
+                return true;
+            }
+            this._extLstCapture.parts.push(`</${name}>`);
+            this._extLstCapture.depth--;
+            if (this._extLstCapture.depth === 0) {
+                this.model.cNvPrExtLst = this._extLstCapture.parts.join("");
+                this._extLstCapture = null;
+            }
+            return true;
+        }
+        switch (name) {
+            case this.tag:
+                return false;
+            case "xdr:cNvPr":
+                this._inNvPr = false;
+                return true;
+            case "a:graphicData":
+                this._inGraphicData = false;
+                return true;
+            default:
+                return true;
+        }
+    }
+}
+export { GraphicFrameXform };

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

@@ -1,6 +1,7 @@
 import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
 import { CellPositionXform } from "./cell-position-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";
 class OneCellAnchorXform extends BaseCellAnchorXform {
@@ -10,6 +11,7 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
             "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
             "xdr:ext": new ExtXform({ tag: "xdr:ext" }),
             "xdr:pic": new PicXform(),
+            "xdr:graphicFrame": new GraphicFrameXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -17,13 +19,23 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
         return "xdr:oneCellAnchor";
     }
     prepare(model, options) {
-        this.map["xdr:pic"].prepare(model.picture, options);
+        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, { editAs: model.range.editAs ?? "oneCell" });
         this.map["xdr:from"].render(xmlStream, model.range.tl);
         this.map["xdr:ext"].render(xmlStream, model.range.ext);
-        this.map["xdr:pic"].render(xmlStream, model.picture);
+        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();
     }
@@ -39,6 +51,7 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
                 this.model.range.tl = this.map["xdr:from"].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:
                 // could be some unrecognised tags
@@ -46,7 +59,9 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
         }
     }
     reconcile(model, options) {
-        model.medium = this.reconcilePicture(model.picture, options);
+        if (model.picture) {
+            model.medium = this.reconcilePicture(model.picture, options);
+        }
     }
 }
 export { OneCellAnchorXform };

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

@@ -1,16 +1,30 @@
 import { BaseCellAnchorXform } from "./base-cell-anchor-xform.js";
 import { CellPositionXform } from "./cell-position-xform.js";
+import { GraphicFrameXform } from "./graphic-frame-xform.js";
 import { PicXform } from "./pic-xform.js";
 import { SpXform } from "./sp-xform.js";
 import { StaticXform } from "../static-xform.js";
 class TwoCellAnchorXform extends BaseCellAnchorXform {
     constructor() {
         super();
+        // Parse state for the inner `<mc:AlternateContent>` block that
+        // chartEx drawings place in the shape slot of a `<xdr:twoCellAnchor>`.
+        // See `render()` for the canonical layout. When `_inFallback`
+        // flips on we swallow every open/close/text until the matching
+        // `</mc:Fallback>` — the Fallback contents are a legacy-Excel
+        // placeholder shape that structured consumers don't need to
+        // surface; `alternateContent.requires` on the model is enough
+        // to re-emit it verbatim on save.
+        this._acDepth = 0;
+        this._inFallback = false;
+        this._fallbackDepth = 0;
+        this._choiceRequires = undefined;
         this.map = {
             "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
             "xdr:to": new CellPositionXform({ tag: "xdr:to" }),
             "xdr:pic": new PicXform(),
             "xdr:sp": new SpXform(),
+            "xdr:graphicFrame": new GraphicFrameXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -21,40 +35,304 @@ class TwoCellAnchorXform 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) {
-        const wrapAlternateContent = !!model.alternateContent;
-        if (wrapAlternateContent) {
+        // ChartEx anchors (sunburst, treemap, funnel, waterfall, boxplot,
+        // histogram, region map, …) MUST be wrapped in
+        // `<mc:AlternateContent>`. ChartEx is a Microsoft extension that
+        // was never in the base OOXML spec; Excel's strict loader
+        // rejects a bare `<xdr:graphicFrame><cx:chart/>` anchor with
+        // "Removed Part: /xl/drawings/drawingN.xml (Drawing shape)".
+        //
+        // CRITICAL: Excel emits `<mc:AlternateContent>` as the SHAPE slot
+        // INSIDE the `<xdr:twoCellAnchor>`, between `<xdr:to>` and
+        // `<xdr:clientData>` — NOT around the whole anchor. The Choice
+        // carries the `<xdr:graphicFrame>` and the Fallback carries the
+        // `<xdr:sp>`; they share the single `<xdr:from>`/`<xdr:to>` of
+        // the outer anchor. This is how Microsoft Excel itself writes
+        // chartEx drawings — see `tmp/ttttt.xlsx` (Excel 2021-authored)
+        // for the canonical byte layout. Earlier revisions of this file
+        // wrapped the ENTIRE anchor in `<mc:AlternateContent>` and
+        // duplicated `<xdr:from>`/`<xdr:to>` in both Choice and
+        // Fallback. Excel's strict loader rejected that nesting even
+        // though MC substitution rules permit it in theory — the
+        // "Removed Part: drawing1.xml" repair dialog users saw on open
+        // was caused by this exact mis-nesting.
+        //
+        // Canonical structure:
+        //
+        //   <xdr:twoCellAnchor>
+        //     <xdr:from>…</xdr:from>
+        //     <xdr:to>…</xdr:to>
+        //     <mc:AlternateContent>
+        //       <mc:Choice Requires="cx1" xmlns:cx1="…/2015/9/8/chartex">
+        //         <xdr:graphicFrame>…<cx:chart/>…</xdr:graphicFrame>
+        //       </mc:Choice>
+        //       <mc:Fallback>
+        //         <xdr:sp>…placeholder…</xdr:sp>
+        //       </mc:Fallback>
+        //     </mc:AlternateContent>
+        //     <xdr:clientData/>
+        //   </xdr:twoCellAnchor>
+        //
+        // The Fallback MUST NOT be empty — an empty fallback is spec-legal
+        // but Excel's validator treats an empty-choice+empty-fallback
+        // pair as "collapses to nothing" and drops the drawing. The
+        // placeholder shape we emit mirrors the "This chart isn't
+        // available in your version of Excel" message Office uses.
+        //
+        // The `a14`-requires branch (form-control shapes) uses the LEGACY
+        // wrap-the-whole-anchor form with an empty Fallback. That form
+        // was fine for 2010-era form controls and round-tripping code
+        // still depends on it; it is NOT the chartEx shape.
+        const requires = model.alternateContent?.requires;
+        const isChartEx = requires === "cx1" || requires === "cx";
+        const wrapAnchorInAc = !!requires && !isChartEx;
+        if (wrapAnchorInAc) {
+            // Legacy wrap-the-whole-anchor path (form controls, etc.)
             xmlStream.openNode("mc:AlternateContent", {
                 "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
             });
             xmlStream.openNode("mc:Choice", {
-                Requires: model.alternateContent?.requires,
-                ...(model.alternateContent?.requires === "a14"
-                    ? {
-                        "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
-                    }
+                Requires: requires,
+                ...(requires === "a14"
+                    ? { "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main" }
                     : {})
             });
         }
-        xmlStream.openNode(this.tag, { editAs: model.range.editAs ?? "oneCell" });
+        const editAs = model.range.editAs ?? (model.graphicFrame ? undefined : "oneCell");
+        // `editAs="twoCell"` is the default per the CT_TwoCellAnchor
+        // schema — Microsoft Excel omits the attribute in this case.
+        // Emitting it anyway is spec-valid but byte-diverges from
+        // Excel's own output for chartEx drawings, so suppress it when
+        // the effective value is the default.
+        const emitEditAs = editAs && editAs !== "twoCell" ? { editAs } : {};
+        xmlStream.openNode(this.tag, emitEditAs);
         this.map["xdr:from"].render(xmlStream, model.range.tl);
         this.map["xdr:to"].render(xmlStream, model.range.br);
-        if (model.picture) {
+        if (isChartEx) {
+            // ChartEx: wrap the graphicFrame/shape INSIDE the anchor in
+            // mc:AlternateContent, matching Excel's emitted layout.
+            this.renderChartExAlternateContent(xmlStream, model);
+        }
+        else if (model.picture) {
             this.map["xdr:pic"].render(xmlStream, model.picture);
         }
+        else if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
+        }
         else if (model.shape) {
             this.map["xdr:sp"].render(xmlStream, model.shape);
         }
         this.map["xdr:clientData"].render(xmlStream, {});
-        xmlStream.closeNode();
-        if (wrapAlternateContent) {
+        xmlStream.closeNode(); // xdr:twoCellAnchor
+        if (wrapAnchorInAc) {
             xmlStream.closeNode(); // mc:Choice
             xmlStream.leafNode("mc:Fallback");
             xmlStream.closeNode(); // mc:AlternateContent
         }
     }
+    /**
+     * Emit the ChartEx `<mc:AlternateContent>` block that occupies the
+     * shape slot inside a `<xdr:twoCellAnchor>` — between `<xdr:to>`
+     * and `<xdr:clientData>`.
+     *
+     * Structure mirrors Microsoft Excel's own output:
+     *
+     *   <mc:AlternateContent>
+     *     <mc:Choice Requires="cx1" xmlns:cx1="…/2015/9/8/chartex">
+     *       <xdr:graphicFrame>…<cx:chart/>…</xdr:graphicFrame>
+     *     </mc:Choice>
+     *     <mc:Fallback>
+     *       <xdr:sp>…placeholder shape…</xdr:sp>
+     *     </mc:Fallback>
+     *   </mc:AlternateContent>
+     *
+     * Both the Choice graphicFrame and the Fallback shape inherit
+     * sizing from the outer `<xdr:from>`/`<xdr:to>` cell range — they
+     * do NOT each re-declare the anchor; there is only one anchor.
+     */
+    renderChartExAlternateContent(xmlStream, model) {
+        xmlStream.openNode("mc:AlternateContent", {
+            "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006"
+        });
+        xmlStream.openNode("mc:Choice", {
+            "xmlns:cx1": "http://schemas.microsoft.com/office/drawing/2015/9/8/chartex",
+            Requires: "cx1"
+        });
+        if (model.graphicFrame) {
+            this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
+        }
+        xmlStream.closeNode(); // mc:Choice
+        xmlStream.openNode("mc:Fallback");
+        this.renderChartExFallbackShape(xmlStream, model);
+        xmlStream.closeNode(); // mc:Fallback
+        xmlStream.closeNode(); // mc:AlternateContent
+    }
+    /**
+     * Emit the placeholder `<xdr:sp>` that lives inside the
+     * `<mc:Fallback>` of a ChartEx anchor. Legacy Excel (2010/2013)
+     * and non-Microsoft loaders that don't understand the `cx1`
+     * namespace render this in place of the `cx:chart`.
+     *
+     * Matches Microsoft Excel's convention: cNvPr id=0 / empty name
+     * (a deliberate placeholder, not a real drawing object), a white
+     * rectangle sized to the anchor's cell range, and the localizable
+     * "This chart isn't available" message. The shape's own xfrm
+     * carries concrete EMU values rather than zeros because the
+     * Fallback expansion is meant to be rendered standalone — a
+     * zero-size shape would collapse and Excel 2016+ flags that as
+     * "drawing shape" validation failure even though the outer
+     * twoCellAnchor provides sizing.
+     */
+    renderChartExFallbackShape(xmlStream, model) {
+        xmlStream.openNode("xdr:sp", { macro: "", textlink: "" });
+        xmlStream.openNode("xdr:nvSpPr");
+        // `id=0`, empty name — Microsoft's convention for Fallback
+        // placeholders. Using a real numeric id here would conflict with
+        // the real graphicFrame id in Choice on loaders that scan both
+        // branches during validation.
+        xmlStream.leafNode("xdr:cNvPr", { id: 0, name: "" });
+        xmlStream.openNode("xdr:cNvSpPr");
+        xmlStream.leafNode("a:spLocks", { noTextEdit: 1 });
+        xmlStream.closeNode(); // xdr:cNvSpPr
+        xmlStream.closeNode(); // xdr:nvSpPr
+        xmlStream.openNode("xdr:spPr");
+        xmlStream.openNode("a:xfrm");
+        // Non-zero placeholder geometry. Excel expects the fallback
+        // shape to have a concrete size even though the outer
+        // twoCellAnchor already pins its bounds to from/to. Using
+        // 6"×4" (5486400 × 3657600 EMU) here — the dimensions Excel
+        // uses in its own fallback shapes. The position (3917950,
+        // 698500) roughly tracks Excel's offset for the same fallback
+        // shape (the exact values don't matter for validation; they
+        // only affect legacy-client rendering).
+        xmlStream.leafNode("a:off", { x: 3917950, y: 698500 });
+        xmlStream.leafNode("a:ext", { cx: 5486400, cy: 3657600 });
+        xmlStream.closeNode(); // a:xfrm
+        xmlStream.openNode("a:prstGeom", { prst: "rect" });
+        xmlStream.leafNode("a:avLst");
+        xmlStream.closeNode(); // a:prstGeom
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:prstClr", { val: "white" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.openNode("a:ln", { w: 1 });
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:prstClr", { val: "black" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.closeNode(); // a:ln
+        xmlStream.closeNode(); // xdr:spPr
+        xmlStream.openNode("xdr:txBody");
+        xmlStream.leafNode("a:bodyPr", { vertOverflow: "clip", horzOverflow: "clip" });
+        xmlStream.leafNode("a:lstStyle");
+        xmlStream.openNode("a:p");
+        xmlStream.openNode("a:r");
+        xmlStream.leafNode("a:rPr", { lang: "en-US", sz: 1100 });
+        xmlStream.openNode("a:t");
+        xmlStream.writeText("This chart isn't available in your version of Excel.\n\n" +
+            "Editing this shape or saving this workbook into a different file format will permanently break the chart.");
+        xmlStream.closeNode(); // a:t
+        xmlStream.closeNode(); // a:r
+        xmlStream.closeNode(); // a:p
+        xmlStream.closeNode(); // xdr:txBody
+        xmlStream.closeNode(); // xdr:sp
+    }
+    parseOpen(node) {
+        // Swallow everything inside `<mc:Fallback>` — it is a legacy
+        // placeholder shape the writer regenerates verbatim.
+        if (this._inFallback) {
+            this._fallbackDepth++;
+            return true;
+        }
+        // Intercept the MC substitution elements. The children of
+        // `<mc:Choice>` (a `<xdr:graphicFrame>`, typically) should be
+        // parsed by the existing xforms as if the wrapper weren't there.
+        switch (node.name) {
+            case "mc:AlternateContent":
+                this._acDepth++;
+                return true;
+            case "mc:Choice":
+                if (this._acDepth > 0) {
+                    this._choiceRequires = node.attributes?.Requires;
+                }
+                return true;
+            case "mc:Fallback":
+                if (this._acDepth > 0) {
+                    this._inFallback = true;
+                    this._fallbackDepth = 1;
+                }
+                return true;
+            default:
+                break;
+        }
+        if (this.parser) {
+            this.parser.parseOpen(node);
+            return true;
+        }
+        switch (node.name) {
+            case this.tag:
+                this.reset();
+                this.model = {
+                    range: {
+                        editAs: node.attributes.editAs
+                    }
+                };
+                this._acDepth = 0;
+                this._inFallback = false;
+                this._fallbackDepth = 0;
+                this._choiceRequires = undefined;
+                break;
+            default:
+                this.parser = this.map[node.name];
+                if (this.parser) {
+                    this.parser.parseOpen(node);
+                }
+                break;
+        }
+        return true;
+    }
+    parseText(text) {
+        if (this._inFallback) {
+            return;
+        }
+        if (this.parser) {
+            this.parser.parseText(text);
+        }
+    }
     parseClose(name) {
+        // Close matching against the inner `<mc:Fallback>` skip window
+        // first. `_fallbackDepth` tracks nested opens inside the
+        // fallback shape (xdr:sp → xdr:spPr → …); only when it drops
+        // back to zero do we exit skip mode.
+        if (this._inFallback) {
+            this._fallbackDepth--;
+            if (this._fallbackDepth === 0) {
+                this._inFallback = false;
+            }
+            return true;
+        }
+        switch (name) {
+            case "mc:AlternateContent":
+                this._acDepth--;
+                if (this._acDepth <= 0) {
+                    this._acDepth = 0;
+                    // Tag the anchor model with the Requires value so the
+                    // writer re-emits the MC wrapper on save.
+                    if (this._choiceRequires) {
+                        this.model.alternateContent = { requires: this._choiceRequires };
+                    }
+                    this._choiceRequires = undefined;
+                }
+                return true;
+            case "mc:Choice":
+            case "mc:Fallback":
+                return true;
+            default:
+                break;
+        }
         if (this.parser) {
             if (!this.parser.parseClose(name)) {
                 this.parser = undefined;
@@ -66,6 +344,7 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
                 this.model.range.tl = this.map["xdr:from"].model;
                 this.model.range.br = this.map["xdr:to"].model;
                 this.model.picture = this.map["xdr:pic"].model;
+                this.model.graphicFrame = this.map["xdr:graphicFrame"].model;
                 return false;
             default:
                 // could be some unrecognised tags
@@ -73,7 +352,10 @@ class TwoCellAnchorXform extends BaseCellAnchorXform {
         }
     }
     reconcile(model, options) {
-        model.medium = this.reconcilePicture(model.picture, options);
+        if (model.picture) {
+            model.medium = this.reconcilePicture(model.picture, options);
+        }
+        // graphicFrame reconciliation handled at DrawingXform level
     }
 }
 export { TwoCellAnchorXform };