@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/plugins/xlsx/drawing.js

@@ -0,0 +1,941 @@
+import { __assign, __awaiter, __generator, __values } from "tslib";
+import { uuid } from "@rowsncolumns/utils";
+import { get } from "lodash-es";
+/**
+ * Create a data URL from binary data and MIME type
+ * @param data Binary data of the image
+ * @param mimeType MIME type of the image
+ * @returns Data URL string
+ */
+function createDataUrl(data, mimeType) {
+    // Convert ArrayBuffer to Base64 string
+    var base64 = arrayBufferToBase64(data);
+    return "data:".concat(mimeType, ";base64,").concat(base64);
+}
+/**
+ * Convert an ArrayBuffer to a Base64 string
+ * @param buffer ArrayBuffer to convert
+ * @returns Base64 string
+ */
+function arrayBufferToBase64(buffer) {
+    var bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    // Use Buffer in Node.js, btoa in browser
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("base64");
+    }
+    var binary = "";
+    var len = bytes.byteLength;
+    for (var i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+// Conversion constant: 1 pixel is approximately 9525 EMUs (at 96 DPI)
+var EMU_PER_PIXEL = 9525;
+var DEFAULT_CELL_IMAGE_MAX_SIZE_PX = 60;
+var CELL_IMAGE_OFFSET_THRESHOLD_PX = 1;
+/**
+ * Convert EMUs to pixels
+ * @param emuValue Value in English Metric Units
+ * @returns Value in pixels (at 96 DPI)
+ */
+function emuToPixels(emuValue) {
+    return Math.round(emuValue / EMU_PER_PIXEL);
+}
+/**
+ * Process different types of image anchors
+ * @param anchors The anchor elements from the drawing
+ * @param anchorType The type of anchor
+ * @param drawingPath The path to the drawing file
+ * @param sheetName The name of the worksheet
+ * @param zipParser The zip parser instance
+ * @param xmlParser The XML parser instance
+ * @returns An array of image objects with their properties and binary data
+ */
+export function processAnchors(anchors, anchorType, drawingPath, sheetId, zipParser, xmlParser) {
+    return __awaiter(this, void 0, void 0, function () {
+        var images, anchorArray, _loop_1, anchorArray_1, anchorArray_1_1, anchor, e_1_1;
+        var e_1, _a;
+        var _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    images = [];
+                    if (!anchors)
+                        return [2 /*return*/, images];
+                    anchorArray = Array.isArray(anchors) ? anchors : [anchors];
+                    _loop_1 = function (anchor) {
+                        var isInsideCell, position, fromColBase0, fromRowBase0, toColBase0, toRowBase0, fromCol, fromRow, toCol, toRow, fromColOffEmu, fromRowOffEmu, toColOffEmu, toRowOffEmu, fromColOff, fromRowOff, toColOff, toRowOff, cxEmu, cyEmu, width, height, editAs, fromColBase0, fromRowBase0, fromCol, fromRow, fromColOffEmu, fromRowOffEmu, fromColOff, fromRowOff, cxEmu, cyEmu, width, height, fLocksWithSheet, posXEmu, posYEmu, posX, posY, cxEmu, cyEmu, width, height, picture, shape, shapeSpec, cxEmu, cyEmu, rotUnits, txBody, textBoxName, textBoxId, cxEmu, cyEmu, width, height, textBoxSpec, blipRId, imageName, imageId, imageTitle, drawingDir, drawingFilename, drawingRelsPath, drawingRelsContent, drawingRels, imageRelations, imageRel, imageTarget, imagePath, baseDir, imageData, imageExt, imageType;
+                        return __generator(this, function (_d) {
+                            switch (_d.label) {
+                                case 0:
+                                    isInsideCell = false;
+                                    position = {
+                                        sheetId: sheetId,
+                                        // sheet: sheetName,
+                                        // anchorType: anchorType, // Store the anchor type to differentiate positioning
+                                    };
+                                    if (anchorType === "twoCellAnchors") {
+                                        fromColBase0 = parseInt(get(anchor, "xdr:from.xdr:col.t$") ||
+                                            get(anchor, "from.col.t$") ||
+                                            get(anchor, "xdr:from.xdr:col") ||
+                                            get(anchor, "from.col") ||
+                                            "0");
+                                        fromRowBase0 = parseInt(get(anchor, "xdr:from.xdr:row.t$") ||
+                                            get(anchor, "from.row.t$") ||
+                                            get(anchor, "xdr:from.xdr:row") ||
+                                            get(anchor, "from.row") ||
+                                            "0");
+                                        toColBase0 = parseInt(get(anchor, "xdr:to.xdr:col.t$") ||
+                                            get(anchor, "to.col.t$") ||
+                                            get(anchor, "xdr:to.xdr:col") ||
+                                            get(anchor, "to.col") ||
+                                            "0");
+                                        toRowBase0 = parseInt(get(anchor, "xdr:to.xdr:row.t$") ||
+                                            get(anchor, "to.row.t$") ||
+                                            get(anchor, "xdr:to.xdr:row") ||
+                                            get(anchor, "to.row") ||
+                                            "0");
+                                        fromCol = fromColBase0 + 1;
+                                        fromRow = fromRowBase0 + 1;
+                                        toCol = toColBase0 + 1;
+                                        toRow = toRowBase0 + 1;
+                                        fromColOffEmu = parseInt(get(anchor, "xdr:from.xdr:colOff.t$") ||
+                                            get(anchor, "from.colOff.t$") ||
+                                            get(anchor, "xdr:from.xdr:colOff") ||
+                                            get(anchor, "from.colOff") ||
+                                            "0");
+                                        fromRowOffEmu = parseInt(get(anchor, "xdr:from.xdr:rowOff.t$") ||
+                                            get(anchor, "from.rowOff.t$") ||
+                                            get(anchor, "xdr:from.xdr:rowOff") ||
+                                            get(anchor, "from.rowOff") ||
+                                            "0");
+                                        toColOffEmu = parseInt(get(anchor, "xdr:to.xdr:colOff.t$") ||
+                                            get(anchor, "to.colOff.t$") ||
+                                            get(anchor, "xdr:to.xdr:colOff") ||
+                                            get(anchor, "to.colOff") ||
+                                            "0");
+                                        toRowOffEmu = parseInt(get(anchor, "xdr:to.xdr:rowOff.t$") ||
+                                            get(anchor, "to.rowOff.t$") ||
+                                            get(anchor, "xdr:to.xdr:rowOff") ||
+                                            get(anchor, "to.rowOff") ||
+                                            "0");
+                                        fromColOff = emuToPixels(fromColOffEmu);
+                                        fromRowOff = emuToPixels(fromRowOffEmu);
+                                        toColOff = emuToPixels(toColOffEmu);
+                                        toRowOff = emuToPixels(toRowOffEmu);
+                                        cxEmu = parseInt(get(anchor, "xdr:pic.xdr:spPr.a:xfrm.a:ext.a$.cx") ||
+                                            get(anchor, "pic.spPr.xfrm.ext.a$.cx") ||
+                                            "0");
+                                        cyEmu = parseInt(get(anchor, "xdr:pic.xdr:spPr.a:xfrm.a:ext.a$.cy") ||
+                                            get(anchor, "pic.spPr.xfrm.ext.a$.cy") ||
+                                            "0");
+                                        width = emuToPixels(cxEmu);
+                                        height = emuToPixels(cyEmu);
+                                        editAs = get(anchor, "a$.editAs") || "";
+                                        isInsideCell = determineIfTwoCellInsideCell(editAs, fromColBase0, fromRowBase0, toColBase0, toRowBase0);
+                                        position = __assign(__assign({}, position), { overlayPosition: {
+                                                anchorCell: {
+                                                    rowIndex: fromRow,
+                                                    columnIndex: fromCol,
+                                                },
+                                                heightPixels: height,
+                                                widthPixels: width,
+                                                offsetXPixels: fromColOff,
+                                                offsetYPixels: fromRowOff,
+                                            } });
+                                    }
+                                    else if (anchorType === "oneCellAnchor") {
+                                        fromColBase0 = parseInt(get(anchor, "xdr:from.xdr:col.t$") ||
+                                            get(anchor, "from.col.t$") ||
+                                            get(anchor, "xdr:from.xdr:col") ||
+                                            get(anchor, "from.col") ||
+                                            "0");
+                                        fromRowBase0 = parseInt(get(anchor, "xdr:from.xdr:row.t$") ||
+                                            get(anchor, "from.row.t$") ||
+                                            get(anchor, "xdr:from.xdr:row") ||
+                                            get(anchor, "from.row") ||
+                                            "0");
+                                        fromCol = fromColBase0 + 1;
+                                        fromRow = fromRowBase0 + 1;
+                                        fromColOffEmu = parseInt(get(anchor, "xdr:from.xdr:colOff.t$") ||
+                                            get(anchor, "from.colOff.t$") ||
+                                            get(anchor, "xdr:from.xdr:colOff") ||
+                                            get(anchor, "from.colOff") ||
+                                            "0");
+                                        fromRowOffEmu = parseInt(get(anchor, "xdr:from.xdr:rowOff.t$") ||
+                                            get(anchor, "from.rowOff.t$") ||
+                                            get(anchor, "xdr:from.xdr:rowOff") ||
+                                            get(anchor, "from.rowOff") ||
+                                            "0");
+                                        fromColOff = emuToPixels(fromColOffEmu);
+                                        fromRowOff = emuToPixels(fromRowOffEmu);
+                                        cxEmu = parseInt(get(anchor, "xdr:ext.a$.cx") || get(anchor, "ext.a$.cx") || "0");
+                                        cyEmu = parseInt(get(anchor, "xdr:ext.a$.cy") || get(anchor, "ext.a$.cy") || "0");
+                                        width = emuToPixels(cxEmu);
+                                        height = emuToPixels(cyEmu);
+                                        fLocksWithSheet = get(anchor, "xdr:clientData.a$.fLocksWithSheet") ||
+                                            get(anchor, "clientData.a$.fLocksWithSheet") ||
+                                            "0";
+                                        isInsideCell = determineIfOneCellInsideCell(fromColOffEmu, fromRowOffEmu, fLocksWithSheet, cxEmu, cyEmu);
+                                        position = __assign(__assign({}, position), { overlayPosition: {
+                                                anchorCell: {
+                                                    rowIndex: fromRow,
+                                                    columnIndex: fromCol,
+                                                },
+                                                heightPixels: height,
+                                                widthPixels: width,
+                                                offsetXPixels: fromColOff,
+                                                offsetYPixels: fromRowOff,
+                                            } });
+                                        // position = {
+                                        //   ...position,
+                                        //   fromCol,
+                                        //   fromRow,
+                                        //   fromColOff,
+                                        //   fromRowOff,
+                                        //   width,
+                                        //   height,
+                                        //   // Store original indices in case they're needed
+                                        //   _fromColBase0: fromColBase0,
+                                        //   _fromRowBase0: fromRowBase0,
+                                        //   // Store original EMU values for reference if needed
+                                        //   _fromColOffEmu: fromColOffEmu,
+                                        //   _fromRowOffEmu: fromRowOffEmu,
+                                        //   _widthEmu: cxEmu,
+                                        //   _heightEmu: cyEmu,
+                                        //   fLocksWithSheet: fLocksWithSheet === "1",
+                                        //   // For oneCellAnchor, determine based on offsets and locking
+                                        //   isInsideCell: determineIfOneCellInsideCell(
+                                        //     fromColOffEmu,
+                                        //     fromRowOffEmu,
+                                        //     fLocksWithSheet,
+                                        //     cxEmu,
+                                        //     cyEmu
+                                        //   ),
+                                        // };
+                                    }
+                                    else if (anchorType === "absoluteAnchors") {
+                                        posXEmu = parseInt(get(anchor, "xdr:pos.a$.x") || get(anchor, "pos.a$.x") || "0") || 0;
+                                        posYEmu = parseInt(get(anchor, "xdr:pos.a$.y") || get(anchor, "pos.a$.y") || "0") || 0;
+                                        posX = emuToPixels(posXEmu);
+                                        posY = emuToPixels(posYEmu);
+                                        cxEmu = parseInt(get(anchor, "xdr:ext.a$.cx") || get(anchor, "ext.a$.cx") || "0") || 0;
+                                        cyEmu = parseInt(get(anchor, "xdr:ext.a$.cy") || get(anchor, "ext.a$.cy") || "0") || 0;
+                                        width = emuToPixels(cxEmu);
+                                        height = emuToPixels(cyEmu);
+                                        position = __assign(__assign({}, position), { overlayPosition: {
+                                                anchorCell: {
+                                                    rowIndex: 1,
+                                                    columnIndex: 1,
+                                                },
+                                                heightPixels: height,
+                                                widthPixels: width,
+                                                offsetXPixels: posX,
+                                                offsetYPixels: posY,
+                                            } });
+                                    }
+                                    picture = get(anchor, "xdr:pic") || get(anchor, "pic");
+                                    shape = get(anchor, "xdr:sp") || get(anchor, "sp");
+                                    // Drawing shape (Insert → Shapes): parsed into an `EmbedShapeSpec` so the
+                                    // geometry/fill/outline render. A shape is only routed here when it is
+                                    // visibly a *shape* — a non-rect preset geometry, an explicit fill, or an
+                                    // `<xdr:style>` theme-style block. Plain text boxes (`txBox="1"`, or a bare
+                                    // unstyled rect) keep the textbox path below, so they don't inherit the
+                                    // shape renderer's default accent styling.
+                                    if (shape && isDrawingShape(shape)) {
+                                        shapeSpec = parseShapeSpec(shape);
+                                        cxEmu = parseInt(get(shape, "xdr:spPr.a:xfrm.a:ext.a$.cx") ||
+                                            get(shape, "spPr.xfrm.ext.a$.cx") ||
+                                            "0");
+                                        cyEmu = parseInt(get(shape, "xdr:spPr.a:xfrm.a:ext.a$.cy") ||
+                                            get(shape, "spPr.xfrm.ext.a$.cy") ||
+                                            "0");
+                                        if (cxEmu > 0 && cyEmu > 0 && position.overlayPosition) {
+                                            position.overlayPosition.widthPixels = emuToPixels(cxEmu);
+                                            position.overlayPosition.heightPixels = emuToPixels(cyEmu);
+                                        }
+                                        rotUnits = parseInt(get(shape, "xdr:spPr.a:xfrm.a$.rot") ||
+                                            get(shape, "spPr.xfrm.a$.rot") ||
+                                            "0");
+                                        images.push({
+                                            isInsideCell: isInsideCell,
+                                            embedId: uuid(),
+                                            spec: shapeSpec,
+                                            position: position,
+                                            rotation: rotUnits ? rotUnits / 60000 : undefined,
+                                            draggable: true,
+                                        });
+                                        return [2 /*return*/, "continue"];
+                                    }
+                                    // Process textbox if shape has text body
+                                    if (shape) {
+                                        txBody = get(shape, "xdr:txBody") || get(shape, "txBody");
+                                        if (txBody) {
+                                            textBoxName = get(shape, "xdr:nvSpPr.xdr:cNvPr.a$.name") ||
+                                                get(shape, "nvSpPr.cNvPr.a$.name") ||
+                                                "TextBox";
+                                            textBoxId = get(shape, "xdr:nvSpPr.xdr:cNvPr.a$.id") ||
+                                                get(shape, "nvSpPr.cNvPr.a$.id") ||
+                                                "";
+                                            cxEmu = parseInt(get(shape, "xdr:spPr.a:xfrm.a:ext.a$.cx") ||
+                                                get(shape, "spPr.xfrm.ext.a$.cx") ||
+                                                "0");
+                                            cyEmu = parseInt(get(shape, "xdr:spPr.a:xfrm.a:ext.a$.cy") ||
+                                                get(shape, "spPr.xfrm.ext.a$.cy") ||
+                                                "0");
+                                            // Convert EMUs to pixels and override position dimensions if available
+                                            if (cxEmu > 0 && cyEmu > 0) {
+                                                width = emuToPixels(cxEmu);
+                                                height = emuToPixels(cyEmu);
+                                                if (position.overlayPosition) {
+                                                    position.overlayPosition.widthPixels = width;
+                                                    position.overlayPosition.heightPixels = height;
+                                                }
+                                            }
+                                            textBoxSpec = parseTextBoxContent(txBody, shape);
+                                            images.push({
+                                                isInsideCell: isInsideCell,
+                                                embedId: uuid(),
+                                                spec: textBoxSpec,
+                                                position: position,
+                                                draggable: true,
+                                            });
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                    }
+                                    if (!picture)
+                                        return [2 /*return*/, "continue"];
+                                    blipRId = get(picture, "xdr:blipFill.a:blip.a$.embed") ||
+                                        get(picture, "xdr:blipFill.a:blip.a$.r:embed") ||
+                                        get(picture, "blipFill.a:blip.a$.embed") ||
+                                        get(picture, "blipFill.a:blip.a$.r:embed") ||
+                                        get(picture, "blipFill.blip.a$.embed") ||
+                                        get(picture, "blipFill.blip.a$.r:embed");
+                                    if (!blipRId)
+                                        return [2 /*return*/, "continue"];
+                                    imageName = get(picture, "xdr:nvPicPr.xdr:cNvPr.a$.name") ||
+                                        get(picture, "nvPicPr.cNvPr.a$.name") ||
+                                        "Image";
+                                    imageId = get(picture, "xdr:nvPicPr.xdr:cNvPr.a$.id") ||
+                                        get(picture, "nvPicPr.cNvPr.a$.id") ||
+                                        "";
+                                    imageTitle = get(picture, "xdr:nvPicPr.xdr:cNvPr.a$.title") ||
+                                        get(picture, "nvPicPr.cNvPr.a$.title") ||
+                                        "";
+                                    drawingDir = drawingPath.substring(0, drawingPath.lastIndexOf("/"));
+                                    drawingFilename = drawingPath.split("/").pop();
+                                    drawingRelsPath = "".concat(drawingDir, "/_rels/").concat(drawingFilename, ".rels");
+                                    return [4 /*yield*/, zipParser.getText(drawingRelsPath)];
+                                case 1:
+                                    drawingRelsContent = _d.sent();
+                                    if (!drawingRelsContent)
+                                        return [2 /*return*/, "continue"];
+                                    drawingRels = xmlParser.parse(drawingRelsContent);
+                                    imageRelations = get(drawingRels, "Relationships.Relationship");
+                                    if (!imageRelations)
+                                        return [2 /*return*/, "continue"];
+                                    imageRel = Array.isArray(imageRelations)
+                                        ? imageRelations.find(function (rel) { return rel.a$.Id === blipRId; })
+                                        : imageRelations.a$.Id === blipRId
+                                            ? imageRelations
+                                            : null;
+                                    if (!imageRel)
+                                        return [2 /*return*/, "continue"];
+                                    imageTarget = imageRel.a$.Target;
+                                    imagePath = void 0;
+                                    // Handle different path formats
+                                    if (imageTarget.startsWith("/")) {
+                                        // Absolute path from the root of the zip
+                                        imagePath = imageTarget.substring(1);
+                                    }
+                                    else if (imageTarget.startsWith("../")) {
+                                        baseDir = drawingDir.split("/").slice(0, -1).join("/");
+                                        imagePath = "".concat(baseDir, "/").concat(imageTarget.replace("../", ""));
+                                    }
+                                    else {
+                                        // Relative path in the same directory
+                                        imagePath = "".concat(drawingDir, "/").concat(imageTarget);
+                                    }
+                                    return [4 /*yield*/, zipParser.getBinary(imagePath)];
+                                case 2:
+                                    imageData = _d.sent();
+                                    if (!imageData)
+                                        return [2 /*return*/, "continue"];
+                                    imageExt = ((_b = imagePath.split(".").pop()) === null || _b === void 0 ? void 0 : _b.toLowerCase()) || "";
+                                    imageType = "image/".concat(imageExt === "jpg" ? "jpeg" : imageExt);
+                                    // Add the image to our collection
+                                    images.push({
+                                        isInsideCell: isInsideCell,
+                                        embedId: uuid(),
+                                        spec: {
+                                            id: imageId,
+                                            imageUrl: createDataUrl(imageData, imageType),
+                                            type: "image",
+                                            description: imageName,
+                                        },
+                                        position: position,
+                                        draggable: true,
+                                        lockAspectRatio: true,
+                                    });
+                                    return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 6, 7, 8]);
+                    anchorArray_1 = __values(anchorArray), anchorArray_1_1 = anchorArray_1.next();
+                    _c.label = 2;
+                case 2:
+                    if (!!anchorArray_1_1.done) return [3 /*break*/, 5];
+                    anchor = anchorArray_1_1.value;
+                    return [5 /*yield**/, _loop_1(anchor)];
+                case 3:
+                    _c.sent();
+                    _c.label = 4;
+                case 4:
+                    anchorArray_1_1 = anchorArray_1.next();
+                    return [3 /*break*/, 2];
+                case 5: return [3 /*break*/, 8];
+                case 6:
+                    e_1_1 = _c.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 8];
+                case 7:
+                    try {
+                        if (anchorArray_1_1 && !anchorArray_1_1.done && (_a = anchorArray_1.return)) _a.call(anchorArray_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 8: return [2 /*return*/, images];
+            }
+        });
+    });
+}
+/**
+ * Parse color from DrawingML color element
+ * Supports both RGB (srgbClr) and theme colors (schemeClr)
+ */
+function parseDrawingColor(colorElement) {
+    if (!colorElement)
+        return undefined;
+    // RGB color
+    var srgbClr = get(colorElement, "a:srgbClr.a$.val");
+    if (srgbClr) {
+        return "#".concat(srgbClr);
+    }
+    // Theme color - map to approximate RGB values
+    var schemeClr = get(colorElement, "a:schemeClr.a$.val");
+    if (schemeClr) {
+        // Basic theme color mapping (Office theme defaults)
+        var themeColorMap = {
+            accent1: "#4472C4",
+            accent2: "#ED7D31",
+            accent3: "#A5A5A5",
+            accent4: "#FFC000",
+            accent5: "#5B9BD5",
+            accent6: "#70AD47",
+            dk1: "#000000",
+            lt1: "#FFFFFF",
+            dk2: "#44546A",
+            lt2: "#E7E6E6",
+            hlink: "#0563C1",
+            folHlink: "#954F72",
+        };
+        return themeColorMap[schemeClr] || "#000000";
+    }
+    return undefined;
+}
+var toArray = function (value) {
+    return Array.isArray(value) ? value : value ? [value] : [];
+};
+/** DrawingML scheme-color names → the spreadsheet theme's ColorIndex slots. */
+var SCHEME_TO_THEME_INDEX = {
+    bg1: 0,
+    lt1: 0,
+    tx1: 1,
+    dk1: 1,
+    bg2: 2,
+    lt2: 2,
+    tx2: 3,
+    dk2: 3,
+    accent1: 4,
+    accent2: 5,
+    accent3: 6,
+    accent4: 7,
+    accent5: 8,
+    accent6: 9,
+    hlink: 10,
+};
+/** OOXML preset names → the renderer's preset union where they differ. */
+var PRESET_RENAMES = {
+    rtTriangle: "rightTriangle",
+    snip1Rect: "snipSingleCornerRect",
+};
+/**
+ * Parse a DrawingML color element into a `Color` — a live theme reference
+ * (`{ theme, tint }`) for `<a:schemeClr>` (so the shape follows document theme
+ * changes, unlike {@link parseDrawingColor}'s baked-in hex), or a hex string
+ * for `<a:srgbClr>`. Luminance/tint modifiers map onto the theme tint:
+ * `lumOff`/`tint` lighten (accent1 "lighter 40%" = lumMod 60000 + lumOff 40000
+ * → tint 0.4), `shade`/`lumMod`-only darken.
+ */
+function parseDrawingColorValue(colorElement) {
+    if (!colorElement)
+        return undefined;
+    var srgbClr = get(colorElement, "a:srgbClr.a$.val");
+    if (srgbClr)
+        return "#".concat(srgbClr);
+    var schemeClr = get(colorElement, "a:schemeClr");
+    var schemeVal = get(schemeClr, "a$.val");
+    if (schemeVal) {
+        var theme = SCHEME_TO_THEME_INDEX[schemeVal];
+        if (theme === undefined) {
+            // Unmapped scheme name (e.g. folHlink): fall back to the baked hex.
+            return parseDrawingColor(colorElement);
+        }
+        var lumOff = parseInt(get(schemeClr, "a:lumOff.a$.val") || "0");
+        var tintVal = parseInt(get(schemeClr, "a:tint.a$.val") || "0");
+        var shade = parseInt(get(schemeClr, "a:shade.a$.val") || "0");
+        var lumMod = parseInt(get(schemeClr, "a:lumMod.a$.val") || "0");
+        var tint = void 0;
+        if (lumOff > 0)
+            tint = lumOff / 100000;
+        else if (tintVal > 0)
+            tint = tintVal / 100000;
+        else if (shade > 0)
+            tint = -(1 - shade / 100000);
+        else if (lumMod > 0 && lumMod < 100000)
+            tint = -(1 - lumMod / 100000);
+        return tint !== undefined ? { theme: theme, tint: tint } : { theme: theme };
+    }
+    return undefined;
+}
+/** `<a:alpha val>` (1/100000) under a color element → 0–1 opacity, if reduced. */
+function parseColorOpacity(colorElement) {
+    var alpha = parseInt(get(colorElement, "a:srgbClr.a:alpha.a$.val") ||
+        get(colorElement, "a:schemeClr.a:alpha.a$.val") ||
+        "0");
+    return alpha > 0 && alpha < 100000 ? alpha / 100000 : undefined;
+}
+/** `<a:prstGeom>` → geometry preset + `<a:avLst>` adjust guides. */
+function parseShapeGeometry(spPr) {
+    var e_2, _a;
+    var _b;
+    var prstGeom = get(spPr, "a:prstGeom");
+    var prst = get(prstGeom, "a$.prst");
+    if (!prst)
+        return undefined;
+    var adjustments;
+    try {
+        for (var _c = __values(toArray(get(prstGeom, "a:avLst.a:gd"))), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var gd = _d.value;
+            var name_1 = get(gd, "a$.name");
+            var fmla = get(gd, "a$.fmla") || "";
+            var match = /^val\s+(-?\d+)$/.exec(fmla);
+            if (name_1 && match) {
+                (adjustments !== null && adjustments !== void 0 ? adjustments : (adjustments = {}))[name_1] = parseInt(match[1]);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return { preset: (_b = PRESET_RENAMES[prst]) !== null && _b !== void 0 ? _b : prst, adjustments: adjustments };
+}
+/** Empty elements (`<a:noFill/>`) parse to `""` — presence must not be truthiness. */
+var hasElement = function (obj, path) {
+    return get(obj, path) !== undefined;
+};
+/** Explicit `<a:noFill>`/`<a:solidFill>`/`<a:gradFill>` on `spPr` (style refs are separate). */
+function parseShapeFill(spPr) {
+    if (hasElement(spPr, "a:noFill"))
+        return { kind: "none" };
+    var solidFill = get(spPr, "a:solidFill");
+    if (solidFill) {
+        var color = parseDrawingColorValue(solidFill);
+        if (color) {
+            return { kind: "solid", color: color, opacity: parseColorOpacity(solidFill) };
+        }
+    }
+    var gradFill = get(spPr, "a:gradFill");
+    if (gradFill) {
+        var stops = toArray(get(gradFill, "a:gsLst.a:gs"))
+            .map(function (gs) {
+            var _a;
+            return ({
+                position: parseInt(get(gs, "a$.pos") || "0") / 100000,
+                color: (_a = parseDrawingColorValue(gs)) !== null && _a !== void 0 ? _a : "#FFFFFF",
+                opacity: parseColorOpacity(gs),
+            });
+        })
+            .sort(function (a, b) { return a.position - b.position; });
+        if (stops.length) {
+            var ang = parseInt(get(gradFill, "a:lin.a$.ang") || "0");
+            return {
+                kind: "gradient",
+                stops: stops,
+                angle: ang ? ang / 60000 : 90,
+                shading: get(gradFill, "a:path") ? "radial" : "linear",
+            };
+        }
+    }
+    return undefined;
+}
+var DASH_RENAMES = {
+    solid: "solid",
+    dot: "dot",
+    sysDot: "dot",
+    dash: "dash",
+    sysDash: "dash",
+    dashDot: "dashDot",
+    sysDashDot: "dashDot",
+    lgDash: "longDash",
+    lgDashDot: "longDashDot",
+    lgDashDotDot: "longDashDotDot",
+};
+/** `<a:ln>` → outline; `<a:noFill>` inside it means explicitly strokeless (width 0). */
+function parseShapeOutline(spPr) {
+    var ln = get(spPr, "a:ln");
+    if (ln === undefined)
+        return undefined;
+    if (hasElement(ln, "a:noFill"))
+        return { width: 0 };
+    var solidFill = get(ln, "a:solidFill");
+    var color = parseDrawingColorValue(solidFill);
+    var wEmu = parseInt(get(ln, "a$.w") || "0");
+    var dashVal = get(ln, "a:prstDash.a$.val");
+    if (!color && !wEmu && !dashVal)
+        return undefined;
+    return {
+        color: color,
+        width: wEmu ? emuToPixels(wEmu) : undefined,
+        dash: dashVal ? DASH_RENAMES[dashVal] : undefined,
+        opacity: solidFill ? parseColorOpacity(solidFill) : undefined,
+    };
+}
+/** `<a:effectLst><a:outerShdw>` → drop shadow (distance+direction → x/y offsets). */
+function parseShapeShadow(spPr) {
+    var shdw = get(spPr, "a:effectLst.a:outerShdw");
+    if (!shdw)
+        return undefined;
+    var distPx = emuToPixels(parseInt(get(shdw, "a$.dist") || "0"));
+    var dirRad = (parseInt(get(shdw, "a$.dir") || "0") / 60000) * (Math.PI / 180);
+    var blurRad = parseInt(get(shdw, "a$.blurRad") || "0");
+    return {
+        color: parseDrawingColorValue(shdw),
+        opacity: parseColorOpacity(shdw),
+        blurRadius: blurRad ? emuToPixels(blurRad) : undefined,
+        offsetXPixels: distPx ? Math.round(Math.cos(dirRad) * distPx) : undefined,
+        offsetYPixels: distPx ? Math.round(Math.sin(dirRad) * distPx) : undefined,
+    };
+}
+/** `<xdr:style>` fill/line/effect/font references into the theme format scheme. */
+function parseShapeStyleRefs(shape) {
+    var style = get(shape, "xdr:style") || get(shape, "style");
+    if (!style)
+        return undefined;
+    var parseRef = function (name) {
+        var ref = get(style, name);
+        if (!ref)
+            return undefined;
+        var index = parseInt(get(ref, "a$.idx") || "0");
+        var color = parseDrawingColorValue(ref);
+        return color ? { index: index, color: color } : undefined;
+    };
+    var refs = {
+        fill: parseRef("a:fillRef"),
+        line: parseRef("a:lnRef"),
+        effect: parseRef("a:effectRef"),
+    };
+    var fontRef = get(style, "a:fontRef");
+    if (fontRef) {
+        var scheme = get(fontRef, "a$.idx");
+        if (scheme === "major" || scheme === "minor") {
+            refs.font = { scheme: scheme, color: parseDrawingColorValue(fontRef) };
+        }
+    }
+    return refs.fill || refs.line || refs.effect || refs.font ? refs : undefined;
+}
+/**
+ * Whether an `<xdr:sp>` should import as a drawing shape (`EmbedShapeSpec`)
+ * rather than a textbox. Text boxes are excluded explicitly (`txBox="1"`), and
+ * a rect with no `<xdr:style>` block stays a textbox too — routing those to
+ * the shape renderer would repaint plain text notes with the default accent
+ * shape style.
+ */
+export function isDrawingShape(shape) {
+    var txBox = get(shape, "xdr:nvSpPr.xdr:cNvSpPr.a$.txBox") ||
+        get(shape, "nvSpPr.cNvSpPr.a$.txBox");
+    if (txBox === "1" || txBox === true)
+        return false;
+    var spPr = get(shape, "xdr:spPr") || get(shape, "spPr");
+    var preset = get(spPr, "a:prstGeom.a$.prst");
+    if (preset && preset !== "rect")
+        return true;
+    return hasElement(shape, "xdr:style") || hasElement(shape, "style");
+}
+/** Parse an `<xdr:sp>` drawing shape into an {@link EmbedShapeSpec}. */
+export function parseShapeSpec(shape) {
+    var _a, _b, _c;
+    var spPr = get(shape, "xdr:spPr") || get(shape, "spPr");
+    var name = get(shape, "xdr:nvSpPr.xdr:cNvPr.a$.name") ||
+        get(shape, "nvSpPr.cNvPr.a$.name");
+    // Shape text rides the textbox content model; box-level background/borders
+    // are shape fill/outline concerns, so only the text fields carry over. An
+    // empty text body (Excel writes one on every shape) is omitted entirely.
+    var textBody;
+    var txBody = get(shape, "xdr:txBody") || get(shape, "txBody");
+    if (txBody) {
+        var tb = parseTextBoxContent(txBody, shape);
+        var hasText = Boolean((_a = tb.text) === null || _a === void 0 ? void 0 : _a.trim()) ||
+            Boolean((_b = tb.richText) === null || _b === void 0 ? void 0 : _b.some(function (run) { return run.text.trim(); }));
+        if (hasText) {
+            textBody = {
+                text: tb.text,
+                richText: tb.richText,
+                textFormat: tb.textFormat,
+                verticalAlignment: tb.verticalAlignment,
+                horizontalAlignment: tb.horizontalAlignment,
+                wrapStrategy: tb.wrapStrategy,
+                textRotation: tb.textRotation,
+                padding: tb.padding,
+            };
+        }
+    }
+    var xfrm = get(spPr, "a:xfrm");
+    var flipH = get(xfrm, "a$.flipH");
+    var flipV = get(xfrm, "a$.flipV");
+    return {
+        type: "shape",
+        name: name,
+        geometry: (_c = parseShapeGeometry(spPr)) !== null && _c !== void 0 ? _c : { preset: "rect" },
+        fill: parseShapeFill(spPr),
+        outline: parseShapeOutline(spPr),
+        shadow: parseShapeShadow(spPr),
+        styleRefs: parseShapeStyleRefs(shape),
+        textBody: textBody,
+        flipHorizontal: flipH === "1" || flipH === true ? true : undefined,
+        flipVertical: flipV === "1" || flipV === true ? true : undefined,
+    };
+}
+/**
+ * Parse textbox content from DrawingML text body
+ * @param txBody The text body element from DrawingML
+ * @param shape The shape element containing formatting properties
+ * @returns EmbedTextBoxSpec object
+ */
+function parseTextBoxContent(txBody, shape) {
+    var e_3, _a, e_4, _b;
+    var richText = [];
+    var plainText = "";
+    // Get paragraphs
+    var paragraphs = get(txBody, "a:p") || [];
+    var paragraphArray = Array.isArray(paragraphs) ? paragraphs : [paragraphs];
+    try {
+        for (var paragraphArray_1 = __values(paragraphArray), paragraphArray_1_1 = paragraphArray_1.next(); !paragraphArray_1_1.done; paragraphArray_1_1 = paragraphArray_1.next()) {
+            var paragraph = paragraphArray_1_1.value;
+            // Extract paragraph properties for indentation and bullets
+            var pPr = get(paragraph, "a:pPr") || {};
+            var indentEmu = parseInt(get(pPr, "a$.marL") || get(pPr, "a$.indent") || "0");
+            // Convert EMUs to approximate character spaces (roughly 90000 EMUs ≈ 1 character space)
+            var indentSpaces = Math.round(indentEmu / 90000);
+            // Check for bullets
+            var bulletChar = "";
+            var buChar = get(pPr, "a:buChar.a$.char");
+            var buAutoNum = get(pPr, "a:buAutoNum");
+            var buNone = get(pPr, "a:buNone");
+            if (!buNone) {
+                if (buChar) {
+                    // Custom bullet character (e.g., "•", "-", etc.)
+                    bulletChar = buChar + " ";
+                }
+                else if (buAutoNum) {
+                    // Auto-numbered bullets (would need context to track numbering)
+                    bulletChar = "• ";
+                }
+            }
+            // Get text runs
+            var runs = get(paragraph, "a:r") || [];
+            var runArray = Array.isArray(runs) ? runs : runs ? [runs] : [];
+            // Add indentation and bullet to the first run of the paragraph
+            var isFirstRun = true;
+            try {
+                for (var runArray_1 = (e_4 = void 0, __values(runArray)), runArray_1_1 = runArray_1.next(); !runArray_1_1.done; runArray_1_1 = runArray_1.next()) {
+                    var run = runArray_1_1.value;
+                    var text = get(run, "a:t.t$") || get(run, "a:t") || "";
+                    // Handle tab characters
+                    var tabElements = get(run, "a:tab");
+                    if (tabElements) {
+                        var tabCount = Array.isArray(tabElements) ? tabElements.length : 1;
+                        text = "\t".repeat(tabCount) + text;
+                    }
+                    // Add indentation and bullet to the first run
+                    if (isFirstRun) {
+                        if (indentSpaces > 0) {
+                            var indent = " ".repeat(indentSpaces);
+                            text = indent + text;
+                        }
+                        if (bulletChar) {
+                            text = bulletChar + text;
+                        }
+                        isFirstRun = false;
+                    }
+                    plainText += text;
+                    // Parse run properties
+                    var rPr = get(run, "a:rPr") || {};
+                    var format = {};
+                    // Font size (in points * 100, e.g., 1100 = 11pt)
+                    var sz = parseInt(get(rPr, "a$.sz") || "0");
+                    if (sz > 0) {
+                        format.fontSize = sz / 100;
+                    }
+                    // Bold
+                    var bold = get(rPr, "a$.b");
+                    if (bold === "1" || bold === true) {
+                        format.bold = true;
+                    }
+                    // Italic
+                    var italic = get(rPr, "a$.i");
+                    if (italic === "1" || italic === true) {
+                        format.italic = true;
+                    }
+                    // Underline
+                    var underline = get(rPr, "a$.u");
+                    if (underline && underline !== "none") {
+                        format.underline = true;
+                    }
+                    // Strikethrough
+                    var strike = get(rPr, "a$.strike");
+                    if (strike && strike !== "noStrike") {
+                        format.strikethrough = true;
+                    }
+                    // Font family
+                    var fontFamily = get(rPr, "a:latin.a$.typeface");
+                    if (fontFamily) {
+                        format.fontFamily = fontFamily;
+                    }
+                    // Text color (supports RGB and theme colors)
+                    var solidFill_1 = get(rPr, "a:solidFill");
+                    var color = parseDrawingColor(solidFill_1);
+                    if (color) {
+                        format.color = color;
+                    }
+                    richText.push({
+                        text: text,
+                        format: Object.keys(format).length > 0 ? format : undefined,
+                    });
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (runArray_1_1 && !runArray_1_1.done && (_b = runArray_1.return)) _b.call(runArray_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            // Add paragraph break (newline) between paragraphs
+            if (paragraphArray.indexOf(paragraph) < paragraphArray.length - 1) {
+                plainText += "\n";
+                richText.push({ text: "\n" });
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (paragraphArray_1_1 && !paragraphArray_1_1.done && (_a = paragraphArray_1.return)) _a.call(paragraphArray_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // Get shape properties for background, borders, etc.
+    var spPr = get(shape, "xdr:spPr") || get(shape, "spPr");
+    var spec = {
+        type: "textbox",
+        text: plainText,
+        richText: richText.length > 0 ? richText : undefined,
+    };
+    // Parse background color (supports RGB and theme colors)
+    var solidFill = get(spPr, "a:solidFill");
+    var bgColor = parseDrawingColor(solidFill);
+    if (bgColor) {
+        spec.backgroundColor = bgColor;
+    }
+    // Parse text alignment and other properties from body properties
+    var bodyPr = get(txBody, "a:bodyPr") || {};
+    var anchor = get(bodyPr, "a$.anchor");
+    if (anchor) {
+        // Map DrawingML anchor to our vertical alignment
+        var anchorMap = {
+            t: "top",
+            ctr: "middle",
+            b: "bottom",
+        };
+        spec.verticalAlignment = anchorMap[anchor];
+    }
+    // Parse wrap strategy
+    var wrap = get(bodyPr, "a$.wrap");
+    if (wrap) {
+        var wrapMap = {
+            square: "wrap",
+            none: "overflow",
+        };
+        spec.wrapStrategy = wrapMap[wrap];
+    }
+    // Parse padding (insets) - convert from EMUs to pixels
+    var lIns = parseInt(get(bodyPr, "a$.lIns") || "0");
+    var rIns = parseInt(get(bodyPr, "a$.rIns") || "0");
+    var tIns = parseInt(get(bodyPr, "a$.tIns") || "0");
+    var bIns = parseInt(get(bodyPr, "a$.bIns") || "0");
+    // Use average of insets as padding (or could store separately if needed)
+    var avgPadding = (lIns + rIns + tIns + bIns) / 4;
+    if (avgPadding > 0) {
+        spec.padding = emuToPixels(avgPadding);
+    }
+    return spec;
+}
+/**
+ * Determine if a two-cell anchored image is inside a cell
+ * @param editAs The editAs attribute value
+ * @param fromCol From column
+ * @param fromRow From row
+ * @param toCol To column
+ * @param toRow To row
+ * @returns Boolean indicating if image is inside a cell
+ */
+function determineIfTwoCellInsideCell(editAs, fromCol, fromRow, toCol, toRow) {
+    // Two-cell anchors represent floating images in Excel. We only mark them as
+    // "cell" content when the rectangle is constrained to a single cell.
+    return fromCol === toCol && fromRow === toRow;
+}
+/**
+ * Determine if a oneCellAnchor image is inside a cell
+ * Using EMU values for accurate assessment
+ * @param fromColOff Column offset in EMUs
+ * @param fromRowOff Row offset in EMUs
+ * @param fLocksWithSheet Whether image locks with sheet
+ * @param cx Image width in EMUs
+ * @param cy Image height in EMUs
+ * @returns Boolean indicating if the image is inside a cell
+ */
+export function determineIfOneCellInsideCell(fromColOff, fromRowOff, fLocksWithSheet, cx, cy) {
+    var widthPixels = emuToPixels(Math.max(0, cx));
+    var heightPixels = emuToPixels(Math.max(0, cy));
+    var exceedsCellSize = (!!widthPixels && widthPixels > DEFAULT_CELL_IMAGE_MAX_SIZE_PX) ||
+        (!!heightPixels && heightPixels > DEFAULT_CELL_IMAGE_MAX_SIZE_PX);
+    if (exceedsCellSize) {
+        return false;
+    }
+    if (fLocksWithSheet === "1") {
+        return true;
+    }
+    var offsetXPixels = Math.abs(emuToPixels(fromColOff));
+    var offsetYPixels = Math.abs(emuToPixels(fromRowOff));
+    return (offsetXPixels <= CELL_IMAGE_OFFSET_THRESHOLD_PX &&
+        offsetYPixels <= CELL_IMAGE_OFFSET_THRESHOLD_PX);
+}