@a3s-lab/office 0.12.0 → 0.13.1

package/dist/0~work-docx-large-document-import.js

@@ -0,0 +1,559 @@
+import { documentSectionDomAttributes, applyDocumentPageGeometry, documentPaperSizeForGeometry, windowDocumentModel } from "./6282.js";
+const LARGE_SIMPLE_DOCX_MINIMUM_LOGICAL_BLOCKS = 20000;
+const WORD_TWIPS_PER_MILLIMETER = 1440 / 25.4;
+const UNSUPPORTED_SIMPLE_WORD_ELEMENT = /<(?:\/)?(?!w:(?:t(?:bl(?:Grid|Layout|Pr|W)?|c(?:Pr|W)?|r)?|p(?:g(?:Mar|Sz))?|r|sectPr|body|document|gridCol)(?=[\s/>]))[A-Za-z_][\w.-]*:[A-Za-z_][\w.-]*(?=[\s/>])/;
+const SIMPLE_WORD_ENVELOPE_ELEMENT = /<w:(document|body|sectPr)(?=[\s/>])/g;
+const WORD_PARAGRAPH_CLOSE = '</w:p>';
+const WORD_TABLE_CLOSE = '</w:tbl>';
+const WORD_TABLE_CELL_CLOSE = '</w:tc>';
+const WORD_TABLE_ROW_CLOSE = '</w:tr>';
+const WORD_TEXT_CLOSE = '</w:t>';
+function streamLargeSimpleDocxDocumentXml(source, options, sink) {
+    const minimumLogicalBlocks = positiveInteger(options.minimumLogicalBlocks, LARGE_SIMPLE_DOCX_MINIMUM_LOGICAL_BLOCKS);
+    const eligibilityStartedAt = largeDocxImportNow();
+    if (!simpleDocxXmlHasSupportedStructure(source)) {
+        recordLargeDocxImportMeasure('a3s-office.document.large-simple-eligibility', eligibilityStartedAt, largeDocxImportNow(), {
+            accepted: false
+        });
+        return null;
+    }
+    recordLargeDocxImportMeasure('a3s-office.document.large-simple-eligibility', eligibilityStartedAt, largeDocxImportNow(), {
+        accepted: true
+    });
+    const envelopeStartedAt = largeDocxImportNow();
+    const body = elementContentRange(source, 'body');
+    if (null === body) return null;
+    const layout = simpleDocumentLayout(source, body.start, body.end);
+    recordLargeDocxImportMeasure('a3s-office.document.large-simple-envelope', envelopeStartedAt, largeDocxImportNow());
+    let topLevelBlockCount = 0;
+    let paragraphCount = 0;
+    let standaloneParagraphCount = 0;
+    let tableRowCount = 0;
+    const contentStartedAt = largeDocxImportNow();
+    let blockCursor = body.start;
+    let paragraphStart = findWordStartTag(source, 'p', blockCursor, body.end);
+    let tableStart = findWordStartTag(source, 'tbl', blockCursor, body.end);
+    while(paragraphStart >= 0 || tableStart >= 0){
+        const blockStart = firstIndex(paragraphStart, tableStart);
+        const tagEnd = source.indexOf('>', blockStart);
+        if (tagEnd < 0 || tagEnd >= body.end) return null;
+        if (blockStart === paragraphStart) {
+            const contentEnd = source.indexOf(WORD_PARAGRAPH_CLOSE, tagEnd + 1);
+            if (contentEnd < 0 || contentEnd > body.end) return null;
+            sink.paragraph(simpleText(source, tagEnd + 1, contentEnd));
+            topLevelBlockCount += 1;
+            paragraphCount += 1;
+            standaloneParagraphCount += 1;
+            blockCursor = contentEnd + WORD_PARAGRAPH_CLOSE.length;
+            paragraphStart = findWordStartTag(source, 'p', blockCursor, body.end);
+            if (tableStart >= 0 && tableStart < blockCursor) tableStart = findWordStartTag(source, 'tbl', blockCursor, body.end);
+            continue;
+        }
+        const contentEnd = source.indexOf(WORD_TABLE_CLOSE, tagEnd + 1);
+        if (contentEnd < 0 || contentEnd > body.end) return null;
+        if (findWordStartTag(source, 'tbl', tagEnd + 1, contentEnd) >= 0) return null;
+        sink.tableStart();
+        const table = streamSimpleTableRows(source, tagEnd + 1, contentEnd, sink.tableRow);
+        if (!table) return null;
+        sink.tableEnd();
+        topLevelBlockCount += 1;
+        paragraphCount += table.paragraphCount;
+        tableRowCount += table.rowCount;
+        blockCursor = contentEnd + WORD_TABLE_CLOSE.length;
+        tableStart = findWordStartTag(source, 'tbl', blockCursor, body.end);
+        if (paragraphStart >= 0 && paragraphStart < blockCursor) paragraphStart = findWordStartTag(source, 'p', blockCursor, body.end);
+    }
+    if (!topLevelBlockCount) return null;
+    recordLargeDocxImportMeasure('a3s-office.document.large-simple-content', contentStartedAt, largeDocxImportNow(), {
+        paragraphs: paragraphCount,
+        tableRows: tableRowCount
+    });
+    const logicalBlockCount = tableRowCount + standaloneParagraphCount;
+    if (logicalBlockCount < minimumLogicalBlocks) return null;
+    return {
+        layout,
+        logicalBlockCount,
+        paragraphCount,
+        tableRowCount
+    };
+}
+function simpleDocxXmlHasSupportedStructure(source) {
+    if (!source || source.includes('<!DOCTYPE') || source.includes('<![CDATA[')) return false;
+    if (UNSUPPORTED_SIMPLE_WORD_ELEMENT.test(source)) return false;
+    const counts = simpleDocxEnvelopeElementCounts(source);
+    return 1 === counts.document && 1 === counts.body && 1 === counts.sectPr;
+}
+function streamSimpleTableRows(source, start, end, visit) {
+    let paragraphCount = 0;
+    let rowCount = 0;
+    let rowCursor = start;
+    while(rowCursor < end){
+        const rowStart = findWordStartTag(source, 'tr', rowCursor, end);
+        if (rowStart < 0) break;
+        const rowTagEnd = source.indexOf('>', rowStart);
+        if (rowTagEnd < 0 || rowTagEnd >= end) return null;
+        const rowEnd = source.indexOf(WORD_TABLE_ROW_CLOSE, rowTagEnd + 1);
+        if (rowEnd < 0 || rowEnd > end) return null;
+        const cellParagraphCounts = [];
+        const texts = [];
+        let cellCursor = rowTagEnd + 1;
+        while(cellCursor < rowEnd){
+            const cellStart = findWordStartTag(source, 'tc', cellCursor, rowEnd);
+            if (cellStart < 0) break;
+            const cellTagEnd = source.indexOf('>', cellStart);
+            if (cellTagEnd < 0 || cellTagEnd >= rowEnd) return null;
+            const cellEnd = source.indexOf(WORD_TABLE_CELL_CLOSE, cellTagEnd + 1);
+            if (cellEnd < 0 || cellEnd > rowEnd) return null;
+            let cellParagraphCount = 0;
+            let paragraphCursor = cellTagEnd + 1;
+            while(paragraphCursor < cellEnd){
+                const paragraphStart = findWordStartTag(source, 'p', paragraphCursor, cellEnd);
+                if (paragraphStart < 0) break;
+                const paragraphTagEnd = source.indexOf('>', paragraphStart);
+                if (paragraphTagEnd < 0 || paragraphTagEnd >= cellEnd) return null;
+                const paragraphEnd = source.indexOf(WORD_PARAGRAPH_CLOSE, paragraphTagEnd + 1);
+                if (paragraphEnd < 0 || paragraphEnd > cellEnd) return null;
+                texts.push(simpleText(source, paragraphTagEnd + 1, paragraphEnd));
+                cellParagraphCount += 1;
+                paragraphCount += 1;
+                paragraphCursor = paragraphEnd + WORD_PARAGRAPH_CLOSE.length;
+            }
+            if (!cellParagraphCount) {
+                texts.push('');
+                cellParagraphCount = 1;
+                paragraphCount += 1;
+            }
+            cellParagraphCounts.push(cellParagraphCount);
+            cellCursor = cellEnd + WORD_TABLE_CELL_CLOSE.length;
+        }
+        if (!cellParagraphCounts.length) return null;
+        visit({
+            cellParagraphCounts,
+            texts
+        });
+        rowCount += 1;
+        rowCursor = rowEnd + WORD_TABLE_ROW_CLOSE.length;
+    }
+    return rowCount ? {
+        paragraphCount,
+        rowCount
+    } : null;
+}
+function simpleText(source, start, end) {
+    let result = '';
+    let cursor = start;
+    while(cursor < end){
+        const textStart = findWordStartTag(source, 't', cursor, end);
+        if (textStart < 0) break;
+        const tagEnd = source.indexOf('>', textStart);
+        if (tagEnd < 0 || tagEnd >= end) return '';
+        const textEnd = source.indexOf(WORD_TEXT_CLOSE, tagEnd + 1);
+        if (textEnd < 0 || textEnd > end) return '';
+        result += decodeXmlText(source.slice(tagEnd + 1, textEnd));
+        cursor = textEnd + WORD_TEXT_CLOSE.length;
+    }
+    return result;
+}
+function simpleDocumentLayout(source, bodyStart = 0, bodyEnd = source.length) {
+    const base = initialSimpleDocumentLayout();
+    const sectionCandidate = source.lastIndexOf('<w:sectPr', bodyEnd);
+    const sectionStart = sectionCandidate >= bodyStart && wordTagNameBoundary(source.charCodeAt(sectionCandidate + 9)) ? sectionCandidate : bodyStart;
+    const pageSizeTag = startTag(source, 'pgSz', sectionStart, bodyEnd);
+    const width = wordIntegerAttribute(pageSizeTag, 'w');
+    const height = wordIntegerAttribute(pageSizeTag, 'h');
+    const orientation = 'landscape' === wordAttribute(pageSizeTag, 'orient') ? 'landscape' : 'portrait';
+    const geometry = width && height ? {
+        width,
+        height,
+        orientation
+    } : null;
+    const pageMarginsTag = startTag(source, 'pgMar', sectionStart, bodyEnd);
+    const margins = {
+        top: wordMarginMillimeters(pageMarginsTag, 'top', base.margins.top),
+        right: wordMarginMillimeters(pageMarginsTag, 'right', base.margins.right),
+        bottom: wordMarginMillimeters(pageMarginsTag, 'bottom', base.margins.bottom),
+        left: wordMarginMillimeters(pageMarginsTag, 'left', base.margins.left)
+    };
+    const layout = {
+        ...base,
+        margins,
+        orientation,
+        ...geometry ? {
+            pageSize: documentPaperSizeForGeometry(geometry),
+            pageGeometry: geometry
+        } : {}
+    };
+    return geometry ? applyDocumentPageGeometry(layout, geometry) : layout;
+}
+function initialSimpleDocumentLayout() {
+    return {
+        pageSize: 'a4',
+        orientation: 'portrait',
+        margins: {
+            top: 25,
+            right: 23,
+            bottom: 25,
+            left: 23
+        },
+        columns: {
+            count: 1,
+            spacing: 12,
+            separator: false
+        },
+        breakAfter: 'nextPage',
+        headerText: void 0,
+        footerText: void 0,
+        showPageNumbers: false,
+        pageNumberStart: void 0,
+        pageChrome: {
+            differentFirstPage: false,
+            differentOddEvenPages: false,
+            default: {
+                headerHtml: '',
+                footerHtml: '',
+                showPageNumber: false
+            },
+            first: {
+                headerHtml: '',
+                footerHtml: '',
+                showPageNumber: false
+            },
+            even: {
+                headerHtml: '',
+                footerHtml: '',
+                showPageNumber: false
+            }
+        }
+    };
+}
+function elementContentRange(source, localName) {
+    const start = findWordStartTag(source, localName, 0);
+    if (start < 0) return null;
+    const tagEnd = source.indexOf('>', start);
+    if (tagEnd < 0) return null;
+    const end = source.indexOf(`</w:${localName}>`, tagEnd + 1);
+    return end < 0 ? null : {
+        end,
+        start: tagEnd + 1
+    };
+}
+function startTag(source, localName, searchStart = 0, searchEnd = source.length) {
+    const start = findWordStartTag(source, localName, searchStart, searchEnd);
+    if (start < 0) return '';
+    const end = source.indexOf('>', start);
+    return end < 0 || end >= searchEnd ? '' : source.slice(start, end + 1);
+}
+function wordAttribute(source, localName) {
+    const escaped = localName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(?:[A-Za-z_][\\w.-]*:)?${escaped}="([^"]*)"`).exec(source)?.[1] ?? null;
+}
+function wordIntegerAttribute(source, localName) {
+    const value = Number(wordAttribute(source, localName));
+    return Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function wordMarginMillimeters(source, name, fallback) {
+    const value = wordAttribute(source, name);
+    if (null === value) return fallback;
+    const twips = Number(value);
+    return Number.isFinite(twips) && twips >= 0 ? Math.round(twips / WORD_TWIPS_PER_MILLIMETER * 100) / 100 : fallback;
+}
+function simpleDocxEnvelopeElementCounts(source) {
+    let body = 0;
+    let document = 0;
+    let sectPr = 0;
+    for (const match of source.matchAll(SIMPLE_WORD_ENVELOPE_ELEMENT))if ('body' === match[1]) body += 1;
+    else if ('document' === match[1]) document += 1;
+    else sectPr += 1;
+    return {
+        body,
+        document,
+        sectPr
+    };
+}
+function findWordStartTag(source, localName, start, end = source.length) {
+    const prefix = `<w:${localName}`;
+    let index = source.indexOf(prefix, start);
+    while(index >= 0 && index < end){
+        if (wordTagNameBoundary(source.charCodeAt(index + prefix.length))) return index;
+        index = source.indexOf(prefix, index + prefix.length);
+    }
+    return -1;
+}
+function firstIndex(left, right) {
+    if (left < 0) return right;
+    if (right < 0) return left;
+    return Math.min(left, right);
+}
+function wordTagNameBoundary(code) {
+    return 32 === code || 9 === code || 10 === code || 13 === code || 47 === code || 62 === code;
+}
+function decodeXmlText(value) {
+    if (!value.includes('&')) return value;
+    return value.replace(/&(?:#(\d+)|#x([\da-f]+)|(amp|apos|gt|lt|quot));/gi, (entity, decimal, hexadecimal, named)=>{
+        if (decimal) return safeCodePoint(Number.parseInt(decimal, 10), entity);
+        if (hexadecimal) return safeCodePoint(Number.parseInt(hexadecimal, 16), entity);
+        return ({
+            amp: '&',
+            apos: "'",
+            gt: '>',
+            lt: '<',
+            quot: '"'
+        })[named.toLowerCase()] ?? entity;
+    });
+}
+function safeCodePoint(value, fallback) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 0x10ffff) return fallback;
+    try {
+        return String.fromCodePoint(value);
+    } catch  {
+        return fallback;
+    }
+}
+function positiveInteger(value, fallback) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : fallback;
+}
+function largeDocxImportNow() {
+    return globalThis.performance?.now?.() ?? Date.now();
+}
+function recordLargeDocxImportMeasure(name, start, end, detail) {
+    try {
+        globalThis.performance?.measure(name, {
+            detail,
+            end,
+            start
+        });
+    } catch  {}
+}
+const HTML_SPECIAL_CHARACTER = /[&<>"]/;
+async function parseLargeSimpleDocxPackage(archive, options = {}) {
+    if (!largeSimpleDocxPackageIsCandidate(archive)) return null;
+    return parseLargeSimpleDocxDocumentXml(await archive.text('word/document.xml'), options);
+}
+function largeSimpleDocxPackageIsCandidate(archive) {
+    const wordParts = archive.paths('word/');
+    return 1 === wordParts.length && wordParts[0]?.toLowerCase() === 'word/document.xml';
+}
+function parseLargeSimpleDocxDocumentXml(source, options = {}) {
+    const blocks = [];
+    const html = [];
+    let tableRows = null;
+    let tableHtml = null;
+    const streamed = streamLargeSimpleDocxDocumentXml(source, options, {
+        paragraph: (text)=>{
+            if (tableRows || tableHtml) throw new Error('A table stream cannot contain a top-level paragraph.');
+            const paragraph = createLargeSimpleDocxParagraph(text);
+            blocks.push(paragraph.node);
+            html.push(paragraph.html);
+        },
+        tableEnd: ()=>{
+            if (!tableRows || !tableHtml) throw new Error('A simple DOCX table stream was not started.');
+            const table = createLargeSimpleDocxTable(tableRows, tableHtml);
+            blocks.push(table.node);
+            html.push(table.html);
+            tableRows = null;
+            tableHtml = null;
+        },
+        tableRow: (row)=>{
+            if (!tableRows || !tableHtml) throw new Error('A simple DOCX table row has no owning table.');
+            const projected = createLargeSimpleDocxTableRow(row);
+            tableRows.push(projected.node);
+            tableHtml.push(projected.html);
+        },
+        tableStart: ()=>{
+            if (tableRows || tableHtml) throw new Error('Nested simple DOCX tables are not supported.');
+            tableRows = [];
+            tableHtml = [];
+        }
+    });
+    if (!streamed || tableRows || tableHtml || !blocks.length) return null;
+    return createLargeSimpleDocxParseResult(streamed, blocks, html, options);
+}
+function createLargeSimpleDocxParseResult(streamed, blocks, html, options = {}) {
+    const sectionId = 'document-section-1';
+    const projectionStartedAt = work_docx_large_document_import_largeDocxImportNow();
+    const sectionAttributes = documentSectionDomAttributes(streamed.layout, sectionId);
+    const canonicalHtml = `<section${htmlAttributes(sectionAttributes)}>${html.join('')}</section>`;
+    work_docx_large_document_import_recordLargeDocxImportMeasure('a3s-office.document.large-simple-html', projectionStartedAt, work_docx_large_document_import_largeDocxImportNow());
+    const windowingStartedAt = work_docx_large_document_import_largeDocxImportNow();
+    const root = windowDocumentModel({
+        type: 'doc',
+        content: [
+            {
+                type: 'documentSection',
+                attrs: documentSectionModelAttributes(streamed.layout, sectionId),
+                content: blocks
+            }
+        ]
+    }, {
+        ...options.windowing,
+        trustedIntegrityFeatures: 0
+    });
+    work_docx_large_document_import_recordLargeDocxImportMeasure('a3s-office.document.large-simple-windowing', windowingStartedAt, work_docx_large_document_import_largeDocxImportNow());
+    return {
+        html: canonicalHtml,
+        layout: streamed.layout,
+        logicalBlockCount: streamed.logicalBlockCount,
+        paragraphCount: streamed.paragraphCount,
+        root,
+        tableRowCount: streamed.tableRowCount
+    };
+}
+function createLargeSimpleDocxTable(rows, htmlRows) {
+    return {
+        html: `<table data-office-table-imported="true"><tbody>${htmlRows.join('')}</tbody></table>`,
+        node: {
+            type: 'table',
+            attrs: {
+                officeImported: true
+            },
+            content: rows
+        }
+    };
+}
+function createLargeSimpleDocxParagraph(text) {
+    return {
+        html: `<p>${escapeHtml(text)}</p>`,
+        node: {
+            type: 'paragraph',
+            ...text ? {
+                content: [
+                    {
+                        type: 'text',
+                        text
+                    }
+                ]
+            } : {}
+        }
+    };
+}
+function createLargeSimpleDocxTableRow(row) {
+    const cellNodes = [];
+    const cellHtml = [];
+    let textIndex = 0;
+    for (const paragraphCount of row.cellParagraphCounts){
+        const paragraphNodes = [];
+        let paragraphsHtml = '';
+        for(let index = 0; index < paragraphCount; index += 1){
+            const text = row.texts[textIndex] ?? '';
+            const projected = createLargeSimpleDocxParagraph(text);
+            paragraphNodes.push(projected.node);
+            paragraphsHtml += projected.html;
+            textIndex += 1;
+        }
+        cellNodes.push({
+            type: 'tableCell',
+            content: paragraphNodes
+        });
+        cellHtml.push(`<td>${paragraphsHtml}</td>`);
+    }
+    return {
+        html: `<tr>${cellHtml.join('')}</tr>`,
+        node: {
+            type: 'tableRow',
+            content: cellNodes
+        }
+    };
+}
+function largeSimpleDocxContent(result) {
+    return {
+        type: 'document',
+        html: result.html,
+        pageSize: result.layout.pageSize,
+        orientation: result.layout.orientation,
+        margins: result.layout.margins,
+        columns: result.layout.columns,
+        headerText: result.layout.headerText,
+        footerText: result.layout.footerText,
+        showPageNumbers: result.layout.showPageNumbers,
+        pageNumberStart: result.layout.pageNumberStart,
+        pageChrome: result.layout.pageChrome,
+        pageBorders: result.layout.pageBorders,
+        pageMargins: result.layout.pageMargins,
+        pageGeometry: result.layout.pageGeometry,
+        paperSource: result.layout.paperSource
+    };
+}
+function largeSimpleDocxCompatibilityReport(file, result) {
+    return {
+        sourceFormat: 'DOCX',
+        sourceName: file.name,
+        assessedAt: Date.now(),
+        issues: [
+            {
+                code: 'docx.page-layout',
+                feature: 'Page layout',
+                message: 'Paper size and margins are preserved; exact pagination and line wrapping may normalize.',
+                severity: 'warning'
+            },
+            {
+                code: 'docx.package-state',
+                feature: 'OOXML package state',
+                message: 'The plain source package remains attached for source-backed export.',
+                severity: 'info'
+            },
+            {
+                code: 'docx.large-document-windowing',
+                feature: 'Large document rendering',
+                message: `${result.logicalBlockCount} logical block(s) use bounded viewport rendering while the complete structured model remains editable.`,
+                severity: 'info'
+            },
+            ...result.tableRowCount ? [
+                {
+                    code: 'docx.tables',
+                    feature: 'Tables',
+                    message: `${result.tableRowCount} table row(s) remain editable and are joined into canonical DOCX tables on export.`,
+                    severity: 'info'
+                }
+            ] : []
+        ]
+    };
+}
+function documentSectionModelAttributes(layout, id) {
+    const attributes = documentSectionDomAttributes(layout, id);
+    return {
+        id,
+        pageSize: layout.pageSize,
+        orientation: layout.orientation,
+        marginTop: layout.margins.top,
+        marginRight: layout.margins.right,
+        marginBottom: layout.margins.bottom,
+        marginLeft: layout.margins.left,
+        columnCount: layout.columns.count,
+        columnSpacing: layout.columns.spacing,
+        columnSeparator: layout.columns.separator,
+        columnLayout: attributes['data-section-column-layout'] ?? '',
+        breakAfter: layout.breakAfter,
+        headerText: layout.headerText ?? '',
+        footerText: layout.footerText ?? '',
+        showPageNumbers: Boolean(layout.showPageNumbers),
+        pageNumberStart: layout.pageNumberStart ?? null,
+        pageChrome: attributes['data-section-page-chrome'] ?? '',
+        pageBorders: attributes['data-section-page-borders'] ?? '',
+        pageMargins: attributes['data-section-page-margins'] ?? '',
+        pageGeometry: attributes['data-section-page-geometry'] ?? '',
+        paperSource: attributes['data-section-paper-source'] ?? '',
+        documentGridType: attributes['data-section-document-grid-type'] ?? '',
+        documentGridLinePitch: null
+    };
+}
+function htmlAttributes(attributes) {
+    return Object.entries(attributes).map(([name, value])=>` ${name}="${escapeHtml(value)}"`).join('');
+}
+function escapeHtml(value) {
+    if (!HTML_SPECIAL_CHARACTER.test(value)) return value;
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
+}
+function work_docx_large_document_import_largeDocxImportNow() {
+    return globalThis.performance?.now?.() ?? Date.now();
+}
+function work_docx_large_document_import_recordLargeDocxImportMeasure(name, start, end, detail) {
+    try {
+        globalThis.performance?.measure(name, {
+            detail,
+            end,
+            start
+        });
+    } catch  {}
+}
+export { createLargeSimpleDocxParagraph, createLargeSimpleDocxParseResult, createLargeSimpleDocxTable, largeSimpleDocxCompatibilityReport, largeSimpleDocxContent, largeSimpleDocxPackageIsCandidate, parseLargeSimpleDocxPackage };