@a3s-lab/office 0.9.2 → 0.11.0

package/dist/0~document-editor.js

@@ -769,7 +769,7 @@ function DocumentChangesPanel({ editor, changes, decisions = [], trackChanges, s
                                             }).run(),
                                         children: [
                                             /*#__PURE__*/ jsx("span", {
-                                                children: 'insertion' === change.kind ? '插入' : '删除'
+                                                children: documentChangeKindLabel(change.kind)
                                             }),
                                             /*#__PURE__*/ jsx("strong", {
                                                 children: change.text.trim() || '（空白字符）'
@@ -868,6 +868,7 @@ function DocumentChangeDecisionHistory({ decisions }) {
             /*#__PURE__*/ jsx("ol", {
                 children: visible.map((decision)=>/*#__PURE__*/ jsxs("li", {
                         "data-document-change-decision": decision.decision,
+                        "data-document-change-kind": decision.changeKind,
                         children: [
                             /*#__PURE__*/ jsx("span", {
                                 children: 'accept' === decision.decision ? '已接受' : '已拒绝'
@@ -892,6 +893,12 @@ function DocumentChangeDecisionHistory({ decisions }) {
 function documentChangeDecisionKey(changeKey, decision) {
     return `${changeKey}:${decision}`;
 }
+function documentChangeKindLabel(kind) {
+    if ('insertion' === kind) return '插入';
+    if ('formatting' === kind) return '格式';
+    if ('paragraph-formatting' === kind) return '段落格式';
+    return '删除';
+}
 function documentChangeWindowKey(change) {
     return `${change.kind}:${change.id}`;
 }

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, parseDocumentParagraphFormatting, documentTableRowIdentityFromElement, normalizeDocumentBookmarkNativeId, collectDocumentNotes, 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;
@@ -2870,10 +3104,223 @@ async function patchDocxNumberingRestartRules(buffer, rules) {
 function wordQualifiedName(root, localName) {
     return `${xmlNamespacePrefix(root, work_docx_numbering_WORD_NAMESPACE) ?? root.prefix ?? 'w'}:${localName}`;
 }
+const work_docx_paragraph_format_change_export_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_paragraph_format_change_export_WORD_2012_NAMESPACE = 'http://schemas.microsoft.com/office/word/2012/wordml';
+const work_docx_paragraph_format_change_export_XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
+const MAX_PARAGRAPH_FORMATTING_CHANGE_PATCHES = 65536;
+const PARAGRAPH_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes)\.xml$/i;
+class DocxParagraphFormattingChangePatchCollector {
+    patches = [];
+    register(element, id) {
+        if ('paragraph-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 = work_docx_paragraph_format_change_export_normalizedRevisionDate(element.dataset.changeDate);
+        const before = element.dataset.changeBefore ?? '';
+        if (!key || !author || author.length > 255 || !parseDocumentParagraphFormatting(before)) throw new Error('Document contains an invalid paragraph-formatting revision.');
+        if (this.patches.length >= MAX_PARAGRAPH_FORMATTING_CHANGE_PATCHES) throw new Error('Document exceeds the paragraph-formatting revision limit.');
+        const marker = `__A3S_WORK_PARAGRAPH_FORMAT_CHANGE_EXPORT_${this.patches.length + 1}__`;
+        this.patches.push({
+            marker,
+            id,
+            author,
+            date,
+            before
+        });
+        return marker;
+    }
+}
+async function patchDocxParagraphFormattingChanges(buffer, patches) {
+    if (!patches.length) return buffer;
+    if (patches.length > MAX_PARAGRAPH_FORMATTING_CHANGE_PATCHES) throw new Error('Document exceeds the paragraph-formatting revision limit.');
+    const archive = await jszip.loadAsync(buffer);
+    const byMarker = new Map(patches.map((patch)=>[
+            patch.marker,
+            patch
+        ]));
+    const applied = new Set();
+    for (const entry of Object.values(archive.files)){
+        if (entry.dir || !PARAGRAPH_PART_PATTERN.test(entry.name)) continue;
+        const document = parseXml(decodeXmlBytes(await entry.async('uint8array'), `generated DOCX ${entry.name}`), `generated DOCX ${entry.name}`);
+        let changed = false;
+        for (const paragraph of descendants(document, 'p').filter((element)=>element.namespaceURI === work_docx_paragraph_format_change_export_WORD_NAMESPACE)){
+            const marker = paragraphFormattingMarker(paragraph, byMarker);
+            if (marker) {
+                setParagraphFormattingChange(document, paragraph, marker.patch);
+                marker.run.remove();
+                applied.add(marker.patch.marker);
+                changed = true;
+            }
+        }
+        if (changed) archive.file(entry.name, serializeUtf8Xml(document));
+    }
+    const missing = patches.filter((patch)=>!applied.has(patch.marker));
+    if (missing.length) throw new Error(`DOCX paragraph-formatting revision markers were not emitted: ${missing.map((patch)=>patch.marker).join(', ')}.`);
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function paragraphFormattingMarker(paragraph, patches) {
+    const matches = directChildren(paragraph, 'r').flatMap((run)=>{
+        if (run.namespaceURI !== work_docx_paragraph_format_change_export_WORD_NAMESPACE) return [];
+        const texts = directChildren(run, 't').filter((text)=>text.namespaceURI === work_docx_paragraph_format_change_export_WORD_NAMESPACE);
+        if (1 !== texts.length || !work_docx_paragraph_format_change_export_runHasOnlyMarkerText(run, texts[0])) return [];
+        const patch = patches.get(texts[0]?.textContent ?? '');
+        return patch ? [
+            {
+                patch,
+                run
+            }
+        ] : [];
+    });
+    if (matches.length > 1) throw new Error('Generated DOCX paragraph has duplicate revision markers.');
+    return matches[0] ?? null;
+}
+function work_docx_paragraph_format_change_export_runHasOnlyMarkerText(run, markerText) {
+    return Boolean(markerText && directChildren(run).every((child)=>child === markerText || 'rPr' === child.localName && child.namespaceURI === work_docx_paragraph_format_change_export_WORD_NAMESPACE));
+}
+function setParagraphFormattingChange(document, paragraph, patch) {
+    const propertyNodes = directChildren(paragraph, 'pPr').filter((element)=>element.namespaceURI === work_docx_paragraph_format_change_export_WORD_NAMESPACE);
+    if (propertyNodes.length > 1) throw new Error('Generated DOCX paragraph contains duplicate properties.');
+    const prefix = xmlNamespacePrefix(document.documentElement, work_docx_paragraph_format_change_export_WORD_NAMESPACE) ?? 'w';
+    const properties = propertyNodes[0] ?? insertParagraphProperties(document, paragraph, prefix);
+    if (directChildren(properties, 'pPrChange').some((element)=>element.namespaceURI === work_docx_paragraph_format_change_export_WORD_NAMESPACE)) throw new Error('Generated DOCX paragraph already contains a formatting revision.');
+    const change = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'pPrChange');
+    work_docx_paragraph_format_change_export_setWordAttribute(document, change, 'id', String(patch.id));
+    work_docx_paragraph_format_change_export_setWordAttribute(document, change, 'author', patch.author);
+    work_docx_paragraph_format_change_export_setWordAttribute(document, change, 'date', patch.date);
+    const before = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'pPr');
+    appendParagraphFormattingProperties(document, before, patch.before, prefix);
+    change.append(before);
+    properties.append(change);
+}
+function appendParagraphFormattingProperties(document, properties, serialized, prefix) {
+    const parsed = parseDocumentParagraphFormatting(serialized);
+    if (!parsed) throw new Error('Document contains an invalid paragraph-formatting revision.');
+    const formatting = parsed;
+    appendOnOff(document, properties, prefix, 'keepNext', formatting.keepWithNext);
+    appendOnOff(document, properties, prefix, 'keepLines', formatting.keepLines);
+    appendOnOff(document, properties, prefix, 'pageBreakBefore', formatting.pageBreakBefore);
+    appendOnOff(document, properties, prefix, 'widowControl', formatting.widowControl);
+    appendBorders(document, properties, prefix, formatting.paragraphBorders);
+    appendShading(document, properties, prefix, formatting.paragraphShading);
+    appendTabStops(document, properties, prefix, formatting.tabStops);
+    if (formatting.paragraphDirection) appendOnOff(document, properties, prefix, 'bidi', 'rtl' === formatting.paragraphDirection);
+    appendSpacing(document, properties, prefix, formatting);
+    appendIndent(document, properties, prefix, formatting);
+    appendOnOff(document, properties, prefix, 'contextualSpacing', formatting.contextualSpacing);
+    if (formatting.textAlign) work_docx_paragraph_format_change_export_appendValuedProperty(document, properties, prefix, 'jc', 'justify' === formatting.textAlign ? 'both' : formatting.textAlign);
+    if (null !== formatting.outlineLevel) work_docx_paragraph_format_change_export_appendValuedProperty(document, properties, prefix, 'outlineLvl', String(formatting.outlineLevel));
+    appendDefaultCollapsed(document, properties, prefix, formatting.defaultCollapsed);
+}
+function appendSpacing(document, properties, prefix, formatting) {
+    const spacing = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'spacing');
+    if (null !== formatting.spaceBefore) work_docx_paragraph_format_change_export_setWordAttribute(document, spacing, 'before', String(Math.round(20 * formatting.spaceBefore)));
+    if (null !== formatting.spaceAfter) work_docx_paragraph_format_change_export_setWordAttribute(document, spacing, 'after', String(Math.round(20 * formatting.spaceAfter)));
+    if (formatting.lineHeight && formatting.lineRule) {
+        const line = docxLineHeight(formatting.lineHeight, formatting.lineRule);
+        if (null !== line) {
+            work_docx_paragraph_format_change_export_setWordAttribute(document, spacing, 'line', String(line));
+            work_docx_paragraph_format_change_export_setWordAttribute(document, spacing, 'lineRule', formatting.lineRule);
+        }
+    }
+    if (spacing.attributes.length) properties.append(spacing);
+}
+function docxLineHeight(value, rule) {
+    if ('auto' === rule) {
+        const multiple = Number(value.replace(/%$/, ''));
+        if (!Number.isFinite(multiple)) return null;
+        return Math.round((value.endsWith('%') ? multiple / 100 : multiple) * 240);
+    }
+    const length = /^(\d+(?:\.\d+)?)(px|pt)?$/i.exec(value);
+    if (!length?.[1]) return null;
+    const points = length[2]?.toLowerCase() === 'px' ? 0.75 * Number(length[1]) : Number(length[1]);
+    return Math.round(20 * points);
+}
+function appendIndent(document, properties, prefix, formatting) {
+    const indent = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'ind');
+    work_docx_paragraph_format_change_export_setWordAttribute(document, indent, 'left', String(Math.round(24 * formatting.indentLevel * 15)));
+    work_docx_paragraph_format_change_export_setWordAttribute(document, indent, 'right', String(Math.round(15 * formatting.rightIndent)));
+    formatting.firstLineIndent < 0 ? work_docx_paragraph_format_change_export_setWordAttribute(document, indent, 'hanging', String(Math.round(15 * Math.abs(formatting.firstLineIndent)))) : work_docx_paragraph_format_change_export_setWordAttribute(document, indent, 'firstLine', String(Math.round(15 * formatting.firstLineIndent)));
+    properties.append(indent);
+}
+function appendTabStops(document, properties, prefix, tabStops) {
+    if (!tabStops?.length) return;
+    const tabs = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'tabs');
+    for (const stop of tabStops){
+        const tab = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'tab');
+        work_docx_paragraph_format_change_export_setWordAttribute(document, tab, 'val', stop.alignment);
+        work_docx_paragraph_format_change_export_setWordAttribute(document, tab, 'pos', String(Math.round(15 * stop.position)));
+        if ('none' !== stop.leader) work_docx_paragraph_format_change_export_setWordAttribute(document, tab, 'leader', stop.leader);
+        tabs.append(tab);
+    }
+    properties.append(tabs);
+}
+function appendBorders(document, properties, prefix, borders) {
+    if (!borders) return;
+    const container = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'pBdr');
+    for (const edge of DOCUMENT_PARAGRAPH_BORDER_EDGES){
+        const border = borders[edge];
+        if (!border) continue;
+        const element = work_docx_paragraph_format_change_export_wordElement(document, prefix, edge);
+        setDocxBorderAttributes(document, element, border);
+        container.append(element);
+    }
+    if (container.children.length) properties.append(container);
+}
+function appendShading(document, properties, prefix, shading) {
+    if (!shading) return;
+    const element = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'shd');
+    work_docx_paragraph_format_change_export_setWordAttribute(document, element, 'val', shading.pattern);
+    appendShadingColor(document, element, 'color', shading.color);
+    appendShadingColor(document, element, 'fill', shading.fill);
+    properties.append(element);
+}
+function appendShadingColor(document, element, kind, color) {
+    if (!color) return;
+    work_docx_paragraph_format_change_export_setWordAttribute(document, element, kind, 'auto' === color.value ? 'auto' : color.value.slice(1).toUpperCase());
+    if (!color.theme) return;
+    const themeName = 'color' === kind ? 'themeColor' : 'themeFill';
+    work_docx_paragraph_format_change_export_setWordAttribute(document, element, themeName, color.theme.theme);
+    if (color.theme.tint) work_docx_paragraph_format_change_export_setWordAttribute(document, element, `${themeName}Tint`, color.theme.tint);
+    if (color.theme.shade) work_docx_paragraph_format_change_export_setWordAttribute(document, element, `${themeName}Shade`, color.theme.shade);
+}
+function appendDefaultCollapsed(document, properties, wordPrefix, value) {
+    if (null === value) return;
+    const element = document.createElementNS(work_docx_paragraph_format_change_export_WORD_2012_NAMESPACE, 'w15:collapsed');
+    element.setAttributeNS(work_docx_paragraph_format_change_export_XMLNS_NAMESPACE, 'xmlns:w15', work_docx_paragraph_format_change_export_WORD_2012_NAMESPACE);
+    element.setAttributeNS(work_docx_paragraph_format_change_export_WORD_NAMESPACE, `${wordPrefix}:val`, value ? '1' : '0');
+    properties.append(element);
+}
+function appendOnOff(document, properties, prefix, name, value) {
+    if (null === value) return;
+    work_docx_paragraph_format_change_export_appendValuedProperty(document, properties, prefix, name, value ? '1' : '0');
+}
+function work_docx_paragraph_format_change_export_appendValuedProperty(document, properties, prefix, name, value) {
+    const element = work_docx_paragraph_format_change_export_wordElement(document, prefix, name);
+    work_docx_paragraph_format_change_export_setWordAttribute(document, element, 'val', value);
+    properties.append(element);
+}
+function insertParagraphProperties(document, paragraph, prefix) {
+    const properties = work_docx_paragraph_format_change_export_wordElement(document, prefix, 'pPr');
+    paragraph.insertBefore(properties, paragraph.firstChild);
+    return properties;
+}
+function work_docx_paragraph_format_change_export_wordElement(document, prefix, name) {
+    return document.createElementNS(work_docx_paragraph_format_change_export_WORD_NAMESPACE, `${prefix}:${name}`);
+}
+function work_docx_paragraph_format_change_export_setWordAttribute(document, element, name, value) {
+    const prefix = xmlNamespacePrefix(document.documentElement, work_docx_paragraph_format_change_export_WORD_NAMESPACE) ?? 'w';
+    element.setAttributeNS(work_docx_paragraph_format_change_export_WORD_NAMESPACE, `${prefix}:${name}`, value);
+}
+function work_docx_paragraph_format_change_export_normalizedRevisionDate(value) {
+    const time = Date.parse(value?.trim() ?? '');
+    return Number.isFinite(time) ? new Date(time).toISOString() : new Date().toISOString();
+}
 const work_docx_paragraph_identity_WORD_2010_NAMESPACE = 'http://schemas.microsoft.com/office/word/2010/wordml';
 const work_docx_paragraph_identity_MARKUP_COMPATIBILITY_NAMESPACE = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
 const MAX_PARAGRAPH_IDENTITY_PATCHES = 65536;
-const PARAGRAPH_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes)\.xml$/i;
+const work_docx_paragraph_identity_PARAGRAPH_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes)\.xml$/i;
 class DocxParagraphIdentityPatchCollector {
     source;
     patches = [];
@@ -2923,7 +3370,7 @@ async function patchDocxParagraphIdentities(buffer, patches) {
             patch
         ]));
     const applied = new Set();
-    const entries = Object.values(archive.files).filter((entry)=>!entry.dir && PARAGRAPH_PART_PATTERN.test(entry.name));
+    const entries = Object.values(archive.files).filter((entry)=>!entry.dir && work_docx_paragraph_identity_PARAGRAPH_PART_PATTERN.test(entry.name));
     for (const entry of entries){
         const document = parseXml(decodeXmlBytes(await entry.async('uint8array'), `generated DOCX ${entry.name}`), `generated DOCX ${entry.name}`);
         if (!isParagraphPartRoot(document.documentElement, entry.name)) continue;
@@ -6868,7 +7315,9 @@ 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(),
+        paragraphFormattingChangePatches: new DocxParagraphFormattingChangePatchCollector()
     };
     const commentRecords = createDocxCommentRecords(commentThreads, docx, noteContext.commentIds);
     const sections = [];
@@ -6915,7 +7364,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);
@@ -6929,7 +7379,8 @@ async function createDocxBlob(content, sourcePackage) {
     const bookmarkPatched = await patchDocxBookmarks(imageIdentityPatched, noteContext.bookmarkPatches.patches);
     const paragraphDefaultCollapsedPatched = await patchDocxParagraphDefaultCollapsed(bookmarkPatched, noteContext.paragraphDefaultCollapsedPatches.patches);
     const paragraphIdentityPatched = await patchDocxParagraphIdentities(paragraphDefaultCollapsedPatched, noteContext.paragraphIdentityPatches.patches);
-    const equationPatched = await patchDocxEquations(paragraphIdentityPatched, noteContext.equationPatches.patches);
+    const paragraphFormattingChangesPatched = await patchDocxParagraphFormattingChanges(paragraphIdentityPatched, noteContext.paragraphFormattingChangePatches.patches);
+    const equationPatched = await patchDocxEquations(paragraphFormattingChangesPatched, noteContext.equationPatches.patches);
     const patched = await patchDocxPageColor(equationPatched, normalizedContent.pageColor);
     const preserved = sourcePackage ? await preserveDocxSourcePackage(patched, sourcePackage, {
         numberingIdentities: noteContext.numberingSourceIdentities
@@ -7095,8 +7546,12 @@ async function pageChromeBlocks(html, docx, noteContext) {
 async function paragraphRuns(element, docx, noteContext) {
     const identityMarker = noteContext.paragraphIdentityPatches.marker(element);
     noteContext.paragraphDefaultCollapsedPatches.register(identityMarker, element);
+    const paragraphFormattingChangeMarker = element.hasAttribute('data-document-change') && 'paragraph-formatting' === element.dataset.changeKind ? noteContext.paragraphFormattingChangePatches.register(element, docxRevisionId(element, noteContext)) : null;
     return [
         new docx.TextRun(identityMarker),
+        ...paragraphFormattingChangeMarker ? [
+            new docx.TextRun(paragraphFormattingChangeMarker)
+        ] : [],
         ...await work_docx_export_inlineRuns(element, docx, noteContext)
     ];
 }
@@ -7157,7 +7612,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 +7659,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 +7668,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 +7693,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 +7703,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"], [data-document-change][data-change-kind="paragraph-formatting"]'));
 }
 function anchoredDocumentComments(content) {
     const document = new DOMParser().parseFromString(content.html, 'text/html');