@rowsncolumns/spreadsheet-state 28.0.66

package/dist/cjs/api/parse-html.js

@@ -0,0 +1,1066 @@
+import { __assign, __awaiter, __generator, __read, __values } from "tslib";
+import { getImageDimensionsFromUrl } from "@rowsncolumns/toolkit";
+import { colorStringToHex, isNil, normalizeColor, pixelToPoint, pointToPixel, uuid, } from "@rowsncolumns/utils";
+import { defaultCellCoords, SheetCell } from "../sheet-cell";
+var BLOCK_TAGS = new Set([
+    "p",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "div",
+    "pre",
+    "li",
+]);
+var INLINE_TAGS = new Set([
+    "span",
+    "font",
+    "strong",
+    "em",
+    "b",
+    "i",
+    "u",
+    "a",
+]);
+var VALUE_NODE_SELECTOR = [
+    "[data-sheets-value]",
+    "[data-sheets-formula]",
+    "[data-formula]",
+    "[data-t]",
+    "[data-v]",
+].join(",");
+var TABLE_CONTAINER_TAGS = new Set([
+    "table",
+    "tbody",
+    "thead",
+    "tr",
+    "colgroup",
+]);
+var EXCEL_EPOCH = Date.UTC(1899, 11, 30);
+var MS_IN_DAY = 24 * 60 * 60 * 1000;
+export var parseHtml = function (clipboardValue, plainTextValue, activeCell, sheetId, preserveFormatting, idCreationStrategy, locale, sanitizeHtml) { return __awaiter(void 0, void 0, void 0, function () {
+    var context, safeHtml, _a, root, cleanup, combinedValue;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                context = {
+                    sheetId: sheetId,
+                    activeCell: activeCell,
+                    locale: locale,
+                    preserveFormatting: preserveFormatting,
+                    idCreationStrategy: idCreationStrategy,
+                    rows: [],
+                    merges: [],
+                    embeds: [],
+                    rowHeights: [],
+                    columnWidths: [],
+                    sheetCell: new SheetCell(),
+                    hadBlockLikeNode: false,
+                    rowStrings: [],
+                };
+                if (!(clipboardValue === null || clipboardValue === void 0 ? void 0 : clipboardValue.trim())) return [3 /*break*/, 4];
+                safeHtml = sanitizeHtml ? sanitizeHtml(clipboardValue) : clipboardValue;
+                _a = mountClipboardHtml(safeHtml), root = _a.root, cleanup = _a.cleanup;
+                _b.label = 1;
+            case 1:
+                _b.trys.push([1, , 3, 4]);
+                return [4 /*yield*/, traverseHtml(root, context)];
+            case 2:
+                _b.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                cleanup();
+                return [7 /*endfinally*/];
+            case 4:
+                if (!context.hadBlockLikeNode &&
+                    context.rows.length > 1 &&
+                    context.rows.every(function (row) { return row.length === 1; })) {
+                    combinedValue = context.rowStrings
+                        .map(function (value) { return value !== null && value !== void 0 ? value : ""; })
+                        .join("");
+                    context.rows = [];
+                    context.rowStrings = [];
+                    pushPlainTextRow(combinedValue, context);
+                }
+                if (!context.rows.length && plainTextValue) {
+                    pushPlainTextRow(plainTextValue, context);
+                }
+                return [2 /*return*/, {
+                        results: context.rows,
+                        merges: context.merges,
+                        embeds: context.embeds,
+                        rowHeights: context.rowHeights,
+                        columnWidths: context.columnWidths,
+                    }];
+        }
+    });
+}); };
+var mountClipboardHtml = function (clipboardValue) {
+    var _a, _b, _c, _d;
+    var parser = new DOMParser();
+    var doc = parser.parseFromString(clipboardValue, "text/html");
+    var sandbox = document.createElement("div");
+    sandbox.style.cssText =
+        "position:fixed;left:-10000px;top:-10000px;width:0;height:0;overflow:hidden;opacity:0;pointer-events:none;font-size:10pt;";
+    sandbox.innerHTML = (_b = (_a = doc.body) === null || _a === void 0 ? void 0 : _a.innerHTML) !== null && _b !== void 0 ? _b : "";
+    var styles = (_d = (_c = doc.head) === null || _c === void 0 ? void 0 : _c.querySelectorAll("style")) !== null && _d !== void 0 ? _d : [];
+    styles.forEach(function (style) { return sandbox.appendChild(style.cloneNode(true)); });
+    document.body.appendChild(sandbox);
+    return {
+        root: sandbox,
+        cleanup: function () { return sandbox.remove(); },
+    };
+};
+var traverseHtml = function (root, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var node;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                node = root.firstChild;
+                _a.label = 1;
+            case 1:
+                if (!node) return [3 /*break*/, 3];
+                return [4 /*yield*/, parseNode(node, root, context)];
+            case 2:
+                node = _a.sent();
+                return [3 /*break*/, 1];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+var parseNode = function (node, root, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var text, element, tag, _a, handled;
+    var _b, _c, _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                if (node.nodeType === Node.TEXT_NODE) {
+                    text = getTextContentFromNode(node);
+                    if (text.trim()) {
+                        pushPlainTextRow(text, context);
+                    }
+                    else if (shouldPreserveEmptyTextNode(node, root)) {
+                        pushPlainTextRow("", context, undefined, true);
+                    }
+                    return [2 /*return*/, getNextSibling(node, root)];
+                }
+                if (node.nodeType !== Node.ELEMENT_NODE) {
+                    return [2 /*return*/, getNextSibling(node, root)];
+                }
+                element = node;
+                tag = element.tagName.toLowerCase();
+                _a = tag;
+                switch (_a) {
+                    case "style": return [3 /*break*/, 1];
+                    case "meta": return [3 /*break*/, 1];
+                    case "script": return [3 /*break*/, 1];
+                    case "table": return [3 /*break*/, 2];
+                    case "pre": return [3 /*break*/, 4];
+                    case "img": return [3 /*break*/, 8];
+                    case "div": return [3 /*break*/, 10];
+                    case "span": return [3 /*break*/, 13];
+                }
+                return [3 /*break*/, 14];
+            case 1: return [2 /*return*/, getNextSibling(element, root)];
+            case 2:
+                context.hadBlockLikeNode = true;
+                return [4 /*yield*/, handleTableNode(element, context)];
+            case 3:
+                _e.sent();
+                return [2 /*return*/, skipNode(element, root)];
+            case 4:
+                context.hadBlockLikeNode = true;
+                return [4 /*yield*/, handlePreNode(element, context)];
+            case 5:
+                handled = _e.sent();
+                if (!!handled) return [3 /*break*/, 7];
+                return [4 /*yield*/, pushElementAsRow(element, context)];
+            case 6:
+                _e.sent();
+                _e.label = 7;
+            case 7: return [2 /*return*/, getNextSibling(element, root)];
+            case 8:
+                context.hadBlockLikeNode = true;
+                return [4 /*yield*/, pushElementAsRow(element, context)];
+            case 9:
+                _e.sent();
+                return [2 /*return*/, getNextSibling(element, root)];
+            case 10:
+                if (element.querySelector("table")) {
+                    return [2 /*return*/, (_b = element.firstChild) !== null && _b !== void 0 ? _b : getNextSibling(element, root)];
+                }
+                if (!shouldTreatDivAsText(element)) return [3 /*break*/, 12];
+                context.hadBlockLikeNode = true;
+                return [4 /*yield*/, pushElementAsRow(element, context)];
+            case 11:
+                _e.sent();
+                return [2 /*return*/, getNextSibling(element, root)];
+            case 12: return [2 /*return*/, (_c = element.firstChild) !== null && _c !== void 0 ? _c : getNextSibling(element, root)];
+            case 13: return [2 /*return*/, handleSpanNode(element, root, context)];
+            case 14:
+                if (!BLOCK_TAGS.has(tag)) return [3 /*break*/, 16];
+                context.hadBlockLikeNode = true;
+                return [4 /*yield*/, pushElementAsRow(element, context)];
+            case 15:
+                _e.sent();
+                return [2 /*return*/, getNextSibling(element, root)];
+            case 16:
+                if (!INLINE_TAGS.has(tag)) return [3 /*break*/, 18];
+                return [4 /*yield*/, pushElementAsRow(element, context)];
+            case 17:
+                _e.sent();
+                return [2 /*return*/, getNextSibling(element, root)];
+            case 18: return [2 /*return*/, (_d = element.firstChild) !== null && _d !== void 0 ? _d : getNextSibling(element, root)];
+        }
+    });
+}); };
+var getNextSibling = function (node, root) {
+    if (node.nextSibling) {
+        return node.nextSibling;
+    }
+    return skipNode(node, root);
+};
+var skipNode = function (node, root) {
+    var current = node;
+    while (current && current !== root && !current.nextSibling) {
+        current = current.parentNode;
+    }
+    if (!current || current === root) {
+        return null;
+    }
+    return current.nextSibling;
+};
+var getPreviousElementSibling = function (node) {
+    var current = node.previousSibling;
+    while (current) {
+        if (current.nodeType === Node.ELEMENT_NODE) {
+            return current;
+        }
+        current = current.previousSibling;
+    }
+    return null;
+};
+var getNextElementSiblingNode = function (node) {
+    var current = node.nextSibling;
+    while (current) {
+        if (current.nodeType === Node.ELEMENT_NODE) {
+            return current;
+        }
+        current = current.nextSibling;
+    }
+    return null;
+};
+var shouldPreserveEmptyTextNode = function (node, root) {
+    var _a;
+    if (node.nodeType !== Node.TEXT_NODE) {
+        return false;
+    }
+    if (node.parentNode !== root) {
+        return false;
+    }
+    var rawText = (_a = node.textContent) !== null && _a !== void 0 ? _a : "";
+    if (!/\r|\n/.test(rawText)) {
+        return false;
+    }
+    var previousElement = getPreviousElementSibling(node);
+    var nextElement = getNextElementSiblingNode(node);
+    return (!!previousElement &&
+        !!nextElement &&
+        isRowBoundaryElement(previousElement) &&
+        isRowBoundaryElement(nextElement));
+};
+var isRowBoundaryElement = function (element) {
+    var tag = element.tagName.toLowerCase();
+    if (TABLE_CONTAINER_TAGS.has(tag) ||
+        tag === "meta" ||
+        tag === "style" ||
+        tag === "script") {
+        return false;
+    }
+    if (BLOCK_TAGS.has(tag)) {
+        return true;
+    }
+    return tag === "img" || tag === "br";
+};
+var handleSpanNode = function (element, root, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var directAnchor, aggregatedText, cursor, lastNode;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!hasStructuredValue(element)) return [3 /*break*/, 2];
+                return [4 /*yield*/, pushElementAsRow(element, context)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/, getNextSibling(element, root)];
+            case 2:
+                directAnchor = element.querySelector("a[href]");
+                if (!directAnchor) return [3 /*break*/, 4];
+                return [4 /*yield*/, pushElementAsRow(directAnchor, context)];
+            case 3:
+                _a.sent();
+                return [2 /*return*/, getNextSibling(element, root)];
+            case 4:
+                aggregatedText = extractTextContent(element);
+                cursor = element.nextSibling;
+                lastNode = element;
+                while (cursor &&
+                    cursor.nodeType === Node.ELEMENT_NODE &&
+                    cursor.tagName.toLowerCase() === "span" &&
+                    !hasStructuredValue(cursor)) {
+                    aggregatedText += getTextContentFromNode(cursor);
+                    lastNode = cursor;
+                    cursor = cursor.nextSibling;
+                }
+                pushPlainTextRow(aggregatedText, context, element, true);
+                if (cursor) {
+                    return [2 /*return*/, cursor];
+                }
+                return [2 /*return*/, skipNode(lastNode, root)];
+        }
+    });
+}); };
+var handlePreNode = function (element, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var markdownRows, markdownRows_1, markdownRows_1_1, markdownRow, parsedRow, markdownRow_1, markdownRow_1_1, cellText;
+    var e_1, _a, e_2, _b;
+    return __generator(this, function (_c) {
+        markdownRows = parseMarkdownTableFromPre(element);
+        if (!markdownRows.length) {
+            return [2 /*return*/, false];
+        }
+        try {
+            for (markdownRows_1 = __values(markdownRows), markdownRows_1_1 = markdownRows_1.next(); !markdownRows_1_1.done; markdownRows_1_1 = markdownRows_1.next()) {
+                markdownRow = markdownRows_1_1.value;
+                parsedRow = [];
+                try {
+                    for (markdownRow_1 = (e_2 = void 0, __values(markdownRow)), markdownRow_1_1 = markdownRow_1.next(); !markdownRow_1_1.done; markdownRow_1_1 = markdownRow_1.next()) {
+                        cellText = markdownRow_1_1.value;
+                        parsedRow.push(createPlainTextCell(cellText, context));
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (markdownRow_1_1 && !markdownRow_1_1.done && (_b = markdownRow_1.return)) _b.call(markdownRow_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                context.rows.push(parsedRow);
+                context.rowStrings.push(undefined);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (markdownRows_1_1 && !markdownRows_1_1.done && (_a = markdownRows_1.return)) _a.call(markdownRows_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return [2 /*return*/, true];
+    });
+}); };
+var handleTableNode = function (table, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var rowOffset, _a, tableRows, cellMatrix, colGroup, cols, rowIndex, cells, parsedRow, columnIndex, cell, valueNode, cellData, rowSpan, colSpan, startRowIndex, startColumnIndex;
+    var _b, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                rowOffset = context.rows.length;
+                _a = __read(convertTableToArrayOfNodes(table), 2), tableRows = _a[0], cellMatrix = _a[1];
+                colGroup = table.querySelector("colgroup");
+                if (colGroup) {
+                    cols = colGroup.querySelectorAll("col");
+                    cols.forEach(function (col, index) {
+                        var _a;
+                        var width = extractNumericValue(col.getAttribute("width") || col.style.width);
+                        if (!isNil(width)) {
+                            context.columnWidths[index] = Math.max((_a = context.columnWidths[index]) !== null && _a !== void 0 ? _a : 0, width);
+                        }
+                    });
+                }
+                tableRows.forEach(function (row, index) {
+                    var height = extractNumericValue(row.getAttribute("height") || row.style.height);
+                    if (!isNil(height)) {
+                        context.rowHeights[rowOffset + index] = height;
+                    }
+                });
+                rowIndex = 0;
+                _d.label = 1;
+            case 1:
+                if (!(rowIndex < cellMatrix.length)) return [3 /*break*/, 8];
+                cells = cellMatrix[rowIndex];
+                parsedRow = [];
+                columnIndex = 0;
+                _d.label = 2;
+            case 2:
+                if (!(columnIndex < cells.length)) return [3 /*break*/, 6];
+                cell = cells[columnIndex];
+                if (!cell) return [3 /*break*/, 4];
+                valueNode = pickValueSource(cell);
+                return [4 /*yield*/, createCellFromNode(valueNode !== null && valueNode !== void 0 ? valueNode : cell, context, cell)];
+            case 3:
+                cellData = (_d.sent()).cellData;
+                parsedRow.push(cellData !== null && cellData !== void 0 ? cellData : {});
+                rowSpan = Number((_b = cell.getAttribute("rowspan")) !== null && _b !== void 0 ? _b : 1);
+                colSpan = Number((_c = cell.getAttribute("colspan")) !== null && _c !== void 0 ? _c : 1);
+                if (rowSpan > 1 || colSpan > 1) {
+                    startRowIndex = context.activeCell.rowIndex + rowOffset + rowIndex;
+                    startColumnIndex = context.activeCell.columnIndex + columnIndex;
+                    context.merges.push({
+                        startRowIndex: startRowIndex,
+                        endRowIndex: startRowIndex + rowSpan - 1,
+                        startColumnIndex: startColumnIndex,
+                        endColumnIndex: startColumnIndex + colSpan - 1,
+                    });
+                }
+                return [3 /*break*/, 5];
+            case 4:
+                parsedRow.push({});
+                _d.label = 5;
+            case 5:
+                columnIndex++;
+                return [3 /*break*/, 2];
+            case 6:
+                context.rows.push(parsedRow);
+                context.rowStrings.push(undefined);
+                _d.label = 7;
+            case 7:
+                rowIndex++;
+                return [3 /*break*/, 1];
+            case 8: return [2 /*return*/];
+        }
+    });
+}); };
+var pickValueSource = function (cell) {
+    var preferred = cell.querySelector(VALUE_NODE_SELECTOR);
+    if (preferred) {
+        return preferred;
+    }
+    var anchor = cell.querySelector("a[href]");
+    if (anchor) {
+        return anchor;
+    }
+    return cell;
+};
+var pushElementAsRow = function (element, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var cellData, text;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, createCellFromNode(element, context)];
+            case 1:
+                cellData = (_a.sent()).cellData;
+                if (cellData) {
+                    context.rows.push([cellData]);
+                    text = extractTextContent(element);
+                    context.rowStrings.push(text || undefined);
+                }
+                return [2 /*return*/];
+        }
+    });
+}); };
+var pushPlainTextRow = function (text, context, formattingElement, allowEmpty) {
+    if (allowEmpty === void 0) { allowEmpty = false; }
+    if (!allowEmpty && !(text === null || text === void 0 ? void 0 : text.trim())) {
+        return;
+    }
+    var cell = createPlainTextCell(text !== null && text !== void 0 ? text : "", context, formattingElement);
+    context.rows.push([cell]);
+    context.rowStrings.push(text !== null && text !== void 0 ? text : "");
+};
+var createPlainTextCell = function (text, context, formattingElement) {
+    var _a;
+    var sheetCell = context.sheetCell;
+    sheetCell.assign(context.sheetId, defaultCellCoords, {}, {
+        locale: context.locale,
+    });
+    sheetCell.setUserEnteredValue(text);
+    if (context.preserveFormatting && formattingElement) {
+        setFormatting(sheetCell, formattingElement);
+    }
+    return (_a = sheetCell.getCellData()) !== null && _a !== void 0 ? _a : {};
+};
+var createCellFromNode = function (node, context, formattingNode) { return __awaiter(void 0, void 0, void 0, function () {
+    var sheetCell, element, formatTarget, _a, handled, fallbackText, formulaResultText;
+    var _b, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                sheetCell = context.sheetCell;
+                sheetCell.assign(context.sheetId, defaultCellCoords, {}, {
+                    locale: context.locale,
+                });
+                element = node.nodeType === Node.ELEMENT_NODE ? node : undefined;
+                formatTarget = formattingNode !== null && formattingNode !== void 0 ? formattingNode : element;
+                _a = element;
+                if (!_a) return [3 /*break*/, 2];
+                return [4 /*yield*/, tryHandleImageElement(element, context)];
+            case 1:
+                _a = (_d.sent());
+                _d.label = 2;
+            case 2:
+                if (_a) {
+                    return [2 /*return*/, { cellData: (_b = sheetCell.getCellData()) !== null && _b !== void 0 ? _b : {} }];
+                }
+                handled = false;
+                if (element) {
+                    handled =
+                        applyGoogleSheetsFormula(element, sheetCell) ||
+                            applyGoogleSheetsValue(element, sheetCell) ||
+                            applyExcelValue(element, sheetCell);
+                    if (!handled && element.tagName.toLowerCase() === "a") {
+                        handled = applyAnchorValue(element, sheetCell);
+                    }
+                }
+                if (!handled) {
+                    fallbackText = node.nodeType === Node.TEXT_NODE
+                        ? getTextContentFromNode(node)
+                        : extractTextContent(element !== null && element !== void 0 ? element : node);
+                    sheetCell.setUserEnteredValue(fallbackText);
+                }
+                if (element && sheetCell.isFormula()) {
+                    formulaResultText = extractTextContent(element);
+                    if (formulaResultText.trim()) {
+                        sheetCell.setEffectiveValue(formulaResultText, true, true);
+                    }
+                }
+                if (context.preserveFormatting && formatTarget) {
+                    setFormatting(sheetCell, formatTarget);
+                }
+                return [2 /*return*/, { cellData: (_c = sheetCell.getCellData()) !== null && _c !== void 0 ? _c : {} }];
+        }
+    });
+}); };
+var tryHandleImageElement = function (element, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var image, imageUrl, text, sheetCell, embed;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                image = element.tagName.toLowerCase() === "img"
+                    ? element
+                    : element.querySelector("img");
+                if (!image) {
+                    return [2 /*return*/, false];
+                }
+                imageUrl = image.getAttribute("src");
+                if (!imageUrl) {
+                    return [2 /*return*/, false];
+                }
+                text = extractTextContent(element);
+                if (text.trim()) {
+                    return [2 /*return*/, false];
+                }
+                sheetCell = context.sheetCell;
+                sheetCell.setUserEnteredValue("");
+                sheetCell.imageUrl = imageUrl;
+                sheetCell.formattedValue = "";
+                return [4 /*yield*/, getEmbedFromImageUrl(imageUrl, context.sheetId, context.activeCell, context.idCreationStrategy)];
+            case 1:
+                embed = _a.sent();
+                if (embed) {
+                    context.embeds.push(embed);
+                }
+                return [2 /*return*/, true];
+        }
+    });
+}); };
+var applyGoogleSheetsFormula = function (element, sheetCell) {
+    var formula = element.getAttribute("data-sheets-formula");
+    if (!formula) {
+        return false;
+    }
+    sheetCell.setFormulaValue(formula);
+    return true;
+};
+var applyGoogleSheetsValue = function (element, sheetCell) {
+    var e_3, _a, e_4, _b, e_5, _c;
+    var rawValue = element.getAttribute("data-sheets-value");
+    if (!rawValue) {
+        return false;
+    }
+    try {
+        var parsed = JSON.parse(rawValue);
+        var candidates = [parsed["4"], parsed["3"], parsed["2"]];
+        try {
+            for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+                var candidate = candidates_1_1.value;
+                if (typeof candidate === "boolean") {
+                    sheetCell.setUserEnteredValue(candidate);
+                    return true;
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (candidates_1_1 && !candidates_1_1.done && (_a = candidates_1.return)) _a.call(candidates_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        try {
+            for (var candidates_2 = __values(candidates), candidates_2_1 = candidates_2.next(); !candidates_2_1.done; candidates_2_1 = candidates_2.next()) {
+                var candidate = candidates_2_1.value;
+                if (typeof candidate === "number") {
+                    sheetCell.setUserEnteredValue(candidate);
+                    return true;
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (candidates_2_1 && !candidates_2_1.done && (_b = candidates_2.return)) _b.call(candidates_2);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        try {
+            for (var candidates_3 = __values(candidates), candidates_3_1 = candidates_3.next(); !candidates_3_1.done; candidates_3_1 = candidates_3.next()) {
+                var candidate = candidates_3_1.value;
+                if (typeof candidate === "string" && candidate.length) {
+                    sheetCell.setUserEnteredValue(candidate);
+                    return true;
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (candidates_3_1 && !candidates_3_1.done && (_c = candidates_3.return)) _c.call(candidates_3);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    }
+    catch (_d) {
+        return false;
+    }
+    return false;
+};
+var applyExcelValue = function (element, sheetCell) {
+    var excelFormula = element.getAttribute("data-formula");
+    if (excelFormula) {
+        sheetCell.setFormulaValue(excelFormula);
+        return true;
+    }
+    var excelType = element.getAttribute("data-t");
+    var excelValue = element.getAttribute("data-v");
+    if (!(excelValue === null || excelValue === void 0 ? void 0 : excelValue.length)) {
+        return false;
+    }
+    if (excelType === "n") {
+        var numeric = Number(excelValue);
+        if (!Number.isNaN(numeric)) {
+            sheetCell.setUserEnteredValue(numeric);
+            return true;
+        }
+    }
+    if (excelType === "d") {
+        var serial = Number(excelValue);
+        var date = excelSerialToDate(serial);
+        if (date) {
+            sheetCell.setUserEnteredValue(date);
+            return true;
+        }
+    }
+    if (excelType === "b") {
+        sheetCell.setUserEnteredValue(excelValue === "1" || excelValue === "TRUE");
+        return true;
+    }
+    sheetCell.setUserEnteredValue(excelValue);
+    return true;
+};
+var excelSerialToDate = function (serial) {
+    if (!Number.isFinite(serial)) {
+        return undefined;
+    }
+    var serialNumber = serial;
+    if (serialNumber >= 60) {
+        serialNumber -= 1;
+    }
+    var millis = serialNumber * MS_IN_DAY;
+    return new Date(EXCEL_EPOCH + millis);
+};
+var applyAnchorValue = function (element, sheetCell) {
+    var href = element.getAttribute("href");
+    if (!href) {
+        return false;
+    }
+    var title = extractTextContent(element) || href;
+    sheetCell.setUrl(href, title);
+    return true;
+};
+var hasStructuredValue = function (element) {
+    return Boolean(element.getAttribute("data-sheets-value") ||
+        element.getAttribute("data-sheets-formula") ||
+        element.getAttribute("data-t") ||
+        element.getAttribute("data-v") ||
+        element.getAttribute("data-formula"));
+};
+var shouldTreatDivAsText = function (element) {
+    var _a, _b;
+    if (hasStructuredValue(element)) {
+        return true;
+    }
+    if (!element.children.length) {
+        return Boolean((_a = element.textContent) === null || _a === void 0 ? void 0 : _a.trim());
+    }
+    var firstChild = element.firstElementChild;
+    return (Boolean((_b = element.textContent) === null || _b === void 0 ? void 0 : _b.trim()) &&
+        !!firstChild &&
+        (INLINE_TAGS.has(firstChild.tagName.toLowerCase()) ||
+            firstChild.tagName.toLowerCase() === "br"));
+};
+function extractNumericValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    var isPt = value.endsWith("pt");
+    var isRem = value.endsWith("rem");
+    var match = value.match(/(\d+(?:\.\d+)?)/);
+    var numericValue = match ? parseFloat(match[1]) : 0;
+    if (isPt) {
+        return pointToPixel(numericValue);
+    }
+    if (isRem) {
+        return numericValue * 16;
+    }
+    return numericValue;
+}
+var getTextContentFromNode = function (node) {
+    var _a;
+    var text = (_a = node.textContent) !== null && _a !== void 0 ? _a : "";
+    return text.replace(/[\n\r]+/g, " ").replace(/[\s]{2,}/g, " ");
+};
+export function extractTextContent(element) {
+    var e_6, _a;
+    var text = "";
+    function processNode(node) {
+        var e_7, _a;
+        if (node.nodeType === Node.TEXT_NODE) {
+            text += getTextContentFromNode(node);
+        }
+        else if (node.nodeType === Node.ELEMENT_NODE) {
+            var el = node;
+            if (el.tagName === "BR") {
+                text += "\n";
+            }
+            else {
+                try {
+                    for (var _b = __values(Array.from(el.childNodes)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var child = _c.value;
+                        processNode(child);
+                    }
+                }
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+            }
+        }
+    }
+    try {
+        for (var _b = __values(Array.from(element.childNodes)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            processNode(child);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return text.trim();
+}
+var setFormatting = function (sheetCell, cell) {
+    var e_8, _a;
+    var _b, _c, _d, _e;
+    var style = getComputedStyle(cell);
+    var fontElements = cell.querySelectorAll("font");
+    var fontColor;
+    var fontFace;
+    var fontSizeFromTag;
+    if (fontElements.length > 0) {
+        var fontElement = fontElements[0];
+        var colorAttr = fontElement.getAttribute("color");
+        if (colorAttr) {
+            fontColor = extractColor(colorAttr);
+        }
+        var faceAttr = fontElement.getAttribute("face");
+        if (faceAttr) {
+            fontFace = faceAttr;
+        }
+        var sizeAttr = fontElement.getAttribute("size");
+        if (sizeAttr) {
+            var numericSize = parseInt(sizeAttr, 10);
+            if (!isNaN(numericSize)) {
+                var fontSizeMap = {
+                    1: 8,
+                    2: 10,
+                    3: 12,
+                    4: 14,
+                    5: 18,
+                    6: 24,
+                    7: 36,
+                };
+                fontSizeFromTag = (_b = fontSizeMap[numericSize]) !== null && _b !== void 0 ? _b : undefined;
+            }
+        }
+    }
+    var inlineColor = extractColor(cell.style.color);
+    var computedColor = extractColor(style.color);
+    var fontWeight = cell.style.fontWeight || style.fontWeight;
+    var childElementColor;
+    try {
+        for (var _f = __values(Array.from(cell.children)), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var childElement = _g.value;
+            // Prefer the parsed inline `color` property over the raw style attribute
+            // string. Passing `getAttribute("style")` (the entire CSS rule list) to a
+            // color extractor was how CSS fragments like
+            // `font-family:"Times New Roman",serif;mso-ansi-language:EN-US` ended up
+            // stored as a cell's color value.
+            var inlineChildColor = childElement instanceof HTMLElement
+                ? extractColor(childElement.style.color)
+                : undefined;
+            var childFontColor = (_c = childElement.getAttribute("color")) !== null && _c !== void 0 ? _c : undefined;
+            var childComputedColor = extractColor(getComputedStyle(childElement).color);
+            var extractedChildColor = inlineChildColor ||
+                extractColor(childFontColor) ||
+                childComputedColor;
+            if (extractedChildColor &&
+                extractedChildColor !== "#000000" &&
+                extractedChildColor !== "rgb(0, 0, 0)") {
+                childElementColor = extractedChildColor;
+                break;
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    var color = inlineColor || childElementColor || computedColor || fontColor;
+    var backgroundColor = extractColor(style.backgroundColor);
+    // No computed-style fallback: the sandbox lives in document.body, so an
+    // unstyled paste (e.g. ProseMirror's bare <div>) would re-inherit the OS
+    // system font and clobber the destination cell's own font family.
+    // The browser also wraps space-containing families in quotes when
+    // serializing inline styles ("Comic Sans MS"), so strip them and keep
+    // only the first family from a comma-separated stack.
+    var rawFontFamily = fontFace || cell.style.fontFamily || undefined;
+    var fontFamily = rawFontFamily
+        ? rawFontFamily
+            .split(",")[0]
+            .trim()
+            .replace(/^["']|["']$/g, "")
+        : undefined;
+    var fontSize = fontSizeFromTag || getFontSize(cell.style.fontSize || style.fontSize);
+    var italic = cell.style.fontStyle || style.fontStyle;
+    // Prefer the data attribute written by use-on-copy.ts. `getComputedStyle`
+    // would otherwise fabricate `"start"` even when no text-align was set.
+    var horizontalAlignmentAttr = cell.getAttribute("data-sheets-horizontal-alignment");
+    var horizontalAlignment = horizontalAlignmentAttr !== null && horizontalAlignmentAttr !== void 0 ? horizontalAlignmentAttr : (cell.style.textAlign || style.textAlign);
+    var verticalAlignmentAttr = cell.getAttribute("data-sheets-vertical-alignment");
+    var textDecoration = cell.style.textDecoration || style.textDecoration;
+    var underline = String(textDecoration).indexOf("underline") !== -1;
+    var strikethrough = String(textDecoration).indexOf("line-through") !== -1;
+    // Detect super/subscript from semantic tags or CSS vertical-align. A cell
+    // wrapping its entire value in <sup>/<sub> (or with a single child carrying
+    // vertical-align:super|sub) gets the corresponding baselineOffset.
+    var baselineOffset;
+    var verticalAlign = (cell.style.verticalAlign ||
+        style.verticalAlign ||
+        "").toLowerCase();
+    if (cell.querySelector("sup")) {
+        baselineOffset = "superscript";
+    }
+    else if (cell.querySelector("sub")) {
+        baselineOffset = "subscript";
+    }
+    else if (verticalAlign === "super") {
+        baselineOffset = "superscript";
+    }
+    else if (verticalAlign === "sub") {
+        baselineOffset = "subscript";
+    }
+    var inlineWhiteSpace = (_d = cell.style.whiteSpace) === null || _d === void 0 ? void 0 : _d.toLowerCase();
+    var computedWhiteSpace = (_e = style.whiteSpace) === null || _e === void 0 ? void 0 : _e.toLowerCase();
+    var wrap = cell.style.textWrap === "wrap" ||
+        cell.style.wordBreak === "break-word" ||
+        inlineWhiteSpace === "normal" ||
+        inlineWhiteSpace === "pre-wrap" ||
+        (!inlineWhiteSpace && computedWhiteSpace === "pre-wrap");
+    var textFormat = __assign({ bold: fontWeight === "bold" || Number(fontWeight) > 400, color: color, fontFamily: fontFamily, italic: italic === "italic", fontSize: fontSize, underline: underline, strikethrough: strikethrough }, (baselineOffset ? { baselineOffset: baselineOffset } : {}));
+    // Pasted clipboard formatting is persisted as user-entered so it survives
+    // serialization (`ef` is no longer written to cellData).
+    sheetCell.setUserEnteredFormat("textFormat", textFormat);
+    if (wrap) {
+        sheetCell.setUserEnteredFormat("wrapStrategy", "wrap");
+    }
+    if (backgroundColor) {
+        sheetCell.setUserEnteredFormat("backgroundColor", backgroundColor);
+    }
+    // When the data attribute is present (our own copy) trust whatever value
+    // it carries — including "left", which is an explicit user choice. Falling
+    // back to CSS, only accept right/center: "left" matches the CSS default so
+    // we can't tell it apart from an unset value, and "start"/"end"/"justify"
+    // aren't valid HorizontalAlign values.
+    if (horizontalAlignmentAttr) {
+        if (horizontalAlignmentAttr === "left" ||
+            horizontalAlignmentAttr === "right" ||
+            horizontalAlignmentAttr === "center") {
+            sheetCell.setUserEnteredFormat("horizontalAlignment", horizontalAlignmentAttr);
+        }
+    }
+    else if (horizontalAlignment === "right" ||
+        horizontalAlignment === "center") {
+        sheetCell.setUserEnteredFormat("horizontalAlignment", horizontalAlignment);
+    }
+    if (verticalAlignmentAttr === "top" ||
+        verticalAlignmentAttr === "middle" ||
+        verticalAlignmentAttr === "bottom") {
+        sheetCell.setUserEnteredFormat("verticalAlignment", verticalAlignmentAttr);
+    }
+    // numberFormat is encoded as data attributes on the <td> at copy time
+    // (the HTML representation otherwise carries only the formatted text, so
+    // patterns like "$"#,##0.0000 would be lost). Apply after setUserEnteredValue
+    // ran so we overwrite any heuristically-detected pattern.
+    var numberFormatType = cell.getAttribute("data-sheets-numberformat-type");
+    var numberFormatPattern = cell.getAttribute("data-sheets-numberformat-pattern");
+    if (numberFormatType) {
+        sheetCell.setUserEnteredFormat("numberFormat", __assign({ type: numberFormatType }, (numberFormatPattern ? { pattern: numberFormatPattern } : {})));
+    }
+};
+var getFontSize = function (value) {
+    var match = value.match(/(\d+(?:\.\d+)?)/);
+    if (!match) {
+        return undefined;
+    }
+    var numericValue = parseFloat(match[1]);
+    if (value.endsWith("pt")) {
+        return numericValue;
+    }
+    if (value.endsWith("rem")) {
+        return pixelToPoint(numericValue * 16);
+    }
+    return pixelToPoint(numericValue);
+};
+export var extractColor = function (color) {
+    var _a;
+    if (color && color !== "transparent") {
+        var rgb = normalizeColor(color);
+        if ((rgb === null || rgb === void 0 ? void 0 : rgb.r) === 0 && rgb.g === 0 && rgb.b === 0 && rgb.a === 0) {
+            return undefined;
+        }
+        // Drop unrecognized values. Returning the raw string used to let CSS
+        // fragments (e.g. `font-family:"Times New Roman"`) leak into cell.color,
+        // which broke xlsx export by writing invalid `rgb=""` attrs.
+        return (_a = colorStringToHex(color)) !== null && _a !== void 0 ? _a : undefined;
+    }
+    return undefined;
+};
+export var getEmbedFromImageUrl = function (imageUrl, sheetId, activeCell, idCreationStrategy) { return __awaiter(void 0, void 0, void 0, function () {
+    var imageDimensions, _a, widthPixels, heightPixels;
+    var _b;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                if (!imageUrl) {
+                    return [2 /*return*/, undefined];
+                }
+                return [4 /*yield*/, getImageDimensionsFromUrl(imageUrl)];
+            case 1:
+                imageDimensions = _c.sent();
+                if (imageDimensions) {
+                    _a = __read(imageDimensions, 2), widthPixels = _a[0], heightPixels = _a[1];
+                    return [2 /*return*/, {
+                            embedId: (_b = idCreationStrategy === null || idCreationStrategy === void 0 ? void 0 : idCreationStrategy("embed")) !== null && _b !== void 0 ? _b : uuid(),
+                            position: {
+                                overlayPosition: {
+                                    anchorCell: activeCell,
+                                    widthPixels: widthPixels,
+                                    heightPixels: heightPixels,
+                                    offsetXPixels: 0,
+                                    offsetYPixels: 0,
+                                },
+                                sheetId: sheetId,
+                            },
+                            lockAspectRatio: true,
+                            spec: {
+                                imageUrl: imageUrl,
+                                type: "image",
+                            },
+                        }];
+                }
+                return [2 /*return*/];
+        }
+    });
+}); };
+export var convertTableToArrayOfNodes = function (node) {
+    var rows = node.querySelectorAll("tr");
+    var result = [];
+    rows.forEach(function (row, rowIndex) {
+        var cells = row.querySelectorAll("td,th");
+        var cellIndex = 0;
+        cells.forEach(function (cell) {
+            while (result[rowIndex] && result[rowIndex][cellIndex] !== undefined) {
+                cellIndex++;
+            }
+            var colspan = Number(cell.getAttribute("colspan") || 1);
+            var rowspan = Number(cell.getAttribute("rowspan") || 1);
+            for (var i = 0; i < colspan; i++) {
+                for (var j = 0; j < rowspan; j++) {
+                    var targetRowIndex = rowIndex + j;
+                    var targetCellIndex = cellIndex + i;
+                    if (!result[targetRowIndex]) {
+                        result[targetRowIndex] = [];
+                    }
+                    if (!result[targetRowIndex][targetCellIndex]) {
+                        result[targetRowIndex][targetCellIndex] =
+                            i === 0 && j === 0 ? cell : null;
+                    }
+                }
+            }
+            cellIndex += colspan;
+        });
+        var rowLength = result[rowIndex].length;
+        for (var i = cellIndex; i < rowLength; i++) {
+            result[rowIndex][i] = null;
+        }
+    });
+    return [rows, result];
+};
+function parseMarkdownTableFromPre(preElement) {
+    var _a;
+    var result = [];
+    var tokenLines = preElement.querySelectorAll(".token-line");
+    if (tokenLines.length === 0) {
+        return result;
+    }
+    var firstLine = (_a = tokenLines[0]) === null || _a === void 0 ? void 0 : _a.textContent;
+    if (!firstLine || !firstLine.includes("|")) {
+        return result;
+    }
+    tokenLines.forEach(function (line) {
+        var lineText = line.textContent || "";
+        if (lineText.includes("---")) {
+            return;
+        }
+        if (lineText.includes("|")) {
+            var cells = lineText
+                .split("|")
+                .map(function (cell) { return cell.trim(); })
+                .filter(function (cell) { return cell.length > 0; });
+            if (cells.length > 0) {
+                result.push(cells);
+            }
+        }
+    });
+    return result;
+}