@a3s-lab/office 0.9.2 → 0.10.0

package/dist/0~work-docx-export.js

@@ -1,5 +1,5 @@
 import jszip from "jszip";
-import { normalizeDocumentBookmarkName, applyDocumentImageIdentityToElement, DOCUMENT_PAGE_BORDER_EDGES, createDocumentImageIdentityRegistry, normalizeDocumentColumns, normalizeDocumentTableVerticalAlign, uniqueDocumentParagraphIdentity, documentTableColumnPercentagesFromElement, documentTableCellMarginOverridesFromElement, applyDocumentTableRowIdentityToElement, normalizeDocumentBookmarksHtml, documentImageIdentityFromElement, documentTableGeometryFromElement, normalizeDocumentTableRowHeightRule, documentNoteKey, normalizeDocumentParagraphBorders, normalizeDocumentTableBorderWidth, normalizeDocumentParagraphId, normalizeDocumentTableBorderStyle, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, parseDocumentParagraphBordersElement, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentPageChrome, documentPageMarginsForLayout, normalizeDocumentImageLayer, documentBookmarkReferenceInstruction, documentImageCropFromElement, normalizeDocumentPageBorders, documentImageLayerFromElement, normalizeTableColor, documentCaptionLabel, documentCaptionKind, applyDocumentParagraphIdentityToElement, isContourImageLayout, normalizeDocumentImageIdentity, documentTableBordersFromElement, parseDocxThemeReference, documentSections, createDocumentParagraphIdentityRegistry, documentCitationTags, docxDocumentFieldKind, wrapsBesideImage, DocxThemePatchCollector, defaultDocumentImageWrapContour, normalizeDocumentParagraphIdentity, normalizeDocumentPaperSource, documentEquationFromElement, DOCUMENT_PARAGRAPH_BORDER_EDGES, documentTableRowIdentityFromElement, patchDocxThemeReferences, parseDocumentParagraphShadingElement, documentParagraphIdentityFromElement, normalizeDocumentEquation, collectDocumentNotes, normalizeDocumentBookmarkNativeId, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentImageLayoutFromElement, documentPageHorizontalMarginTwips, documentPageGeometryForLayout, normalizeDocumentPageMargins, documentNoteKind } from "./8928.js";
+import { normalizeDocumentBookmarkName, applyDocumentImageIdentityToElement, DOCUMENT_PAGE_BORDER_EDGES, createDocumentImageIdentityRegistry, normalizeDocumentColumns, normalizeDocumentTableVerticalAlign, uniqueDocumentParagraphIdentity, documentTableColumnPercentagesFromElement, documentTableCellMarginOverridesFromElement, applyDocumentTableRowIdentityToElement, normalizeDocumentBookmarksHtml, documentImageIdentityFromElement, documentTableGeometryFromElement, normalizeDocumentTableRowHeightRule, documentNoteKey, normalizeDocumentParagraphBorders, normalizeDocumentTableBorderWidth, normalizeDocumentParagraphId, normalizeDocumentTableBorderStyle, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, parseDocumentParagraphBordersElement, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentPageChrome, documentPageMarginsForLayout, normalizeDocumentImageLayer, documentBookmarkReferenceInstruction, documentImageCropFromElement, normalizeDocumentPageBorders, documentImageLayerFromElement, parseDocxThemeReference, documentCaptionLabel, documentCaptionKind, applyDocumentParagraphIdentityToElement, isContourImageLayout, normalizeDocumentImageIdentity, normalizeTableColor, documentTableBordersFromElement, documentSections, createDocumentParagraphIdentityRegistry, documentCitationTags, docxDocumentFieldKind, wrapsBesideImage, DocxThemePatchCollector, defaultDocumentImageWrapContour, normalizeDocumentParagraphIdentity, normalizeDocumentPaperSource, documentEquationFromElement, DOCUMENT_PARAGRAPH_BORDER_EDGES, parseDocumentCharacterFormatting, patchDocxThemeReferences, parseDocumentParagraphShadingElement, documentParagraphIdentityFromElement, normalizeDocumentEquation, documentTableRowIdentityFromElement, collectDocumentNotes, normalizeDocumentBookmarkNativeId, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentImageLayoutFromElement, documentPageHorizontalMarginTwips, documentPageGeometryForLayout, normalizeDocumentPageMargins, documentNoteKind } from "./8928.js";
 import { serializeUtf8Xml, directChildren, xmlNamespacePrefix, parseXml, decodeXmlBytes, descendants, resolvePartTarget, directChild, attribute as work_ooxml_package_attribute } from "./5184.js";
 import { assignDocxNoteIds, patchDocxPageColor, normalizeDocxCommentId, assignDocxCommentThreads } from "./0~4980.js";
 import { paragraphTabStops, mergeDocxIgnorableExtensionsAtPairs, patchDocxBibliography, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, paragraphAlignment, paragraphSpacingOptions, xmlNamespaceUri, hasNonWhitespaceXmlText, cloneXmlElement, cssColorToHex, DocxParagraphDefaultCollapsedPatchCollector, assertXmlRoot, xmlDeclaredPrefix, paragraphIndent, domDirection, DOCX_WORDPROCESSING_NAMESPACES, paragraphBidirectional, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, patchDocxParagraphDefaultCollapsed, xmlAttributeNamespace, dataBoolean, mergeDocxIgnorableExtensions, parseDocxColorSchemeMappingElement, paragraphPaginationOptions, DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, xmlAttributeLocalName, cssFontSize, paragraphDirectionOptions, cssFontFamily } from "./0~2805.js";
