@cj-tech-master/excelts 9.6.1 → 10.0.0

package/dist/browser/modules/word/writer/header-footer-writer.js

@@ -66,12 +66,17 @@ export function renderWatermarkHeader(xml, watermark, imageRId) {
         "xmlns:o": NS_O,
         "xmlns:w10": NS_W10
     });
-    // Watermark goes in a paragraph with a single pict run. Skip pPr
-    // entirely — emitting an empty <w:pStyle/> without @w:val is a hard
-    // schema violation Word rejects, and the default style is good enough
-    // for an auto-generated watermark header.
+    // Watermark lives in a paragraph styled as a Header, matching what
+    // Microsoft Word emits. The run carries <w:noProof/> so the WordArt
+    // text is not spell-checked.
     xml.openNode("w:p");
+    xml.openNode("w:pPr");
+    xml.leafNode("w:pStyle", { "w:val": "Header" });
+    xml.closeNode(); // pPr
     xml.openNode("w:r");
+    xml.openNode("w:rPr");
+    xml.leafNode("w:noProof");
+    xml.closeNode(); // rPr
     xml.openNode("w:pict");
     if (watermark.type === "text") {
         renderTextWatermarkVml(xml, watermark);
@@ -87,49 +92,130 @@ export function renderWatermarkHeader(xml, watermark, imageRId) {
 function renderTextWatermarkVml(xml, wm) {
     const color = wm.color ?? "C0C0C0";
     const font = wm.font ?? "Calibri";
-    const fontSize = wm.fontSize ?? 1; // half-points; Word uses pt string in style
-    const fontPt = fontSize / 2;
     const rotation = wm.rotation ?? -45;
-    const opacity = wm.semiTransparent !== false ? ".5" : "1";
-    // VML shape for text watermark (PowerWash / WASHOUT style)
-    xml.leafNode("v:shapetype", {
+    // Full WordArt shapetype definition (t136) exactly as Microsoft Word
+    // emits it. Word for Mac will NOT render the text path unless the
+    // shapetype carries the formula/path/textpath/handles/lock children —
+    // an empty <v:shapetype/> produces an invisible watermark.
+    xml.openNode("v:shapetype", {
         id: "_x0000_t136",
         coordsize: "21600,21600",
         "o:spt": "136",
+        adj: "10800",
         path: "m@7,l@8,m@5,21600l@6,21600e"
     });
+    xml.openNode("v:formulas");
+    for (const eqn of [
+        "sum #0 0 10800",
+        "prod #0 2 1",
+        "sum 21600 0 @1",
+        "sum 0 0 @2",
+        "sum 21600 0 @3",
+        "if @0 @3 0",
+        "if @0 21600 @1",
+        "if @0 0 @2",
+        "if @0 @4 21600",
+        "mid @5 @6",
+        "mid @8 @5",
+        "mid @7 @8",
+        "mid @6 @7",
+        "sum @6 0 @5"
+    ]) {
+        xml.leafNode("v:f", { eqn });
+    }
+    xml.closeNode(); // formulas
+    xml.leafNode("v:path", {
+        textpathok: "t",
+        "o:connecttype": "custom",
+        "o:connectlocs": "@9,0;@10,10800;@11,21600;@12,10800",
+        "o:connectangles": "270,180,90,0"
+    });
+    xml.leafNode("v:textpath", { on: "t", fitshape: "t" });
+    xml.openNode("v:handles");
+    xml.leafNode("v:h", { position: "#0,bottomRight", xrange: "6629,14971" });
+    xml.closeNode(); // handles
+    xml.leafNode("o:lock", { "v:ext": "edit", text: "t", shapetype: "t" });
+    xml.closeNode(); // shapetype
+    // The watermark shape itself. Word fixes font-size at 1pt and relies on
+    // fitshape="t" to scale the text to fill the shape box; rotation is
+    // applied on the shape via the style string.
     const style = `position:absolute;margin-left:0;margin-top:0;width:468pt;height:234pt;` +
-        `rotation:${rotation};z-index:-251658752;mso-position-horizontal:center;` +
-        `mso-position-horizontal-relative:margin;mso-position-vertical:center;` +
-        `mso-position-vertical-relative:margin`;
+        `${rotation ? `rotation:${rotation};` : ""}z-index:-251658752;` +
+        `mso-position-horizontal:center;mso-position-horizontal-relative:margin;` +
+        `mso-position-vertical:center;mso-position-vertical-relative:margin`;
     xml.openNode("v:shape", {
         id: "PowerPlusWaterMarkObject",
         "o:spid": "_x0000_s2049",
         type: "#_x0000_t136",
+        alt: "",
         style,
         "o:allowincell": "f",
         fillcolor: `#${color}`,
         stroked: "f"
     });
-    xml.leafNode("v:fill", { opacity });
+    if (wm.semiTransparent !== false) {
+        xml.leafNode("v:fill", { opacity: ".5" });
+    }
     xml.leafNode("v:textpath", {
-        style: `font-family:&quot;${font}&quot;;font-size:${fontPt}pt`,
+        style: `font-family:"${font}";font-size:1pt`,
         string: wm.text
     });
-    xml.leafNode("w10:wrap", { anchorx: "margin", anchory: "margin" });
     xml.closeNode(); // v:shape
 }
 function renderImageWatermarkVml(xml, wm, rId) {
-    const scale = wm.scale ?? 100;
     const rid = rId ?? wm.rId;
-    const style = `position:absolute;margin-left:0;margin-top:0;width:0;height:0;` +
+    // Default to a large area covering most of the body so the picture is
+    // actually visible. width:0;height:0 produces an invisible dot.
+    const widthPt = wm.widthPt ?? 415.2;
+    const heightPt = wm.heightPt ?? 233.5;
+    // Picture-frame shapetype (t75) as Microsoft Word emits it. Without a
+    // proper shapetype + non-zero size the image watermark will not render.
+    xml.openNode("v:shapetype", {
+        id: "_x0000_t75",
+        coordsize: "21600,21600",
+        "o:spt": "75",
+        "o:preferrelative": "t",
+        path: "m@4@5l@4@11@9@11@9@5xe",
+        filled: "f",
+        stroked: "f"
+    });
+    xml.openNode("v:stroke", { joinstyle: "miter" });
+    xml.closeNode();
+    xml.openNode("v:formulas");
+    for (const eqn of [
+        "if lineDrawn pixelLineWidth 0",
+        "sum @0 1 0",
+        "sum 0 0 @1",
+        "prod @2 1 2",
+        "prod @3 21600 pixelWidth",
+        "prod @3 21600 pixelHeight",
+        "sum @0 0 1",
+        "prod @6 1 2",
+        "prod @7 21600 pixelWidth",
+        "sum @8 21600 0",
+        "prod @7 21600 pixelHeight",
+        "sum @10 21600 0"
+    ]) {
+        xml.leafNode("v:f", { eqn });
+    }
+    xml.closeNode(); // formulas
+    xml.leafNode("v:path", {
+        "o:extrusionok": "f",
+        gradientshapeok: "t",
+        "o:connecttype": "rect"
+    });
+    xml.leafNode("o:lock", { "v:ext": "edit", aspectratio: "t" });
+    xml.closeNode(); // shapetype
+    const style = `position:absolute;margin-left:0;margin-top:0;` +
+        `width:${widthPt}pt;height:${heightPt}pt;` +
         `z-index:-251658752;mso-position-horizontal:center;` +
         `mso-position-horizontal-relative:margin;mso-position-vertical:center;` +
         `mso-position-vertical-relative:margin`;
     xml.openNode("v:shape", {
         id: "PowerPlusWaterMarkObject",
         "o:spid": "_x0000_s2050",
-        type: "",
+        type: "#_x0000_t75",
+        alt: "",
         style,
         "o:allowincell": "f"
     });
@@ -139,8 +225,7 @@ function renderImageWatermarkVml(xml, wm, rId) {
         "r:id": rid,
         "o:title": "",
         gain,
-        blacklevel,
-        ...(scale !== 100 ? { "o:detectmouseclick": "t" } : {})
+        blacklevel
     });
     xml.leafNode("w10:wrap", { anchorx: "margin", anchory: "margin" });
     xml.closeNode(); // v:shape

package/dist/browser/modules/word/writer/math-writer.js

@@ -175,8 +175,13 @@ function renderMathPhantom(xml, p) {
         p.transparent !== undefined;
     if (hasProps) {
         xml.openNode("m:phantPr");
-        if (p.show) {
-            xml.leafNode("m:show", { "m:val": "1" });
+        // `m:show` defaults to ON in OOXML (the phantom base is still drawn). To
+        // make a phantom "occupy space but stay invisible" the producer must
+        // emit `<m:show m:val="0"/>` explicitly — simply omitting it leaves the
+        // content visible. So serialize `show` whenever it is defined, mapping
+        // false → "0" and true → "1".
+        if (p.show !== undefined) {
+            xml.leafNode("m:show", { "m:val": p.show ? "1" : "0" });
         }
         if (p.zeroWidth) {
             xml.leafNode("m:zeroWid", { "m:val": "1" });

package/dist/browser/utils/font-metrics.d.ts

@@ -61,3 +61,11 @@ export declare function getStandardFontNames(): string[];
  * Falls back to "Helvetica" for unknown fonts.
  */
 export declare function mapToStandardFont(fontName: string): string;
+/**
+ * Given a standard PDF base font and bold/italic flags, return the matching
+ * metric variant name (e.g. "Helvetica" + bold → "Helvetica-Bold"). This keeps
+ * width measurement consistent with the glyphs that are actually drawn, so
+ * bold/italic runs are measured with their true (wider) metrics rather than
+ * the regular ones. Falls back to the base name when a variant is unknown.
+ */
+export declare function styledFontVariant(baseFont: string, bold?: boolean, italic?: boolean): string;

package/dist/browser/utils/font-metrics.js

@@ -291,3 +291,46 @@ export function mapToStandardFont(fontName) {
     const lower = fontName.toLowerCase().trim();
     return FONT_FAMILY_MAP[lower] ?? "Helvetica";
 }
+/**
+ * Given a standard PDF base font and bold/italic flags, return the matching
+ * metric variant name (e.g. "Helvetica" + bold → "Helvetica-Bold"). This keeps
+ * width measurement consistent with the glyphs that are actually drawn, so
+ * bold/italic runs are measured with their true (wider) metrics rather than
+ * the regular ones. Falls back to the base name when a variant is unknown.
+ */
+export function styledFontVariant(baseFont, bold, italic) {
+    const std = mapToStandardFont(baseFont);
+    if (!bold && !italic) {
+        return std;
+    }
+    // Determine the family from the resolved standard name.
+    const isTimes = std.startsWith("Times");
+    const isCourier = std.startsWith("Courier");
+    let candidate;
+    if (isTimes) {
+        // Times family uses -Roman / -Bold / -Italic / -BoldItalic.
+        if (bold && italic) {
+            candidate = "Times-BoldItalic";
+        }
+        else if (bold) {
+            candidate = "Times-Bold";
+        }
+        else {
+            candidate = "Times-Italic";
+        }
+    }
+    else {
+        // Helvetica / Courier families use -Bold / -Oblique / -BoldOblique.
+        const family = isCourier ? "Courier" : "Helvetica";
+        if (bold && italic) {
+            candidate = `${family}-BoldOblique`;
+        }
+        else if (bold) {
+            candidate = `${family}-Bold`;
+        }
+        else {
+            candidate = `${family}-Oblique`;
+        }
+    }
+    return candidate in FONT_DESCRIPTORS ? candidate : std;
+}

package/dist/browser/utils/theme-colors.js

@@ -115,6 +115,9 @@ export function resolveOoxmlThemeColor(themeColorName, colors, tint, shade) {
 // Helpers
 // =============================================================================
 function toHex2(n) {
-    const h = Math.max(0, Math.min(255, n)).toString(16);
+    // Emit uppercase hex to match the OOXML ST_HexColorRGB convention and the
+    // casing of theme scheme colors (which are stored uppercase), so a tinted /
+    // shaded result is consistent with an un-transformed passthrough.
+    const h = Math.max(0, Math.min(255, n)).toString(16).toUpperCase();
     return h.length < 2 ? "0" + h : h;
 }

package/dist/cjs/modules/excel/note.js

@@ -39,7 +39,11 @@ class Note {
     set model(value) {
         const { note } = value;
         const { texts } = note;
-        if (texts && texts.length === 1 && Object.keys(texts[0]).length === 1) {
+        // A single, plain text run with no extra box geometry can be flattened
+        // back to a simple string. Custom width/height must keep the full config
+        // so the sizing survives the model round-trip.
+        const hasCustomSize = note.width !== undefined || note.height !== undefined;
+        if (texts && texts.length === 1 && Object.keys(texts[0]).length === 1 && !hasCustomSize) {
             this.note = texts[0].text;
         }
         else {

package/dist/cjs/modules/excel/row.js

@@ -216,12 +216,13 @@ class Row {
             // (e.g. DB entities). Cell.value setter handles unknown values via Value.getType
             // fallback to JSON type, so this cast is safe at runtime.
             this._worksheet.eachColumnKey((column, key) => {
-                if (value[key] !== undefined) {
+                const resolved = resolveColumnKeyValue(value, key);
+                if (resolved !== undefined) {
                     this.getCellEx({
                         address: col_cache_1.colCache.encodeAddress(this._number, column.number),
                         row: this._number,
                         col: column.number
-                    }).value = value[key];
+                    }).value = resolved;
                 }
             });
         }
@@ -463,3 +464,35 @@ class Row {
     }
 }
 exports.Row = Row;
+/**
+ * Resolve a column key against a row object, supporting dotted nested paths.
+ *
+ * A key without a `.` takes the original fast path (`obj[key]`), preserving
+ * exact backward compatibility — including keys that legitimately contain a
+ * dot only as a flat property name, which still resolve via the fast path
+ * first. A dotted key (e.g. `"address.city"`) is resolved by walking each
+ * segment; if any segment is missing or not an object, the result is
+ * `undefined` (the same signal the caller already uses to skip a cell).
+ *
+ * @param obj - The row object supplied to `row.values = {...}` / `addRow({...})`.
+ * @param key - The column key, optionally a dotted path.
+ * @returns The resolved value, or `undefined` when the path cannot be followed.
+ */
+function resolveColumnKeyValue(obj, key) {
+    // Fast path: a flat key (no dot) or an exact flat property match. This keeps
+    // existing behaviour identical and also lets a literal "a.b" property win
+    // over nested traversal when it is actually present on the object.
+    const direct = obj[key];
+    if (direct !== undefined || !key.includes(".")) {
+        return direct;
+    }
+    // Dotted path: walk segments, bailing out to undefined on any gap.
+    let current = obj;
+    for (const segment of key.split(".")) {
+        if (current === null || typeof current !== "object") {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}

package/dist/cjs/modules/excel/stream/workbook-writer.browser.js

@@ -390,13 +390,33 @@ class WorkbookWriterBase {
      * ```
      */
     addImage(image) {
+        const { svg, ...raster } = image;
+        if (svg &&
+            raster.link &&
+            raster.buffer == null &&
+            raster.base64 == null &&
+            raster.filename == null) {
+            throw new errors_1.ImageError("An SVG image requires an embedded raster fallback (buffer/base64/filename); it cannot be combined with an external link.");
+        }
         const id = this.media.length;
         const medium = {
-            ...image,
+            ...raster,
             type: "image",
-            name: `image${id}.${image.extension}`
+            name: `image${id}.${raster.extension}`
         };
         this.media.push(medium);
+        if (svg) {
+            // Register the SVG companion as a second image medium and link it back to
+            // the raster blip so the drawing serializer emits the svgBlip extension.
+            const svgId = this.media.length;
+            this.media.push({
+                ...svg,
+                type: "image",
+                extension: "svg",
+                name: `image${svgId}.svg`
+            });
+            medium.svgMediaId = svgId;
+        }
         return id;
     }
     getImage(id) {

package/dist/cjs/modules/excel/utils/drawing-utils.js

@@ -130,6 +130,23 @@ function buildDrawingAnchorsAndRels(media, existingRels, options) {
             },
             range: medium.range
         };
+        // SVG companion: allocate (and dedupe) a rel for the vector media, then
+        // record its rId so the blip serializer emits the asvg:svgBlip extension.
+        if (bookImage.svgMediaId !== undefined) {
+            const svgKey = `svg:${bookImage.svgMediaId}`;
+            let rIdSvg = imageRIdMap[svgKey];
+            if (!rIdSvg) {
+                const svgImage = options.getBookImage(bookImage.svgMediaId);
+                if (svgImage) {
+                    rIdSvg = options.nextRId(rels);
+                    imageRIdMap[svgKey] = rIdSvg;
+                    rels.push(buildImageRel(rIdSvg, svgImage));
+                }
+            }
+            if (rIdSvg) {
+                anchor.picture.svgRId = rIdSvg;
+            }
+        }
         // Pass through watermark opacity as alphaModFix
         if (medium.opacity !== undefined) {
             const clamped = Math.max(0, Math.min(1, medium.opacity));
@@ -180,8 +197,8 @@ function filterDrawingAnchors(anchors) {
         if (a.range?.br && a.shape) {
             return true;
         }
-        // One-cell anchors need a valid picture or graphicFrame (charts)
-        if (!a.range?.br && !a.picture && !a.graphicFrame) {
+        // One-cell anchors need a valid picture, graphicFrame (charts) or shape.
+        if (!a.range?.br && !a.picture && !a.graphicFrame && !a.shape) {
             return false;
         }
         // Two-cell anchors need either picture, shape, or graphicFrame (charts)

package/dist/cjs/modules/excel/workbook.browser.js

@@ -1736,10 +1736,40 @@ class Workbook {
      * const id = workbook.addImage({ extension: "png", link: "https://example.com/logo.png" });
      * worksheet.addImage(id, "B2:D6");
      * ```
+     *
+     * @example SVG with raster fallback — crisp in modern Excel, safe everywhere
+     * ```typescript
+     * const id = workbook.addImage({
+     *   buffer: pngFallbackBytes, // shown by older Excel / non-SVG consumers
+     *   extension: "png",
+     *   svg: { buffer: svgBytes } // shown by Excel 2016+
+     * });
+     * worksheet.addImage(id, "B2:D6");
+     * ```
      */
     addImage(image) {
+        const { svg, ...raster } = image;
+        if (svg &&
+            raster.link &&
+            raster.buffer == null &&
+            raster.base64 == null &&
+            raster.filename == null) {
+            // An SVG companion needs an embedded raster fallback; a *linked* (external)
+            // raster has no package part to attach the svgBlip extension to.
+            throw new errors_1.ImageError("An SVG image requires an embedded raster fallback (buffer/base64/filename); it cannot be combined with an external link.");
+        }
         const id = this.media.length;
-        this.media.push({ ...image, type: "image" });
+        const rasterMedia = { ...raster, type: "image" };
+        this.media.push(rasterMedia);
+        if (svg) {
+            // Register the SVG as a second `type: "image"` media so it flows through
+            // the existing media naming, content-types, and zip-writing paths. Link
+            // it back to the raster blip so the drawing serializer can emit the
+            // asvg:svgBlip extension.
+            const svgId = this.media.length;
+            this.media.push({ ...svg, type: "image", extension: "svg" });
+            rasterMedia.svgMediaId = svgId;
+        }
         return id;
     }
     getImage(id) {

package/dist/cjs/modules/excel/worksheet.js

@@ -108,6 +108,8 @@ class Worksheet {
         this.autoFilter = options.autoFilter ?? null;
         // for images, etc
         this._media = [];
+        // for user-drawn shapes (rectangles, lines, text boxes, …)
+        this._shapes = [];
         // for charts
         this._charts = [];
         this._sparklineGroups = [];
@@ -1012,6 +1014,85 @@ class Worksheet {
         };
         this._media.push(new image_1.Image(this, model));
     }
+    /**
+     * Add a free-form drawing shape (rectangle, ellipse, line, text box, …) to
+     * the worksheet, anchored to a cell range.
+     *
+     * Unlike images, shapes need no media file — the geometry, fill, outline and
+     * optional text label are written directly into the drawing part.
+     *
+     * @example
+     * ```typescript
+     * worksheet.addShape({
+     *   type: "rect",
+     *   range: "B2:D5",
+     *   fillColor: "FFD966",
+     *   lineColor: "000000",
+     *   lineWidth: 1,
+     *   text: "Important"
+     * });
+     * ```
+     */
+    addShape(options) {
+        const range = options.range;
+        // A shape must cover an area, mirroring images. Reject inputs that resolve
+        // to no size up front, with a clear shape-specific message — otherwise the
+        // failure surfaces much later as a confusing `ImageError` from the internal
+        // range parser when the worksheet is serialized.
+        const hasArea = (typeof range === "string" && range.includes(":")) ||
+            (typeof range === "object" &&
+                range !== null &&
+                ("br" in range || "ext" in range || "pos" in range));
+        if (!hasArea) {
+            throw new errors_1.ImageError('addShape requires a range covering an area: a cell range like "B2:D5", or an object with `br`, `ext`, or `pos`.');
+        }
+        this._shapes.push({
+            type: "shape",
+            shapeType: options.type ?? "rect",
+            range,
+            fillColor: options.fillColor,
+            lineColor: options.lineColor,
+            lineWidth: options.lineWidth,
+            text: options.text,
+            name: options.name
+        });
+    }
+    /** All shapes added to this worksheet. */
+    getShapes() {
+        return this._shapes.slice();
+    }
+    /**
+     * Resolve a shape's `range` into concrete two-cell anchor coordinates,
+     * reusing the `Image` range parser so cell-address/anchor handling stays in
+     * one place. Returns a serializable ShapeModel for the worksheet xform.
+     */
+    _resolveShapeModel(shape) {
+        let range;
+        try {
+            const probe = new image_1.Image(this, { type: "image", imageId: "", range: shape.range });
+            // The probe is always an "image" type, so its model carries `range`.
+            range = probe.model.range;
+        }
+        catch {
+            // Range could not be parsed into an anchor (addShape validates the common
+            // cases up front; this guards exotic inputs). Drop the anchor so the
+            // serializer skips this shape rather than failing the whole worksheet.
+            range = undefined;
+        }
+        if (!range) {
+            return { ...shape, anchorRange: undefined };
+        }
+        return {
+            ...shape,
+            anchorRange: {
+                tl: range.tl,
+                br: range.br,
+                ext: range.ext,
+                pos: range.pos,
+                editAs: range.editAs
+            }
+        };
+    }
     getImages() {
         return this._media.filter(m => m.type === "image");
     }
@@ -1757,6 +1838,7 @@ class Worksheet {
             views: this.views,
             autoFilter: this.autoFilter,
             media: this._media.map(medium => medium.model),
+            shapes: this._shapes.map(shape => this._resolveShapeModel(shape)),
             sheetProtection: this.sheetProtection,
             tables: Object.values(this.tables).map(table => table.model),
             pivotTables: this.pivotTables,
@@ -1822,6 +1904,7 @@ class Worksheet {
         this.views = value.views;
         this.autoFilter = value.autoFilter;
         this._media = value.media.map(medium => new image_1.Image(this, medium));
+        this._shapes = value.shapes ? value.shapes.slice() : [];
         // Restore watermark state from media entries
         this._watermark = value.watermark ?? null;
         if (!this._watermark) {

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

@@ -4,6 +4,9 @@ exports.VmlShapeXform = void 0;
 const base_xform_1 = require("../base-xform.js");
 const vml_client_data_xform_1 = require("./vml-client-data-xform.js");
 const vml_textbox_xform_1 = require("./vml-textbox-xform.js");
+/** Default comment box geometry in points (matches legacy Excel notes). */
+const DEFAULT_NOTE_WIDTH_PT = 97.8;
+const DEFAULT_NOTE_HEIGHT_PT = 59.1;
 class VmlShapeXform extends base_xform_1.BaseXform {
     constructor() {
         super();
@@ -40,6 +43,21 @@ class VmlShapeXform extends base_xform_1.BaseXform {
                     editAs: "",
                     protection: {}
                 };
+                {
+                    // Recover the comment box geometry from the VML style string
+                    // (e.g. "...width:120pt;height:80pt;..."). Only surface width/height
+                    // when they differ from the legacy defaults, so untouched notes keep
+                    // a clean model (and stay byte-compatible with prior behaviour).
+                    const style = node.attributes.style ?? "";
+                    const width = VmlShapeXform.parseStyleLength(style, "width");
+                    const height = VmlShapeXform.parseStyleLength(style, "height");
+                    if (width !== undefined && width !== DEFAULT_NOTE_WIDTH_PT) {
+                        this.model.width = width;
+                    }
+                    if (height !== undefined && height !== DEFAULT_NOTE_HEIGHT_PT) {
+                        this.model.height = height;
+                    }
+                }
                 break;
             default:
                 this.parser = this.map[node.name];
@@ -78,13 +96,29 @@ class VmlShapeXform extends base_xform_1.BaseXform {
                 return true;
         }
     }
+    /**
+     * Extract a points-valued length (e.g. `width:120pt`) from a VML style
+     * string. Returns `undefined` when the property is absent or not in `pt`.
+     */
+    static parseStyleLength(style, prop) {
+        const match = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([0-9.]+)pt`, "i").exec(style);
+        if (!match) {
+            return undefined;
+        }
+        const value = parseFloat(match[1]);
+        return Number.isFinite(value) ? value : undefined;
+    }
 }
 exports.VmlShapeXform = VmlShapeXform;
-VmlShapeXform.V_SHAPE_ATTRIBUTES = (model, index) => ({
-    id: `_x0000_s${1025 + index}`,
-    type: "#_x0000_t202",
-    style: "position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:97.8pt;height:59.1pt;z-index:1;visibility:hidden",
-    fillcolor: "infoBackground [80]",
-    strokecolor: "none [81]",
-    "o:insetmode": model.note.margins && model.note.margins.insetmode
-});
+VmlShapeXform.V_SHAPE_ATTRIBUTES = (model, index) => {
+    const width = model.note?.width ?? DEFAULT_NOTE_WIDTH_PT;
+    const height = model.note?.height ?? DEFAULT_NOTE_HEIGHT_PT;
+    return {
+        id: `_x0000_s${1025 + index}`,
+        type: "#_x0000_t202",
+        style: `position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:${width}pt;height:${height}pt;z-index:1;visibility:hidden`,
+        fillcolor: "infoBackground [80]",
+        strokecolor: "none [81]",
+        "o:insetmode": model.note.margins && model.note.margins.insetmode
+    };
+};

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

@@ -24,7 +24,9 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                     mediaHash[imageType] = true;
                     xmlStream.leafNode("Default", {
                         Extension: imageType,
-                        ContentType: `image/${imageType}`
+                        // SVG's IANA media type is "image/svg+xml"; everything else follows
+                        // the "image/<ext>" convention.
+                        ContentType: imageType === "svg" ? "image/svg+xml" : `image/${imageType}`
                     });
                 }
             }