smartrte-core 0.2.0 → 1.0.0-beta.1

package/dist/foundation/formats/docx/export.js

@@ -0,0 +1,285 @@
+import JSZip from "jszip";
+import { isTextNode } from "../../identity.js";
+import { occupancyGridFor } from "../../table/grid.js";
+import { foundationListStyleForPresetDepth, isFoundationSmartListPreset } from "../../list/presets.js";
+import { portableFormulaMarker, portableImageMarker } from "./portableAtoms.js";
+export const DOCX_MEDIA_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+const xmlEscape = (value) => String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const colorValue = (value) => {
+    const hex = /^#([0-9a-f]{6})$/i.exec(value.trim());
+    if (hex)
+        return hex[1].toUpperCase();
+    const rgb = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/i.exec(value.trim());
+    return rgb
+        ? rgb.slice(1, 4).map((part) => Math.max(0, Math.min(255, Number(part))).toString(16).padStart(2, "0")).join("").toUpperCase()
+        : "";
+};
+/**
+ * table_cell's border attrs are free-form CSS border shorthand strings - the
+ * editor's own UI only ever writes "{width}px {style} {hex|rgb}" (style one
+ * of solid/dashed/dotted; see CanonicalAuthorityEditor.tsx's
+ * composeBorderShorthand), so that's the one shape parsed into real OOXML
+ * here; anything else (arbitrary pasted CSS) falls through to no override,
+ * same as before per-side support existed - not a regression, since nothing
+ * but the "none" sentinel was ever handled here originally. w:sz is eighths
+ * of a point; this codebase's own px->pt conversion elsewhere
+ * (columnWidths/row height * 15 for twips, i.e. 1px = 0.75pt) gives
+ * eighths = pt * 8 = px * 6.
+ */
+const DOCX_BORDER_STYLE = { solid: "single", dashed: "dashed", dotted: "dotted", double: "double" };
+const parseCellBorderValue = (value) => {
+    if (typeof value !== "string")
+        return null;
+    const width = /(\d+(?:\.\d+)?)\s*px/.exec(value);
+    const color = /#[0-9a-f]{3,6}\b|rgba?\([^)]+\)/i.exec(value);
+    if (!width || !color)
+        return null;
+    const hex = colorValue(color[0]);
+    if (!hex)
+        return null;
+    const styleMatch = /\b(solid|dashed|dotted|double)\b/i.exec(value);
+    return { sz: Math.max(2, Math.round(Number(width[1]) * 6)), val: DOCX_BORDER_STYLE[styleMatch?.[1].toLowerCase() ?? "solid"] ?? "single", color: hex };
+};
+/** borderTop/Right/Bottom/Left (the border-options UI's per-side control) win over the uniform `borders` fallback for that one side, same precedence order the live renderer applies them in. */
+const cellSideBorderXml = (name, sideValue, uniformValue) => {
+    const parsed = parseCellBorderValue(sideValue) ?? parseCellBorderValue(uniformValue);
+    return parsed ? `<w:${name} w:val="${parsed.val}" w:sz="${parsed.sz}" w:color="${parsed.color}"/>` : "";
+};
+const cellBorderXml = (attrs, borderNone) => {
+    if (attrs?.borders === "none")
+        return borderNone;
+    const xml = [
+        cellSideBorderXml("top", attrs?.borderTop, attrs?.borders),
+        cellSideBorderXml("left", attrs?.borderLeft, attrs?.borders),
+        cellSideBorderXml("bottom", attrs?.borderBottom, attrs?.borders),
+        cellSideBorderXml("right", attrs?.borderRight, attrs?.borders),
+    ].join("");
+    return xml ? `<w:tcBorders>${xml}</w:tcBorders>` : "";
+};
+const runProperties = (marks = []) => marks.map((mark) => {
+    if (mark.type === "bold")
+        return "<w:b/>";
+    if (mark.type === "italic")
+        return "<w:i/>";
+    if (mark.type === "underline")
+        return '<w:u w:val="single"/>';
+    if (mark.type === "strike")
+        return "<w:strike/>";
+    if (mark.type === "superscript")
+        return '<w:vertAlign w:val="superscript"/>';
+    if (mark.type === "subscript")
+        return '<w:vertAlign w:val="subscript"/>';
+    if (mark.type === "textColor") {
+        const color = colorValue(String(mark.attrs?.value || ""));
+        return color ? `<w:color w:val="${color}"/>` : "";
+    }
+    if (mark.type === "backgroundColor") {
+        const color = colorValue(String(mark.attrs?.value || ""));
+        return color ? `<w:shd w:val="clear" w:color="auto" w:fill="${color}"/>` : "";
+    }
+    if (mark.type === "fontSize")
+        return `<w:sz w:val="${Math.max(2, Math.round(Number(mark.attrs?.valuePx || 0) * 1.5))}"/>`;
+    return "";
+}).join("");
+const textRun = (text, properties = "") => `<w:r>${properties ? `<w:rPr>${properties}</w:rPr>` : ""}<w:t xml:space="preserve">${xmlEscape(text)}</w:t></w:r>`;
+const createSerializationContext = () => ({
+    relationships: [], hyperlinkIds: new Map(), media: [], drawingId: 1,
+});
+const hyperlinkRelationshipId = (context, href) => {
+    const existing = context.hyperlinkIds.get(href);
+    if (existing)
+        return existing;
+    const id = `rId${context.relationships.length + 2}`;
+    context.hyperlinkIds.set(href, id);
+    context.relationships.push({ id, target: href, kind: "hyperlink" });
+    return id;
+};
+const embeddableImage = (src) => {
+    const match = /^data:(image\/(?:png|jpeg|gif));base64,([a-z0-9+/=\s]+)$/i.exec(src);
+    if (!match)
+        return;
+    return { mimeType: match[1].toLowerCase(), base64: match[2].replace(/\s/g, "") };
+};
+const imageRun = (node, context) => {
+    const src = String(node.attrs?.src || "");
+    const alt = node.attrs?.alt !== undefined ? String(node.attrs.alt) : undefined;
+    const title = node.attrs?.title !== undefined ? String(node.attrs.title) : undefined;
+    const image = embeddableImage(src);
+    if (!image)
+        return textRun(portableImageMarker(src, alt, title));
+    const extension = image.mimeType === "image/jpeg" ? "jpg" : image.mimeType.split("/")[1];
+    const filename = `image${context.media.length + 1}.${extension}`;
+    const relationshipId = `rId${context.relationships.length + 2}`;
+    const drawingId = context.drawingId++;
+    context.media.push({ filename, ...image });
+    context.relationships.push({ id: relationshipId, target: `media/${filename}`, kind: "image" });
+    const widthEmu = Math.max(1, Math.round(Number(node.attrs?.width || 96) * 9525));
+    const heightEmu = Math.max(1, Math.round(Number(node.attrs?.height || 96) * 9525));
+    const name = xmlEscape(title || alt || filename);
+    const description = xmlEscape(alt || "");
+    return `<w:r><w:drawing><wp:inline xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing" distT="0" distB="0" distL="0" distR="0"><wp:extent cx="${widthEmu}" cy="${heightEmu}"/><wp:docPr id="${drawingId}" name="${name}" descr="${description}"/><a:graphic xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:nvPicPr><pic:cNvPr id="0" name="${name}" descr="${description}"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed="${relationshipId}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="${widthEmu}" cy="${heightEmu}"/></a:xfrm><a:prstGeom prst="rect"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>`;
+};
+const formulaRun = (node) => {
+    const source = xmlEscape(String(node.attrs?.source || ""));
+    const displayText = node.attrs?.displayText !== undefined ? String(node.attrs.displayText) : undefined;
+    const marker = xmlEscape(portableFormulaMarker(String(node.attrs?.source || ""), displayText));
+    return `<m:oMath><m:r><m:t>${source}</m:t></m:r></m:oMath><w:r><w:rPr><w:vanish/></w:rPr><w:t>${marker}</w:t></w:r>`;
+};
+/** Fidelity: media type "file" (a legacy concept) has no canonical atom equivalent and is skipped. */
+const inlineRun = (node, context) => {
+    if (isTextNode(node)) {
+        const properties = runProperties(node.marks);
+        const runs = node.text.split("\n").map((part, index) => `${index ? "<w:r><w:br/></w:r>" : ""}${part ? textRun(part, properties) : ""}`).join("");
+        const link = node.marks?.find((mark) => mark.type === "link");
+        if (!link || !runs)
+            return runs;
+        return `<w:hyperlink r:id="${hyperlinkRelationshipId(context, String(link.attrs?.href || ""))}"${link.attrs?.target ? ' w:history="1"' : ""}>${runs}</w:hyperlink>`;
+    }
+    if (node.type === "hard_break")
+        return "<w:r><w:br/></w:r>";
+    if (node.type === "formula")
+        return formulaRun(node);
+    if (node.type === "image")
+        return imageRun(node, context);
+    return "";
+};
+const alignmentOf = (node) => typeof node.attrs?.align === "string" ? node.attrs.align : undefined;
+const indentLevelOf = (node) => Number(node.attrs?.indentLevel) || 0;
+const paragraphProperties = (block, extra = "") => [
+    alignmentOf(block) ? `<w:jc w:val="${xmlEscape(alignmentOf(block))}"/>` : "",
+    indentLevelOf(block) ? `<w:ind w:left="${indentLevelOf(block) * 480}"/>` : "",
+    extra,
+].join("");
+const paragraphXml = (children, block, context, extraProperties = "") => {
+    const properties = paragraphProperties(block, extraProperties);
+    const content = children.map((node) => inlineRun(node, context)).join("") || textRun("");
+    return `<w:p>${properties ? `<w:pPr>${properties}</w:pPr>` : ""}${content}</w:p>`;
+};
+const listStyleNumId = {
+    disc: 1, circle: 2, square: 3, decimal: 4,
+    "decimal-leading-zero": 4,
+    "lower-alpha": 5, "upper-alpha": 6, "lower-roman": 7, "upper-roman": 8,
+};
+const orderedList = (node) => {
+    const marker = String(node.attrs?.style || node.attrs?.preset || "");
+    return /^(?:decimal|lower-|upper-|ordered)/.test(marker) || node.attrs?.start !== undefined;
+};
+const effectiveStyle = (node, depth) => {
+    if (typeof node.attrs?.style === "string")
+        return node.attrs.style;
+    if (isFoundationSmartListPreset(node.attrs?.preset))
+        return foundationListStyleForPresetDepth(node.attrs.preset, depth);
+    return "disc";
+};
+const blockChildren = (node) => (node.children || []);
+const elementChildren = (node) => blockChildren(node).filter((child) => !isTextNode(child));
+const tableXml = (block, context) => {
+    const grid = occupancyGridFor(block);
+    const widths = Array.from({ length: grid.columns }, (_, index) => Number(block.attrs?.columnWidths?.[index]) || 96);
+    const gridXml = `<w:tblGrid>${widths.map((widthPx) => `<w:gridCol w:w="${Math.max(1, Math.round(widthPx * 15))}"/>`).join("")}</w:tblGrid>`;
+    const borderNone = '<w:tcBorders><w:top w:val="nil"/><w:left w:val="nil"/><w:bottom w:val="nil"/><w:right w:val="nil"/></w:tcBorders>';
+    const rows = elementChildren(block).map((row, rowIndex) => {
+        const header = Array.from({ length: grid.columns }, (_, column) => grid.at(rowIndex, column)?.node.attrs?.header === true).every(Boolean);
+        const rowProperties = [
+            header ? "<w:tblHeader/>" : "",
+            Number(row.attrs?.height) > 0 ? `<w:trHeight w:val="${Math.round(Number(row.attrs?.height) * 15)}" w:hRule="atLeast"/>` : "",
+        ].join("");
+        let cells = "";
+        for (let column = 0; column < grid.columns;) {
+            const cell = grid.at(rowIndex, column);
+            if (!cell || cell.left !== column) {
+                column += 1;
+                continue;
+            }
+            const rowspan = cell.bottom - cell.top;
+            const colspan = cell.right - cell.left;
+            const continuation = cell.top < rowIndex;
+            const shade = colorValue(String(cell.node.attrs?.background || ""));
+            const properties = [
+                colspan > 1 ? `<w:gridSpan w:val="${colspan}"/>` : "",
+                rowspan > 1 ? (continuation ? "<w:vMerge/>" : '<w:vMerge w:val="restart"/>') : "",
+                shade ? `<w:shd w:val="clear" w:color="auto" w:fill="${shade}"/>` : "",
+                cellBorderXml(cell.node.attrs, borderNone),
+            ].join("");
+            const content = continuation ? "<w:p/>" : elementChildren(cell.node).map((child) => blockXml(child, context)).join("") || "<w:p/>";
+            cells += `<w:tc><w:tcPr>${properties}</w:tcPr>${content}</w:tc>`;
+            column += colspan;
+        }
+        return `<w:tr>${rowProperties ? `<w:trPr>${rowProperties}</w:trPr>` : ""}${cells}</w:tr>`;
+    }).join("");
+    return `<w:tbl><w:tblPr><w:tblW w:w="0" w:type="auto"/><w:tblBorders><w:top w:val="single" w:sz="4" w:color="D1D5DB"/><w:left w:val="single" w:sz="4" w:color="D1D5DB"/><w:bottom w:val="single" w:sz="4" w:color="D1D5DB"/><w:right w:val="single" w:sz="4" w:color="D1D5DB"/><w:insideH w:val="single" w:sz="4" w:color="D1D5DB"/><w:insideV w:val="single" w:sz="4" w:color="D1D5DB"/></w:tblBorders></w:tblPr>${gridXml}${rows}</w:tbl>`;
+};
+/** Fidelity: DOCX export is `semantic` for structure; formulas fall back to a portable text marker (`lossy`), matching Phase 7's explicit decision not to build partial OMML. */
+const blockXml = (block, context, listLevel = 0) => {
+    if (block.type === "paragraph")
+        return paragraphXml(blockChildren(block), block, context);
+    if (block.type === "heading")
+        return paragraphXml(blockChildren(block), block, context, `<w:pStyle w:val="Heading${Number(block.attrs?.level) || 1}"/>`);
+    if (block.type === "code_block") {
+        const text = blockChildren(block).map((child) => isTextNode(child) ? child.text : child.type === "hard_break" ? "\n" : "").join("");
+        return paragraphXml([{ type: "text", text, marks: [{ type: "code" }] }], block, context);
+    }
+    if (block.type === "blockquote") {
+        return elementChildren(block).map((child) => child.type === "paragraph"
+            ? paragraphXml(blockChildren(child), child, context, '<w:ind w:left="720"/>')
+            : blockXml(child, context, listLevel)).join("");
+    }
+    if (block.type === "list") {
+        const style = effectiveStyle(block, listLevel);
+        return elementChildren(block).flatMap((item) => elementChildren(item).map((child) => child.type === "paragraph"
+            ? paragraphXml(blockChildren(child), child, context, `<w:numPr><w:ilvl w:val="${Math.min(listLevel, 8)}"/><w:numId w:val="${listStyleNumId[style]}"/></w:numPr>`)
+            : blockXml(child, context, listLevel + 1))).join("");
+    }
+    if (block.type === "table")
+        return tableXml(block, context);
+    if (block.type === "block_image")
+        return paragraphXml([{ ...block, type: "image" }], block, context);
+    if (block.type === "block_formula")
+        return paragraphXml([{ ...block, type: "formula" }], block, context);
+    return paragraphXml([{ type: "text", text: String(block.attrs?.title || block.attrs?.src || "") }], block, context);
+};
+const numberingLevelXml = (level, format, text, font) => `<w:lvl w:ilvl="${level}"><w:start w:val="1"/><w:numFmt w:val="${format}"/><w:lvlText w:val="${text}"/><w:lvlJc w:val="left"/><w:pPr><w:tabs><w:tab w:val="num" w:pos="${720 + level * 360}"/></w:tabs><w:ind w:left="${720 + level * 360}" w:hanging="360"/></w:pPr>${font ? `<w:rPr><w:rFonts w:ascii="${font}" w:hAnsi="${font}"/></w:rPr>` : ""}</w:lvl>`;
+const numberingXml = () => {
+    const definitions = [
+        { id: 1, format: "bullet", text: "•", font: "Symbol" },
+        { id: 2, format: "bullet", text: "○", font: "Arial" },
+        { id: 3, format: "bullet", text: "▪", font: "Arial" },
+        { id: 4, format: "decimal", text: "%1." },
+        { id: 5, format: "lowerLetter", text: "%1." },
+        { id: 6, format: "upperLetter", text: "%1." },
+        { id: 7, format: "lowerRoman", text: "%1." },
+        { id: 8, format: "upperRoman", text: "%1." },
+    ];
+    const abstracts = definitions.map(({ id, format, text, font }) => `<w:abstractNum w:abstractNumId="${id}"><w:multiLevelType w:val="multilevel"/>${Array.from({ length: 9 }, (_, level) => numberingLevelXml(level, format, text.replace("%1", `%${level + 1}`), font)).join("")}</w:abstractNum>`).join("");
+    const instances = definitions.map(({ id }) => `<w:num w:numId="${id}"><w:abstractNumId w:val="${id}"/></w:num>`).join("");
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:numbering xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">${abstracts}${instances}</w:numbering>`;
+};
+const serializeDocxDocument = (document) => {
+    const context = createSerializationContext();
+    const body = elementChildren(document).map((block) => blockXml(block, context)).join("");
+    return {
+        documentXml: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"><w:body>${body}<w:sectPr><w:pgSz w:w="12240" w:h="15840"/><w:pgMar w:top="720" w:right="720" w:bottom="720" w:left="720"/></w:sectPr></w:body></w:document>`,
+        relationships: context.relationships,
+        media: context.media,
+    };
+};
+export const smartDocumentToDocxXml = (document) => serializeDocxDocument(document).documentXml;
+export const exportDocxDocument = async (document) => {
+    const zip = new JSZip();
+    const serialized = serializeDocxDocument(document);
+    const imageTypes = [...new Set(serialized.media.map(({ filename, mimeType }) => JSON.stringify({
+            extension: filename.split(".").pop(), mimeType,
+        })))].map((entry) => JSON.parse(entry));
+    zip.file("[Content_Types].xml", `<?xml version="1.0" encoding="UTF-8"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/>${imageTypes.map(({ extension, mimeType }) => `<Default Extension="${extension}" ContentType="${mimeType}"/>`).join("")}<Override PartName="/word/document.xml" ContentType="${DOCX_MEDIA_TYPE}.main+xml"/><Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/></Types>`);
+    zip.folder("_rels")?.file(".rels", `<?xml version="1.0" encoding="UTF-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>`);
+    zip.folder("word")?.file("document.xml", serialized.documentXml);
+    zip.folder("word")?.file("numbering.xml", numberingXml());
+    serialized.media.forEach(({ filename, base64 }) => {
+        zip.folder("word")?.folder("media")?.file(filename, base64, { base64: true });
+    });
+    const relationships = serialized.relationships.map((relationship) => relationship.kind === "hyperlink"
+        ? `<Relationship Id="${relationship.id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="${xmlEscape(relationship.target)}" TargetMode="External"/>`
+        : `<Relationship Id="${relationship.id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="${relationship.target}"/>`).join("");
+    zip.folder("word")?.folder("_rels")?.file("document.xml.rels", `<?xml version="1.0" encoding="UTF-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" Target="numbering.xml"/>${relationships}</Relationships>`);
+    return zip.generateAsync({ type: "blob", mimeType: DOCX_MEDIA_TYPE });
+};