@@ -2095,6 +2095,240 @@ function docxDocumentFieldRun(element, docx) {
     if (!docxDocumentFieldKind(instruction)) return new docx.TextRun(display);
     return new docx.SimpleField(instruction, display);
 }
+const MAX_RUN_FORMATTING_CHANGE_PATCHES = 65536;
+const RUN_FORMATTING_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes)\.xml$/i;
+class DocxRunFormattingChangePatchCollector {
+    patches = [];
+    register(element, id) {
+        if ('formatting' !== element.dataset.changeKind || !element.hasAttribute('data-document-change')) return null;
+        const key = element.dataset.changeId?.trim() ?? '';
+        const author = element.dataset.changeAuthor?.trim() ?? '';
+        const date = normalizedRevisionDate(element.dataset.changeDate);
+        const before = element.dataset.changeBefore ?? '';
+        if (!key || !author || author.length > 255 || !parseDocumentCharacterFormatting(before)) throw new Error('Document contains an invalid character-formatting revision.');
+        if (this.patches.length >= MAX_RUN_FORMATTING_CHANGE_PATCHES) throw new Error('Document exceeds the character-formatting revision limit.');
+        const sequence = this.patches.length + 1;
+        const start = `__A3S_WORK_FORMAT_CHANGE_START_${sequence}__`;
+        const end = `__A3S_WORK_FORMAT_CHANGE_END_${sequence}__`;
+        this.patches.push({
+            start,
+            end,
+            id,
+            author,
+            date,
+            before
+        });
+        return {
+            start,
+            end
+        };
+    }
+}
+async function patchDocxRunFormattingChanges(buffer, patches) {
+    if (!patches.length) return buffer;
+    if (patches.length > MAX_RUN_FORMATTING_CHANGE_PATCHES) throw new Error('Document exceeds the character-formatting revision limit.');
+    const archive = await jszip.loadAsync(buffer);
+    const byMarker = new Map();
+    for (const patch of patches){
+        byMarker.set(patch.start, patch);
+        byMarker.set(patch.end, patch);
+    }
+    const applied = new Set();
+    for (const entry of Object.values(archive.files)){
+        if (entry.dir || !RUN_FORMATTING_PART_PATTERN.test(entry.name)) continue;
+        const document = parseXml(decodeXmlBytes(await entry.async('uint8array'), `generated DOCX ${entry.name}`), `generated DOCX ${entry.name}`);
+        const runs = descendants(document, 'r').filter((run)=>DOCX_WORDPROCESSING_NAMESPACES.has(run.namespaceURI ?? ''));
+        const markerRuns = new Map();
+        for (const run of runs){
+            const marker = runMarker(run, byMarker);
+            if (!marker) continue;
+            const current = markerRuns.get(marker.patch) ?? {};
+            if ('start' === marker.kind) {
+                if (current.start) throw duplicateMarker(marker.patch.start);
+                current.start = run;
+            } else {
+                if (current.end) throw duplicateMarker(marker.patch.end);
+                current.end = run;
+            }
+            markerRuns.set(marker.patch, current);
+        }
+        let changed = false;
+        for (const [patch, markers] of markerRuns){
+            if (!markers.start || !markers.end) continue;
+            const start = runs.indexOf(markers.start);
+            const end = runs.indexOf(markers.end);
+            if (start < 0 || end <= start + 1) throw new Error('Generated DOCX character-formatting markers are invalid.');
+            const targets = runs.slice(start + 1, end).filter((run)=>directChildren(run, 't').length > 0);
+            if (!targets.length) throw new Error('A character-formatting revision must mark text.');
+            for (const run of targets)setRunFormattingChange(document, run, patch);
+            markers.start.remove();
+            markers.end.remove();
+            applied.add(patch);
+            changed = true;
+        }
+        if (changed) archive.file(entry.name, serializeUtf8Xml(document));
+    }
+    const missing = patches.filter((patch)=>!applied.has(patch));
+    if (missing.length) throw new Error(`DOCX character-formatting revision markers were not emitted: ${missing.map((patch)=>patch.start).join(', ')}.`);
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function runMarker(run, patches) {
+    const texts = directChildren(run, 't').filter((text)=>DOCX_WORDPROCESSING_NAMESPACES.has(text.namespaceURI ?? ''));
+    if (1 !== texts.length || !work_docx_format_change_export_runHasOnlyMarkerText(run, texts[0])) return null;
+    const value = texts[0].textContent ?? '';
+    const patch = patches.get(value);
+    if (!patch) return null;
+    return {
+        patch,
+        kind: value === patch.start ? 'start' : 'end'
+    };
+}
+function work_docx_format_change_export_runHasOnlyMarkerText(run, text) {
+    return directChildren(run).every((child)=>child === text || 'rPr' === child.localName && DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? ''));
+}
+function setRunFormattingChange(document, run, patch) {
+    const wordNamespace = run.namespaceURI ?? '';
+    const prefix = run.prefix || 'w';
+    const existing = directChildren(run, 'rPr').filter((element)=>element.namespaceURI === wordNamespace);
+    if (existing.length > 1) throw new Error('Generated DOCX run contains duplicate properties.');
+    const properties = existing[0] ?? insertRunProperties(document, run, wordNamespace, prefix);
+    if (directChildren(properties, 'rPrChange').some((element)=>element.namespaceURI === wordNamespace)) throw new Error('Generated DOCX run already contains a formatting revision.');
+    const change = wordElement(document, wordNamespace, prefix, 'rPrChange');
+    work_docx_format_change_export_setWordAttribute(change, wordNamespace, prefix, 'id', String(patch.id));
+    work_docx_format_change_export_setWordAttribute(change, wordNamespace, prefix, 'author', patch.author);
+    work_docx_format_change_export_setWordAttribute(change, wordNamespace, prefix, 'date', patch.date);
+    const before = wordElement(document, wordNamespace, prefix, 'rPr');
+    appendFormattingProperties(document, before, wordNamespace, prefix, patch.before);
+    change.append(before);
+    properties.append(change);
+}
+function insertRunProperties(document, run, namespace, prefix) {
+    const properties = wordElement(document, namespace, prefix, 'rPr');
+    run.insertBefore(properties, run.firstChild);
+    return properties;
+}
+function appendFormattingProperties(document, properties, namespace, prefix, serialized) {
+    const formatting = parseDocumentCharacterFormatting(serialized);
+    if (!formatting) throw new Error('Document contains an invalid character-formatting revision.');
+    const byType = new Map(formatting.map((mark)=>[
+            mark.type,
+            mark
+        ]));
+    appendFontProperties(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendBooleanProperty(document, properties, namespace, prefix, byType, 'bold', 'b');
+    appendBooleanProperty(document, properties, namespace, prefix, byType, 'bold', 'bCs');
+    appendBooleanProperty(document, properties, namespace, prefix, byType, 'italic', 'i');
+    appendBooleanProperty(document, properties, namespace, prefix, byType, 'italic', 'iCs');
+    if (byType.has('underline')) appendValuedProperty(document, properties, namespace, prefix, 'u', 'single');
+    appendBooleanProperty(document, properties, namespace, prefix, byType, 'strike', 'strike');
+    appendColorProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendFontSizeProperties(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendHighlightProperty(document, properties, namespace, prefix, byType.get('highlight'));
+    appendSnapToGridProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendVerticalAlignProperty(document, properties, namespace, prefix, byType);
+}
+function appendFontProperties(document, properties, namespace, prefix, mark) {
+    const family = firstFontFamily(mark?.attrs?.fontFamily);
+    if (!family) return;
+    const fonts = wordElement(document, namespace, prefix, 'rFonts');
+    for (const name of [
+        'ascii',
+        'hAnsi',
+        'eastAsia',
+        'cs'
+    ])work_docx_format_change_export_setWordAttribute(fonts, namespace, prefix, name, family);
+    properties.append(fonts);
+}
+function appendBooleanProperty(document, properties, namespace, prefix, marks, mark, property) {
+    if (marks.has(mark)) properties.append(wordElement(document, namespace, prefix, property));
+}
+function appendValuedProperty(document, properties, namespace, prefix, property, value) {
+    const element = wordElement(document, namespace, prefix, property);
+    work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'val', value);
+    properties.append(element);
+}
+function appendColorProperty(document, properties, namespace, prefix, mark) {
+    const color = normalizedHex(mark?.attrs?.color);
+    const theme = themeReference(mark?.attrs?.themeColor);
+    if (!color && !theme) return;
+    const element = wordElement(document, namespace, prefix, 'color');
+    work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'val', color ?? normalizedHex(theme?.resolved) ?? '000000');
+    if (theme) setThemeAttributes(element, namespace, prefix, theme, 'themeColor');
+    properties.append(element);
+}
+function appendFontSizeProperties(document, properties, namespace, prefix, mark) {
+    const halfPoints = fontSizeHalfPoints(mark?.attrs?.fontSize);
+    if (null === halfPoints) return;
+    appendValuedProperty(document, properties, namespace, prefix, 'sz', String(halfPoints));
+    appendValuedProperty(document, properties, namespace, prefix, 'szCs', String(halfPoints));
+}
+function appendHighlightProperty(document, properties, namespace, prefix, mark) {
+    const fill = normalizedHex(mark?.attrs?.color);
+    const theme = themeReference(mark?.attrs?.themeFill);
+    if (!fill && !theme) return;
+    const shading = wordElement(document, namespace, prefix, 'shd');
+    work_docx_format_change_export_setWordAttribute(shading, namespace, prefix, 'val', 'clear');
+    work_docx_format_change_export_setWordAttribute(shading, namespace, prefix, 'color', 'auto');
+    work_docx_format_change_export_setWordAttribute(shading, namespace, prefix, 'fill', fill ?? normalizedHex(theme?.resolved) ?? 'FFFFFF');
+    if (theme) setThemeAttributes(shading, namespace, prefix, theme, 'themeFill');
+    properties.append(shading);
+}
+function appendSnapToGridProperty(document, properties, namespace, prefix, mark) {
+    const value = mark?.attrs?.wordSnapToGrid;
+    if ('boolean' != typeof value) return;
+    appendValuedProperty(document, properties, namespace, prefix, 'snapToGrid', value ? '1' : '0');
+}
+function appendVerticalAlignProperty(document, properties, namespace, prefix, marks) {
+    if (marks.has("subscript")) appendValuedProperty(document, properties, namespace, prefix, 'vertAlign', "subscript");
+    else if (marks.has("superscript")) appendValuedProperty(document, properties, namespace, prefix, 'vertAlign', "superscript");
+}
+function setThemeAttributes(element, namespace, prefix, theme, name) {
+    work_docx_format_change_export_setWordAttribute(element, namespace, prefix, name, theme.theme);
+    if (theme.tint) work_docx_format_change_export_setWordAttribute(element, namespace, prefix, `${name}Tint`, theme.tint);
+    if (theme.shade) work_docx_format_change_export_setWordAttribute(element, namespace, prefix, `${name}Shade`, theme.shade);
+}
+function themeReference(value) {
+    return 'string' == typeof value ? parseDocxThemeReference(value) : null;
+}
+function firstFontFamily(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim();
+    if (!source || source.length > 255) return null;
+    const quote = source[0];
+    if ('"' === quote || "'" === quote) {
+        const end = source.indexOf(quote, 1);
+        if (end > 1) return source.slice(1, end).trim() || null;
+    }
+    return source.split(',')[0]?.trim() || null;
+}
+function fontSizeHalfPoints(value) {
+    if ('string' != typeof value) return null;
+    const match = /^(\d+(?:\.\d+)?)pt$/i.exec(value.trim());
+    if (!match) return null;
+    const points = Number(match[1]);
+    if (!Number.isFinite(points) || points <= 0 || points > 512) return null;
+    return Math.round(2 * points);
+}
+function normalizedHex(value) {
+    if ('string' != typeof value) return null;
+    const match = /^#?([0-9a-f]{6})$/i.exec(value.trim());
+    return match?.[1]?.toUpperCase() ?? null;
+}
+function wordElement(document, namespace, prefix, name) {
+    return document.createElementNS(namespace, `${prefix}:${name}`);
+}
+function work_docx_format_change_export_setWordAttribute(element, namespace, prefix, name, value) {
+    element.setAttributeNS(namespace, `${prefix}:${name}`, value);
+}
+function normalizedRevisionDate(value) {
+    const time = Date.parse(value ?? '');
+    return Number.isFinite(time) ? new Date(time).toISOString() : new Date().toISOString();
+}
+function duplicateMarker(marker) {
+    return new Error(`Generated DOCX marker '${marker}' is duplicated.`);
+}
 class DocxImageCropPatchCollector {
     patches = [];
     nextMarker = 1;
@@ -6868,7 +7102,8 @@ async function createDocxBlob(content, sourcePackage) {
         paragraphBorderPatches: new DocxParagraphBorderPatchCollector(JSON.stringify(normalizedContent)),
         paragraphDefaultCollapsedPatches: new DocxParagraphDefaultCollapsedPatchCollector(),
         paragraphIdentityPatches: new DocxParagraphIdentityPatchCollector(JSON.stringify(normalizedContent)),
-        equationPatches: new DocxEquationPatchCollector(JSON.stringify(normalizedContent))
+        equationPatches: new DocxEquationPatchCollector(JSON.stringify(normalizedContent)),
+        formattingChangePatches: new DocxRunFormattingChangePatchCollector()
     };
     const commentRecords = createDocxCommentRecords(commentThreads, docx, noteContext.commentIds);
     const sections = [];
@@ -6915,7 +7150,8 @@ async function createDocxBlob(content, sourcePackage) {
         }
     });
     const packed = await docx.Packer.toBlob(document);
