smartrte-react 0.3.3 → 0.3.5

package/dist/adapters/pdfFormat.js

@@ -0,0 +1,204 @@
+import { normalizeSmartDocument } from "smartrte-core";
+import { exportTextDocument } from "./documentFormats.js";
+import { smartDocumentFromHtml } from "./domSmartDocument.js";
+export const PDF_MEDIA_TYPE = "application/pdf";
+const escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const spanFor = (item) => {
+    const family = item.fontFamily?.toLowerCase() || "";
+    const styles = [
+        `font-size:${Math.max(8, Math.round(item.height))}px`,
+        family.includes("bold") ? "font-weight:700" : "",
+        family.includes("italic") || family.includes("oblique") ? "font-style:italic" : "",
+    ].filter(Boolean).join(";");
+    return `<span style="${styles}">${escapeHtml(item.text)}</span>`;
+};
+const lineContent = (items) => {
+    let previousRight;
+    let text = "";
+    let html = "";
+    const starts = [];
+    const gaps = [];
+    items.forEach((item, index) => {
+        const gap = previousRight === undefined ? 0 : item.x - previousRight;
+        if (index === 0 || gap > 20)
+            starts.push(item.x);
+        if (gap > 2) {
+            text += " ";
+            html += " ";
+            if (gap > 20)
+                gaps.push(gap);
+        }
+        text += item.text;
+        html += spanFor(item);
+        previousRight = item.x + item.width;
+    });
+    return { text, html, starts, gaps };
+};
+const alignmentForLine = (items, pageWidth) => {
+    const first = items[0]?.x || 0;
+    const last = items[items.length - 1];
+    const right = last ? last.x + last.width : first;
+    const center = (first + right) / 2;
+    if (Math.abs(center - pageWidth / 2) < pageWidth * 0.12)
+        return "center";
+    if (first > pageWidth * 0.55)
+        return "right";
+    return "";
+};
+export const reconstructPdfPages = (pages, ownerDocument) => {
+    let layoutHtml = "";
+    pages.forEach((page) => {
+        const heights = page.items.map((item) => item.height).filter((height) => height > 0).sort((a, b) => a - b);
+        const medianHeight = heights[Math.floor(heights.length / 2)] || 12;
+        const lines = [];
+        page.items.filter((item) => item.text.trim()).forEach((item) => {
+            const line = lines.find((candidate) => Math.abs(candidate.y - item.y) < medianHeight * 0.5);
+            if (line)
+                line.items.push(item);
+            else
+                lines.push({ y: item.y, items: [item] });
+        });
+        lines.sort((left, right) => right.y - left.y);
+        lines.forEach((line) => line.items.sort((left, right) => left.x - right.x));
+        let pageHtml = "";
+        let activeList;
+        let tableColumns = [];
+        let tableRows = [];
+        const closeList = () => {
+            if (activeList)
+                pageHtml += `</${activeList}>`;
+            activeList = undefined;
+        };
+        const closeTable = () => {
+            if (tableRows.length) {
+                pageHtml += `<table style="border-collapse:collapse;width:100%"><tbody>${tableRows.join("")}</tbody></table>`;
+            }
+            tableRows = [];
+            tableColumns = [];
+        };
+        lines.forEach((line) => {
+            const content = lineContent(line.items);
+            const alignsWithTable = tableColumns.length > 0
+                && content.starts.some((x) => tableColumns.some((column) => Math.abs(column - x) < 20));
+            const beginsTable = content.starts.length >= 2 && content.gaps.some((gap) => gap > 30);
+            if (beginsTable || alignsWithTable) {
+                closeList();
+                if (!tableColumns.length)
+                    tableColumns = [...content.starts];
+                const cells = new Array(tableColumns.length).fill("");
+                line.items.forEach((item) => {
+                    let column = 0;
+                    tableColumns.forEach((start, index) => {
+                        if (item.x >= start - 10)
+                            column = index;
+                    });
+                    cells[column] += `${cells[column] ? " " : ""}${spanFor(item)}`;
+                });
+                tableRows.push(`<tr>${cells.map((cell) => `<td style="border:1px solid #d1d5db;padding:8px;vertical-align:top">${cell || "&nbsp;"}</td>`).join("")}</tr>`);
+                return;
+            }
+            closeTable();
+            const bullet = /^[•\-*]\s/.test(content.text);
+            const numbered = /^\d+[.)]\s/.test(content.text);
+            if (bullet || numbered) {
+                const type = bullet ? "ul" : "ol";
+                if (activeList !== type) {
+                    closeList();
+                    activeList = type;
+                    pageHtml += `<${type}>`;
+                }
+                const listItems = line.items.map((item, index) => index === 0
+                    ? { ...item, text: item.text.replace(bullet ? /^[•\-*]\s*/ : /^\d+[.)]\s*/, "") }
+                    : item);
+                pageHtml += `<li>${lineContent(listItems).html.trim()}</li>`;
+                return;
+            }
+            closeList();
+            const largest = Math.max(...line.items.map((item) => item.height));
+            const heading = largest > medianHeight * 1.2;
+            const tag = heading ? (largest > medianHeight * 1.5 ? "h2" : "h3") : "p";
+            const alignment = alignmentForLine(line.items, page.width);
+            const indent = !alignment && line.items[0]?.x > 40 ? `margin-left:${Math.round(line.items[0].x)}px` : "";
+            const style = [alignment ? `text-align:${alignment}` : "", indent].filter(Boolean).join(";");
+            pageHtml += `<${tag}${style ? ` style="${style}"` : ""}>${content.html}</${tag}>`;
+        });
+        closeList();
+        closeTable();
+        layoutHtml += pageHtml;
+    });
+    return {
+        document: normalizeSmartDocument(smartDocumentFromHtml(layoutHtml, ownerDocument)),
+        layoutHtml,
+        pages: pages.length,
+    };
+};
+export const importPdfDocument = async (arrayBuffer, ownerDocument) => {
+    const pdfjsLib = await import("pdfjs-dist");
+    if (typeof window !== "undefined") {
+        pdfjsLib.GlobalWorkerOptions.workerSrc = new URL("pdfjs-dist/build/pdf.worker.min.mjs", import.meta.url).toString();
+    }
+    const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
+    const pages = [];
+    for (let index = 1; index <= pdf.numPages; index += 1) {
+        const page = await pdf.getPage(index);
+        const viewport = page.getViewport({ scale: 1 });
+        const content = await page.getTextContent();
+        const styles = content.styles;
+        pages.push({
+            width: viewport.width,
+            items: content.items.map((item) => ({
+                text: item.str || "",
+                x: item.transform[4],
+                y: item.transform[5],
+                width: item.width || 0,
+                height: Math.abs(item.transform[3]) || 0,
+                fontFamily: styles[item.fontName]?.fontFamily,
+            })),
+        });
+    }
+    return reconstructPdfPages(pages, ownerDocument);
+};
+export const buildPdfPrintDocument = (document) => {
+    const html = exportTextDocument("html", document);
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>Smart RTE PDF Export</title>
+  <style>
+    @page { margin: 18mm; }
+    html, body { background: #fff; }
+    body {
+      color: #111;
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      line-height: 1.6;
+      padding: 32px;
+    }
+    table { border-collapse: collapse; width: 100%; margin: 12px 0; break-inside: auto; }
+    tr, img, blockquote, pre { break-inside: avoid; }
+    td, th { border: 1px solid #d1d5db; padding: 8px; vertical-align: top; }
+    img { max-width: 100%; height: auto; }
+    blockquote { border-left: 4px solid #d1d5db; padding-left: 12px; color: #374151; }
+    pre, code { background: #f3f4f6; }
+    pre { padding: 12px; white-space: pre-wrap; }
+    @media print { body { padding: 0; } }
+  </style>
+</head>
+<body>${html || "<p></p>"}</body>
+</html>`;
+};
+export const printSmartDocumentAsPdf = (document, hostWindow, delayMs = 150) => {
+    const printWindow = hostWindow.open("", "_blank", "width=900,height=700");
+    if (!printWindow)
+        return false;
+    printWindow.addEventListener("load", () => {
+        printWindow.setTimeout(() => {
+            printWindow.focus();
+            printWindow.print();
+        }, delayMs);
+    }, { once: true });
+    printWindow.document.open();
+    printWindow.document.write(buildPdfPrintDocument(document));
+    printWindow.document.close();
+    return true;
+};

package/dist/adapters/portableDocxAtoms.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, ownerDocument: Document) => string;

package/dist/adapters/portableDocxAtoms.js

@@ -0,0 +1,58 @@
+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 }))}⟧`;
+/** Restores Smart RTE atom fallback markers retained by DOCX text runs. */
+export const restorePortableDocxAtoms = (html, ownerDocument) => {
+    const root = ownerDocument.createElement("div");
+    root.innerHTML = html;
+    const walker = ownerDocument.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const textNodes = [];
+    let current = walker.nextNode();
+    while (current) {
+        textNodes.push(current);
+        current = walker.nextNode();
+    }
+    textNodes.forEach((textNode) => {
+        const text = textNode.data;
+        marker.lastIndex = 0;
+        if (!marker.test(text))
+            return;
+        marker.lastIndex = 0;
+        const fragment = ownerDocument.createDocumentFragment();
+        let cursor = 0;
+        let match;
+        while ((match = marker.exec(text))) {
+            if (match.index > cursor)
+                fragment.append(text.slice(cursor, match.index));
+            try {
+                const payload = JSON.parse(decodeURIComponent(match[2]));
+                if (match[1] === "FORMULA" && payload.value) {
+                    const formula = ownerDocument.createElement("span");
+                    formula.dataset.formula = payload.value;
+                    formula.textContent = payload.displayText || `$${payload.value}$`;
+                    fragment.append(formula);
+                }
+                else if (match[1] === "IMAGE" && payload.src) {
+                    const image = ownerDocument.createElement("img");
+                    image.src = payload.src;
+                    image.alt = payload.alt || "";
+                    if (payload.title)
+                        image.title = payload.title;
+                    image.dataset.srteInline = "true";
+                    fragment.append(image);
+                }
+                else {
+                    fragment.append(match[0]);
+                }
+            }
+            catch {
+                fragment.append(match[0]);
+            }
+            cursor = marker.lastIndex;
+        }
+        if (cursor < text.length)
+            fragment.append(text.slice(cursor));
+        textNode.replaceWith(fragment);
+    });
+    return root.innerHTML;
+};

package/dist/adapters/styledDocxFormat.d.ts

@@ -0,0 +1,8 @@
+import { type SmartDocument } from "smartrte-core";
+export interface StyledDocxImportResult {
+    document: SmartDocument;
+    layoutHtml: string;
+    source: "wordprocessingml" | "mammoth";
+}
+export declare const enhanceDocxTables: (root: HTMLElement) => void;
+export declare const importStyledDocxDocument: (arrayBuffer: ArrayBuffer, ownerDocument: Document) => Promise<StyledDocxImportResult>;

package/dist/adapters/styledDocxFormat.js

@@ -0,0 +1,190 @@
+import JSZip from "jszip";
+import { normalizeSmartDocument } from "smartrte-core";
+import { restorePortableDocxAtoms } from "./portableDocxAtoms.js";
+import { serializeSmartDocument, smartDocumentFromHtml } from "./domSmartDocument.js";
+import { importDocxDocumentWithMammoth } from "./docxFormat.js";
+const directChildren = (node) => Array.from(node.children);
+const firstChildByName = (node, localName) => node ? directChildren(node).find((child) => child.localName === localName) : undefined;
+const childrenByName = (node, localName) => node ? directChildren(node).filter((child) => child.localName === localName) : [];
+const docxAttr = (node, name) => {
+    if (!node)
+        return "";
+    return node.getAttribute(`w:${name}`)
+        || node.getAttribute(name)
+        || node.getAttributeNS("http://schemas.openxmlformats.org/wordprocessingml/2006/main", name)
+        || "";
+};
+const escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const docxHexColor = (value) => {
+    if (!value || value.toLowerCase() === "auto")
+        return "";
+    const normalized = value.replace(/[^0-9a-f]/gi, "");
+    return normalized.length === 6 ? `#${normalized}` : "";
+};
+const twipsToPt = (value) => {
+    if (!value)
+        return "";
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? `${Math.max(numeric / 20, 0)}pt` : "";
+};
+const halfPointsToPt = (value) => {
+    if (!value)
+        return "";
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? `${Math.max(numeric / 2, 1)}pt` : "";
+};
+const cssRules = (rules) => rules.filter(([, value]) => Boolean(value)).map(([name, value]) => `${name}: ${value}`).join("; ");
+const styleAttr = (style) => style ? ` style="${escapeHtml(style)}"` : "";
+const borderCss = (border) => {
+    if (!border)
+        return "";
+    const value = docxAttr(border, "val");
+    if (!value || value === "nil" || value === "none")
+        return "";
+    const size = Number(docxAttr(border, "sz")) || 4;
+    const color = docxHexColor(docxAttr(border, "color")) || "#d1d5db";
+    return `${Math.max(size / 8, 0.5)}px solid ${color}`;
+};
+const paragraphStyle = (paragraph) => {
+    const properties = firstChildByName(paragraph, "pPr");
+    if (!properties)
+        return "";
+    const spacing = firstChildByName(properties, "spacing");
+    const justification = firstChildByName(properties, "jc");
+    const indent = firstChildByName(properties, "ind");
+    const bottomBorder = firstChildByName(firstChildByName(properties, "pBdr"), "bottom");
+    const line = docxAttr(spacing, "line");
+    return cssRules([
+        ["text-align", docxAttr(justification, "val")],
+        ["margin-top", twipsToPt(docxAttr(spacing, "before"))],
+        ["margin-bottom", twipsToPt(docxAttr(spacing, "after"))],
+        ["margin-left", twipsToPt(docxAttr(indent, "left"))],
+        ["text-indent", twipsToPt(docxAttr(indent, "firstLine"))],
+        ["line-height", line && docxAttr(spacing, "lineRule") === "auto" ? `${Number(line) / 240}` : ""],
+        ["border-bottom", borderCss(bottomBorder)],
+    ]);
+};
+const runStyle = (run) => {
+    const properties = firstChildByName(run, "rPr");
+    if (!properties)
+        return "";
+    const color = docxHexColor(docxAttr(firstChildByName(properties, "color"), "val"));
+    const highlight = docxHexColor(docxAttr(firstChildByName(properties, "highlight"), "val"));
+    const shade = docxHexColor(docxAttr(firstChildByName(properties, "shd"), "fill"));
+    return cssRules([
+        ["font-weight", firstChildByName(properties, "b") ? "700" : ""],
+        ["font-style", firstChildByName(properties, "i") ? "italic" : ""],
+        ["text-decoration", firstChildByName(properties, "u") ? "underline" : ""],
+        ["color", color],
+        ["background-color", highlight || shade],
+        ["font-size", halfPointsToPt(docxAttr(firstChildByName(properties, "sz"), "val"))],
+    ]);
+};
+const runHtml = (run) => {
+    const properties = firstChildByName(run, "rPr");
+    const verticalAlignment = docxAttr(firstChildByName(properties, "vertAlign"), "val");
+    const content = directChildren(run).map((child) => {
+        if (child.localName === "t")
+            return escapeHtml(child.textContent || "");
+        if (child.localName === "tab")
+            return "&emsp;";
+        if (child.localName === "br") {
+            return docxAttr(child, "type") === "page" ? '<hr class="srte-docx-page-break">' : "<br>";
+        }
+        return "";
+    }).join("");
+    if (!content)
+        return "";
+    const tag = verticalAlignment === "superscript" ? "sup" : verticalAlignment === "subscript" ? "sub" : "span";
+    return `<${tag}${styleAttr(runStyle(run))}>${content}</${tag}>`;
+};
+const paragraphHtml = (paragraph) => {
+    const content = childrenByName(paragraph, "r").map(runHtml).join("");
+    return `<p${styleAttr(paragraphStyle(paragraph))}>${content || "<br>"}</p>`;
+};
+const cellStyle = (cell) => {
+    const properties = firstChildByName(cell, "tcPr");
+    const borders = firstChildByName(properties, "tcBorders");
+    return cssRules([
+        ["width", twipsToPt(docxAttr(firstChildByName(properties, "tcW"), "w"))],
+        ["background-color", docxHexColor(docxAttr(firstChildByName(properties, "shd"), "fill"))],
+        ["border-top", borderCss(firstChildByName(borders, "top"))],
+        ["border-right", borderCss(firstChildByName(borders, "right"))],
+        ["border-bottom", borderCss(firstChildByName(borders, "bottom"))],
+        ["border-left", borderCss(firstChildByName(borders, "left"))],
+        ["padding", "8px"],
+        ["vertical-align", "top"],
+    ]);
+};
+const tableHtml = (table) => {
+    const rows = childrenByName(table, "tr").map((row) => {
+        const cells = childrenByName(row, "tc").map((cell) => {
+            const content = directChildren(cell)
+                .filter((child) => child.localName === "p" || child.localName === "tbl")
+                .map((child) => child.localName === "p" ? paragraphHtml(child) : tableHtml(child))
+                .join("");
+            return `<td${styleAttr(cellStyle(cell))}>${content || "<p><br></p>"}</td>`;
+        }).join("");
+        return `<tr>${cells}</tr>`;
+    }).join("");
+    return `<table style="border-collapse: collapse; width: 100%; margin: 12px 0;"><tbody>${rows}</tbody></table>`;
+};
+export const enhanceDocxTables = (root) => {
+    root.querySelectorAll("table").forEach((table) => {
+        var _a, _b;
+        const styledTable = table;
+        (_a = styledTable.style).borderCollapse || (_a.borderCollapse = "collapse");
+        (_b = styledTable.style).width || (_b.width = "100%");
+        table.querySelectorAll("td, th").forEach((cell) => {
+            var _a, _b;
+            const styledCell = cell;
+            if (!styledCell.style.border && !styledCell.style.borderTop && !styledCell.style.borderRight
+                && !styledCell.style.borderBottom && !styledCell.style.borderLeft) {
+                styledCell.style.border = "1px solid #d1d5db";
+            }
+            (_a = styledCell.style).padding || (_a.padding = "8px");
+            (_b = styledCell.style).verticalAlign || (_b.verticalAlign = "top");
+        });
+    });
+};
+const mammothFallback = async (arrayBuffer, ownerDocument) => {
+    const document = await importDocxDocumentWithMammoth(arrayBuffer, ownerDocument);
+    const container = ownerDocument.createElement("div");
+    container.innerHTML = serializeSmartDocument(document);
+    enhanceDocxTables(container);
+    return { document, layoutHtml: container.innerHTML, source: "mammoth" };
+};
+export const importStyledDocxDocument = async (arrayBuffer, ownerDocument) => {
+    try {
+        const zip = await JSZip.loadAsync(arrayBuffer);
+        const documentXml = await zip.file("word/document.xml")?.async("text");
+        if (!documentXml)
+            return mammothFallback(arrayBuffer, ownerDocument);
+        const parsed = new ownerDocument.defaultView.DOMParser().parseFromString(documentXml, "application/xml");
+        if (parsed.querySelector("parsererror"))
+            return mammothFallback(arrayBuffer, ownerDocument);
+        const body = Array.from(parsed.getElementsByTagName("*")).find((node) => node.localName === "body");
+        if (!body)
+            return mammothFallback(arrayBuffer, ownerDocument);
+        const rawHtml = directChildren(body).filter((node) => node.localName !== "sectPr").map((node) => {
+            if (node.localName === "p")
+                return paragraphHtml(node);
+            if (node.localName === "tbl")
+                return tableHtml(node);
+            return "";
+        }).join("");
+        if (!rawHtml.trim())
+            return mammothFallback(arrayBuffer, ownerDocument);
+        const container = ownerDocument.createElement("div");
+        container.innerHTML = restorePortableDocxAtoms(rawHtml, ownerDocument);
+        enhanceDocxTables(container);
+        return {
+            document: normalizeSmartDocument(smartDocumentFromHtml(container.innerHTML, ownerDocument)),
+            layoutHtml: container.innerHTML,
+            source: "wordprocessingml",
+        };
+    }
+    catch {
+        return mammothFallback(arrayBuffer, ownerDocument);
+    }
+};

package/dist/builtInFormatDefinitions.d.ts

@@ -0,0 +1,5 @@
+import type { EditorFormatDefinition } from "./formatRuntime.js";
+export interface BuiltInFormatDefinitionOptions {
+    preserveDocxStyles?: boolean;
+}
+export declare const createBuiltInFormatDefinitions: (options?: BuiltInFormatDefinitionOptions) => readonly EditorFormatDefinition[];

package/dist/builtInFormatDefinitions.js

@@ -0,0 +1,82 @@
+import { exportTextDocument, importTextDocument } from "./adapters/documentFormats.js";
+import { exportDocxDocument, importDocxDocumentWithMammoth } from "./adapters/docxFormat.js";
+import { importPdfDocument, printSmartDocumentAsPdf } from "./adapters/pdfFormat.js";
+import { enhanceDocxTables, importStyledDocxDocument } from "./adapters/styledDocxFormat.js";
+import { serializeSmartDocument } from "./adapters/domSmartDocument.js";
+const standaloneHtmlDocument = (html) => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Smart RTE Export</title><style>
+html,body{margin:0;background:#fff;color:#111;font-family:system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;line-height:1.6}
+body{padding:32px}.srte-export{max-width:960px;margin:0 auto}h1,h2,h3,h4,h5,h6{line-height:1.3;margin:1.25em 0 .5em}
+p{margin:0 0 .85em}blockquote{border-left:4px solid #1e90ff;margin:.75em 0;padding:.5em 1em;background:#f3f4f6}
+ul,ol{margin:.75em 0;padding-left:1.75em;list-style-position:outside}li{display:list-item;margin:.25em 0;padding-left:.25em}
+table{border-collapse:collapse;width:100%;margin:12px 0}td,th{border:1px solid #d1d5db;padding:8px;vertical-align:top;text-align:left}
+th{background:#f3f4f6;font-weight:700}img{max-width:100%;height:auto}pre,code{background:#f3f4f6;border-radius:4px}
+pre{padding:12px;overflow-x:auto;white-space:pre-wrap}@media print{body{padding:0}.srte-export{max-width:none}}
+</style></head><body><main class="srte-export">${html || "<p></p>"}</main></body></html>`;
+export const createBuiltInFormatDefinitions = (options = {}) => [
+    {
+        id: "pdf", label: "PDF", extension: "pdf", accept: "application/pdf",
+        canImport: true, canExport: true, confirmImportWhenNotEmpty: true,
+        importFile: async (file, context) => {
+            const result = await importPdfDocument(await file.arrayBuffer(), context.ownerDocument);
+            return { ...result, preserveColors: true, preserveDocumentLayout: true };
+        },
+        exportDocument: (document, context) => {
+            printSmartDocumentAsPdf(document, context.hostWindow);
+            return { kind: "handled" };
+        },
+    },
+    {
+        id: "docx", label: "Microsoft Word", extension: "docx", accept: ".docx",
+        canImport: true, canExport: true, confirmImportWhenNotEmpty: true,
+        importFile: async (file, context) => {
+            const buffer = await file.arrayBuffer();
+            if (options.preserveDocxStyles ?? true) {
+                const result = await importStyledDocxDocument(buffer, context.ownerDocument);
+                return {
+                    document: result.document,
+                    layoutHtml: `<div class="srte-preserve-colors">${result.layoutHtml}</div>`,
+                    preserveColors: true,
+                    preserveDocumentLayout: true,
+                };
+            }
+            const document = await importDocxDocumentWithMammoth(buffer, context.ownerDocument);
+            const container = context.ownerDocument.createElement("div");
+            container.innerHTML = serializeSmartDocument(document);
+            enhanceDocxTables(container);
+            return {
+                document,
+                layoutHtml: `<div class="srte-preserve-colors">${container.innerHTML}</div>`,
+            };
+        },
+        exportDocument: async (document) => ({
+            kind: "blob", filename: "smart-rte-export.docx",
+            content: await exportDocxDocument(document),
+        }),
+    },
+    {
+        id: "html", label: "HTML", extension: "html", accept: ".html,.htm,text/html",
+        canImport: true, canExport: true,
+        importFile: async (file, context) => ({
+            document: importTextDocument("html", await file.text(), context),
+            preserveColors: true, preserveDocumentLayout: true,
+        }),
+        exportDocument: (document) => ({
+            kind: "text", filename: "smart-rte-export.html", mediaType: "text/html;charset=utf-8",
+            content: standaloneHtmlDocument(exportTextDocument("html", document)),
+        }),
+    },
+    {
+        id: "markdown", label: "Markdown", extension: "md",
+        accept: ".md,.markdown,text/markdown,text/plain", canImport: true, canExport: true,
+        importFile: async (file, context) => ({
+            document: importTextDocument("markdown", await file.text(), context),
+            preserveColors: true, preserveDocumentLayout: true,
+        }),
+        exportDocument: (document) => ({
+            kind: "text", filename: "smart-rte-export.md", mediaType: "text/markdown;charset=utf-8",
+            content: exportTextDocument("markdown", document),
+        }),
+    },
+];

package/dist/canonicalAuthorityFlag.d.ts

@@ -0,0 +1,32 @@
+export interface CanonicalAuthorityContext {
+    tenantId?: string;
+    documentId?: string;
+}
+export interface CanonicalAuthorityFlagSnapshot {
+    global: boolean;
+    tenants: Readonly<Record<string, boolean>>;
+    documents: Readonly<Record<string, boolean>>;
+}
+/**
+ * Runtime rollback switch. Resolution order is direct component override,
+ * document, tenant, then global. Development stays opt-in until the Phase 8b
+ * replay and production-surface gates have passed.
+ */
+declare class CanonicalAuthorityFlag {
+    private globalEnabled;
+    private tenants;
+    private documents;
+    private listeners;
+    private version;
+    private changed;
+    enabled(context?: CanonicalAuthorityContext, direct?: boolean): boolean;
+    setGlobal(enabled: boolean): void;
+    setTenant(tenantId: string, enabled: boolean | null): void;
+    setDocument(documentId: string, enabled: boolean | null): void;
+    snapshot(): CanonicalAuthorityFlagSnapshot;
+    subscribe(listener: () => void): () => void;
+    getVersion(): number;
+    reset(): void;
+}
+export declare const canonicalAuthorityFlag: CanonicalAuthorityFlag;
+export {};

package/dist/canonicalAuthorityFlag.js

@@ -0,0 +1,49 @@
+/**
+ * Runtime rollback switch. Resolution order is direct component override,
+ * document, tenant, then global. Development stays opt-in until the Phase 8b
+ * replay and production-surface gates have passed.
+ */
+class CanonicalAuthorityFlag {
+    constructor() {
+        this.globalEnabled = false;
+        this.tenants = new Map();
+        this.documents = new Map();
+        this.listeners = new Set();
+        this.version = 0;
+    }
+    changed() { this.version += 1; this.listeners.forEach((listener) => listener()); }
+    enabled(context = {}, direct) {
+        if (direct !== undefined)
+            return direct;
+        if (context.documentId && this.documents.has(context.documentId))
+            return this.documents.get(context.documentId);
+        if (context.tenantId && this.tenants.has(context.tenantId))
+            return this.tenants.get(context.tenantId);
+        return this.globalEnabled;
+    }
+    setGlobal(enabled) { if (this.globalEnabled !== enabled) {
+        this.globalEnabled = enabled;
+        this.changed();
+    } }
+    setTenant(tenantId, enabled) {
+        if (enabled === null)
+            this.tenants.delete(tenantId);
+        else
+            this.tenants.set(tenantId, enabled);
+        this.changed();
+    }
+    setDocument(documentId, enabled) {
+        if (enabled === null)
+            this.documents.delete(documentId);
+        else
+            this.documents.set(documentId, enabled);
+        this.changed();
+    }
+    snapshot() {
+        return { global: this.globalEnabled, tenants: Object.fromEntries(this.tenants), documents: Object.fromEntries(this.documents) };
+    }
+    subscribe(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+    getVersion() { return this.version; }
+    reset() { this.globalEnabled = false; this.tenants.clear(); this.documents.clear(); this.changed(); }
+}
+export const canonicalAuthorityFlag = new CanonicalAuthorityFlag();

package/dist/canonicalClipboardRuntime.d.ts

@@ -0,0 +1,15 @@
+import { type ClipboardDiagnosticReport } from "smartrte-core/foundation";
+/**
+ * ROLLBACK_ADAPTER: canonical-clipboard-dom-insert; unreachable from canonical authority.
+ * Legacy rollback-only DOM insertion. The canonical product path never imports this module.
+ */
+export declare const insertCanonicalClipboardData: (transfer: DataTransfer, ownerDocument: Document, onDiagnostic?: (report: ClipboardDiagnosticReport) => void) => boolean;
+export interface CanonicalClipboardRuntimeOptions {
+    ownerDocument: Document;
+    onFiles?: (files: readonly File[]) => boolean;
+    beforeInsert?: () => void;
+    afterInsert?: () => void;
+    onDiagnostic?: (report: ClipboardDiagnosticReport) => void;
+}
+/** Owns the product paste listener outside ClassicEditor. */
+export declare const installCanonicalClipboardRuntime: (root: HTMLElement, options: CanonicalClipboardRuntimeOptions) => (() => void);