package/dist/foundation/formats/docx/import.d.ts

@@ -0,0 +1,9 @@
+import type { SmartDocument } from "../../types.js";
+/**
+ * Fidelity: `semantic` for structure. Matches the established pattern for
+ * plain HTML import (CanonicalAuthorityEditor's runImport) - mammoth already
+ * produces clean semantic HTML, so no compatibility/normalize pass is
+ * inserted here; parseCanonicalListHtml's own fallback ("unknown" node with
+ * raw HTML) handles anything it doesn't recognize.
+ */
+export declare const importDocxDocumentWithMammoth: (arrayBuffer: ArrayBuffer) => Promise<SmartDocument>;

package/dist/foundation/formats/docx/import.js

@@ -0,0 +1,37 @@
+import JSZip from "jszip";
+import mammoth from "mammoth";
+import { parseCanonicalListHtml } from "../../list/formats.js";
+import { restorePortableDocxAtoms } from "./portableAtoms.js";
+import { assertDocxXmlWithinDepthLimit } from "./nestingGuard.js";
+/**
+ * Fidelity: `semantic` for structure. Matches the established pattern for
+ * plain HTML import (CanonicalAuthorityEditor's runImport) - mammoth already
+ * produces clean semantic HTML, so no compatibility/normalize pass is
+ * inserted here; parseCanonicalListHtml's own fallback ("unknown" node with
+ * raw HTML) handles anything it doesn't recognize.
+ */
+export const importDocxDocumentWithMammoth = async (arrayBuffer) => {
+    // Defense-in-depth against pathologically deep XML - see nestingGuard.ts's
+    // own doc comment for why this exists alongside (not instead of) the real
+    // fixes in mammoth's own patched code. Checked against document.xml
+    // specifically: the primary, always-present part every .docx has, and the
+    // one the disclosed attack targets. A package that fails to unzip or has
+    // no document.xml is left for mammoth's own error handling below, not
+    // rejected here - this guard only rejects on a confirmed-deep document.
+    try {
+        const zip = await JSZip.loadAsync(arrayBuffer);
+        const documentXml = await zip.file("word/document.xml")?.async("text");
+        if (documentXml)
+            assertDocxXmlWithinDepthLimit(documentXml);
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "DocxNestingTooDeepError")
+            throw error;
+        // Any other failure here (corrupt zip, etc.) is mammoth's to report.
+    }
+    // Mammoth's browser entry reads `arrayBuffer`, while its Node entry reads
+    // `buffer`. Supplying both keeps the adapter portable across bundlers/tests.
+    const result = await mammoth.convertToHtml({ arrayBuffer, buffer: arrayBuffer });
+    const html = restorePortableDocxAtoms(result.value);
+    return parseCanonicalListHtml(html);
+};

