@rowsncolumns/spreadsheet-state 28.0.66

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

@@ -0,0 +1,865 @@
+import { getImageDimensionsFromUrl } from "@rowsncolumns/toolkit";
+import { colorStringToHex, isNil, normalizeColor, pixelToPoint, pointToPixel, uuid, } from "@rowsncolumns/utils";
+import { defaultCellCoords, SheetCell } from "../sheet-cell";
+const BLOCK_TAGS = new Set([
+    "p",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "div",
+    "pre",
+    "li",
+]);
+const INLINE_TAGS = new Set([
+    "span",
+    "font",
+    "strong",
+    "em",
+    "b",
+    "i",
+    "u",
+    "a",
+]);
+const VALUE_NODE_SELECTOR = [
+    "[data-sheets-value]",
+    "[data-sheets-formula]",
+    "[data-formula]",
+    "[data-t]",
+    "[data-v]",
+].join(",");
+const TABLE_CONTAINER_TAGS = new Set([
+    "table",
+    "tbody",
+    "thead",
+    "tr",
+    "colgroup",
+]);
+const EXCEL_EPOCH = Date.UTC(1899, 11, 30);
+const MS_IN_DAY = 24 * 60 * 60 * 1000;
+export const parseHtml = async (clipboardValue, plainTextValue, activeCell, sheetId, preserveFormatting, idCreationStrategy, locale, sanitizeHtml) => {
+    const context = {
+        sheetId,
+        activeCell,
+        locale,
+        preserveFormatting,
+        idCreationStrategy,
+        rows: [],
+        merges: [],
+        embeds: [],
+        rowHeights: [],
+        columnWidths: [],
+        sheetCell: new SheetCell(),
+        hadBlockLikeNode: false,
+        rowStrings: [],
+    };
+    if (clipboardValue?.trim()) {
+        const safeHtml = sanitizeHtml ? sanitizeHtml(clipboardValue) : clipboardValue;
+        const { root, cleanup } = mountClipboardHtml(safeHtml);
+        try {
+            await traverseHtml(root, context);
+        }
+        finally {
+            cleanup();
+        }
+    }
+    if (!context.hadBlockLikeNode &&
+        context.rows.length > 1 &&
+        context.rows.every((row) => row.length === 1)) {
+        const combinedValue = context.rowStrings
+            .map((value) => value ?? "")
+            .join("");
+        context.rows = [];
+        context.rowStrings = [];
+        pushPlainTextRow(combinedValue, context);
+    }
+    if (!context.rows.length && plainTextValue) {
+        pushPlainTextRow(plainTextValue, context);
+    }
+    return {
+        results: context.rows,
+        merges: context.merges,
+        embeds: context.embeds,
+        rowHeights: context.rowHeights,
+        columnWidths: context.columnWidths,
+    };
+};
+const mountClipboardHtml = (clipboardValue) => {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(clipboardValue, "text/html");
+    const 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 = doc.body?.innerHTML ?? "";
+    const styles = doc.head?.querySelectorAll("style") ?? [];
+    styles.forEach((style) => sandbox.appendChild(style.cloneNode(true)));
+    document.body.appendChild(sandbox);
+    return {
+        root: sandbox,
+        cleanup: () => sandbox.remove(),
+    };
+};
+const traverseHtml = async (root, context) => {
+    let node = root.firstChild;
+    while (node) {
+        node = await parseNode(node, root, context);
+    }
+};
+const parseNode = async (node, root, context) => {
+    if (node.nodeType === Node.TEXT_NODE) {
+        const text = getTextContentFromNode(node);
+        if (text.trim()) {
+            pushPlainTextRow(text, context);
+        }
+        else if (shouldPreserveEmptyTextNode(node, root)) {
+            pushPlainTextRow("", context, undefined, true);
+        }
+        return getNextSibling(node, root);
+    }
+    if (node.nodeType !== Node.ELEMENT_NODE) {
+        return getNextSibling(node, root);
+    }
+    const element = node;
+    const tag = element.tagName.toLowerCase();
+    switch (tag) {
+        case "style":
+        case "meta":
+        case "script":
+            return getNextSibling(element, root);
+        case "table":
+            context.hadBlockLikeNode = true;
+            await handleTableNode(element, context);
+            return skipNode(element, root);
+        case "pre": {
+            context.hadBlockLikeNode = true;
+            const handled = await handlePreNode(element, context);
+            if (!handled) {
+                await pushElementAsRow(element, context);
+            }
+            return getNextSibling(element, root);
+        }
+        case "img":
+            context.hadBlockLikeNode = true;
+            await pushElementAsRow(element, context);
+            return getNextSibling(element, root);
+        case "div": {
+            if (element.querySelector("table")) {
+                return element.firstChild ?? getNextSibling(element, root);
+            }
+            if (shouldTreatDivAsText(element)) {
+                context.hadBlockLikeNode = true;
+                await pushElementAsRow(element, context);
+                return getNextSibling(element, root);
+            }
+            return element.firstChild ?? getNextSibling(element, root);
+        }
+        case "span":
+            return handleSpanNode(element, root, context);
+        default: {
+            if (BLOCK_TAGS.has(tag)) {
+                context.hadBlockLikeNode = true;
+                await pushElementAsRow(element, context);
+                return getNextSibling(element, root);
+            }
+            if (INLINE_TAGS.has(tag)) {
+                await pushElementAsRow(element, context);
+                return getNextSibling(element, root);
+            }
+            return element.firstChild ?? getNextSibling(element, root);
+        }
+    }
+};
+const getNextSibling = (node, root) => {
+    if (node.nextSibling) {
+        return node.nextSibling;
+    }
+    return skipNode(node, root);
+};
+const skipNode = (node, root) => {
+    let current = node;
+    while (current && current !== root && !current.nextSibling) {
+        current = current.parentNode;
+    }
+    if (!current || current === root) {
+        return null;
+    }
+    return current.nextSibling;
+};
+const getPreviousElementSibling = (node) => {
+    let current = node.previousSibling;
+    while (current) {
+        if (current.nodeType === Node.ELEMENT_NODE) {
+            return current;
+        }
+        current = current.previousSibling;
+    }
+    return null;
+};
+const getNextElementSiblingNode = (node) => {
+    let current = node.nextSibling;
+    while (current) {
+        if (current.nodeType === Node.ELEMENT_NODE) {
+            return current;
+        }
+        current = current.nextSibling;
+    }
+    return null;
+};
+const shouldPreserveEmptyTextNode = (node, root) => {
+    if (node.nodeType !== Node.TEXT_NODE) {
+        return false;
+    }
+    if (node.parentNode !== root) {
+        return false;
+    }
+    const rawText = node.textContent ?? "";
+    if (!/\r|\n/.test(rawText)) {
+        return false;
+    }
+    const previousElement = getPreviousElementSibling(node);
+    const nextElement = getNextElementSiblingNode(node);
+    return (!!previousElement &&
+        !!nextElement &&
+        isRowBoundaryElement(previousElement) &&
+        isRowBoundaryElement(nextElement));
+};
+const isRowBoundaryElement = (element) => {
+    const 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";
+};
+const handleSpanNode = async (element, root, context) => {
+    if (hasStructuredValue(element)) {
+        await pushElementAsRow(element, context);
+        return getNextSibling(element, root);
+    }
+    const directAnchor = element.querySelector("a[href]");
+    if (directAnchor) {
+        await pushElementAsRow(directAnchor, context);
+        return getNextSibling(element, root);
+    }
+    let aggregatedText = extractTextContent(element);
+    let cursor = element.nextSibling;
+    let 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 cursor;
+    }
+    return skipNode(lastNode, root);
+};
+const handlePreNode = async (element, context) => {
+    const markdownRows = parseMarkdownTableFromPre(element);
+    if (!markdownRows.length) {
+        return false;
+    }
+    for (const markdownRow of markdownRows) {
+        const parsedRow = [];
+        for (const cellText of markdownRow) {
+            parsedRow.push(createPlainTextCell(cellText, context));
+        }
+        context.rows.push(parsedRow);
+        context.rowStrings.push(undefined);
+    }
+    return true;
+};
+const handleTableNode = async (table, context) => {
+    const rowOffset = context.rows.length;
+    const [tableRows, cellMatrix] = convertTableToArrayOfNodes(table);
+    const colGroup = table.querySelector("colgroup");
+    if (colGroup) {
+        const cols = colGroup.querySelectorAll("col");
+        cols.forEach((col, index) => {
+            const width = extractNumericValue(col.getAttribute("width") || col.style.width);
+            if (!isNil(width)) {
+                context.columnWidths[index] = Math.max(context.columnWidths[index] ?? 0, width);
+            }
+        });
+    }
+    tableRows.forEach((row, index) => {
+        const height = extractNumericValue(row.getAttribute("height") || row.style.height);
+        if (!isNil(height)) {
+            context.rowHeights[rowOffset + index] = height;
+        }
+    });
+    for (let rowIndex = 0; rowIndex < cellMatrix.length; rowIndex++) {
+        const cells = cellMatrix[rowIndex];
+        const parsedRow = [];
+        for (let columnIndex = 0; columnIndex < cells.length; columnIndex++) {
+            const cell = cells[columnIndex];
+            if (cell) {
+                const valueNode = pickValueSource(cell);
+                const { cellData } = await createCellFromNode(valueNode ?? cell, context, cell);
+                parsedRow.push(cellData ?? {});
+                const rowSpan = Number(cell.getAttribute("rowspan") ?? 1);
+                const colSpan = Number(cell.getAttribute("colspan") ?? 1);
+                if (rowSpan > 1 || colSpan > 1) {
+                    const startRowIndex = context.activeCell.rowIndex + rowOffset + rowIndex;
+                    const startColumnIndex = context.activeCell.columnIndex + columnIndex;
+                    context.merges.push({
+                        startRowIndex,
+                        endRowIndex: startRowIndex + rowSpan - 1,
+                        startColumnIndex,
+                        endColumnIndex: startColumnIndex + colSpan - 1,
+                    });
+                }
+            }
+            else {
+                parsedRow.push({});
+            }
+        }
+        context.rows.push(parsedRow);
+        context.rowStrings.push(undefined);
+    }
+};
+const pickValueSource = (cell) => {
+    const preferred = cell.querySelector(VALUE_NODE_SELECTOR);
+    if (preferred) {
+        return preferred;
+    }
+    const anchor = cell.querySelector("a[href]");
+    if (anchor) {
+        return anchor;
+    }
+    return cell;
+};
+const pushElementAsRow = async (element, context) => {
+    const { cellData } = await createCellFromNode(element, context);
+    if (cellData) {
+        context.rows.push([cellData]);
+        const text = extractTextContent(element);
+        context.rowStrings.push(text || undefined);
+    }
+};
+const pushPlainTextRow = (text, context, formattingElement, allowEmpty = false) => {
+    if (!allowEmpty && !text?.trim()) {
+        return;
+    }
+    const cell = createPlainTextCell(text ?? "", context, formattingElement);
+    context.rows.push([cell]);
+    context.rowStrings.push(text ?? "");
+};
+const createPlainTextCell = (text, context, formattingElement) => {
+    const sheetCell = context.sheetCell;
+    sheetCell.assign(context.sheetId, defaultCellCoords, {}, {
+        locale: context.locale,
+    });
+    sheetCell.setUserEnteredValue(text);
+    if (context.preserveFormatting && formattingElement) {
+        setFormatting(sheetCell, formattingElement);
+    }
+    return sheetCell.getCellData() ?? {};
+};
+const createCellFromNode = async (node, context, formattingNode) => {
+    const sheetCell = context.sheetCell;
+    sheetCell.assign(context.sheetId, defaultCellCoords, {}, {
+        locale: context.locale,
+    });
+    const element = node.nodeType === Node.ELEMENT_NODE ? node : undefined;
+    const formatTarget = formattingNode ?? element;
+    if (element && (await tryHandleImageElement(element, context))) {
+        return { cellData: sheetCell.getCellData() ?? {} };
+    }
+    let 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) {
+        const fallbackText = node.nodeType === Node.TEXT_NODE
+            ? getTextContentFromNode(node)
+            : extractTextContent(element ?? node);
+        sheetCell.setUserEnteredValue(fallbackText);
+    }
+    if (element && sheetCell.isFormula()) {
+        const formulaResultText = extractTextContent(element);
+        if (formulaResultText.trim()) {
+            sheetCell.setEffectiveValue(formulaResultText, true, true);
+        }
+    }
+    if (context.preserveFormatting && formatTarget) {
+        setFormatting(sheetCell, formatTarget);
+    }
+    return { cellData: sheetCell.getCellData() ?? {} };
+};
+const tryHandleImageElement = async (element, context) => {
+    const image = element.tagName.toLowerCase() === "img"
+        ? element
+        : element.querySelector("img");
+    if (!image) {
+        return false;
+    }
+    const imageUrl = image.getAttribute("src");
+    if (!imageUrl) {
+        return false;
+    }
+    const text = extractTextContent(element);
+    if (text.trim()) {
+        return false;
+    }
+    const sheetCell = context.sheetCell;
+    sheetCell.setUserEnteredValue("");
+    sheetCell.imageUrl = imageUrl;
+    sheetCell.formattedValue = "";
+    const embed = await getEmbedFromImageUrl(imageUrl, context.sheetId, context.activeCell, context.idCreationStrategy);
+    if (embed) {
+        context.embeds.push(embed);
+    }
+    return true;
+};
+const applyGoogleSheetsFormula = (element, sheetCell) => {
+    const formula = element.getAttribute("data-sheets-formula");
+    if (!formula) {
+        return false;
+    }
+    sheetCell.setFormulaValue(formula);
+    return true;
+};
+const applyGoogleSheetsValue = (element, sheetCell) => {
+    const rawValue = element.getAttribute("data-sheets-value");
+    if (!rawValue) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(rawValue);
+        const candidates = [parsed["4"], parsed["3"], parsed["2"]];
+        for (const candidate of candidates) {
+            if (typeof candidate === "boolean") {
+                sheetCell.setUserEnteredValue(candidate);
+                return true;
+            }
+        }
+        for (const candidate of candidates) {
+            if (typeof candidate === "number") {
+                sheetCell.setUserEnteredValue(candidate);
+                return true;
+            }
+        }
+        for (const candidate of candidates) {
+            if (typeof candidate === "string" && candidate.length) {
+                sheetCell.setUserEnteredValue(candidate);
+                return true;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+};
+const applyExcelValue = (element, sheetCell) => {
+    const excelFormula = element.getAttribute("data-formula");
+    if (excelFormula) {
+        sheetCell.setFormulaValue(excelFormula);
+        return true;
+    }
+    const excelType = element.getAttribute("data-t");
+    const excelValue = element.getAttribute("data-v");
+    if (!excelValue?.length) {
+        return false;
+    }
+    if (excelType === "n") {
+        const numeric = Number(excelValue);
+        if (!Number.isNaN(numeric)) {
+            sheetCell.setUserEnteredValue(numeric);
+            return true;
+        }
+    }
+    if (excelType === "d") {
+        const serial = Number(excelValue);
+        const 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;
+};
+const excelSerialToDate = (serial) => {
+    if (!Number.isFinite(serial)) {
+        return undefined;
+    }
+    let serialNumber = serial;
+    if (serialNumber >= 60) {
+        serialNumber -= 1;
+    }
+    const millis = serialNumber * MS_IN_DAY;
+    return new Date(EXCEL_EPOCH + millis);
+};
+const applyAnchorValue = (element, sheetCell) => {
+    const href = element.getAttribute("href");
+    if (!href) {
+        return false;
+    }
+    const title = extractTextContent(element) || href;
+    sheetCell.setUrl(href, title);
+    return true;
+};
+const hasStructuredValue = (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"));
+};
+const shouldTreatDivAsText = (element) => {
+    if (hasStructuredValue(element)) {
+        return true;
+    }
+    if (!element.children.length) {
+        return Boolean(element.textContent?.trim());
+    }
+    const firstChild = element.firstElementChild;
+    return (Boolean(element.textContent?.trim()) &&
+        !!firstChild &&
+        (INLINE_TAGS.has(firstChild.tagName.toLowerCase()) ||
+            firstChild.tagName.toLowerCase() === "br"));
+};
+function extractNumericValue(value) {
+    if (!value) {
+        return undefined;
+    }
+    const isPt = value.endsWith("pt");
+    const isRem = value.endsWith("rem");
+    const match = value.match(/(\d+(?:\.\d+)?)/);
+    const numericValue = match ? parseFloat(match[1]) : 0;
+    if (isPt) {
+        return pointToPixel(numericValue);
+    }
+    if (isRem) {
+        return numericValue * 16;
+    }
+    return numericValue;
+}
+const getTextContentFromNode = (node) => {
+    const text = node.textContent ?? "";
+    return text.replace(/[\n\r]+/g, " ").replace(/[\s]{2,}/g, " ");
+};
+export function extractTextContent(element) {
+    let text = "";
+    function processNode(node) {
+        if (node.nodeType === Node.TEXT_NODE) {
+            text += getTextContentFromNode(node);
+        }
+        else if (node.nodeType === Node.ELEMENT_NODE) {
+            const el = node;
+            if (el.tagName === "BR") {
+                text += "\n";
+            }
+            else {
+                for (const child of Array.from(el.childNodes)) {
+                    processNode(child);
+                }
+            }
+        }
+    }
+    for (const child of Array.from(element.childNodes)) {
+        processNode(child);
+    }
+    return text.trim();
+}
+const setFormatting = (sheetCell, cell) => {
+    const style = getComputedStyle(cell);
+    const fontElements = cell.querySelectorAll("font");
+    let fontColor;
+    let fontFace;
+    let fontSizeFromTag;
+    if (fontElements.length > 0) {
+        const fontElement = fontElements[0];
+        const colorAttr = fontElement.getAttribute("color");
+        if (colorAttr) {
+            fontColor = extractColor(colorAttr);
+        }
+        const faceAttr = fontElement.getAttribute("face");
+        if (faceAttr) {
+            fontFace = faceAttr;
+        }
+        const sizeAttr = fontElement.getAttribute("size");
+        if (sizeAttr) {
+            const numericSize = parseInt(sizeAttr, 10);
+            if (!isNaN(numericSize)) {
+                const fontSizeMap = {
+                    1: 8,
+                    2: 10,
+                    3: 12,
+                    4: 14,
+                    5: 18,
+                    6: 24,
+                    7: 36,
+                };
+                fontSizeFromTag = fontSizeMap[numericSize] ?? undefined;
+            }
+        }
+    }
+    const inlineColor = extractColor(cell.style.color);
+    const computedColor = extractColor(style.color);
+    const fontWeight = cell.style.fontWeight || style.fontWeight;
+    let childElementColor;
+    for (const childElement of Array.from(cell.children)) {
+        // 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.
+        const inlineChildColor = childElement instanceof HTMLElement
+            ? extractColor(childElement.style.color)
+            : undefined;
+        const childFontColor = childElement.getAttribute("color") ?? undefined;
+        const childComputedColor = extractColor(getComputedStyle(childElement).color);
+        const extractedChildColor = inlineChildColor ||
+            extractColor(childFontColor) ||
+            childComputedColor;
+        if (extractedChildColor &&
+            extractedChildColor !== "#000000" &&
+            extractedChildColor !== "rgb(0, 0, 0)") {
+            childElementColor = extractedChildColor;
+            break;
+        }
+    }
+    const color = inlineColor || childElementColor || computedColor || fontColor;
+    const 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.
+    const rawFontFamily = fontFace || cell.style.fontFamily || undefined;
+    const fontFamily = rawFontFamily
+        ? rawFontFamily
+            .split(",")[0]
+            .trim()
+            .replace(/^["']|["']$/g, "")
+        : undefined;
+    const fontSize = fontSizeFromTag || getFontSize(cell.style.fontSize || style.fontSize);
+    const 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.
+    const horizontalAlignmentAttr = cell.getAttribute("data-sheets-horizontal-alignment");
+    const horizontalAlignment = horizontalAlignmentAttr ??
+        (cell.style.textAlign || style.textAlign);
+    const verticalAlignmentAttr = cell.getAttribute("data-sheets-vertical-alignment");
+    const textDecoration = cell.style.textDecoration || style.textDecoration;
+    const underline = String(textDecoration).indexOf("underline") !== -1;
+    const 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.
+    let baselineOffset;
+    const 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";
+    }
+    const inlineWhiteSpace = cell.style.whiteSpace?.toLowerCase();
+    const computedWhiteSpace = style.whiteSpace?.toLowerCase();
+    const wrap = cell.style.textWrap === "wrap" ||
+        cell.style.wordBreak === "break-word" ||
+        inlineWhiteSpace === "normal" ||
+        inlineWhiteSpace === "pre-wrap" ||
+        (!inlineWhiteSpace && computedWhiteSpace === "pre-wrap");
+    const textFormat = {
+        bold: fontWeight === "bold" || Number(fontWeight) > 400,
+        color,
+        fontFamily,
+        italic: italic === "italic",
+        fontSize,
+        underline,
+        strikethrough,
+        ...(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.
+    const numberFormatType = cell.getAttribute("data-sheets-numberformat-type");
+    const numberFormatPattern = cell.getAttribute("data-sheets-numberformat-pattern");
+    if (numberFormatType) {
+        sheetCell.setUserEnteredFormat("numberFormat", {
+            type: numberFormatType,
+            ...(numberFormatPattern ? { pattern: numberFormatPattern } : {}),
+        });
+    }
+};
+const getFontSize = (value) => {
+    const match = value.match(/(\d+(?:\.\d+)?)/);
+    if (!match) {
+        return undefined;
+    }
+    const numericValue = parseFloat(match[1]);
+    if (value.endsWith("pt")) {
+        return numericValue;
+    }
+    if (value.endsWith("rem")) {
+        return pixelToPoint(numericValue * 16);
+    }
+    return pixelToPoint(numericValue);
+};
+export const extractColor = (color) => {
+    if (color && color !== "transparent") {
+        const rgb = normalizeColor(color);
+        if (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 colorStringToHex(color) ?? undefined;
+    }
+    return undefined;
+};
+export const getEmbedFromImageUrl = async (imageUrl, sheetId, activeCell, idCreationStrategy) => {
+    if (!imageUrl) {
+        return undefined;
+    }
+    const imageDimensions = await getImageDimensionsFromUrl(imageUrl);
+    if (imageDimensions) {
+        const [widthPixels, heightPixels] = imageDimensions;
+        return {
+            embedId: idCreationStrategy?.("embed") ?? uuid(),
+            position: {
+                overlayPosition: {
+                    anchorCell: activeCell,
+                    widthPixels,
+                    heightPixels,
+                    offsetXPixels: 0,
+                    offsetYPixels: 0,
+                },
+                sheetId,
+            },
+            lockAspectRatio: true,
+            spec: {
+                imageUrl,
+                type: "image",
+            },
+        };
+    }
+};
+export const convertTableToArrayOfNodes = (node) => {
+    const rows = node.querySelectorAll("tr");
+    const result = [];
+    rows.forEach((row, rowIndex) => {
+        const cells = row.querySelectorAll("td,th");
+        let cellIndex = 0;
+        cells.forEach((cell) => {
+            while (result[rowIndex] && result[rowIndex][cellIndex] !== undefined) {
+                cellIndex++;
+            }
+            const colspan = Number(cell.getAttribute("colspan") || 1);
+            const rowspan = Number(cell.getAttribute("rowspan") || 1);
+            for (let i = 0; i < colspan; i++) {
+                for (let j = 0; j < rowspan; j++) {
+                    const targetRowIndex = rowIndex + j;
+                    const targetCellIndex = cellIndex + i;
+                    if (!result[targetRowIndex]) {
+                        result[targetRowIndex] = [];
+                    }
+                    if (!result[targetRowIndex][targetCellIndex]) {
+                        result[targetRowIndex][targetCellIndex] =
+                            i === 0 && j === 0 ? cell : null;
+                    }
+                }
+            }
+            cellIndex += colspan;
+        });
+        const rowLength = result[rowIndex].length;
+        for (let i = cellIndex; i < rowLength; i++) {
+            result[rowIndex][i] = null;
+        }
+    });
+    return [rows, result];
+};
+function parseMarkdownTableFromPre(preElement) {
+    const result = [];
+    const tokenLines = preElement.querySelectorAll(".token-line");
+    if (tokenLines.length === 0) {
+        return result;
+    }
+    const firstLine = tokenLines[0]?.textContent;
+    if (!firstLine || !firstLine.includes("|")) {
+        return result;
+    }
+    tokenLines.forEach((line) => {
+        const lineText = line.textContent || "";
+        if (lineText.includes("---")) {
+            return;
+        }
+        if (lineText.includes("|")) {
+            const cells = lineText
+                .split("|")
+                .map((cell) => cell.trim())
+                .filter((cell) => cell.length > 0);
+            if (cells.length > 0) {
+                result.push(cells);
+            }
+        }
+    });
+    return result;
+}