-    const noteImageRelationshipsPatched = await patchDocxNoteImageRelationships(await packed.arrayBuffer());
+    const formattingChangesPatched = await patchDocxRunFormattingChanges(await packed.arrayBuffer(), noteContext.formattingChangePatches.patches);
+    const noteImageRelationshipsPatched = await patchDocxNoteImageRelationships(formattingChangesPatched);
     const commentMetadataPatched = await patchDocxCommentMetadata(noteImageRelationshipsPatched, commentThreads);
     const numberingPatched = await patchDocxNumberingRestartRules(commentMetadataPatched, noteContext.numberingRestartRules);
     const bibliographyPatched = await patchDocxBibliography(numberingPatched, normalizedContent.bibliography);
@@ -7157,7 +7393,9 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
                 'footnote' === kind ? new docx.FootnoteReferenceRun(noteId) : new docx.EndnoteReferenceRun(noteId)
             ];
         }
-        const change = node.hasAttribute('data-document-change') ? docxTextRevision(node, 'del' === tag ? 'deletion' : 'insertion', noteContext) : revision;
+        const textRevisionKind = 'del' === tag ? 'deletion' : 'ins' === tag ? 'insertion' : null;
+        const change = node.hasAttribute('data-document-change') && textRevisionKind ? docxTextRevision(node, textRevisionKind, noteContext) : revision;
+        const formattingChange = node.hasAttribute('data-document-change') && 'formatting' === node.dataset.changeKind ? noteContext.formattingChangePatches.register(node, docxRevisionId(node, noteContext)) : null;
         const commentBoundary = node.hasAttribute('data-document-comment') ? nextDocxCommentBoundary(node.dataset.commentId, noteContext) : null;
         const backgroundColor = cssColorToHex(node.style.backgroundColor);
         const direction = domDirection(node);