package/dist/foundation/formats/docx/nestingGuard.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Defense-in-depth against pathologically deep XML inside a `.docx` package.
+ *
+ * Not the real fix for any specific recursion bug - see
+ * docs/bugs/mammoth-own-reader-unguarded-recursion-dos.md and
+ * docs/bugs/mammoth-bundles-vulnerable-transitive-xmldom.md for those (an
+ * iterative rewrite of mammoth's own XML-to-node conversion, and a pinned/
+ * patched @xmldom/xmldom). This exists because verifying those two fixes
+ * against the real attack surfaced a *third*, independent unguarded-recursion
+ * function elsewhere in mammoth's own code (`office-xml-reader.js`'s
+ * `collapseAlternateContent`, out of scope to patch here) - a pattern of
+ * multiple such functions, not one isolated bug. A cheap, iterative (never
+ * recursive - this guard must not become another instance of the same class
+ * of bug) upfront depth check protects against that specific function and
+ * any other not-yet-discovered one, without waiting on an exhaustive audit
+ * of mammoth's entire codebase.
+ *
+ * Deliberately coarse, not a real XML parser: a linear scan counting
+ * tag-open/tag-close balance. Does not correctly account for `<`/`>`
+ * characters inside comments, CDATA sections, or attribute values - for a
+ * generously-set threshold, that only risks *under*-counting depth (a
+ * false negative, i.e. missing a genuinely deep document), never rejecting
+ * a shallow legitimate one, so it stays a safe, one-directional guard.
+ */
+/** Real Word documents essentially never nest structurally beyond a few
+ * dozen levels even in pathological cases (tables nested in tables nested
+ * in tracked-change wrappers nested in content controls). The disclosed
+ * @xmldom/xmldom recursion advisory measured crash thresholds starting
+ * around 5,000 levels for the lightest-per-frame operations tested. 1,000
+ * sits an order of magnitude above any plausible real document and a
+ * comfortable margin below the lowest crash threshold observed for any
+ * function measured so far, leaving room for an undiscovered function with
+ * heavier per-frame stack usage than anything tested to date. */
+export declare const MAX_DOCX_XML_NESTING_DEPTH = 1000;
+export declare class DocxNestingTooDeepError extends Error {
+    constructor(depth: number, max: number);
+}
+/** Returns the deepest tag-nesting level found, without recursing. */
+export declare const maxXmlNestingDepth: (xml: string) => number;
+export declare const assertDocxXmlWithinDepthLimit: (xml: string, max?: number) => void;

