@cj-tech-master/excelts 4.2.1 → 4.2.2-canary.20260115044841.88820eb

package/dist/cjs/modules/excel/xlsx/xform/core/core-xform.js

@@ -6,31 +6,50 @@ const base_xform_1 = require("../base-xform.js");
 const date_xform_1 = require("../simple/date-xform.js");
 const string_xform_1 = require("../simple/string-xform.js");
 const integer_xform_1 = require("../simple/integer-xform.js");
+// Rendering uses namespace prefixes, parsing uses unqualified names (SAX strips prefixes)
+const PROPS = {
+    creator: "dc:creator",
+    title: "dc:title",
+    subject: "dc:subject",
+    description: "dc:description",
+    identifier: "dc:identifier",
+    language: "dc:language",
+    keywords: "cp:keywords",
+    category: "cp:category",
+    lastModifiedBy: "cp:lastModifiedBy",
+    lastPrinted: "cp:lastPrinted",
+    revision: "cp:revision",
+    version: "cp:version",
+    contentStatus: "cp:contentStatus",
+    contentType: "cp:contentType",
+    created: "dcterms:created",
+    modified: "dcterms:modified"
+};
 class CoreXform extends base_xform_1.BaseXform {
     constructor() {
         super();
         this.map = {
-            "dc:creator": new string_xform_1.StringXform({ tag: "dc:creator" }),
-            "dc:title": new string_xform_1.StringXform({ tag: "dc:title" }),
-            "dc:subject": new string_xform_1.StringXform({ tag: "dc:subject" }),
-            "dc:description": new string_xform_1.StringXform({ tag: "dc:description" }),
-            "dc:identifier": new string_xform_1.StringXform({ tag: "dc:identifier" }),
-            "dc:language": new string_xform_1.StringXform({ tag: "dc:language" }),
-            "cp:keywords": new string_xform_1.StringXform({ tag: "cp:keywords" }),
-            "cp:category": new string_xform_1.StringXform({ tag: "cp:category" }),
-            "cp:lastModifiedBy": new string_xform_1.StringXform({ tag: "cp:lastModifiedBy" }),
-            "cp:lastPrinted": new date_xform_1.DateXform({ tag: "cp:lastPrinted", format: CoreXform.DateFormat }),
-            "cp:revision": new integer_xform_1.IntegerXform({ tag: "cp:revision" }),
-            "cp:version": new string_xform_1.StringXform({ tag: "cp:version" }),
-            "cp:contentStatus": new string_xform_1.StringXform({ tag: "cp:contentStatus" }),
-            "cp:contentType": new string_xform_1.StringXform({ tag: "cp:contentType" }),
-            "dcterms:created": new date_xform_1.DateXform({
-                tag: "dcterms:created",
+            creator: new string_xform_1.StringXform({ tag: PROPS.creator }),
+            title: new string_xform_1.StringXform({ tag: PROPS.title }),
+            subject: new string_xform_1.StringXform({ tag: PROPS.subject }),
+            description: new string_xform_1.StringXform({ tag: PROPS.description }),
+            identifier: new string_xform_1.StringXform({ tag: PROPS.identifier }),
+            language: new string_xform_1.StringXform({ tag: PROPS.language }),
+            keywords: new string_xform_1.StringXform({ tag: PROPS.keywords }),
+            category: new string_xform_1.StringXform({ tag: PROPS.category }),
+            lastModifiedBy: new string_xform_1.StringXform({ tag: PROPS.lastModifiedBy }),
+            lastPrinted: new date_xform_1.DateXform({ tag: PROPS.lastPrinted, format: CoreXform.DateFormat }),
+            revision: new integer_xform_1.IntegerXform({ tag: PROPS.revision }),
+            version: new string_xform_1.StringXform({ tag: PROPS.version }),
+            contentStatus: new string_xform_1.StringXform({ tag: PROPS.contentStatus }),
+            contentType: new string_xform_1.StringXform({ tag: PROPS.contentType }),
+            created: new date_xform_1.DateXform({
+                tag: PROPS.created,
                 attrs: CoreXform.DateAttrs,
                 format: CoreXform.DateFormat
             }),
-            "dcterms:modified": new date_xform_1.DateXform({
-                tag: "dcterms:modified",
+            modified: new date_xform_1.DateXform({
+                tag: PROPS.modified,
                 attrs: CoreXform.DateAttrs,
                 format: CoreXform.DateFormat
             })
@@ -39,22 +58,9 @@ class CoreXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
         xmlStream.openNode("cp:coreProperties", CoreXform.CORE_PROPERTY_ATTRIBUTES);
-        this.map["dc:creator"].render(xmlStream, model.creator);
-        this.map["dc:title"].render(xmlStream, model.title);
-        this.map["dc:subject"].render(xmlStream, model.subject);
-        this.map["dc:description"].render(xmlStream, model.description);
-        this.map["dc:identifier"].render(xmlStream, model.identifier);
-        this.map["dc:language"].render(xmlStream, model.language);
-        this.map["cp:keywords"].render(xmlStream, model.keywords);
-        this.map["cp:category"].render(xmlStream, model.category);
-        this.map["cp:lastModifiedBy"].render(xmlStream, model.lastModifiedBy);
-        this.map["cp:lastPrinted"].render(xmlStream, model.lastPrinted);
-        this.map["cp:revision"].render(xmlStream, model.revision);
-        this.map["cp:version"].render(xmlStream, model.version);
-        this.map["cp:contentStatus"].render(xmlStream, model.contentStatus);
-        this.map["cp:contentType"].render(xmlStream, model.contentType);
-        this.map["dcterms:created"].render(xmlStream, model.created);
-        this.map["dcterms:modified"].render(xmlStream, model.modified);
+        for (const key of Object.keys(PROPS)) {
+            this.map[key].render(xmlStream, model[key]);
+        }
         xmlStream.closeNode();
     }
     parseOpen(node) {
@@ -62,18 +68,13 @@ class CoreXform extends base_xform_1.BaseXform {
             this.parser.parseOpen(node);
             return true;
         }
-        switch (node.name) {
-            case "cp:coreProperties":
-            case "coreProperties":
-                return true;
-            default:
-                this.parser = this.map[node.name];
-                if (this.parser) {
-                    this.parser.parseOpen(node);
-                    return true;
-                }
-                throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+        if (node.name !== "coreProperties") {
+            this.parser = this.map[node.name];
+            if (this.parser) {
+                this.parser.parseOpen(node);
+            }
         }
+        return true;
     }
     parseText(text) {
         if (this.parser) {
@@ -87,30 +88,17 @@ class CoreXform extends base_xform_1.BaseXform {
             }
             return true;
         }
-        switch (name) {
-            case "cp:coreProperties":
-            case "coreProperties":
-                this.model = {
-                    creator: this.map["dc:creator"].model,
-                    title: this.map["dc:title"].model,
-                    subject: this.map["dc:subject"].model,
-                    description: this.map["dc:description"].model,
-                    identifier: this.map["dc:identifier"].model,
-                    language: this.map["dc:language"].model,
-                    keywords: this.map["cp:keywords"].model,
-                    category: this.map["cp:category"].model,
-                    lastModifiedBy: this.map["cp:lastModifiedBy"].model,
-                    lastPrinted: this.map["cp:lastPrinted"].model,
-                    revision: this.map["cp:revision"].model,
-                    contentStatus: this.map["cp:contentStatus"].model,
-                    contentType: this.map["cp:contentType"].model,
-                    created: this.map["dcterms:created"].model,
-                    modified: this.map["dcterms:modified"].model
-                };
-                return false;
-            default:
-                throw new Error(`Unexpected xml node in parseClose: ${name}`);
+        if (name === "coreProperties") {
+            this.model = {};
+            for (const key of Object.keys(PROPS)) {
+                const val = this.map[key].model;
+                if (val !== undefined && val !== "") {
+                    this.model[key] = val;
+                }
+            }
+            return false;
         }
+        return true;
     }
 }
 exports.CoreXform = CoreXform;

package/dist/cjs/modules/excel/xlsx/xform/drawing/ctrl-prop-xform.js

@@ -10,6 +10,17 @@ const base_xform_1 = require("../base-xform.js");
  * that stores its properties like objectType, checked state, and linked cell.
  */
 class CtrlPropXform extends base_xform_1.BaseXform {
+    _checkedToXmlValue(checked) {
+        switch (checked) {
+            case "Checked":
+                return "1";
+            case "Mixed":
+                return "2";
+            case "Unchecked":
+            default:
+                return "0";
+        }
+    }
     get tag() {
         return "formControlPr";
     }
@@ -18,7 +29,8 @@ class CtrlPropXform extends base_xform_1.BaseXform {
         const attrs = {
             xmlns: "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main",
             objectType: "CheckBox",
-            checked: renderModel.checked,
+            // Excel tends to serialize this as numeric state (0/1/2), matching VML x:Checked.
+            checked: this._checkedToXmlValue(renderModel.checked),
             lockText: "1"
         };
         // Add linked cell reference

package/dist/cjs/modules/excel/xlsx/xform/drawing/sp-xform.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpXform = void 0;
+const base_xform_1 = require("../base-xform.js");
+class SpXform extends base_xform_1.BaseXform {
+    get tag() {
+        return "xdr:sp";
+    }
+    render(xmlStream, model) {
+        if (!model) {
+            return;
+        }
+        xmlStream.openNode(this.tag, { macro: "", textlink: "" });
+        // Non-visual properties
+        xmlStream.openNode("xdr:nvSpPr");
+        xmlStream.openNode("xdr:cNvPr", {
+            id: model.cNvPrId,
+            name: model.name,
+            hidden: model.hidden ? "1" : undefined
+        });
+        xmlStream.openNode("a:extLst");
+        xmlStream.openNode("a:ext", {
+            uri: "{63B3BB69-23CF-44E3-9099-C40C66FF867C}"
+        });
+        xmlStream.leafNode("a14:compatExt", {
+            spid: model.spid,
+            "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+        }, undefined);
+        xmlStream.closeNode(); // a:ext
+        xmlStream.closeNode(); // a:extLst
+        xmlStream.closeNode(); // xdr:cNvPr
+        xmlStream.leafNode("xdr:cNvSpPr");
+        xmlStream.closeNode(); // xdr:nvSpPr
+        // Shape properties
+        xmlStream.openNode("xdr:spPr", { bwMode: "auto" });
+        xmlStream.openNode("a:xfrm");
+        xmlStream.leafNode("a:off", { x: 0, y: 0 });
+        xmlStream.leafNode("a:ext", { cx: 0, cy: 0 });
+        xmlStream.closeNode(); // a:xfrm
+        xmlStream.openNode("a:prstGeom", { prst: "rect" });
+        xmlStream.leafNode("a:avLst");
+        xmlStream.closeNode(); // a:prstGeom
+        xmlStream.leafNode("a:noFill");
+        xmlStream.openNode("a:ln");
+        xmlStream.leafNode("a:noFill");
+        xmlStream.closeNode(); // a:ln
+        xmlStream.openNode("a:extLst");
+        xmlStream.openNode("a:ext", { uri: "{909E8E84-426E-40DD-AFC4-6F175D3DCCD1}" });
+        xmlStream.openNode("a14:hiddenFill", {
+            "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+        });
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:srgbClr", { val: "F0F0F0" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.closeNode(); // a14:hiddenFill
+        xmlStream.closeNode(); // a:ext
+        xmlStream.openNode("a:ext", { uri: "{91240B29-F687-4F45-9708-019B960494DF}" });
+        xmlStream.openNode("a14:hiddenLine", {
+            w: 9525,
+            "xmlns:a14": "http://schemas.microsoft.com/office/drawing/2010/main"
+        });
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:srgbClr", { val: "000000" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.leafNode("a:miter", { lim: 800000 });
+        xmlStream.leafNode("a:headEnd");
+        xmlStream.leafNode("a:tailEnd");
+        xmlStream.closeNode(); // a14:hiddenLine
+        xmlStream.closeNode(); // a:ext
+        xmlStream.closeNode(); // a:extLst
+        xmlStream.closeNode(); // xdr:spPr
+        // Text body (label)
+        xmlStream.openNode("xdr:txBody");
+        xmlStream.leafNode("a:bodyPr", {
+            vertOverflow: "clip",
+            wrap: "square",
+            lIns: 18288,
+            tIns: 18288,
+            rIns: 0,
+            bIns: 18288,
+            anchor: "ctr",
+            upright: 1
+        });
+        xmlStream.leafNode("a:lstStyle");
+        xmlStream.openNode("a:p");
+        xmlStream.openNode("a:pPr", { algn: "l", rtl: 0 });
+        xmlStream.leafNode("a:defRPr", { sz: 1000 });
+        xmlStream.closeNode(); // a:pPr
+        xmlStream.openNode("a:r");
+        xmlStream.openNode("a:rPr", {
+            lang: "en-US",
+            sz: 800,
+            b: 0,
+            i: 0,
+            u: "none",
+            strike: "noStrike",
+            baseline: 0
+        });
+        xmlStream.openNode("a:solidFill");
+        xmlStream.leafNode("a:srgbClr", { val: "000000" });
+        xmlStream.closeNode(); // a:solidFill
+        xmlStream.leafNode("a:latin", { typeface: "Tahoma", pitchFamily: 2, charset: 0 });
+        xmlStream.leafNode("a:ea", { typeface: "Tahoma", pitchFamily: 2, charset: 0 });
+        xmlStream.leafNode("a:cs", { typeface: "Tahoma", pitchFamily: 2, charset: 0 });
+        xmlStream.closeNode(); // a:rPr
+        xmlStream.openNode("a:t");
+        xmlStream.writeText(model.text ?? "");
+        xmlStream.closeNode(); // a:t
+        xmlStream.closeNode(); // a:r
+        xmlStream.closeNode(); // a:p
+        xmlStream.closeNode(); // xdr:txBody
+        xmlStream.closeNode(); // xdr:sp
+    }
+}
+exports.SpXform = SpXform;

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

@@ -5,6 +5,7 @@ const base_cell_anchor_xform_1 = require("./base-cell-anchor-xform.js");
 const static_xform_1 = require("../static-xform.js");
 const cell_position_xform_1 = require("./cell-position-xform.js");
 const pic_xform_1 = require("./pic-xform.js");
+const sp_xform_1 = require("./sp-xform.js");
 class TwoCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
     constructor() {
         super();
@@ -12,6 +13,7 @@ class TwoCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
             "xdr:from": new cell_position_xform_1.CellPositionXform({ tag: "xdr:from" }),
             "xdr:to": new cell_position_xform_1.CellPositionXform({ tag: "xdr:to" }),
             "xdr:pic": new pic_xform_1.PicXform(),
+            "xdr:sp": new sp_xform_1.SpXform(),
             "xdr:clientData": new static_xform_1.StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -19,15 +21,41 @@ class TwoCellAnchorXform extends base_cell_anchor_xform_1.BaseCellAnchorXform {
         return "xdr:twoCellAnchor";
     }
     prepare(model, options) {
-        this.map["xdr:pic"].prepare(model.picture, options);
+        if (model.picture) {
+            this.map["xdr:pic"].prepare(model.picture, options);
+        }
     }
     render(xmlStream, model) {
+        const wrapAlternateContent = !!model.alternateContent;
+        if (wrapAlternateContent) {
+            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"
+                    }
+                    : {})
+            });
+        }
         xmlStream.openNode(this.tag, { editAs: model.range.editAs || "oneCell" });
         this.map["xdr:from"].render(xmlStream, model.range.tl);
         this.map["xdr:to"].render(xmlStream, model.range.br);
-        this.map["xdr:pic"].render(xmlStream, model.picture);
+        if (model.picture) {
+            this.map["xdr:pic"].render(xmlStream, model.picture);
+        }
+        else if (model.shape) {
+            this.map["xdr:sp"].render(xmlStream, model.shape);
+        }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode();
+        if (wrapAlternateContent) {
+            xmlStream.closeNode(); // mc:Choice
+            xmlStream.leafNode("mc:Fallback");
+            xmlStream.closeNode(); // mc:AlternateContent
+        }
     }
     parseClose(name) {
         if (this.parser) {

package/dist/cjs/modules/excel/xlsx/xform/drawing/vml-drawing-xform.js

@@ -110,14 +110,22 @@ class VmlDrawingXform extends base_xform_1.BaseXform {
         }
         // ClientData - the core of the checkbox control
         xmlStream.openNode("x:ClientData", { ObjectType: "Checkbox" });
+        // Match Excel's VML patterns (similar to Note ClientData): include positioning and cell address.
+        // Omitting these can cause Excel to repair the sheet by dropping all legacy controls.
+        xmlStream.leafNode("x:MoveWithCells");
+        xmlStream.leafNode("x:SizeWithCells");
         // Anchor position
         xmlStream.openNode("x:Anchor");
         xmlStream.writeText(form_control_1.FormCheckbox.getVmlAnchor(control));
         xmlStream.closeNode();
+        // Protection / text locking
+        xmlStream.leafNode("x:Locked", undefined, "False");
+        xmlStream.leafNode("x:LockText", undefined, "True");
         // Print settings
         xmlStream.leafNode("x:PrintObject", undefined, control.print ? "True" : "False");
         xmlStream.leafNode("x:AutoFill", undefined, "False");
         xmlStream.leafNode("x:AutoLine", undefined, "False");
+        xmlStream.leafNode("x:TextHAlign", undefined, "Left");
         xmlStream.leafNode("x:TextVAlign", undefined, "Center");
         // Linked cell
         if (control.link) {
@@ -129,6 +137,9 @@ class VmlDrawingXform extends base_xform_1.BaseXform {
         }
         // Checked state (0 = unchecked, 1 = checked, 2 = mixed)
         xmlStream.leafNode("x:Checked", undefined, String(form_control_1.FormCheckbox.getVmlCheckedValue(control)));
+        // Cell address (0-based row/column)
+        xmlStream.leafNode("x:Row", undefined, String(control.tl.row));
+        xmlStream.leafNode("x:Column", undefined, String(control.tl.col));
         xmlStream.closeNode(); // x:ClientData
         xmlStream.closeNode(); // v:shape
     }

package/dist/cjs/modules/excel/xlsx/xform/list-xform.js

@@ -44,17 +44,15 @@ class ListXform extends base_xform_1.BaseXform {
             this.parser.parseOpen(node);
             return true;
         }
-        switch (node.name) {
-            case this.tag:
-                this.model = [];
-                return true;
-            default:
-                if (this.childXform.parseOpen(node)) {
-                    this.parser = this.childXform;
-                    return true;
-                }
-                return false;
+        if (node.name === this.tag) {
+            this.model = [];
+            return true;
         }
+        if (this.childXform.parseOpen(node)) {
+            this.parser = this.childXform;
+            return true;
+        }
+        return false;
     }
     parseText(text) {
         if (this.parser) {

package/dist/cjs/modules/excel/xlsx/xform/sheet/page-setup-xform.js

@@ -39,13 +39,27 @@ class PageSetupXform extends base_xform_1.BaseXform {
     get tag() {
         return "pageSetup";
     }
+    _dpiToXml(value) {
+        // Excel commonly omits these attributes. 4294967295 is used as a sentinel default
+        // when parsing missing values; it should never be serialized back out.
+        if (value === undefined) {
+            return undefined;
+        }
+        if (!Number.isFinite(value)) {
+            return undefined;
+        }
+        if (value === 4294967295) {
+            return undefined;
+        }
+        return value;
+    }
     render(xmlStream, model) {
         if (model) {
             const attributes = {
                 paperSize: model.paperSize,
                 orientation: model.orientation,
-                horizontalDpi: model.horizontalDpi,
-                verticalDpi: model.verticalDpi,
+                horizontalDpi: this._dpiToXml(model.horizontalDpi),
+                verticalDpi: this._dpiToXml(model.verticalDpi),
                 pageOrder: pageOrderToXml(model.pageOrder),
                 blackAndWhite: booleanToXml(model.blackAndWhite),
                 draft: booleanToXml(model.draft),

package/dist/cjs/modules/excel/xlsx/xform/sheet/worksheet-xform.js

@@ -140,6 +140,14 @@ class WorkSheetXform extends base_xform_1.BaseXform {
         options.merges = new merges_1.Merges();
         model.hyperlinks = options.hyperlinks = [];
         model.comments = options.comments = [];
+        // Some Excel builds are surprisingly strict when legacy form controls exist.
+        // Emitting a default sheetView (workbookViewId=0) matches typical Excel output
+        // and avoids relying on optional element handling.
+        if (model.formControls && model.formControls.length > 0) {
+            if (!model.views || model.views.length === 0) {
+                model.views = [{ workbookViewId: 0 }];
+            }
+        }
         options.formulae = {};
         options.siFormulae = 0;
         this.map.cols.prepare(model.cols, options);
@@ -281,6 +289,23 @@ class WorkSheetXform extends base_xform_1.BaseXform {
         // prepare form controls (legacy checkboxes)
         // Form controls share the VML file with comments, but need separate ctrlProp relationships
         if (model.formControls && model.formControls.length > 0) {
+            // Ensure a DrawingML drawing part exists for form controls.
+            // Excel often repairs sheets that have legacy controls but no <drawing> part.
+            let { drawing } = model;
+            if (!drawing) {
+                drawing = model.drawing = {
+                    rId: nextRid(rels),
+                    name: `drawing${++options.drawingsCount}`,
+                    anchors: [],
+                    rels: []
+                };
+                options.drawings.push(drawing);
+                rels.push({
+                    Id: drawing.rId,
+                    Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+                    Target: (0, ooxml_paths_1.drawingRelTargetFromWorksheet)(drawing.name)
+                });
+            }
             // If no comments, we need to add the VML drawing relationship for form controls
             if (model.comments.length === 0) {
                 rels.push({
@@ -289,6 +314,14 @@ class WorkSheetXform extends base_xform_1.BaseXform {
                     Target: (0, ooxml_paths_1.vmlDrawingRelTargetFromWorksheet)(model.id)
                 });
             }
+            // Add hidden DrawingML shapes that bridge to the VML shape ids.
+            // This mirrors what Excel writes when it "repairs" legacy form controls.
+            const toNativePos = (p) => ({
+                nativeCol: p.col,
+                nativeColOff: p.colOff,
+                nativeRow: p.row,
+                nativeRowOff: p.rowOff
+            });
             // Add ctrlProp relationships for each form control
             for (const control of model.formControls) {
                 const globalCtrlPropId = options.formControlRefs.length + 1;
@@ -301,6 +334,22 @@ class WorkSheetXform extends base_xform_1.BaseXform {
                     Target: (0, ooxml_paths_1.ctrlPropRelTargetFromWorksheet)(globalCtrlPropId)
                 });
                 options.formControlRefs.push(globalCtrlPropId);
+                const defaultName = `Check Box ${Math.max(1, control.shapeId - 1024)}`;
+                drawing.anchors.push({
+                    range: {
+                        editAs: "absolute",
+                        tl: toNativePos(control.tl),
+                        br: toNativePos(control.br)
+                    },
+                    alternateContent: { requires: "a14" },
+                    shape: {
+                        cNvPrId: control.shapeId,
+                        name: control.name || defaultName,
+                        hidden: true,
+                        spid: `_x0000_s${control.shapeId}`,
+                        text: control.text
+                    }
+                });
             }
         }
         // prepare ext items
@@ -308,7 +357,14 @@ class WorkSheetXform extends base_xform_1.BaseXform {
     }
     render(xmlStream, model) {
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
-        xmlStream.openNode("worksheet", WorkSheetXform.WORKSHEET_ATTRIBUTES);
+        const worksheetAttrs = { ...WorkSheetXform.WORKSHEET_ATTRIBUTES };
+        if (model.formControls && model.formControls.length > 0) {
+            worksheetAttrs["xmlns:x14"] = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main";
+            worksheetAttrs["xmlns:xdr"] =
+                "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing";
+            worksheetAttrs["mc:Ignorable"] = `${worksheetAttrs["mc:Ignorable"]} x14`;
+        }
+        xmlStream.openNode("worksheet", worksheetAttrs);
         const sheetFormatPropertiesModel = model.properties
             ? {
                 defaultRowHeight: model.properties.defaultRowHeight,
@@ -358,26 +414,68 @@ class WorkSheetXform extends base_xform_1.BaseXform {
         this.map.colBreaks.render(xmlStream, model.colBreaks);
         this.map.drawing.render(xmlStream, model.drawing); // Note: must be after rowBreaks/colBreaks
         this.map.picture.render(xmlStream, model.background); // Note: must be after drawing
-        this.map.tableParts.render(xmlStream, model.tables);
+        if (model.rels) {
+            // Add a <legacyDrawing /> node for each VML drawing relationship (comments and/or form controls).
+            // NOTE: Excel is picky about worksheet child element order; legacyDrawing must come before controls.
+            model.rels.forEach(rel => {
+                if (rel.Type === rel_type_1.RelType.VmlDrawing) {
+                    xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
+                }
+            });
+        }
         // Controls section for legacy form controls (checkboxes, etc.)
         // Excel expects <controls> entries that reference ctrlProp relationships.
         if (model.formControls && model.formControls.length > 0) {
+            xmlStream.openNode("mc:AlternateContent");
+            xmlStream.openNode("mc:Choice", { Requires: "x14" });
             xmlStream.openNode("controls");
             for (const control of model.formControls) {
-                if (control.ctrlPropRelId) {
-                    xmlStream.leafNode("control", { shapeId: control.shapeId, "r:id": control.ctrlPropRelId });
+                if (!control.ctrlPropRelId) {
+                    continue;
                 }
+                const defaultName = `Check Box ${Math.max(1, control.shapeId - 1024)}`;
+                xmlStream.openNode("mc:AlternateContent");
+                xmlStream.openNode("mc:Choice", { Requires: "x14" });
+                xmlStream.openNode("control", {
+                    shapeId: control.shapeId,
+                    "r:id": control.ctrlPropRelId,
+                    name: control.name || defaultName
+                });
+                xmlStream.openNode("controlPr", {
+                    locked: 0,
+                    defaultSize: 0,
+                    print: control.print ? 1 : 0,
+                    autoFill: 0,
+                    autoLine: 0,
+                    autoPict: 0
+                });
+                xmlStream.openNode("anchor");
+                xmlStream.openNode("from");
+                xmlStream.leafNode("xdr:col", undefined, control.tl.col);
+                xmlStream.leafNode("xdr:colOff", undefined, control.tl.colOff);
+                xmlStream.leafNode("xdr:row", undefined, control.tl.row);
+                xmlStream.leafNode("xdr:rowOff", undefined, control.tl.rowOff);
+                xmlStream.closeNode();
+                xmlStream.openNode("to");
+                xmlStream.leafNode("xdr:col", undefined, control.br.col);
+                xmlStream.leafNode("xdr:colOff", undefined, control.br.colOff);
+                xmlStream.leafNode("xdr:row", undefined, control.br.row);
+                xmlStream.leafNode("xdr:rowOff", undefined, control.br.rowOff);
+                xmlStream.closeNode(); // to
+                xmlStream.closeNode(); // anchor
+                xmlStream.closeNode(); // controlPr
+                xmlStream.closeNode(); // control
+                xmlStream.closeNode(); // mc:Choice
+                xmlStream.leafNode("mc:Fallback");
+                xmlStream.closeNode(); // mc:AlternateContent
             }
             xmlStream.closeNode();
+            xmlStream.closeNode();
+            xmlStream.leafNode("mc:Fallback");
+            xmlStream.closeNode();
         }
-        if (model.rels) {
-            // Add a <legacyDrawing /> node for each VML drawing relationship (comments and/or form controls).
-            model.rels.forEach(rel => {
-                if (rel.Type === rel_type_1.RelType.VmlDrawing) {
-                    xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
-                }
-            });
-        }
+        // Table parts must come after <controls> in worksheet element order.
+        this.map.tableParts.render(xmlStream, model.tables);
         // extLst should be the last element in the worksheet.
         this.map.extLst.render(xmlStream, model);
         xmlStream.closeNode();

package/dist/cjs/modules/excel/xlsx/xform/strings/shared-string-xform.js

@@ -39,16 +39,15 @@ class SharedStringXform extends base_xform_1.BaseXform {
         xmlStream.closeNode();
     }
     parseOpen(node) {
-        const { name } = node;
         if (this.parser) {
             this.parser.parseOpen(node);
             return true;
         }
-        if (name === this.tag) {
+        if (node.name === this.tag) {
             this.model = {};
             return true;
         }
-        this.parser = this.map[name];
+        this.parser = this.map[node.name];
         if (this.parser) {
             this.parser.parseOpen(node);
             return true;