@rowsncolumns/toolkit 24.4.1

package/dist/cjs/excel-parser/plugins/xlsx/data-validations.js

@@ -0,0 +1,515 @@
+import { __assign, __read, __spreadArray, __values } from "tslib";
+import { addressToSelection, checkIfStringIsReference, cellToAddress, } from "@rowsncolumns/utils";
+import { uuid } from "@rowsncolumns/utils";
+import { get } from "lodash-es";
+var formatSheetName = function (sheetName) {
+    if (!sheetName) {
+        return "";
+    }
+    return "'".concat(sheetName.replace(/'/g, "''"), "'");
+};
+var ensureSheetReference = function (reference, sheetName) {
+    if (!sheetName || reference.includes("!")) {
+        return reference;
+    }
+    var prefix = formatSheetName(sheetName);
+    return "".concat(prefix, "!").concat(reference);
+};
+var extractFormulaText = function (entry) {
+    if (entry === undefined || entry === null) {
+        return undefined;
+    }
+    if (typeof entry === "string" || typeof entry === "number") {
+        return String(entry);
+    }
+    if (typeof entry === "object") {
+        if (typeof entry.t$ === "string") {
+            return entry.t$;
+        }
+        if (typeof entry._ === "string") {
+            return entry._;
+        }
+        if (typeof entry["#text"] === "string") {
+            return entry["#text"];
+        }
+    }
+    return undefined;
+};
+var normalizeFormulaText = function (entry) {
+    var text = extractFormulaText(entry);
+    if (text === undefined) {
+        return undefined;
+    }
+    var trimmed = text.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+};
+var normalizeOperator = function (operator, hasSecondValue) { return operator || (hasSecondValue ? "between" : "equal"); };
+var mapNumberOperatorToCondition = function (operator, hasSecondValue) {
+    var normalized = normalizeOperator(operator, hasSecondValue);
+    var operatorMap = {
+        between: "NUMBER_BETWEEN",
+        notBetween: "NUMBER_NOT_BETWEEN",
+        equal: "NUMBER_EQ",
+        notEqual: "NUMBER_NOT_EQ",
+        greaterThan: "NUMBER_GREATER",
+        greaterThanOrEqual: "NUMBER_GREATER_THAN_EQ",
+        lessThan: "NUMBER_LESS",
+        lessThanOrEqual: "NUMBER_LESS_THAN_EQ",
+    };
+    return operatorMap[normalized];
+};
+var mapDateOperatorToCondition = function (operator, hasSecondValue) {
+    var normalized = normalizeOperator(operator, hasSecondValue);
+    var operatorMap = {
+        between: "DATE_BETWEEN",
+        notBetween: "DATE_NOT_BETWEEN",
+        equal: "DATE_EQ",
+        notEqual: "DATE_NOT_EQ",
+        greaterThan: "DATE_AFTER",
+        greaterThanOrEqual: "DATE_ON_OR_AFTER",
+        lessThan: "DATE_BEFORE",
+        lessThanOrEqual: "DATE_ON_OR_BEFORE",
+    };
+    return operatorMap[normalized];
+};
+var buildTextLengthFormula = function (operator, baseCellRef, fromExpr, toExpr) {
+    var lenExpr = "LEN(".concat(baseCellRef, ")");
+    var normalized = normalizeOperator(operator, Boolean(toExpr));
+    if (!fromExpr && normalized !== "between" && normalized !== "notBetween") {
+        return undefined;
+    }
+    switch (normalized) {
+        case "between":
+            if (!fromExpr || !toExpr)
+                return undefined;
+            return "AND(".concat(lenExpr, ">=").concat(fromExpr, ",").concat(lenExpr, "<=").concat(toExpr, ")");
+        case "notBetween":
+            if (!fromExpr || !toExpr)
+                return undefined;
+            return "OR(".concat(lenExpr, "<").concat(fromExpr, ",").concat(lenExpr, ">").concat(toExpr, ")");
+        case "equal":
+            return "".concat(lenExpr, "=").concat(fromExpr);
+        case "notEqual":
+            return "".concat(lenExpr, "<>").concat(fromExpr);
+        case "greaterThan":
+            return "".concat(lenExpr, ">").concat(fromExpr);
+        case "greaterThanOrEqual":
+            return "".concat(lenExpr, ">=").concat(fromExpr);
+        case "lessThan":
+            return "".concat(lenExpr, "<").concat(fromExpr);
+        case "lessThanOrEqual":
+            return "".concat(lenExpr, "<=").concat(fromExpr);
+        default:
+            return undefined;
+    }
+};
+var mapErrorStyle = function (style) {
+    if (!style)
+        return "stop";
+    if (style === "warning")
+        return "warning";
+    if (style === "information")
+        return "information";
+    return "stop";
+};
+var NUMBER_VALIDATION_TYPES = new Set(["whole", "decimal", "time"]);
+var escapeRegExp = function (value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+};
+var parseListValues = function (raw) {
+    var trimmed = raw.trim();
+    if (!trimmed)
+        return [];
+    return [parseTextLiteral(trimmed)];
+};
+var parseTextLiteral = function (raw) {
+    var trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replace(/""/g, '"');
+    }
+    return trimmed;
+};
+var parseCustomValidationFormula = function (rawFormula, baseCellRef) {
+    var formula = rawFormula.trim().startsWith("=")
+        ? rawFormula.trim().slice(1)
+        : rawFormula.trim();
+    if (!formula)
+        return undefined;
+    var baseMatch = /^([A-Z]+)(\d+)$/i.exec(baseCellRef);
+    var baseRefPattern = baseMatch
+        ? "\\$?".concat(baseMatch[1], "\\$?").concat(baseMatch[2])
+        : escapeRegExp(baseCellRef);
+    var basePattern = "(?:".concat(baseRefPattern, "|INDIRECT\\(\"RC\",FALSE\\))");
+    var textContains = new RegExp("^ISNUMBER\\(SEARCH\\((.+),\\s*".concat(basePattern, "\\)\\)$"), "i");
+    var textNotContains = new RegExp("^ISERROR\\(SEARCH\\((.+),\\s*".concat(basePattern, "\\)\\)$"), "i");
+    var textStartsWith = new RegExp("^LEFT\\(".concat(basePattern, ",LEN\\((.+)\\)\\)=(.+)$"), "i");
+    var textEndsWith = new RegExp("^RIGHT\\(".concat(basePattern, ",LEN\\((.+)\\)\\)=(.+)$"), "i");
+    var textIsEmail = new RegExp("^AND\\(ISNUMBER\\(SEARCH\\(\"@\",".concat(basePattern, "\\)\\),ISNUMBER\\(SEARCH\\(\"\\.\",").concat(basePattern, "\\)\\)\\)$"), "i");
+    var textIsUrl = new RegExp("^OR\\(LEFT\\(".concat(basePattern, ",7\\)=\"http://\",LEFT\\(").concat(basePattern, ",8\\)=\"https://\"\\)$"), "i");
+    var blank = new RegExp("^".concat(basePattern, "=\"\"$"), "i");
+    var notBlank = new RegExp("^".concat(basePattern, "<>\"\"$"), "i");
+    var boolean = new RegExp("^OR\\(".concat(basePattern, "=TRUE,").concat(basePattern, "=FALSE\\)$"), "i");
+    var dateIsValid = new RegExp("^ISNUMBER\\(".concat(basePattern, "\\)$"), "i");
+    var previousNumber = new RegExp("^IFERROR\\(".concat(basePattern, "\\s*(>=|<=|>|<)\\s*INDIRECT\\(\"R\\[-1\\]C\",FALSE\\),TRUE\\)$"), "i");
+    var oneOfRange = new RegExp("^COUNTIF\\((.+),\\s*".concat(basePattern, "\\)\\s*>\\s*0$"), "i");
+    var oneOfList = new RegExp("^OR\\((.+)\\)$", "i");
+    var match = formula.match(textContains);
+    if (match) {
+        var value = parseTextLiteral(match[1]);
+        return value
+            ? { type: "TEXT_CONTAINS", values: [{ userEnteredValue: value }] }
+            : undefined;
+    }
+    match = formula.match(textNotContains);
+    if (match) {
+        var value = parseTextLiteral(match[1]);
+        return value
+            ? { type: "TEXT_NOT_CONTAINS", values: [{ userEnteredValue: value }] }
+            : undefined;
+    }
+    match = formula.match(textStartsWith);
+    if (match) {
+        var value = parseTextLiteral(match[1]);
+        return value
+            ? { type: "TEXT_STARTS_WITH", values: [{ userEnteredValue: value }] }
+            : undefined;
+    }
+    match = formula.match(textEndsWith);
+    if (match) {
+        var value = parseTextLiteral(match[1]);
+        return value
+            ? { type: "TEXT_ENDS_WITH", values: [{ userEnteredValue: value }] }
+            : undefined;
+    }
+    if (textIsEmail.test(formula)) {
+        return { type: "TEXT_IS_EMAIL", values: [] };
+    }
+    if (textIsUrl.test(formula)) {
+        return { type: "TEXT_IS_URL", values: [] };
+    }
+    if (blank.test(formula)) {
+        return { type: "BLANK", values: [] };
+    }
+    if (notBlank.test(formula)) {
+        return { type: "NOT_BLANK", values: [] };
+    }
+    if (boolean.test(formula)) {
+        return { type: "BOOLEAN", values: [] };
+    }
+    if (dateIsValid.test(formula)) {
+        return { type: "DATE_IS_VALID", values: [] };
+    }
+    match = formula.match(previousNumber);
+    if (match) {
+        var op = match[1];
+        var opMap = {
+            ">": "NUMBER_GREATER_THAN_PREVIOUS",
+            ">=": "NUMBER_GREATER_THAN_EQ_PREVIOUS",
+            "<": "NUMBER_LESS_THAN_PREVIOUS",
+            "<=": "NUMBER_LESS_THAN_EQ_PREVIOUS",
+        };
+        var type = opMap[op];
+        return type ? { type: type, values: [] } : undefined;
+    }
+    match = formula.match(oneOfRange);
+    if (match) {
+        var rangeRef = match[1].trim();
+        return rangeRef
+            ? { type: "ONE_OF_RANGE", values: [{ userEnteredValue: rangeRef }] }
+            : undefined;
+    }
+    match = formula.match(oneOfList);
+    if (match) {
+        var entries = [];
+        var entryRegex = new RegExp("".concat(basePattern, "\\s*=\\s*([^,\\)]+)"), "gi");
+        var entryMatch = void 0;
+        while ((entryMatch = entryRegex.exec(match[1]))) {
+            var value = parseTextLiteral(entryMatch[1]);
+            if (value) {
+                entries.push({ userEnteredValue: value });
+            }
+        }
+        if (entries.length) {
+            return { type: "ONE_OF_LIST", values: entries };
+        }
+    }
+    return undefined;
+};
+export var getDataValidationsForSheet = function (workbook, sheetId, sheet_data, sheetName) {
+    var e_1, _a;
+    var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    var dataValidations = [];
+    // Handle both with and without namespace prefix
+    var validation = get(sheet_data, "worksheet.dataValidations.dataValidation") ||
+        get(sheet_data, "x:worksheet.x:dataValidations.x:dataValidation") ||
+        [];
+    var validations = Array.isArray(validation) ? validation : [validation];
+    // x14 (worksheet-extLst) validations — what Excel writes when a list rule's
+    // source lives on ANOTHER sheet. Ranges arrive via the `<xm:sqref>` CHILD
+    // (not the classic `sqref` attribute) and formulas via
+    // `<x14:formula1>/<xm:f>`. Normalize each into the classic node shape so
+    // the mapping loop below handles both forms identically.
+    var extEntry = get(sheet_data, "worksheet.extLst.ext") ||
+        get(sheet_data, "x:worksheet.x:extLst.x:ext") ||
+        [];
+    var exts = Array.isArray(extEntry) ? extEntry : [extEntry];
+    var x14Rules = exts
+        .flatMap(function (ext) {
+        var block = get(ext, "x14:dataValidations.x14:dataValidation") ||
+            get(ext, "dataValidations.dataValidation");
+        return block ? (Array.isArray(block) ? block : [block]) : [];
+    })
+        .map(function (node) {
+        var _a, _b, _c, _d;
+        var sqrefEntry = (_a = node === null || node === void 0 ? void 0 : node["xm:sqref"]) !== null && _a !== void 0 ? _a : node === null || node === void 0 ? void 0 : node.sqref;
+        var sqref = (Array.isArray(sqrefEntry) ? sqrefEntry : [sqrefEntry])
+            .map(function (entry) { var _a; return (_a = extractFormulaText(entry)) === null || _a === void 0 ? void 0 : _a.trim(); })
+            .filter(Boolean)
+            .join(" ");
+        if (!sqref) {
+            return undefined;
+        }
+        var formulaText = function (formulaNode) {
+            var _a, _b;
+            if (formulaNode === undefined || formulaNode === null) {
+                return undefined;
+            }
+            return extractFormulaText((_b = (_a = formulaNode === null || formulaNode === void 0 ? void 0 : formulaNode["xm:f"]) !== null && _a !== void 0 ? _a : formulaNode === null || formulaNode === void 0 ? void 0 : formulaNode.f) !== null && _b !== void 0 ? _b : formulaNode);
+        };
+        return {
+            a$: __assign(__assign({}, ((_b = node === null || node === void 0 ? void 0 : node.a$) !== null && _b !== void 0 ? _b : {})), { sqref: sqref }),
+            formula1: formulaText((_c = node === null || node === void 0 ? void 0 : node["x14:formula1"]) !== null && _c !== void 0 ? _c : node === null || node === void 0 ? void 0 : node.formula1),
+            formula2: formulaText((_d = node === null || node === void 0 ? void 0 : node["x14:formula2"]) !== null && _d !== void 0 ? _d : node === null || node === void 0 ? void 0 : node.formula2),
+        };
+    })
+        .filter(Boolean);
+    var namedRanges = workbook.getNamedRanges();
+    var _loop_1 = function (rule) {
+        var e_2, _p;
+        if (!((_b = rule === null || rule === void 0 ? void 0 : rule.a$) === null || _b === void 0 ? void 0 : _b.sqref)) {
+            return "continue";
+        }
+        var sqref = rule.a$.sqref.split(" ");
+        var type = rule.a$.type;
+        var ranges = [];
+        try {
+            for (var sqref_1 = (e_2 = void 0, __values(sqref)), sqref_1_1 = sqref_1.next(); !sqref_1_1.done; sqref_1_1 = sqref_1.next()) {
+                var ref = sqref_1_1.value;
+                var range = (_c = addressToSelection(ref)) === null || _c === void 0 ? void 0 : _c.range;
+                if (range) {
+                    ranges.push(__assign({ sheetId: sheetId }, range));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (sqref_1_1 && !sqref_1_1.done && (_p = sqref_1.return)) _p.call(sqref_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        if (!ranges.length) {
+            return "continue";
+        }
+        var baseCellRef = (_d = cellToAddress({
+            rowIndex: ranges[0].startRowIndex,
+            columnIndex: ranges[0].startColumnIndex,
+        })) !== null && _d !== void 0 ? _d : "A1";
+        var allowBlank = rule.a$.allowBlank === "1";
+        var showInputMessage = rule.a$.showInputMessage === "1";
+        var showErrorMessage = rule.a$.showErrorMessage === "1";
+        var inputMessage = showInputMessage && (rule.a$.prompt || rule.a$.promptTitle)
+            ? {
+                title: (_e = rule.a$.promptTitle) !== null && _e !== void 0 ? _e : undefined,
+                message: (_f = rule.a$.prompt) !== null && _f !== void 0 ? _f : undefined,
+            }
+            : undefined;
+        // showErrorMessage alone (no custom title/text) still means "reject
+        // invalid input with Excel's default alert" — keep the alert with just
+        // its style so the Stop/Warning behavior survives import.
+        var alert_1 = showErrorMessage
+            ? {
+                style: mapErrorStyle(rule.a$.errorStyle),
+                message: rule.a$.error || rule.a$.errorTitle
+                    ? {
+                        title: (_g = rule.a$.errorTitle) !== null && _g !== void 0 ? _g : undefined,
+                        message: (_h = rule.a$.error) !== null && _h !== void 0 ? _h : undefined,
+                    }
+                    : undefined,
+            }
+            : undefined;
+        // Prompt-only DV: Excel's "input message" feature attaches a tooltip
+        // (and/or an error alert) to a cell range without any validation
+        // constraint. These have no `type` attribute. Preserve them so the
+        // tooltip survives the round-trip.
+        if (!type) {
+            if (inputMessage || alert_1) {
+                dataValidations.push({
+                    id: uuid(),
+                    ranges: ranges,
+                    allowBlank: allowBlank,
+                    inputMessage: inputMessage,
+                    alert: alert_1,
+                });
+            }
+            return "continue";
+        }
+        var formula1Node = (_j = rule.formula1) !== null && _j !== void 0 ? _j : rule["x:formula1"];
+        var formula2Node = (_k = rule.formula2) !== null && _k !== void 0 ? _k : rule["x:formula2"];
+        // Capture the source xlsx representation verbatim so the exporter can
+        // round-trip the original `type`/`operator`/formulas instead of
+        // re-synthesizing from the parsed `condition` (which loses fidelity:
+        // `whole` collapses to `decimal`, `textLength` collapses to `custom`,
+        // user formulas get `INDIRECT("RC",FALSE)` rewriting). The source
+        // formula text is kept with any leading `=` stripped (matches xlsx wire
+        // format — `<formula1>` carries the expression without `=`).
+        var formula1Verbatim = (function () {
+            var text = extractFormulaText(formula1Node);
+            if (text === undefined)
+                return undefined;
+            var trimmed = String(text).trim();
+            if (!trimmed)
+                return undefined;
+            return trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+        })();
+        var formula2Verbatim = (function () {
+            var text = extractFormulaText(formula2Node);
+            if (text === undefined)
+                return undefined;
+            var trimmed = String(text).trim();
+            if (!trimmed)
+                return undefined;
+            return trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+        })();
+        var xlsxSource = __assign(__assign(__assign({ type: type }, (rule.a$.operator ? { operator: rule.a$.operator } : {})), (formula1Verbatim !== undefined
+            ? { formula1: formula1Verbatim }
+            : {})), (formula2Verbatim !== undefined
+            ? { formula2: formula2Verbatim }
+            : {}));
+        if (type === "list") {
+            var rawFormula = (_l = extractFormulaText(formula1Node)) !== null && _l !== void 0 ? _l : "";
+            var trimmedFormula = String(rawFormula !== null && rawFormula !== void 0 ? rawFormula : "").trim();
+            var referenceCandidate_1 = trimmedFormula.startsWith("=")
+                ? trimmedFormula.slice(1)
+                : trimmedFormula;
+            var isOffsetFormula = /^offset\(/i.test(referenceCandidate_1);
+            var isNamedRange = !!namedRanges.find(function (n) { return n.name === referenceCandidate_1; });
+            var listValues = parseListValues(trimmedFormula);
+            var isRef = checkIfStringIsReference(referenceCandidate_1) ||
+                isOffsetFormula ||
+                isNamedRange;
+            var normalizedReference = isRef && !isNamedRange
+                ? ensureSheetReference(referenceCandidate_1, sheetName)
+                : referenceCandidate_1;
+            var values_1 = isRef
+                ? [
+                    {
+                        userEnteredValue: normalizedReference.startsWith("=")
+                            ? normalizedReference
+                            : "=".concat(normalizedReference),
+                    },
+                ]
+                : listValues.map(function (value) { return ({ userEnteredValue: value }); });
+            if (!values_1.length) {
+                values_1.push({ userEnteredValue: trimmedFormula });
+            }
+            dataValidations.push({
+                id: uuid(),
+                ranges: ranges,
+                condition: {
+                    type: isRef ? "ONE_OF_RANGE" : "ONE_OF_LIST",
+                    values: values_1,
+                },
+                allowBlank: allowBlank,
+                displayStyle: rule.a$.showDropDown === "1" ? "plain" : undefined,
+                inputMessage: inputMessage,
+                alert: alert_1,
+                xlsxSource: xlsxSource,
+            });
+            return "continue";
+        }
+        var formula1 = normalizeFormulaText(formula1Node);
+        var formula2 = normalizeFormulaText(formula2Node);
+        if (type === "custom") {
+            if (!formula1) {
+                return "continue";
+            }
+            var parsedCondition = parseCustomValidationFormula(formula1, baseCellRef);
+            dataValidations.push({
+                id: uuid(),
+                ranges: ranges,
+                condition: parsedCondition !== null && parsedCondition !== void 0 ? parsedCondition : {
+                    type: "CUSTOM_FORMULA",
+                    values: [{ userEnteredValue: formula1 }],
+                },
+                allowBlank: allowBlank,
+                inputMessage: inputMessage,
+                alert: alert_1,
+                xlsxSource: xlsxSource,
+            });
+            return "continue";
+        }
+        if (type === "textLength") {
+            var lengthFormula = buildTextLengthFormula(rule.a$.operator, baseCellRef, formula1, formula2);
+            if (!lengthFormula) {
+                return "continue";
+            }
+            dataValidations.push({
+                id: uuid(),
+                ranges: ranges,
+                condition: {
+                    type: "CUSTOM_FORMULA",
+                    values: [{ userEnteredValue: lengthFormula }],
+                },
+                allowBlank: allowBlank,
+                inputMessage: inputMessage,
+                alert: alert_1,
+                xlsxSource: xlsxSource,
+            });
+            return "continue";
+        }
+        var isDateType = type === "date";
+        if (!isDateType && !NUMBER_VALIDATION_TYPES.has(type)) {
+            return "continue";
+        }
+        var conditionType = isDateType
+            ? mapDateOperatorToCondition(rule.a$.operator, Boolean(formula2))
+            : mapNumberOperatorToCondition(rule.a$.operator, Boolean(formula2));
+        if (!conditionType || !formula1) {
+            return "continue";
+        }
+        var values = __spreadArray([
+            { userEnteredValue: formula1 }
+        ], __read((formula2 ? [{ userEnteredValue: formula2 }] : [])), false);
+        dataValidations.push({
+            id: uuid(),
+            ranges: ranges,
+            condition: {
+                type: conditionType,
+                values: values,
+            },
+            allowBlank: allowBlank,
+            inputMessage: inputMessage,
+            alert: alert_1,
+            xlsxSource: xlsxSource,
+        });
+    };
+    try {
+        for (var _m = __values(__spreadArray(__spreadArray([], __read(validations), false), __read(x14Rules), false)), _o = _m.next(); !_o.done; _o = _m.next()) {
+            var rule = _o.value;
+            _loop_1(rule);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return dataValidations;
+};

package/dist/cjs/excel-parser/plugins/xlsx/drawing.d.ts

@@ -0,0 +1,39 @@
+import type { EmbeddedObject, EmbedShapeSpec } from "@rowsncolumns/spreadsheet";
+import { type XMLParser } from "fast-xml-parser";
+import { type StreamingZipParser } from "../../zip-parser-streaming";
+export type EmbeddedObjectWithPosition = EmbeddedObject & {
+    isInsideCell?: boolean;
+};
+/**
+ * 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 declare function processAnchors(anchors: any, anchorType: string, drawingPath: string, sheetId: number, zipParser: StreamingZipParser, xmlParser: XMLParser): Promise<EmbeddedObjectWithPosition[]>;
+/**
+ * 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 declare function isDrawingShape(shape: any): boolean;
+/** Parse an `<xdr:sp>` drawing shape into an {@link EmbedShapeSpec}. */
+export declare function parseShapeSpec(shape: any): EmbedShapeSpec;
+/**
+ * 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 declare function determineIfOneCellInsideCell(fromColOff: number, fromRowOff: number, fLocksWithSheet: string, cx: number, cy: number): boolean;
+//# sourceMappingURL=drawing.d.ts.map

package/dist/cjs/excel-parser/plugins/xlsx/drawing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing.d.ts","sourceRoot":"","sources":["../../../../../excel-parser/plugins/xlsx/drawing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,cAAc,EAEd,cAAc,EAWf,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAoDrE,MAAM,MAAM,0BAA0B,GAAG,cAAc,GAAG;IACxD,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,GAAG,EACZ,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,kBAAkB,EAC7B,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,0BAA0B,EAAE,CAAC,CA6dvC;AA6OD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CASlD;AAED,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,GAAG,cAAc,CA8CzD;AA8MD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,MAAM,EACvB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACT,OAAO,CAqBT"}