@a3s-lab/office 0.12.0 → 0.13.1

package/dist/work-document-import.worker.js

@@ -0,0 +1,558 @@
+(()=>{
+    const DOCUMENT_PAPER_SIZE_PRESETS = [
+        'a3',
+        'a4',
+        'a5',
+        'letter',
+        'legal',
+        'tabloid'
+    ];
+    const PAGE_GEOMETRY_PROPERTY_SET = new Set([
+        'width',
+        'height',
+        'orientation',
+        'code'
+    ]);
+    new Set([
+        'first',
+        'other'
+    ]);
+    const MAX_WORD_PAGE_TWIPS = 31680;
+    const MAX_WORD_PAPER_CODE = 118;
+    const PRESET_TOLERANCE_TWIPS = 2;
+    const PORTRAIT_PAGE_PRESETS = {
+        a3: {
+            width: 16838,
+            height: 23811
+        },
+        a4: {
+            width: 11906,
+            height: 16838
+        },
+        a5: {
+            width: 8391,
+            height: 11906
+        },
+        letter: {
+            width: 12240,
+            height: 15840
+        },
+        legal: {
+            width: 12240,
+            height: 20160
+        },
+        tabloid: {
+            width: 15840,
+            height: 24480
+        }
+    };
+    function normalizeDocumentPageGeometry(source) {
+        if (!source || 'object' != typeof source || Array.isArray(source)) return null;
+        const record = source;
+        if (Object.keys(record).some((key)=>!PAGE_GEOMETRY_PROPERTY_SET.has(key))) return null;
+        const width = pageTwips(record.width);
+        const height = pageTwips(record.height);
+        if (null === width || null === height) return null;
+        const orientation = record.orientation;
+        if (void 0 !== orientation && 'portrait' !== orientation && 'landscape' !== orientation) return null;
+        const code = record.code;
+        if (void 0 !== code && (!Number.isSafeInteger(code) || Number(code) < 0 || Number(code) > MAX_WORD_PAPER_CODE)) return null;
+        return {
+            width,
+            height,
+            ...void 0 !== orientation ? {
+                orientation
+            } : {},
+            ...void 0 !== code ? {
+                code: Number(code)
+            } : {}
+        };
+    }
+    function documentPaperSizeForGeometry(source) {
+        const geometry = normalizeDocumentPageGeometry(source);
+        if (!geometry) return 'custom';
+        for (const preset of DOCUMENT_PAPER_SIZE_PRESETS){
+            const portrait = PORTRAIT_PAGE_PRESETS[preset];
+            if (dimensionsMatch(geometry, portrait.width, portrait.height) || dimensionsMatch(geometry, portrait.height, portrait.width)) return preset;
+        }
+        return 'custom';
+    }
+    function documentPageOrientationForGeometry(source, fallback = 'portrait') {
+        const geometry = normalizeDocumentPageGeometry(source);
+        if (!geometry) return fallback;
+        return geometry.orientation ?? (geometry.width > geometry.height ? 'landscape' : 'portrait');
+    }
+    function applyDocumentPageGeometry(layout, source) {
+        const pageGeometry = normalizeDocumentPageGeometry(source);
+        if (!pageGeometry) return layout;
+        return {
+            ...layout,
+            pageSize: documentPaperSizeForGeometry(pageGeometry),
+            orientation: documentPageOrientationForGeometry(pageGeometry, layout.orientation),
+            pageGeometry
+        };
+    }
+    function pageTwips(value) {
+        return Number.isSafeInteger(value) && Number(value) >= 1 && Number(value) <= MAX_WORD_PAGE_TWIPS ? Number(value) : null;
+    }
+    function dimensionsMatch(geometry, width, height) {
+        return Math.abs(geometry.width - width) <= PRESET_TOLERANCE_TWIPS && Math.abs(geometry.height - height) <= PRESET_TOLERANCE_TWIPS;
+    }
+    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  {}
+    }
+    function decodeXmlBytes(bytes, label) {
+        let encoding = 'utf-8';
+        let offset = 0;
+        if (0xef === bytes[0] && 0xbb === bytes[1] && 0xbf === bytes[2]) offset = 3;
+        else if (0xff === bytes[0] && 0xfe === bytes[1]) {
+            encoding = 'utf-16le';
+            offset = 2;
+        } else if (0xfe === bytes[0] && 0xff === bytes[1]) {
+            encoding = 'utf-16be';
+            offset = 2;
+        } else if (0x3c === bytes[0] && 0 === bytes[1] && 0x3f === bytes[2] && 0 === bytes[3]) encoding = 'utf-16le';
+        else if (0 === bytes[0] && 0x3c === bytes[1] && 0 === bytes[2] && 0x3f === bytes[3]) encoding = 'utf-16be';
+        try {
+            return new TextDecoder(encoding, {
+                fatal: true
+            }).decode(bytes.subarray(offset));
+        } catch  {
+            throw new Error(`${label} uses an invalid ${encoding} XML encoding.`);
+        }
+    }
+    const scope = globalThis;
+    scope.onmessage = (event)=>{
+        if ('parse' !== event.data.kind) return;
+        parseDocument(event.data);
+    };
+    async function parseDocument(request) {
+        try {
+            const xmlStartedAt = workerNow();
+            const source = decodeXmlBytes(new Uint8Array(request.xmlBytes), 'word/document.xml');
+            const xmlFinishedAt = workerNow();
+            const stream = createWorkerStream();
+            const parseStartedAt = workerNow();
+            const streamed = streamLargeSimpleDocxDocumentXml(source, request.options, stream.sink);
+            const parseFinishedAt = workerNow();
+            if (!streamed || !stream.finish()) return void scope.postMessage({
+                kind: 'ineligible'
+            });
+            scope.postMessage({
+                kind: 'success',
+                streamed,
+                timings: {
+                    contentMs: measureDuration('a3s-office.document.large-simple-content'),
+                    eligibilityMs: measureDuration('a3s-office.document.large-simple-eligibility'),
+                    envelopeMs: measureDuration('a3s-office.document.large-simple-envelope'),
+                    parseMs: parseFinishedAt - parseStartedAt,
+                    xmlMs: xmlFinishedAt - xmlStartedAt
+                }
+            });
+        } catch  {
+            scope.postMessage({
+                kind: 'failure'
+            });
+        }
+    }
+    function createWorkerStream() {
+        let paragraphTexts = [];
+        let rowCellCounts = [];
+        let cellParagraphCounts = [];
+        let tableTexts = [];
+        let tableActive = false;
+        const flushParagraphs = ()=>{
+            if (!paragraphTexts.length) return;
+            scope.postMessage({
+                kind: 'paragraphs',
+                texts: paragraphTexts
+            });
+            paragraphTexts = [];
+        };
+        const flushRows = ()=>{
+            if (!rowCellCounts.length) return;
+            const transferredRowCellCounts = new Uint32Array(rowCellCounts);
+            const transferredCellParagraphCounts = new Uint32Array(cellParagraphCounts);
+            scope.postMessage({
+                cellParagraphCounts: transferredCellParagraphCounts,
+                kind: 'table-rows',
+                rowCellCounts: transferredRowCellCounts,
+                texts: tableTexts
+            }, {
+                transfer: [
+                    transferredRowCellCounts.buffer,
+                    transferredCellParagraphCounts.buffer
+                ]
+            });
+            rowCellCounts = [];
+            cellParagraphCounts = [];
+            tableTexts = [];
+        };
+        return {
+            finish: ()=>{
+                flushParagraphs();
+                flushRows();
+                return !tableActive;
+            },
+            sink: {
+                paragraph: (text)=>{
+                    if (tableActive) throw new Error('A table stream cannot contain a paragraph batch.');
+                    paragraphTexts.push(text);
+                    if (paragraphTexts.length >= 2048) flushParagraphs();
+                },
+                tableEnd: ()=>{
+                    if (!tableActive) throw new Error('A streamed table was not started.');
+                    flushRows();
+                    scope.postMessage({
+                        kind: 'table-end'
+                    });
+                    tableActive = false;
+                },
+                tableRow: ({ cellParagraphCounts: counts, texts })=>{
+                    if (!tableActive) throw new Error('A streamed table row has no owning table.');
+                    rowCellCounts.push(counts.length);
+                    cellParagraphCounts.push(...counts);
+                    tableTexts.push(...texts);
+                    if (rowCellCounts.length >= 2048) flushRows();
+                },
+                tableStart: ()=>{
+                    if (tableActive) throw new Error('Nested tables are not supported.');
+                    flushParagraphs();
+                    tableActive = true;
+                    scope.postMessage({
+                        kind: 'table-start'
+                    });
+                }
+            }
+        };
+    }
+    function workerNow() {
+        return globalThis.performance?.now?.() ?? Date.now();
+    }
+    function measureDuration(name) {
+        return globalThis.performance?.getEntriesByName?.(name).at(-1)?.duration ?? 0;
+    }
+})();