@cj-tech-master/excelts 9.6.1 → 10.0.0

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

@@ -21,6 +21,7 @@ exports.getLineHeight = getLineHeight;
 exports.isStandardFont = isStandardFont;
 exports.getStandardFontNames = getStandardFontNames;
 exports.mapToStandardFont = mapToStandardFont;
+exports.styledFontVariant = styledFontVariant;
 // =============================================================================
 // Helvetica Metrics (afm data: Helvetica)
 // =============================================================================
@@ -301,3 +302,46 @@ 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.
+ */
+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/cjs/utils/theme-colors.js

@@ -121,6 +121,9 @@ 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/esm/modules/excel/note.js

@@ -36,7 +36,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/esm/modules/excel/row.js

@@ -213,12 +213,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: colCache.encodeAddress(this._number, column.number),
                         row: this._number,
                         col: column.number
-                    }).value = value[key];
+                    }).value = resolved;
                 }
             });
         }
@@ -459,4 +460,36 @@ class Row {
         this.style = value.style ? structuredClone(value.style) : {};
     }
 }
+/**
+ * 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;
+}
 export { Row };

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

@@ -387,13 +387,33 @@ export class WorkbookWriterBase {
      * ```
      */
     addImage(image) {
+        const { svg, ...raster } = image;
+        if (svg &&
+            raster.link &&
+            raster.buffer == null &&
+            raster.base64 == null &&
+            raster.filename == null) {
+            throw new 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/esm/modules/excel/utils/drawing-utils.js

@@ -122,6 +122,23 @@ export 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));
@@ -172,8 +189,8 @@ export 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/esm/modules/excel/workbook.browser.js

@@ -20,7 +20,7 @@ import { parseNumberFromCsv } from "../csv/utils/number.js";
 import { getChartSupport } from "./chart-host-registry.js";
 import { Chartsheet } from "./chartsheet.js";
 import { DefinedNames } from "./defined-names.js";
-import { ExcelDownloadError, ExcelNotSupportedError, WorksheetNameError } from "./errors.js";
+import { ExcelDownloadError, ExcelNotSupportedError, ImageError, WorksheetNameError } from "./errors.js";
 import { withPivotChartSource } from "./pivot-chart.js";
 import { WorkbookReader } from "./stream/workbook-reader.browser.js";
 import { WorkbookWriter } from "./stream/workbook-writer.browser.js";
@@ -1733,10 +1733,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 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/esm/modules/excel/worksheet.js

@@ -105,6 +105,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 = [];
@@ -1009,6 +1011,85 @@ class Worksheet {
         };
         this._media.push(new 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 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(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");
     }
@@ -1754,6 +1835,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,
@@ -1819,6 +1901,7 @@ class Worksheet {
         this.views = value.views;
         this.autoFilter = value.autoFilter;
         this._media = value.media.map(medium => new 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/esm/modules/excel/xlsx/xform/comment/vml-shape-xform.js

@@ -1,6 +1,9 @@
 import { BaseXform } from "../base-xform.js";
 import { VmlClientDataXform } from "./vml-client-data-xform.js";
 import { VmlTextboxXform } from "./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 BaseXform {
     constructor() {
         super();
@@ -37,6 +40,21 @@ class VmlShapeXform extends 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];
@@ -75,13 +93,29 @@ class VmlShapeXform extends 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;
+    }
 }
-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
+    };
+};
 export { VmlShapeXform };

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

@@ -21,7 +21,9 @@ class ContentTypesXform extends 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}`
                     });
                 }
             }

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

@@ -3,6 +3,7 @@ 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 { ShapeXform } from "./shape-xform.js";
 import { StaticXform } from "../static-xform.js";
 /** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
 const EMU_PER_PIXEL_AT_96_DPI = 9525;
@@ -70,6 +71,7 @@ class AbsoluteAnchorXform extends BaseCellAnchorXform {
             // `<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:userShape": new ShapeXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
     }
@@ -94,6 +96,9 @@ class AbsoluteAnchorXform extends BaseCellAnchorXform {
         else if (model.graphicFrame) {
             this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
         }
+        else if (model.shape?.kind === "userShape") {
+            this.map["xdr:userShape"].render(xmlStream, model.shape);
+        }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode();
     }

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