package/dist/foundation/formats/docx/nestingGuard.js

@@ -0,0 +1,66 @@
+/**
+ * Defense-in-depth against pathologically deep XML inside a `.docx` package.
+ *
+ * Not the real fix for any specific recursion bug - see
+ * docs/bugs/mammoth-own-reader-unguarded-recursion-dos.md and
+ * docs/bugs/mammoth-bundles-vulnerable-transitive-xmldom.md for those (an
+ * iterative rewrite of mammoth's own XML-to-node conversion, and a pinned/
+ * patched @xmldom/xmldom). This exists because verifying those two fixes
+ * against the real attack surfaced a *third*, independent unguarded-recursion
+ * function elsewhere in mammoth's own code (`office-xml-reader.js`'s
+ * `collapseAlternateContent`, out of scope to patch here) - a pattern of
+ * multiple such functions, not one isolated bug. A cheap, iterative (never
+ * recursive - this guard must not become another instance of the same class
+ * of bug) upfront depth check protects against that specific function and
+ * any other not-yet-discovered one, without waiting on an exhaustive audit
+ * of mammoth's entire codebase.
+ *
+ * Deliberately coarse, not a real XML parser: a linear scan counting
+ * tag-open/tag-close balance. Does not correctly account for `<`/`>`
+ * characters inside comments, CDATA sections, or attribute values - for a
+ * generously-set threshold, that only risks *under*-counting depth (a
+ * false negative, i.e. missing a genuinely deep document), never rejecting
+ * a shallow legitimate one, so it stays a safe, one-directional guard.
+ */
+/** Real Word documents essentially never nest structurally beyond a few
+ * dozen levels even in pathological cases (tables nested in tables nested
+ * in tracked-change wrappers nested in content controls). The disclosed
+ * @xmldom/xmldom recursion advisory measured crash thresholds starting
+ * around 5,000 levels for the lightest-per-frame operations tested. 1,000
+ * sits an order of magnitude above any plausible real document and a
+ * comfortable margin below the lowest crash threshold observed for any
+ * function measured so far, leaving room for an undiscovered function with
+ * heavier per-frame stack usage than anything tested to date. */
+export const MAX_DOCX_XML_NESTING_DEPTH = 1000;
+export class DocxNestingTooDeepError extends Error {
+    constructor(depth, max) {
+        super(`DOCX document.xml nests ${depth} levels deep, exceeding the ${max}-level safety limit.`);
+        this.name = "DocxNestingTooDeepError";
+    }
+}
+const TAG_PATTERN = /<(\/?)([^\s/>!?][^>]*?)(\/?)>/g;
+/** Returns the deepest tag-nesting level found, without recursing. */
+export const maxXmlNestingDepth = (xml) => {
+    let depth = 0;
+    let peak = 0;
+    TAG_PATTERN.lastIndex = 0;
+    let match;
+    while ((match = TAG_PATTERN.exec(xml))) {
+        const isClosing = match[1] === "/";
+        const isSelfClosing = match[3] === "/";
+        if (isClosing) {
+            depth = Math.max(0, depth - 1);
+        }
+        else if (!isSelfClosing) {
+            depth += 1;
+            if (depth > peak)
+                peak = depth;
+        }
+    }
+    return peak;
+};
+export const assertDocxXmlWithinDepthLimit = (xml, max = MAX_DOCX_XML_NESTING_DEPTH) => {
+    const depth = maxXmlNestingDepth(xml);
+    if (depth > max)
+        throw new DocxNestingTooDeepError(depth, max);
+};