@@ -7202,7 +7440,7 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
         const children = [];
         for (const child of node.childNodes)children.push(...await visit(child, style, change));
         const href = 'a' === tag ? normalizeDocumentHref(node.getAttribute('href') ?? '') : null;
-        const result = href ? [
+        const linked = href ? [
             href.startsWith('#') ? new docx.InternalHyperlink({
                 anchor: href.slice(1),
                 children
@@ -7211,6 +7449,11 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
                 children
             })
         ] : children;
+        const result = formattingChange ? [
+            new docx.TextRun(formattingChange.start),
+            ...linked,
+            new docx.TextRun(formattingChange.end)
+        ] : linked;
         if (!commentBoundary) return result;
         return [
             ...commentBoundary.start ? [
@@ -7231,13 +7474,7 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
     return runs;
 }
 function docxTextRevision(element, kind, context) {
-    const key = element.dataset.changeId?.trim() || `change-${context.nextChangeId}`;
-    let id = context.changeIds.get(key);
-    if (!id) {
-        id = context.nextChangeId;
-        context.nextChangeId += 1;
-        context.changeIds.set(key, id);
-    }
+    const id = docxRevisionId(element, context);
     const sourceDate = element.dataset.changeDate?.trim() ?? '';
     const time = Date.parse(sourceDate);
     return {
@@ -7247,9 +7484,19 @@ function docxTextRevision(element, kind, context) {
         date: Number.isFinite(time) ? new Date(time).toISOString() : new Date().toISOString()
     };
 }
+function docxRevisionId(element, context) {
+    const key = element.dataset.changeId?.trim() || `change-${context.nextChangeId}`;
+    let id = context.changeIds.get(key);
+    if (!id) {
+        id = context.nextChangeId;
+        context.nextChangeId += 1;
+        context.changeIds.set(key, id);
+    }
+    return id;
+}
 function documentHasTrackedChanges(html) {
     const document = new DOMParser().parseFromString(html, 'text/html');
-    return Boolean(document.body.querySelector('ins[data-document-change], del[data-document-change]'));
+    return Boolean(document.body.querySelector('ins[data-document-change], del[data-document-change], span[data-document-change][data-change-kind="formatting"]'));
 }
 function anchoredDocumentComments(content) {
     const document = new DOMParser().parseFromString(content.html, 'text/html');