@@ -47,8 +47,25 @@ class BaseCellAnchorXform extends BaseXform {
                 const name = match[1];
                 const mediaId = options.mediaIndex[name];
                 const medium = options.media[mediaId];
+                if (!medium) {
+                    return undefined;
+                }
+                // Resolve an SVG companion (asvg:svgBlip extension) back to its media
+                // index and record it on the raster media entry itself, so callers that
+                // look the image up by id (e.g. Workbook.getImage) surface the vector
+                // companion alongside the raster fallback.
+                if (model.svgRId) {
+                    const svgRel = options.rels[model.svgRId];
+                    const svgMatch = svgRel && svgRel.Target.match(/.*\/media\/(.+[.][a-zA-Z]{3,4})/);
+                    if (svgMatch) {
+                        const svgMediaId = options.mediaIndex[svgMatch[1]];
+                        if (svgMediaId !== undefined) {
+                            medium.svgMediaId = svgMediaId;
+                        }
+                    }
+                }
                 // Preserve alphaModFix (transparency) from the picture model if present
-                if (medium && model.alphaModFix !== undefined) {
+                if (model.alphaModFix !== undefined) {
                     return { ...medium, alphaModFix: model.alphaModFix };
                 }
                 return medium;

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

@@ -1,4 +1,9 @@
 import { BaseXform } from "../base-xform.js";
+/** OOXML extension URI for the SVG blip (Office 2016 SVG feature). */
+const SVG_BLIP_EXT_URI = "{96DAC541-7B7A-43D3-8B79-37D633B846F1}";
+/** Namespace for the asvg:svgBlip element. */
+const SVG_BLIP_NS = "http://schemas.microsoft.com/office/drawing/2016/SVG/main";
+const REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
 class BlipXform extends BaseXform {
     constructor() {
         super();
@@ -10,23 +15,37 @@ class BlipXform extends BaseXform {
     render(xmlStream, model) {
         // External (linked) images use `r:link`; embedded images use `r:embed`.
         const relAttr = model.external ? "r:link" : "r:embed";
-        if (model.alphaModFix !== undefined && model.alphaModFix < 100000) {
-            // Render as open/close node with a:alphaModFix child
-            xmlStream.openNode(this.tag, {
-                "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+        const hasAlpha = model.alphaModFix !== undefined && model.alphaModFix < 100000;
+        const hasSvg = model.svgRId !== undefined;
+        // A bare blip can be a leaf node; an alpha modulation or an SVG extension
+        // both require child elements, so switch to the open/close form.
+        if (!hasAlpha && !hasSvg) {
+            xmlStream.leafNode(this.tag, {
+                "xmlns:r": REL_NS,
                 [relAttr]: model.rId,
                 cstate: "print"
             });
+            return;
+        }
+        xmlStream.openNode(this.tag, {
+            "xmlns:r": REL_NS,
+            [relAttr]: model.rId,
+            cstate: "print"
+        });
+        if (hasAlpha) {
             xmlStream.leafNode("a:alphaModFix", { amt: String(model.alphaModFix) });
-            xmlStream.closeNode();
         }
-        else {
-            xmlStream.leafNode(this.tag, {
-                "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
-                [relAttr]: model.rId,
-                cstate: "print"
+        if (hasSvg) {
+            xmlStream.openNode("a:extLst");
+            xmlStream.openNode("a:ext", { uri: SVG_BLIP_EXT_URI });
+            xmlStream.leafNode("asvg:svgBlip", {
+                "xmlns:asvg": SVG_BLIP_NS,
+                "r:embed": model.svgRId
             });
+            xmlStream.closeNode(); // a:ext
+            xmlStream.closeNode(); // a:extLst
         }
+        xmlStream.closeNode(); // a:blip
     }
     parseOpen(node) {
         switch (node.name) {
@@ -46,6 +65,14 @@ class BlipXform extends BaseXform {
                     this.model.alphaModFix = parseInt(node.attributes.amt, 10);
                 }
                 return true;
+            case "asvg:svgBlip": {
+                // Capture the SVG companion's relationship id for round-trip.
+                const embed = node.attributes["r:embed"];
+                if (embed !== undefined && this.model) {
+                    this.model.svgRId = embed;
+                }
+                return true;
+            }
             default:
                 return true;
         }
@@ -56,7 +83,7 @@ class BlipXform extends BaseXform {
             case this.tag:
                 return false;
             default:
-                // unprocessed internal nodes
+                // unprocessed internal nodes (a:extLst / a:ext / alphaModFix)
                 return true;
         }
     }

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

@@ -3,6 +3,7 @@ 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 { ShapeXform } from "./shape-xform.js";
 import { StaticXform } from "../static-xform.js";
 class OneCellAnchorXform extends BaseCellAnchorXform {
     constructor() {
@@ -11,6 +12,7 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
             "xdr:from": new CellPositionXform({ tag: "xdr:from" }),
             "xdr:ext": new ExtXform({ tag: "xdr:ext" }),
             "xdr:pic": new PicXform(),
+            "xdr:userShape": new ShapeXform(),
             "xdr:graphicFrame": new GraphicFrameXform(),
             "xdr:clientData": new StaticXform({ tag: "xdr:clientData" })
         };
@@ -36,6 +38,9 @@ class OneCellAnchorXform extends BaseCellAnchorXform {
         else if (model.graphicFrame) {
             this.map["xdr:graphicFrame"].render(xmlStream, model.graphicFrame);
         }
+        else if (model.shape?.kind === "userShape") {
+            this.map["xdr:userShape"].render(xmlStream, model.shape);
+        }
         this.map["xdr:clientData"].render(xmlStream, {});
         xmlStream.closeNode();
     }

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

@@ -25,7 +25,8 @@ class PicXform extends BaseXform {
         this.map["xdr:blipFill"].render(xmlStream, {
             rId: model.rId,
             alphaModFix: model.alphaModFix,
-            external: model.external
+            external: model.external,
+            svgRId: model.svgRId
         });
         this.map["xdr:spPr"].render(xmlStream, model);
         xmlStream.closeNode();