package/dist/foundation/formats/docx/portableAtoms.d.ts

@@ -0,0 +1,4 @@
+export declare const portableFormulaMarker: (value: string, displayText?: string) => string;
+export declare const portableImageMarker: (src: string, alt?: string, title?: string) => string;
+/** Restores Smart RTE atom fallback markers retained by DOCX text runs. */
+export declare const restorePortableDocxAtoms: (html: string) => string;

package/dist/foundation/formats/docx/portableAtoms.js

@@ -0,0 +1,66 @@
+import { parseFragment, serialize } from "parse5";
+const marker = /⟦SRTE_(FORMULA|IMAGE):([^⟧]+)⟧/g;
+export const portableFormulaMarker = (value, displayText) => `⟦SRTE_FORMULA:${encodeURIComponent(JSON.stringify({ value, displayText }))}⟧`;
+export const portableImageMarker = (src, alt, title) => `⟦SRTE_IMAGE:${encodeURIComponent(JSON.stringify({ src, alt, title }))}⟧`;
+const XHTML_NS = "http://www.w3.org/1999/xhtml";
+const textNode = (value) => ({ nodeName: "#text", value });
+const elementNode = (tagName, attrs, childNodes = []) => ({
+    nodeName: tagName, tagName, namespaceURI: XHTML_NS, attrs, childNodes,
+});
+const splitPortableAtoms = (text) => {
+    marker.lastIndex = 0;
+    if (!marker.test(text))
+        return [textNode(text)];
+    marker.lastIndex = 0;
+    const output = [];
+    let cursor = 0;
+    let match;
+    while ((match = marker.exec(text))) {
+        if (match.index > cursor)
+            output.push(textNode(text.slice(cursor, match.index)));
+        try {
+            const payload = JSON.parse(decodeURIComponent(match[2]));
+            if (match[1] === "FORMULA" && payload.value) {
+                // Fidelity note: canonical's own native HTML round-trip never
+                // preserves formula displayText either (atomToHtml doesn't write
+                // it, the parser doesn't read it back) - only source/notation
+                // survive. Not a DOCX-specific gap.
+                output.push(elementNode("span", [
+                    { name: "data-smart-type", value: "formula" },
+                    { name: "data-smart-formula", value: payload.value },
+                ], [textNode(payload.displayText || `$${payload.value}$`)]));
+            }
+            else if (match[1] === "IMAGE" && payload.src) {
+                const attrs = [
+                    { name: "src", value: payload.src },
+                    { name: "alt", value: payload.alt || "" },
+                    { name: "data-srte-inline", value: "true" },
+                ];
+                if (payload.title)
+                    attrs.push({ name: "title", value: payload.title });
+                output.push(elementNode("img", attrs));
+            }
+            else {
+                output.push(textNode(match[0]));
+            }
+        }
+        catch {
+            output.push(textNode(match[0]));
+        }
+        cursor = marker.lastIndex;
+    }
+    if (cursor < text.length)
+        output.push(textNode(text.slice(cursor)));
+    return output;
+};
+const visit = (node) => {
+    if (!node.childNodes)
+        return node;
+    const childNodes = node.childNodes.flatMap((child) => child.nodeName === "#text" && child.value ? splitPortableAtoms(child.value) : [visit(child)]);
+    return { ...node, childNodes };
+};
+/** Restores Smart RTE atom fallback markers retained by DOCX text runs. */
+export const restorePortableDocxAtoms = (html) => {
+    const fragment = visit(parseFragment(html));
+    return serialize(fragment);
+};

package/dist/foundation/formats/docx/styledImport.d.ts

@@ -0,0 +1,10 @@
+import type { SmartDocument } from "../../types.js";
+export interface StyledDocxImportResult {
+    document: SmartDocument;
+    layoutHtml: string;
+    source: "wordprocessingml" | "mammoth";
+}
+/** Defensive baseline styling for any table missing explicit inline styles (e.g. the mammoth fallback path, which produces plain semantic HTML with no inline CSS at all). */
+export declare const enhanceDocxTables: (html: string) => string;
+/** Fidelity: `semantic` for structure, richer visual reproduction than plain mammoth import via inline CSS reconstructed from raw wordprocessingml formatting XML, with graceful fallback to mammoth if that XML is missing or malformed. */
+export declare const importStyledDocxDocument: (arrayBuffer: ArrayBuffer) => Promise<StyledDocxImportResult>;