@a3s-lab/office 0.9.2 → 0.11.0

package/dist/8928.js

@@ -1,7 +1,7 @@
 import { Extension, Mark, Node as core_Node, ResizableNodeView, generateHTML, getSchema, mergeAttributes } from "@tiptap/core";
 import { Collaboration, isChangeOrigin } from "@tiptap/extension-collaboration";
 import { NodeSelection, Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
-import { AddMarkStep, Mapping, RemoveMarkStep, ReplaceStep } from "@tiptap/pm/transform";
+import { AddMarkStep, Mapping, RemoveMarkStep, ReplaceAroundStep, ReplaceStep } from "@tiptap/pm/transform";
 import { defaultDeleteFilter, defaultProtectedNodes, prosemirrorJSONToYXmlFragment, ySyncPluginKey, yXmlFragmentToProsemirrorJSON } from "@tiptap/y-tiptap";
 import extension_color from "@tiptap/extension-color";
 import { Table, TableCell, TableHeader, TableKit, TableRow, TableView, createTable } from "@tiptap/extension-table";
@@ -8382,6 +8382,570 @@ function work_document_caption_nodes_stringAttribute(value) {
 function isBookmarkCrossReferenceTarget(target) {
     return 'type' in target && 'bookmark' === target.type;
 }
+const DOCUMENT_CHARACTER_FORMAT_MARKS = [
+    'bold',
+    'italic',
+    'underline',
+    'strike',
+    "subscript",
+    "superscript",
+    'textStyle',
+    'highlight'
+];
+const CHARACTER_FORMAT_MARK_NAMES = new Set(DOCUMENT_CHARACTER_FORMAT_MARKS);
+const CHARACTER_FORMAT_MARK_ORDER = new Map(DOCUMENT_CHARACTER_FORMAT_MARKS.map((name, index)=>[
+        name,
+        index
+    ]));
+const MAX_CHARACTER_FORMAT_SNAPSHOT_BYTES = 4096;
+const MAX_CHARACTER_FORMAT_ATTRIBUTE_LENGTH = 512;
+const ALLOWED_ATTRIBUTES = {
+    bold: new Set(),
+    italic: new Set(),
+    underline: new Set(),
+    strike: new Set(),
+    subscript: new Set(),
+    superscript: new Set(),
+    textStyle: new Set([
+        'color',
+        'fontFamily',
+        'fontSize',
+        'themeColor',
+        'wordLineHeightFactor',
+        'wordSnapToGrid'
+    ]),
+    highlight: new Set([
+        'color',
+        'themeFill'
+    ])
+};
+function isDocumentCharacterFormatMark(value) {
+    return CHARACTER_FORMAT_MARK_NAMES.has(value);
+}
+function serializeDocumentCharacterFormatting(marks) {
+    return JSON.stringify(marks.flatMap((mark)=>{
+        const normalized = normalizeCharacterFormatMark({
+            type: mark.type.name,
+            attrs: mark.attrs
+        });
+        return normalized ? [
+            normalized
+        ] : [];
+    }).sort(compareCharacterFormatMarks));
+}
+function parseDocumentCharacterFormatting(value) {
+    if ('string' != typeof value || value.length > MAX_CHARACTER_FORMAT_SNAPSHOT_BYTES) return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    } catch  {
+        return null;
+    }
+    if (!Array.isArray(parsed) || parsed.length > DOCUMENT_CHARACTER_FORMAT_MARKS.length) return null;
+    const result = [];
+    const names = new Set();
+    for (const candidate of parsed){
+        const mark = normalizeCharacterFormatMark(candidate);
+        if (!mark || names.has(mark.type)) return null;
+        names.add(mark.type);
+        result.push(mark);
+    }
+    result.sort(compareCharacterFormatMarks);
+    return JSON.stringify(result) === value ? result : null;
+}
+function restoreDocumentCharacterFormatting(transaction, schema, from, to, serialized) {
+    const formatting = parseDocumentCharacterFormatting(serialized);
+    if (!formatting || from < 0 || to <= from || to > transaction.doc.content.size) return false;
+    for (const name of DOCUMENT_CHARACTER_FORMAT_MARKS){
+        const type = schema.marks[name];
+        if (type) transaction.removeMark(from, to, type);
+    }
+    for (const mark of formatting){
+        const type = schema.marks[mark.type];
+        if (!type) return false;
+        transaction.addMark(from, to, createCharacterFormatMark(type, mark));
+    }
+    return true;
+}
+function importedDocumentCharacterFormatting(formatting) {
+    const marks = [];
+    for (const name of [
+        'bold',
+        'italic',
+        'underline',
+        'strike',
+        "subscript",
+        "superscript"
+    ])if (formatting[name]) marks.push({
+        type: name
+    });
+    const textStyle = compactAttributes({
+        color: formatting.color,
+        fontFamily: formatting.fontFamily,
+        fontSize: void 0 === formatting.fontSize ? void 0 : `${formatting.fontSize}pt`,
+        themeColor: formatting.themeColor,
+        wordLineHeightFactor: formatting.wordLineHeightFactor,
+        wordSnapToGrid: formatting.wordSnapToGrid
+    });
+    if (textStyle) marks.push({
+        type: 'textStyle',
+        attrs: textStyle
+    });
+    const highlight = compactAttributes({
+        color: formatting.backgroundColor,
+        themeFill: formatting.themeFill
+    });
+    if (highlight) marks.push({
+        type: 'highlight',
+        attrs: highlight
+    });
+    marks.sort(compareCharacterFormatMarks);
+    return JSON.stringify(marks);
+}
+function normalizeCharacterFormatMark(value) {
+    if (!work_document_format_changes_isRecord(value) || 'string' != typeof value.type) return null;
+    if (!isDocumentCharacterFormatMark(value.type)) return null;
+    const type = value.type;
+    const allowed = ALLOWED_ATTRIBUTES[type];
+    const source = value.attrs;
+    if (void 0 !== source && !work_document_format_changes_isRecord(source)) return null;
+    const attrs = {};
+    for (const [key, candidate] of Object.entries(source ?? {}))if (allowed.has(key) && null != candidate) {
+        if ('string' == typeof candidate) {
+            if (!candidate.length || candidate.length > MAX_CHARACTER_FORMAT_ATTRIBUTE_LENGTH) return null;
+            attrs[key] = candidate;
+            continue;
+        }
+        if ('boolean' == typeof candidate) {
+            attrs[key] = candidate;
+            continue;
+        }
+        if ('number' == typeof candidate && Number.isFinite(candidate)) {
+            attrs[key] = candidate;
+            continue;
+        }
+        return null;
+    }
+    const keys = Object.keys(attrs).sort();
+    const normalizedAttributes = keys.length ? Object.fromEntries(keys.map((key)=>[
+            key,
+            attrs[key]
+        ])) : void 0;
+    return {
+        type,
+        ...normalizedAttributes ? {
+            attrs: normalizedAttributes
+        } : {}
+    };
+}
+function compareCharacterFormatMarks(left, right) {
+    return (CHARACTER_FORMAT_MARK_ORDER.get(left.type) ?? Number.MAX_SAFE_INTEGER) - (CHARACTER_FORMAT_MARK_ORDER.get(right.type) ?? Number.MAX_SAFE_INTEGER);
+}
+function createCharacterFormatMark(type, value) {
+    return type.create(value.attrs ?? void 0);
+}
+function compactAttributes(value) {
+    const entries = Object.entries(value).filter((entry)=>void 0 !== entry[1]);
+    return entries.length ? Object.fromEntries(entries) : void 0;
+}
+function work_document_format_changes_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const MAX_DOCUMENT_TAB_POSITION_PX = 4096;
+const MAX_DOCUMENT_TAB_STOPS = 64;
+const DocumentParagraphTabStops = Extension.create({
+    name: 'documentParagraphTabStops',
+    addGlobalAttributes () {
+        return [
+            {
+                types: [
+                    'paragraph',
+                    'heading'
+                ],
+                attributes: {
+                    tabStops: {
+                        default: null,
+                        parseHTML: (element)=>normalizeDocumentTabStops(element.dataset.officeTabStops),
+                        renderHTML: (attributes)=>{
+                            const tabStops = normalizeDocumentTabStops(attributes.tabStops);
+                            return tabStops.length ? {
+                                'data-office-tab-stops': serializeDocumentTabStops(tabStops)
+                            } : {};
+                        }
+                    }
+                }
+            }
+        ];
+    },
+    addCommands () {
+        return {
+            setDocumentParagraphTabStops: (tabStops, options = {})=>({ chain, editor })=>{
+                    const nodeTypes = activeParagraphNodeTypes(editor);
+                    if (!nodeTypes.length) return false;
+                    const normalized = normalizeDocumentTabStops(tabStops);
+                    let commandChain = chain();
+                    if (false !== options.restoreFocus) commandChain = commandChain.focus();
+                    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, {
+                        tabStops: normalized.length ? normalized : null
+                    });
+                    return commandChain.run();
+                }
+        };
+    }
+});
+function documentParagraphTabStops(editor) {
+    return normalizeDocumentTabStops(activeParagraphAttributes(editor).tabStops);
+}
+function normalizeDocumentTabStops(value) {
+    const source = parsedTabStopSource(value);
+    const byPosition = new Map();
+    for (const candidate of source.slice(0, 4 * MAX_DOCUMENT_TAB_STOPS)){
+        if (!work_document_tab_stops_isRecord(candidate)) continue;
+        const rawPosition = Number(candidate.position);
+        if (!Number.isFinite(rawPosition) || rawPosition <= 0) continue;
+        const position = normalizedTabPosition(rawPosition);
+        if (!(position <= 0)) byPosition.set(position, {
+            position,
+            alignment: normalizedTabAlignment(candidate.alignment),
+            leader: normalizedTabLeader(candidate.leader)
+        });
+    }
+    return Array.from(byPosition.values()).sort((left, right)=>left.position - right.position).slice(0, MAX_DOCUMENT_TAB_STOPS);
+}
+function serializeDocumentTabStops(value) {
+    return JSON.stringify(normalizeDocumentTabStops(value));
+}
+function normalizedTabPosition(value) {
+    if (!Number.isFinite(value)) return 0;
+    return Math.min(MAX_DOCUMENT_TAB_POSITION_PX, Math.max(0, Math.round(100 * value) / 100));
+}
+function nextDocumentTabAlignment(alignment) {
+    if ('left' === alignment) return 'center';
+    if ('center' === alignment) return 'right';
+    if ('right' === alignment) return 'decimal';
+    return 'left';
+}
+function parsedTabStopSource(value) {
+    if (Array.isArray(value)) return value;
+    if ('string' != typeof value || !value.trim()) return [];
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    } catch  {
+        return [];
+    }
+}
+function normalizedTabAlignment(value) {
+    return 'center' === value || 'right' === value || 'decimal' === value ? value : 'left';
+}
+function normalizedTabLeader(value) {
+    return 'dot' === value || 'hyphen' === value || 'underscore' === value || 'middleDot' === value ? value : 'none';
+}
+function activeParagraphAttributes(editor) {
+    return editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
+}
+function activeParagraphNodeTypes(editor) {
+    const types = [];
+    if (editor.isActive('paragraph')) types.push('paragraph');
+    if (editor.isActive('heading')) types.push('heading');
+    return types;
+}
+function work_document_tab_stops_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const DOCUMENT_PARAGRAPH_FORMAT_ATTRIBUTES = [
+    'textAlign',
+    'paragraphDirection',
+    'indentLevel',
+    'rightIndent',
+    'firstLineIndent',
+    'spaceBefore',
+    'spaceAfter',
+    'lineHeight',
+    'lineRule',
+    'autoLineHeight',
+    'keepLines',
+    'keepWithNext',
+    'pageBreakBefore',
+    'widowControl',
+    'contextualSpacing',
+    'outlineLevel',
+    'tabStops',
+    'paragraphBorders',
+    'paragraphShading',
+    'defaultCollapsed'
+];
+const MAX_PARAGRAPH_FORMAT_SNAPSHOT_BYTES = 65536;
+const MAX_DOCUMENT_INDENT_PX = 192;
+function serializeDocumentParagraphFormatting(attributes) {
+    return JSON.stringify(normalizeParagraphFormatting(attributes));
+}
+function parseDocumentParagraphFormatting(value) {
+    if ('string' != typeof value || !value.length || value.length > MAX_PARAGRAPH_FORMAT_SNAPSHOT_BYTES) return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    } catch  {
+        return null;
+    }
+    if (!work_document_paragraph_format_changes_isRecord(parsed)) return null;
+    const keys = Object.keys(parsed);
+    if (keys.length !== DOCUMENT_PARAGRAPH_FORMAT_ATTRIBUTES.length || keys.some((key, index)=>key !== DOCUMENT_PARAGRAPH_FORMAT_ATTRIBUTES[index])) return null;
+    const normalized = normalizeParagraphFormatting(parsed);
+    return JSON.stringify(normalized) === value ? normalized : null;
+}
+function restoredDocumentParagraphAttributes(attributes, serialized) {
+    const formatting = parseDocumentParagraphFormatting(serialized);
+    if (!formatting) return null;
+    return clearDocumentParagraphChangeAttributes({
+        ...attributes,
+        ...formatting
+    });
+}
+function clearDocumentParagraphChangeAttributes(attributes) {
+    return {
+        ...attributes,
+        paragraphChangeKind: null,
+        paragraphChangeId: '',
+        paragraphChangeActorId: '',
+        paragraphChangeAuthor: '',
+        paragraphChangeDate: '',
+        paragraphChangeBefore: ''
+    };
+}
+function normalizeParagraphFormatting(source) {
+    const indentLevel = quarterNumber(source.indentLevel, 0, 8, 0);
+    const leftIndent = 24 * indentLevel;
+    const serializedBorders = serializeDocumentParagraphBorders(source.paragraphBorders);
+    const serializedShading = serializeDocumentParagraphShading(source.paragraphShading);
+    const tabStops = normalizeDocumentTabStops(source.tabStops);
+    return {
+        textAlign: oneOfOrNull(source.textAlign, [
+            'left',
+            'center',
+            'right',
+            'justify'
+        ]),
+        paragraphDirection: oneOfOrNull(source.paragraphDirection, [
+            'ltr',
+            'rtl'
+        ]),
+        indentLevel,
+        rightIndent: integerNumber(source.rightIndent, 0, MAX_DOCUMENT_INDENT_PX, 0),
+        firstLineIndent: integerNumber(source.firstLineIndent, -leftIndent, MAX_DOCUMENT_INDENT_PX, 0),
+        spaceBefore: quarterNumberOrNull(source.spaceBefore, 0, 720),
+        spaceAfter: quarterNumberOrNull(source.spaceAfter, 0, 720),
+        lineHeight: normalizedLineHeight(source.lineHeight),
+        lineRule: oneOfOrNull(source.lineRule, [
+            'auto',
+            'exact',
+            'atLeast'
+        ]),
+        autoLineHeight: decimalNumberOrNull(source.autoLineHeight, 0, 20, 4),
+        keepLines: booleanOrNull(source.keepLines),
+        keepWithNext: booleanOrNull(source.keepWithNext),
+        pageBreakBefore: booleanOrNull(source.pageBreakBefore),
+        widowControl: booleanOrNull(source.widowControl),
+        contextualSpacing: booleanOrNull(source.contextualSpacing),
+        outlineLevel: integerNumberOrNull(source.outlineLevel, 0, 9),
+        tabStops: tabStops.length ? JSON.parse(serializeDocumentTabStops(tabStops)) : null,
+        paragraphBorders: serializedBorders ? JSON.parse(serializedBorders) : null,
+        paragraphShading: serializedShading ? JSON.parse(serializedShading) : null,
+        defaultCollapsed: booleanOrNull(source.defaultCollapsed)
+    };
+}
+function normalizedLineHeight(value) {
+    if (null == value || '' === value) return null;
+    if ('string' != typeof value || value.trim() !== value) return null;
+    return /^(?:\d+(?:\.\d+)?|\d+(?:\.\d+)?(?:px|pt|%))$/i.test(value) ? value : null;
+}
+function oneOfOrNull(value, allowed) {
+    return 'string' == typeof value && allowed.includes(value) ? value : null;
+}
+function booleanOrNull(value) {
+    return 'boolean' == typeof value ? value : null;
+}
+function quarterNumber(value, minimum, maximum, fallback) {
+    const number = Number(value);
+    if (!Number.isFinite(number)) return fallback;
+    return Math.min(maximum, Math.max(minimum, Math.round(4 * number) / 4));
+}
+function quarterNumberOrNull(value, minimum, maximum) {
+    if (null == value || '' === value) return null;
+    return quarterNumber(value, minimum, maximum, minimum);
+}
+function integerNumber(value, minimum, maximum, fallback) {
+    const number = Number(value);
+    if (!Number.isFinite(number)) return fallback;
+    return Math.min(maximum, Math.max(minimum, Math.round(number)));
+}
+function integerNumberOrNull(value, minimum, maximum) {
+    if (null == value || '' === value) return null;
+    const number = Number(value);
+    if (!Number.isSafeInteger(number) || number < minimum || number > maximum) return null;
+    return number;
+}
+function decimalNumberOrNull(value, minimumExclusive, maximum, precision) {
+    if (null == value || '' === value) return null;
+    const number = Number(value);
+    if (!Number.isFinite(number) || number <= minimumExclusive || number > maximum) return null;
+    return Number(number.toFixed(precision));
+}
+function work_document_paragraph_format_changes_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function trackDocumentParagraphFormattingTransaction(transaction, state, options) {
+    if (!transaction.steps.some((step)=>step instanceof ReplaceAroundStep)) return false;
+    let identity = null;
+    let tracked = false;
+    state.doc.descendants((before, position)=>{
+        if (!isParagraph(before)) return;
+        const after = transaction.doc.nodeAt(position);
+        if (!after || after.type !== before.type || !isParagraph(after)) return;
+        const previous = serializeDocumentParagraphFormatting(before.attrs);
+        const current = serializeDocumentParagraphFormatting(after.attrs);
+        if (previous === current || !sameContentIgnoringMarks(before, after)) return;
+        if ('paragraph-formatting' === after.attrs.paragraphChangeKind) return;
+        identity ??= options.createChange();
+        transaction.setNodeMarkup(position, void 0, {
+            ...after.attrs,
+            paragraphChangeKind: 'paragraph-formatting',
+            paragraphChangeId: identity.id,
+            paragraphChangeActorId: identity.actorId ?? '',
+            paragraphChangeAuthor: identity.author || 'A3S Work',
+            paragraphChangeDate: identity.date || new Date().toISOString(),
+            paragraphChangeBefore: previous
+        });
+        tracked = true;
+    });
+    return tracked;
+}
+function isParagraph(node) {
+    return 'paragraph' === node.type.name || 'heading' === node.type.name;
+}
+function sameContentIgnoringMarks(before, after) {
+    return JSON.stringify(childContentIgnoringMarks(before)) === JSON.stringify(childContentIgnoringMarks(after));
+}
+function childContentIgnoringMarks(node) {
+    const content = [];
+    node.forEach((child)=>{
+        content.push(contentIgnoringMarks(child));
+    });
+    return content;
+}
+function contentIgnoringMarks(node) {
+    if (node.isText) return {
+        type: node.type.name,
+        text: node.text ?? ''
+    };
+    const content = childContentIgnoringMarks(node);
+    return {
+        type: node.type.name,
+        ...Object.keys(node.attrs).length ? {
+            attrs: node.attrs
+        } : {},
+        ...content.length ? {
+            content
+        } : {}
+    };
+}
+function trackDocumentFormattingTransaction(transaction, state, type, options, pluginKey) {
+    if (!options.isTracking() || state.doc.eq(transaction.doc)) return;
+    const sync = transaction.getMeta(ySyncPluginKey);
+    if (transaction.getMeta(pluginKey) || sync?.isChangeOrigin || isHistoryTransaction(transaction)) return;
+    const ranges = formattingStepRanges(transaction);
+    const formattedDocument = transaction.doc;
+    let identity = null;
+    for (const range of ranges)for (const segment of formattingSegments(state.doc, formattedDocument, range)){
+        const beforeMarks = textMarksAt(state.doc, segment.from, segment.to);
+        const afterMarks = textMarksAt(formattedDocument, segment.from, segment.to);
+        if (!beforeMarks || !afterMarks) continue;
+        if (state.doc.textBetween(segment.from, segment.to) !== formattedDocument.textBetween(segment.from, segment.to)) continue;
+        const before = serializeDocumentCharacterFormatting(beforeMarks);
+        const after = serializeDocumentCharacterFormatting(afterMarks);
+        if (!(before === after || documentChangeMark(afterMarks))) {
+            identity ??= options.createChange('formatting');
+            transaction.addMark(segment.from, segment.to, type.create({
+                kind: 'formatting',
+                id: identity.id,
+                actorId: identity.actorId ?? '',
+                author: identity.author || 'A3S Work',
+                date: identity.date || new Date().toISOString(),
+                before
+            }));
+        }
+    }
+    const paragraphFormatting = trackDocumentParagraphFormattingTransaction(transaction, state, {
+        createChange: ()=>options.createChange('paragraph-formatting')
+    });
+    if (identity || paragraphFormatting) transaction.setMeta(pluginKey, {
+        ...identity ? {
+            formatting: true
+        } : {},
+        ...paragraphFormatting ? {
+            paragraphFormatting: true
+        } : {}
+    });
+}
+function formattingStepRanges(transaction) {
+    if (transaction.steps.some((step)=>step instanceof ReplaceStep)) return [];
+    const ranges = [];
+    for (const step of transaction.steps)if ((step instanceof AddMarkStep || step instanceof RemoveMarkStep) && isDocumentCharacterFormatMark(step.mark.type.name) && step.from < step.to) ranges.push({
+        from: step.from,
+        to: step.to
+    });
+    return mergeFormattingRanges(ranges);
+}
+function mergeFormattingRanges(ranges) {
+    const merged = [];
+    for (const range of ranges.sort((left, right)=>left.from - right.from)){
+        const previous = merged.at(-1);
+        if (!previous || range.from > previous.to) {
+            merged.push({
+                ...range
+            });
+            continue;
+        }
+        previous.to = Math.max(previous.to, range.to);
+    }
+    return merged;
+}
+function formattingSegments(before, after, range) {
+    const boundaries = new Set([
+        range.from,
+        range.to
+    ]);
+    collectFormattingBoundaries(before, range, boundaries);
+    collectFormattingBoundaries(after, range, boundaries);
+    const ordered = Array.from(boundaries).sort((left, right)=>left - right);
+    return ordered.slice(0, -1).flatMap((from, index)=>{
+        const to = ordered[index + 1];
+        return void 0 !== to && from < to ? [
+            {
+                from,
+                to
+            }
+        ] : [];
+    });
+}
+function collectFormattingBoundaries(document1, range, boundaries) {
+    document1.nodesBetween(range.from, range.to, (node, position)=>{
+        if (!node.isText) return;
+        boundaries.add(Math.max(range.from, position));
+        boundaries.add(Math.min(range.to, position + node.nodeSize));
+    });
+}
+function textMarksAt(document1, from, to) {
+    let marks = null;
+    document1.nodesBetween(from, to, (node, position)=>{
+        if (marks || !node.isText || position > from || position + node.nodeSize < to) return;
+        marks = node.marks;
+    });
+    return marks;
+}
+function documentChangeMark(marks) {
+    return marks.find((mark)=>'documentChange' === mark.type.name);
+}
 const documentChangePluginKey = new PluginKey('documentChangeTracking');
 const CONTINUOUS_INSERTION_WINDOW_MS = 30000;
 const DocumentChange = Mark.create({
@@ -8404,7 +8968,11 @@ const DocumentChange = Mark.create({
         return {
             kind: {
                 default: 'insertion',
-                parseHTML: (element)=>'del' === element.tagName.toLowerCase() ? 'deletion' : 'insertion',
+                parseHTML: (element)=>{
+                    const declared = element.getAttribute('data-change-kind');
+                    if ('formatting' === declared) return 'formatting';
+                    return 'del' === element.tagName.toLowerCase() ? 'deletion' : 'insertion';
+                },
                 renderHTML: (attributes)=>({
                         'data-change-kind': attributes.kind
                     })
@@ -8436,9 +9004,34 @@ const DocumentChange = Mark.create({
                 renderHTML: (attributes)=>({
                         'data-change-date': attributes.date
                     })
+            },
+            before: {
+                default: '',
+                parseHTML: (element)=>element.getAttribute('data-change-before') ?? '',
+                renderHTML: (attributes)=>attributes.before ? {
+                        'data-change-before': attributes.before
+                    } : {}
             }
         };
     },
+    addGlobalAttributes () {
+        return [
+            {
+                types: [
+                    'paragraph',
+                    'heading'
+                ],
+                attributes: {
+                    paragraphChangeKind: paragraphChangeAttribute('kind', 'data-change-kind'),
+                    paragraphChangeId: paragraphChangeAttribute('id', 'data-change-id'),
+                    paragraphChangeActorId: paragraphChangeAttribute('actorId', 'data-change-actor-id'),
+                    paragraphChangeAuthor: paragraphChangeAttribute('author', 'data-change-author'),
+                    paragraphChangeDate: paragraphChangeAttribute('date', 'data-change-date'),
+                    paragraphChangeBefore: paragraphChangeAttribute('before', 'data-change-before')
+                }
+            }
+        ];
+    },
     parseHTML () {
         return [
             {
@@ -8446,12 +9039,16 @@ const DocumentChange = Mark.create({
             },
             {
                 tag: 'del[data-document-change]'
+            },
+            {
+                tag: 'span[data-document-change][data-change-kind="formatting"]'
             }
         ];
     },
     renderHTML ({ mark, HTMLAttributes }) {
+        const tag = 'deletion' === mark.attrs.kind ? 'del' : 'formatting' === mark.attrs.kind ? 'span' : 'ins';
         return [
-            'deletion' === mark.attrs.kind ? 'del' : 'ins',
+            tag,
             mergeAttributes(HTMLAttributes, {
                 'data-document-change': 'true'
             }),
@@ -8491,6 +9088,19 @@ const DocumentChange = Mark.create({
         return [
             new Plugin({
                 key: documentChangePluginKey,
+                filterTransaction: (transaction, state)=>{
+                    trackDocumentFormattingTransaction(transaction, state, changeType, {
+                        isTracking: options.isTracking,
+                        createChange: (kind)=>{
+                            const identity = options.createChange(kind);
+                            return {
+                                ...identity,
+                                id: identity.id || createDocumentChangeId()
+                            };
+                        }
+                    }, documentChangePluginKey);
+                    return true;
+                },
                 props: {
                     handleTextInput: (view, from, to, text)=>{
                         if (!options.isTracking()) return false;
@@ -8536,8 +9146,31 @@ const DocumentChange = Mark.create({
 function collectDocumentChanges(document1) {
     const changes = new Map();
     document1.descendants((node, position)=>{
+        if (('paragraph' === node.type.name || 'heading' === node.type.name) && 'paragraph-formatting' === node.attrs.paragraphChangeKind) {
+            const id = work_document_changes_stringAttribute(node.attrs.paragraphChangeId) || `paragraph-change-at-${position}`;
+            const key = `paragraph-formatting:${id}`;
+            const from = position + 1;
+            const to = from + node.content.size;
+            const current = changes.get(key);
+            if (current) {
+                current.from = Math.min(current.from, from);
+                current.to = Math.max(current.to, to);
+                current.text = `${current.text}\n${node.textContent}`;
+            } else changes.set(key, {
+                id,
+                kind: 'paragraph-formatting',
+                ...work_document_changes_stringAttribute(node.attrs.paragraphChangeActorId) ? {
+                    actorId: work_document_changes_stringAttribute(node.attrs.paragraphChangeActorId)
+                } : {},
+                author: work_document_changes_stringAttribute(node.attrs.paragraphChangeAuthor) || '未知审阅者',
+                date: work_document_changes_stringAttribute(node.attrs.paragraphChangeDate),
+                from,
+                to,
+                text: node.textContent
+            });
+        }
         if (!node.isText || !node.text) return;
-        const mark = documentChangeMark(node.marks);
+        const mark = work_document_changes_documentChangeMark(node.marks);
         if (!mark) return;
         const kind = changeKind(mark.attrs.kind);
         const id = work_document_changes_stringAttribute(mark.attrs.id) || `change-at-${position}`;
@@ -8566,16 +9199,39 @@ function collectDocumentChanges(document1) {
 }
 function resolveDocumentChangesCommand({ state, tr }, type, decision, ids) {
     const segments = documentChangeSegments(state.doc, type).filter((segment)=>!ids || ids.has(segment.id));
-    if (!segments.length) return 0;
-    const removals = [];
-    const deletions = [];
+    const paragraphSegments = paragraphChangeSegments(state.doc).filter((segment)=>!ids || ids.has(segment.id));
+    if (!segments.length && !paragraphSegments.length) return 0;
+    if (paragraphSegments.some((segment)=>!parseDocumentParagraphFormatting(segment.before)) || 'reject' === decision && segments.some((segment)=>'formatting' === segment.kind && !parseDocumentCharacterFormatting(segment.before))) return 0;
+    closeHistory(tr);
+    tr.setMeta(documentChangePluginKey, {
+        decision
+    });
+    const markRemovals = [];
+    const contentDeletions = [];
+    const formattingRejections = [];
     for (const segment of segments){
-        const remove = 'accept' === decision && 'insertion' === segment.kind || 'reject' === decision && 'deletion' === segment.kind;
-        (remove ? removals : deletions).push(segment);
-    }
-    for (const segment of removals)tr.removeMark(segment.from, segment.to, type);
-    for (const segment of deletions.sort((left, right)=>right.from - left.from))tr.delete(segment.from, segment.to);
-    return tr.docChanged ? new Set(segments.map((segment)=>segment.id)).size : 0;
+        if ('formatting' === segment.kind) {
+            markRemovals.push(segment);
+            if ('reject' === decision) formattingRejections.push(segment);
+            continue;
+        }
+        const removeMark = 'accept' === decision && 'insertion' === segment.kind || 'reject' === decision && 'deletion' === segment.kind;
+        (removeMark ? markRemovals : contentDeletions).push(segment);
+    }
+    for (const segment of formattingRejections)restoreDocumentCharacterFormatting(tr, state.schema, segment.from, segment.to, segment.before);
+    for (const segment of paragraphSegments){
+        const node = tr.doc.nodeAt(segment.position);
+        if (!node || 'paragraph' !== node.type.name && 'heading' !== node.type.name) return 0;
+        const attributes = 'reject' === decision ? restoredDocumentParagraphAttributes(node.attrs, segment.before) : clearDocumentParagraphChangeAttributes(node.attrs);
+        if (!attributes) return 0;
+        tr.setNodeMarkup(segment.position, void 0, attributes);
+    }
+    for (const segment of markRemovals)tr.removeMark(segment.from, segment.to, type);
+    for (const segment of contentDeletions.sort((left, right)=>right.from - left.from))tr.delete(segment.from, segment.to);
+    return tr.docChanged ? new Set([
+        ...segments,
+        ...paragraphSegments
+    ].map((segment)=>segment.id)).size : 0;
 }
 function trackedReplacement(transaction, document1, type, from, to, text, createChange) {
     if (from !== to) trackDeletion(transaction, document1, type, from, to, changeMark(type, 'deletion', createChange));
@@ -8622,7 +9278,23 @@ function documentChangeSegments(document1, type) {
             id: work_document_changes_stringAttribute(mark.attrs.id) || `change-at-${position}`,
             kind: changeKind(mark.attrs.kind),
             from: position,
-            to: position + node.nodeSize
+            to: position + node.nodeSize,
+            before: work_document_changes_stringAttribute(mark.attrs.before)
+        });
+    });
+    return segments;
+}
+function paragraphChangeSegments(document1) {
+    const segments = [];
+    document1.descendants((node, position)=>{
+        if ('paragraph' !== node.type.name && 'heading' !== node.type.name || 'paragraph-formatting' !== node.attrs.paragraphChangeKind) return;
+        segments.push({
+            id: work_document_changes_stringAttribute(node.attrs.paragraphChangeId) || `paragraph-change-at-${position}`,
+            kind: 'paragraph-formatting',
+            position,
+            from: position + 1,
+            to: position + 1 + node.content.size,
+            before: work_document_changes_stringAttribute(node.attrs.paragraphChangeBefore)
         });
     });
     return segments;
@@ -8653,14 +9325,15 @@ function adjacentTextRange(document1, position, direction) {
         to: position + character.length
     };
 }
-function changeMark(type, kind, createChange) {
+function changeMark(type, kind, createChange, before = '') {
     const identity = createChange(kind);
     return type.create({
         kind,
         id: identity.id || createDocumentChangeId(),
         actorId: identity.actorId ?? '',
         author: identity.author || 'A3S Work',
-        date: identity.date || new Date().toISOString()
+        date: identity.date || new Date().toISOString(),
+        before
     });
 }
 function continuousInsertionMark(document1, type, position, createChange) {
@@ -8674,11 +9347,33 @@ function continuousInsertionMark(document1, type, position, createChange) {
     if (!Number.isFinite(previousTime) || !Number.isFinite(nextTime) || Math.abs(nextTime - previousTime) > CONTINUOUS_INSERTION_WINDOW_MS) return next;
     return previous;
 }
-function documentChangeMark(marks) {
+function work_document_changes_documentChangeMark(marks) {
     return marks.find((mark)=>'documentChange' === mark.type.name);
 }
 function changeKind(value) {
-    return 'deletion' === value ? 'deletion' : 'insertion';
+    if ('deletion' === value || 'formatting' === value) return value;
+    return 'insertion';
+}
+function paragraphChangeAttribute(field, htmlName) {
+    const modelName = `paragraphChange${field[0]?.toUpperCase() ?? ''}${field.slice(1)}`;
+    return {
+        default: 'kind' === field ? null : '',
+        parseHTML: (element)=>{
+            if ('true' !== element.getAttribute('data-document-change') || 'paragraph-formatting' !== element.getAttribute('data-change-kind')) return 'kind' === field ? null : '';
+            return 'kind' === field ? 'paragraph-formatting' : element.getAttribute(htmlName) ?? '';
+        },
+        renderHTML: (attributes)=>{
+            if ('paragraph-formatting' !== attributes.paragraphChangeKind) return {};
+            if ('kind' === field) return {
+                'data-document-change': 'true',
+                'data-change-kind': 'paragraph-formatting'
+            };
+            const value = work_document_changes_stringAttribute(attributes[modelName]);
+            return value ? {
+                [htmlName]: value
+            } : {};
+        }
+    };
 }
 function work_document_changes_stringAttribute(value) {
     return 'string' == typeof value ? value : '';
@@ -11134,7 +11829,7 @@ const DocumentPageBreak = core_Node.create({
 });
 const DOCUMENT_INDENT_STEP_PX = 24;
 const MAX_DOCUMENT_INDENT_LEVEL = 8;
-const MAX_DOCUMENT_INDENT_PX = DOCUMENT_INDENT_STEP_PX * MAX_DOCUMENT_INDENT_LEVEL;
+const work_document_paragraph_formatting_MAX_DOCUMENT_INDENT_PX = DOCUMENT_INDENT_STEP_PX * MAX_DOCUMENT_INDENT_LEVEL;
 const DOCUMENT_WORD_SINGLE_LINE_HEIGHT = 1.15;
 const DocumentParagraphFormatting = Extension.create({
     name: 'documentParagraphFormatting',
@@ -11148,9 +11843,9 @@ const DocumentParagraphFormatting = Extension.create({
                 attributes: {
                     lineHeight: {
                         default: null,
-                        parseHTML: (element)=>normalizedLineHeight(element.style.lineHeight),
+                        parseHTML: (element)=>work_document_paragraph_formatting_normalizedLineHeight(element.style.lineHeight),
                         renderHTML: (attributes)=>{
-                            const lineHeight = normalizedLineHeight(attributes.lineHeight);
+                            const lineHeight = work_document_paragraph_formatting_normalizedLineHeight(attributes.lineHeight);
                             return lineHeight ? {
                                 style: `line-height: ${lineHeight}`
                             } : {};
@@ -11275,7 +11970,7 @@ function documentParagraphIndent(editor) {
     });
 }
 function documentParagraphPagination(editor) {
-    const attributes = activeParagraphAttributes(editor);
+    const attributes = work_document_paragraph_formatting_activeParagraphAttributes(editor);
     return {
         keepLines: directBoolean(attributes.keepLines) ?? false,
         keepWithNext: directBoolean(attributes.keepWithNext) ?? editor.isActive('heading'),
@@ -11284,15 +11979,15 @@ function documentParagraphPagination(editor) {
     };
 }
 function documentParagraphDirection(editor) {
-    const attributes = editor.isActive('listItem') ? editor.getAttributes('listItem') : activeParagraphAttributes(editor);
+    const attributes = editor.isActive('listItem') ? editor.getAttributes('listItem') : work_document_paragraph_formatting_activeParagraphAttributes(editor);
     return normalizeDocumentParagraphDirection(attributes.paragraphDirection) ?? 'ltr';
 }
 function documentParagraphSpacing(editor) {
-    const attributes = activeParagraphAttributes(editor);
+    const attributes = work_document_paragraph_formatting_activeParagraphAttributes(editor);
     return {
         before: normalizedPointSpacing(attributes.spaceBefore),
         after: normalizedPointSpacing(attributes.spaceAfter),
-        lineHeight: normalizedLineHeight(attributes.lineHeight),
+        lineHeight: work_document_paragraph_formatting_normalizedLineHeight(attributes.lineHeight),
         lineRule: normalizedLineRule(attributes.lineRule)
     };
 }
@@ -11310,7 +12005,7 @@ function normalizeDocumentParagraphDirection(value) {
     return 'ltr' === normalized || 'rtl' === normalized ? normalized : null;
 }
 function setDocumentLineHeightCommand({ chain }, lineHeight) {
-    const value = normalizedLineHeight(lineHeight);
+    const value = work_document_paragraph_formatting_normalizedLineHeight(lineHeight);
     const lineRule = value ? lineRuleForLineHeight(value) : null;
     const attributes = {
         lineHeight: value,
@@ -11338,7 +12033,7 @@ function setDocumentIndentLevelCommand(props, indentLevel, options) {
     }, options);
 }
 function setDocumentParagraphIndentCommand({ chain, editor }, indent, options) {
-    const nodeTypes = activeParagraphNodeTypes(editor);
+    const nodeTypes = work_document_paragraph_formatting_activeParagraphNodeTypes(editor);
     if (!nodeTypes.length) return false;
     const normalized = normalizeDocumentParagraphIndent(indent);
     const attributes = {
@@ -11363,7 +12058,7 @@ function setDocumentParagraphDirectionCommand({ chain, editor }, direction, opti
     return commandChain.run();
 }
 function setDocumentParagraphPaginationCommand({ chain, editor }, pagination, options) {
-    const nodeTypes = activeParagraphNodeTypes(editor);
+    const nodeTypes = work_document_paragraph_formatting_activeParagraphNodeTypes(editor);
     if (!nodeTypes.length) return false;
     const attributes = {};
     for (const key of documentParagraphPaginationKeys)if (Object.hasOwn(pagination, key)) attributes[key] = Boolean(pagination[key]);
@@ -11374,7 +12069,7 @@ function setDocumentParagraphPaginationCommand({ chain, editor }, pagination, op
     return commandChain.run();
 }
 function clearDocumentParagraphPaginationCommand({ chain, editor }, options) {
-    const nodeTypes = activeParagraphNodeTypes(editor);
+    const nodeTypes = work_document_paragraph_formatting_activeParagraphNodeTypes(editor);
     if (!nodeTypes.length) return false;
     const attributes = {
         keepLines: null,
@@ -11388,9 +12083,9 @@ function clearDocumentParagraphPaginationCommand({ chain, editor }, options) {
     return commandChain.run();
 }
 function setDocumentParagraphSpacingCommand({ chain, editor }, spacing, options) {
-    const nodeTypes = activeParagraphNodeTypes(editor);
+    const nodeTypes = work_document_paragraph_formatting_activeParagraphNodeTypes(editor);
     if (!nodeTypes.length) return false;
-    const lineHeight = normalizedLineHeight(spacing.lineHeight);
+    const lineHeight = work_document_paragraph_formatting_normalizedLineHeight(spacing.lineHeight);
     const lineRule = normalizedLineRule(spacing.lineRule) ?? (lineHeight ? lineRuleForLineHeight(lineHeight) : null);
     const attributes = {
         spaceBefore: normalizedPointSpacing(spacing.before),
@@ -11405,7 +12100,8 @@ function setDocumentParagraphSpacingCommand({ chain, editor }, spacing, options)
     return commandChain.run();
 }
 function clearDocumentFormattingCommand({ chain, editor }) {
-    let commandChain = chain().focus().unsetAllMarks();
+    let commandChain = chain().focus();
+    for (const mark of DOCUMENT_CHARACTER_FORMAT_MARKS)if (editor.schema.marks[mark]) commandChain = commandChain.unsetMark(mark);
     if (!editor.isActive('listItem')) commandChain = commandChain.setParagraph();
     return commandChain.unsetTextAlign().updateAttributes('paragraph', {
         indentLevel: 0,
@@ -11440,7 +12136,7 @@ function normalizedIndentLevel(value) {
     if (!Number.isFinite(number)) return 0;
     return Math.min(MAX_DOCUMENT_INDENT_LEVEL, Math.max(0, Math.round(4 * number) / 4));
 }
-function normalizedLineHeight(value) {
+function work_document_paragraph_formatting_normalizedLineHeight(value) {
     if ('string' != typeof value) return null;
     const normalized = value.trim();
     if (!normalized || 'normal' === normalized) return null;
@@ -11475,7 +12171,7 @@ function renderDocumentAutoLineHeight(lineHeight, autoLineHeight = documentAutoL
     };
 }
 function lineHeightMultiple(value) {
-    const normalized = normalizedLineHeight(value);
+    const normalized = work_document_paragraph_formatting_normalizedLineHeight(value);
     if (!normalized) return null;
     const percentage = /^(\d+(?:\.\d+)?)%$/.exec(normalized);
     const multiple = percentage ? Number(percentage[1]) / 100 : /^\d+(?:\.\d+)?$/.test(normalized) ? Number(normalized) : NaN;
@@ -11547,20 +12243,20 @@ function parsedSignedIndentPixels(dataValue, cssValue) {
 function normalizedIndentPixels(value) {
     const number = Number(value);
     if (!Number.isFinite(number)) return 0;
-    return Math.min(MAX_DOCUMENT_INDENT_PX, Math.max(0, Math.round(number)));
+    return Math.min(work_document_paragraph_formatting_MAX_DOCUMENT_INDENT_PX, Math.max(0, Math.round(number)));
 }
 function normalizedSignedIndentPixels(value) {
     const number = Number(value);
     if (!Number.isFinite(number)) return 0;
-    return Math.min(MAX_DOCUMENT_INDENT_PX, Math.max(-MAX_DOCUMENT_INDENT_PX, Math.round(number)));
+    return Math.min(work_document_paragraph_formatting_MAX_DOCUMENT_INDENT_PX, Math.max(-work_document_paragraph_formatting_MAX_DOCUMENT_INDENT_PX, Math.round(number)));
 }
 function normalizedFirstLineIndent(value, leftIndent) {
-    return Math.max(-leftIndent, Math.min(MAX_DOCUMENT_INDENT_PX, normalizedSignedIndentPixels(value)));
+    return Math.max(-leftIndent, Math.min(work_document_paragraph_formatting_MAX_DOCUMENT_INDENT_PX, normalizedSignedIndentPixels(value)));
 }
 function formatPixelValue(value) {
     return Number(value.toFixed(2)).toString();
 }
-function activeParagraphAttributes(editor) {
+function work_document_paragraph_formatting_activeParagraphAttributes(editor) {
     return editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
 }
 function paragraphDirectionAttribute() {
@@ -11615,7 +12311,7 @@ function directBoolean(value) {
     if (false === value || 'false' === value || '0' === value) return false;
     return null;
 }
-function activeParagraphNodeTypes(editor) {
+function work_document_paragraph_formatting_activeParagraphNodeTypes(editor) {
     const nodeTypes = new Set();
     if (editor.isActive('paragraph')) nodeTypes.add('paragraph');
     if (editor.isActive('heading')) nodeTypes.add('heading');
@@ -11632,7 +12328,7 @@ function activeParagraphDirectionNodeTypes(editor) {
     const { from, to } = editor.state.selection;
     if (from === to) return editor.isActive('listItem') ? [
         'listItem'
-    ] : activeParagraphNodeTypes(editor);
+    ] : work_document_paragraph_formatting_activeParagraphNodeTypes(editor);
     const nodeTypes = new Set();
     editor.state.doc.nodesBetween(from, to, (node, _position, parent)=>{
         if ('listItem' === node.type.name) nodeTypes.add('listItem');
@@ -11726,108 +12422,6 @@ function elementForNode(editor, position) {
     if (!node || node.nodeType !== Node.ELEMENT_NODE) return null;
     return node;
 }
-const MAX_DOCUMENT_TAB_POSITION_PX = 4096;
-const MAX_DOCUMENT_TAB_STOPS = 64;
-const DocumentParagraphTabStops = Extension.create({
-    name: 'documentParagraphTabStops',
-    addGlobalAttributes () {
-        return [
-            {
-                types: [
-                    'paragraph',
-                    'heading'
-                ],
-                attributes: {
-                    tabStops: {
-                        default: null,
-                        parseHTML: (element)=>normalizeDocumentTabStops(element.dataset.officeTabStops),
-                        renderHTML: (attributes)=>{
-                            const tabStops = normalizeDocumentTabStops(attributes.tabStops);
-                            return tabStops.length ? {
-                                'data-office-tab-stops': serializeDocumentTabStops(tabStops)
-                            } : {};
-                        }
-                    }
-                }
-            }
-        ];
-    },
-    addCommands () {
-        return {
-            setDocumentParagraphTabStops: (tabStops, options = {})=>({ chain, editor })=>{
-                    const nodeTypes = work_document_tab_stops_activeParagraphNodeTypes(editor);
-                    if (!nodeTypes.length) return false;
-                    const normalized = normalizeDocumentTabStops(tabStops);
-                    let commandChain = chain();
-                    if (false !== options.restoreFocus) commandChain = commandChain.focus();
-                    for (const nodeType of nodeTypes)commandChain = commandChain.updateAttributes(nodeType, {
-                        tabStops: normalized.length ? normalized : null
-                    });
-                    return commandChain.run();
-                }
-        };
-    }
-});
-function documentParagraphTabStops(editor) {
-    return normalizeDocumentTabStops(work_document_tab_stops_activeParagraphAttributes(editor).tabStops);
-}
-function normalizeDocumentTabStops(value) {
-    const source = parsedTabStopSource(value);
-    const byPosition = new Map();
-    for (const candidate of source.slice(0, 4 * MAX_DOCUMENT_TAB_STOPS)){
-        if (!work_document_tab_stops_isRecord(candidate)) continue;
-        const rawPosition = Number(candidate.position);
-        if (!Number.isFinite(rawPosition) || rawPosition <= 0) continue;
-        const position = normalizedTabPosition(rawPosition);
-        if (!(position <= 0)) byPosition.set(position, {
-            position,
-            alignment: normalizedTabAlignment(candidate.alignment),
-            leader: normalizedTabLeader(candidate.leader)
-        });
-    }
-    return Array.from(byPosition.values()).sort((left, right)=>left.position - right.position).slice(0, MAX_DOCUMENT_TAB_STOPS);
-}
-function serializeDocumentTabStops(value) {
-    return JSON.stringify(normalizeDocumentTabStops(value));
-}
-function normalizedTabPosition(value) {
-    if (!Number.isFinite(value)) return 0;
-    return Math.min(MAX_DOCUMENT_TAB_POSITION_PX, Math.max(0, Math.round(100 * value) / 100));
-}
-function nextDocumentTabAlignment(alignment) {
-    if ('left' === alignment) return 'center';
-    if ('center' === alignment) return 'right';
-    if ('right' === alignment) return 'decimal';
-    return 'left';
-}
-function parsedTabStopSource(value) {
-    if (Array.isArray(value)) return value;
-    if ('string' != typeof value || !value.trim()) return [];
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) ? parsed : [];
-    } catch  {
-        return [];
-    }
-}
-function normalizedTabAlignment(value) {
-    return 'center' === value || 'right' === value || 'decimal' === value ? value : 'left';
-}
-function normalizedTabLeader(value) {
-    return 'dot' === value || 'hyphen' === value || 'underscore' === value || 'middleDot' === value ? value : 'none';
-}
-function work_document_tab_stops_activeParagraphAttributes(editor) {
-    return editor.isActive('heading') ? editor.getAttributes('heading') : editor.getAttributes('paragraph');
-}
-function work_document_tab_stops_activeParagraphNodeTypes(editor) {
-    const types = [];
-    if (editor.isActive('paragraph')) types.push('paragraph');
-    if (editor.isActive('heading')) types.push('heading');
-    return types;
-}
-function work_document_tab_stops_isRecord(value) {
-    return 'object' == typeof value && null !== value && !Array.isArray(value);
-}
 const MAX_DOCUMENT_TEXT_LAYOUT_PARAGRAPHS = 16384;
 const MAX_DOCUMENT_TEXT_LAYOUT_RUNS = 16384;
 const MAX_DOCUMENT_TEXT_LAYOUT_BYTES = 1048576;
@@ -16064,9 +16658,9 @@ function changeIdentity(decision) {
     return `${decision.changeKind}:${decision.changeId}`;
 }
 function office_document_collaboration_change_decisions_changeKind(value, shared) {
-    if ('insertion' === value || 'deletion' === value) return value;
+    if ('insertion' === value || 'deletion' === value || 'formatting' === value || 'paragraph-formatting' === value) return value;
     if (shared) invalidSharedSidecars('tracked-change decision kind');
-    invalidInputSidecars('an insertion or deletion tracked-change kind');
+    invalidInputSidecars('an insertion, deletion, formatting, or paragraph-formatting tracked-change kind');
 }
 function decisionAction(value, shared) {
     if ('accept' === value || 'reject' === value) return value;
@@ -16727,7 +17321,14 @@ function strictDocumentChanges(document1) {
     const changes = new Map();
     let valid = true;
     document1.descendants((node)=>{
-        if (!valid || !node.isText || !node.text) return;
+        if (!valid) return;
+        if ('paragraph' === node.type.name || 'heading' === node.type.name) {
+            if (!strictParagraphFormattingChange(node)) {
+                valid = false;
+                return false;
+            }
+        }
+        if (!node.isText || !node.text) return;
         const marks = node.marks.filter((mark)=>'documentChange' === mark.type.name);
         if (0 === marks.length) return;
         if (1 !== marks.length) {
@@ -16740,10 +17341,11 @@ function strictDocumentChanges(document1) {
         const author = strictString(mark.attrs.author);
         const date = strictString(mark.attrs.date);
         const actorId = optionalStrictString(mark.attrs.actorId);
-        if (!id || !kind || null === author || null === date || null === actorId) {
+        if (!id || !kind || null === author || null === date || null === actorId || 'formatting' === kind && !parseDocumentCharacterFormatting(mark.attrs.before)) {
             valid = false;
             return false;
         }
+        if ('formatting' === kind) return;
         const current = changes.get(id);
         const candidate = {
             id,
@@ -16769,7 +17371,7 @@ function documentSuggestionBaseline(node) {
     if (node.isText) {
         const change = node.marks.find((mark)=>'documentChange' === mark.type.name);
         if (change?.attrs.kind === 'insertion') return null;
-        const marks = node.marks.filter((mark)=>'documentChange' !== mark.type.name).map((mark)=>mark.toJSON());
+        const marks = node.marks.filter((mark)=>'documentChange' !== mark.type.name || 'formatting' === mark.attrs.kind).map((mark)=>mark.toJSON());
         if (marks.length > 0) return {
             ...json,
             marks
@@ -16816,7 +17418,19 @@ function optionalStrictString(value) {
     return strictString(value);
 }
 function strictChangeKind(value) {
-    return 'insertion' === value || 'deletion' === value ? value : null;
+    return 'insertion' === value || 'deletion' === value || 'formatting' === value ? value : null;
+}
+function strictParagraphFormattingChange(node) {
+    const kind = node.attrs.paragraphChangeKind;
+    const fields = [
+        node.attrs.paragraphChangeId,
+        node.attrs.paragraphChangeActorId,
+        node.attrs.paragraphChangeAuthor,
+        node.attrs.paragraphChangeDate,
+        node.attrs.paragraphChangeBefore
+    ];
+    if ('paragraph-formatting' !== kind) return (null == kind || '' === kind) && fields.every((field)=>null == field || '' === field);
+    return Boolean(strictString(node.attrs.paragraphChangeId) && null !== optionalStrictString(node.attrs.paragraphChangeActorId) && strictString(node.attrs.paragraphChangeAuthor) && strictString(node.attrs.paragraphChangeDate) && parseDocumentParagraphFormatting(node.attrs.paragraphChangeBefore));
 }
 const DOCUMENT_CONTENT_ROOT = 'document.content';
 const MAX_DOCUMENT_COMMENT_HISTORY = 100;
@@ -17468,4 +18082,4 @@ function capturePages(surface) {
             width: surface.pageWidth
         }));
 }
-export { DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DEFAULT_DOCUMENT_TABLE_GEOMETRY, DOCUMENT_BOOKMARK_DUPLICATE_MESSAGE, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PAGE_MARGIN_KEYS, DOCUMENT_PARAGRAPH_BORDER_EDGES, DOCUMENT_PARAGRAPH_BORDER_STYLES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, DOCUMENT_TABLE_STYLE_OPTIONS, DocumentEquation, DocumentImage, DocumentParagraphFormatting, DocumentParagraphIdentity, DocumentSubscript, DocumentSuperscript, DocumentTableRowIdentity, DocxThemePatchCollector, MAX_DOCUMENT_IMAGE_RELATIVE_HEIGHT, MAX_DOCUMENT_NUMBERING_START, activeDocumentBookmark, activeDocumentSection, activeDocumentTableStyle, applyDocumentImageCropToElement, applyDocumentImageIdentityToElement, applyDocumentImageLayerToElement, applyDocumentImageWrapContourToElement, applyDocumentPageGeometry, applyDocumentParagraphIdentityToElement, applyDocumentTableGeometryToElement, applyDocumentTableRowIdentityToElement, canChangeDocumentIndent, canInsertDocumentComment, canSetDocumentTableRowRepeatHeader, clampDocumentMargin, collectDocumentChanges, collectDocumentCommentAnchors, collectDocumentNotes, collectDocumentTextLayoutParagraphs, createDocumentBibliography, createDocumentEquationElement, createDocumentImageIdentityRegistry, createDocumentNoteElement, createDocumentParagraphIdentityRegistry, createWorkDocumentExtensions, createWorkDocumentModel, createWorkDocumentModelFromContent, createWorkOfficeDocumentCollaborationBinding as createOfficeDocumentCollaborationBinding, defaultDocumentImageWrapContour, documentAutoLineHeight, documentBookmarkNameExists, documentBookmarkReferenceInstruction, documentBulletListStyle, documentCaptionKind, documentCaptionLabel, documentCitationCount, documentCitationInstruction, documentCitationStyle, documentCitationStyleDetails, documentCitationTags, documentCitationTagsFromInstruction, documentCommentDraftRange, documentCommentViews, documentContentLayoutProperties, documentEquationFromElement, documentEquationText, documentImageCropFromElement, documentImageIdentityFromElement, documentImageLayerFromElement, documentImageLayoutFromElement, documentImageLayoutOptions, documentImagePositionFromElement, documentImageProperties, documentImageWrapContourFromElement, documentInitialSectionLayout, documentModelForContent, documentNoteKey, documentNoteKind, documentOrderedListState, documentPageBordersVisible, documentPageChromeLegacyFields, documentPageGeometryForLayout, documentPageHorizontalMarginTwips, documentPageMarginBody, documentPageMarginsForLayout, documentPageMetrics, documentParagraphBordersDomAttributes, documentParagraphDirection, documentParagraphIdentityFromElement, documentParagraphIndent, documentParagraphPagination, documentParagraphShadingDomAttributes, documentParagraphSpacing, documentParagraphTabStops, documentSectionById, documentSectionDomAttributes, documentSections, documentTabLeaderLabel, documentTableBordersFromElement, documentTableCellFormat, documentTableCellMarginOverridesFromElement, documentTableColumnPercentagesFromElement, documentTableGeometryFromElement, documentTableHorizontalAlignment, documentTableRowIdentityFromElement, documentTableRowOptions, documentTableSizing, documentTextLayoutBatches, documentWordLineHeightFactor, docxBookmarkReferenceTarget, docxDocumentFieldKind, editorDocumentBookmarkReferenceTargets, editorDocumentCaptionTargets, initializeWorkOfficeDocumentCollaboration as initializeOfficeDocumentCollaboration, isContourImageLayout, isDocumentParagraphArtBorderStyle, isValidDocumentCitationTag, materializeWorkDocumentContent, measureDocumentLayoutBlocksIncrementally, millimetersToPixels, mountWorkLiveDocumentCapture, nextDocumentTabAlignment, normalizeDocumentBookmarkName, normalizeDocumentBookmarkNativeId, normalizeDocumentBookmarkReferencesHtml, normalizeDocumentBookmarksHtml, normalizeDocumentCaptionsHtml, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentEquation, normalizeDocumentFieldsHtml, normalizeDocumentHtml, normalizeDocumentImageAlignment, normalizeDocumentImageCrop, normalizeDocumentImageIdentity, normalizeDocumentImageLayer, normalizeDocumentImageLayoutOptions, normalizeDocumentImagePosition, normalizeDocumentImageWrapContour, normalizeDocumentImageWrapSide, normalizeDocumentNotesHtml, normalizeDocumentPageBorders, normalizeDocumentPageChrome, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, normalizeDocumentPaperSource, normalizeDocumentParagraphBorder, normalizeDocumentParagraphBorders, normalizeDocumentParagraphId, normalizeDocumentParagraphIdentity, normalizeDocumentParagraphIndent, normalizeDocumentTabStops, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeDocumentTableRowHeightRule, normalizeDocumentTableRowIdentity, normalizeDocumentTableVerticalAlign, normalizeTableColor, normalizedTabPosition, pageTwipsToMillimeters, parseDocumentParagraphBordersElement, parseDocumentParagraphShadingElement, parseDocxThemeReference, patchDocxThemeReferences, positionWorkLiveDocumentCapture, readWorkOfficeDocumentCollaboration as readOfficeDocumentCollaboration, renderDocumentAutoLineHeight, renderDocumentTableBorders, renderDocumentTableCellMarginOverrides, resolveDocumentPageBorders, resolveDocumentPageChrome, resolveDocumentPageMargins, resolveDocumentPageSize, resolveWorkDocumentEditorInput, retainAnchoredDocumentComments, sanitizeDocumentPageChromeHtml, serializeDocumentTabStops, serializeDocxThemeReference, serializeWorkDocumentNode, setCustomDocumentColumns, supportedDocxBookmarkReferenceInstruction, syncDocumentContentFromHtml, uniqueDocumentImageIdentity, uniqueDocumentParagraphIdentity, updateDocumentColumnWidth, updateDocumentCustomPageMillimeters, updateDocumentGutterPosition, updateDocumentMirrorMargins, updateDocumentPageChromeVariant, updateDocumentPageMarginMillimeters, updateDocumentPageMarginMode, updateDocumentPageOrientation, updateDocumentPaperSizePreset, validateDocumentBookmarkName, workDocumentSchema, workOfficeDocumentCollaborationFragment as officeDocumentCollaborationFragment, work_document_page_margins_twipsToMillimeters, wrapsBesideImage };
+export { DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DEFAULT_DOCUMENT_TABLE_GEOMETRY, DOCUMENT_BOOKMARK_DUPLICATE_MESSAGE, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PAGE_MARGIN_KEYS, DOCUMENT_PARAGRAPH_BORDER_EDGES, DOCUMENT_PARAGRAPH_BORDER_STYLES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, DOCUMENT_TABLE_STYLE_OPTIONS, DocumentEquation, DocumentImage, DocumentParagraphFormatting, DocumentParagraphIdentity, DocumentSubscript, DocumentSuperscript, DocumentTableRowIdentity, DocxThemePatchCollector, MAX_DOCUMENT_IMAGE_RELATIVE_HEIGHT, MAX_DOCUMENT_NUMBERING_START, activeDocumentBookmark, activeDocumentSection, activeDocumentTableStyle, applyDocumentImageCropToElement, applyDocumentImageIdentityToElement, applyDocumentImageLayerToElement, applyDocumentImageWrapContourToElement, applyDocumentPageGeometry, applyDocumentParagraphIdentityToElement, applyDocumentTableGeometryToElement, applyDocumentTableRowIdentityToElement, canChangeDocumentIndent, canInsertDocumentComment, canSetDocumentTableRowRepeatHeader, clampDocumentMargin, collectDocumentChanges, collectDocumentCommentAnchors, collectDocumentNotes, collectDocumentTextLayoutParagraphs, createDocumentBibliography, createDocumentEquationElement, createDocumentImageIdentityRegistry, createDocumentNoteElement, createDocumentParagraphIdentityRegistry, createWorkDocumentExtensions, createWorkDocumentModel, createWorkDocumentModelFromContent, createWorkOfficeDocumentCollaborationBinding as createOfficeDocumentCollaborationBinding, defaultDocumentImageWrapContour, documentAutoLineHeight, documentBookmarkNameExists, documentBookmarkReferenceInstruction, documentBulletListStyle, documentCaptionKind, documentCaptionLabel, documentCitationCount, documentCitationInstruction, documentCitationStyle, documentCitationStyleDetails, documentCitationTags, documentCitationTagsFromInstruction, documentCommentDraftRange, documentCommentViews, documentContentLayoutProperties, documentEquationFromElement, documentEquationText, documentImageCropFromElement, documentImageIdentityFromElement, documentImageLayerFromElement, documentImageLayoutFromElement, documentImageLayoutOptions, documentImagePositionFromElement, documentImageProperties, documentImageWrapContourFromElement, documentInitialSectionLayout, documentModelForContent, documentNoteKey, documentNoteKind, documentOrderedListState, documentPageBordersVisible, documentPageChromeLegacyFields, documentPageGeometryForLayout, documentPageHorizontalMarginTwips, documentPageMarginBody, documentPageMarginsForLayout, documentPageMetrics, documentParagraphBordersDomAttributes, documentParagraphDirection, documentParagraphIdentityFromElement, documentParagraphIndent, documentParagraphPagination, documentParagraphShadingDomAttributes, documentParagraphSpacing, documentParagraphTabStops, documentSectionById, documentSectionDomAttributes, documentSections, documentTabLeaderLabel, documentTableBordersFromElement, documentTableCellFormat, documentTableCellMarginOverridesFromElement, documentTableColumnPercentagesFromElement, documentTableGeometryFromElement, documentTableHorizontalAlignment, documentTableRowIdentityFromElement, documentTableRowOptions, documentTableSizing, documentTextLayoutBatches, documentWordLineHeightFactor, docxBookmarkReferenceTarget, docxDocumentFieldKind, editorDocumentBookmarkReferenceTargets, editorDocumentCaptionTargets, importedDocumentCharacterFormatting, initializeWorkOfficeDocumentCollaboration as initializeOfficeDocumentCollaboration, isContourImageLayout, isDocumentParagraphArtBorderStyle, isValidDocumentCitationTag, materializeWorkDocumentContent, measureDocumentLayoutBlocksIncrementally, millimetersToPixels, mountWorkLiveDocumentCapture, nextDocumentTabAlignment, normalizeDocumentBookmarkName, normalizeDocumentBookmarkNativeId, normalizeDocumentBookmarkReferencesHtml, normalizeDocumentBookmarksHtml, normalizeDocumentCaptionsHtml, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentEquation, normalizeDocumentFieldsHtml, normalizeDocumentHtml, normalizeDocumentImageAlignment, normalizeDocumentImageCrop, normalizeDocumentImageIdentity, normalizeDocumentImageLayer, normalizeDocumentImageLayoutOptions, normalizeDocumentImagePosition, normalizeDocumentImageWrapContour, normalizeDocumentImageWrapSide, normalizeDocumentNotesHtml, normalizeDocumentPageBorders, normalizeDocumentPageChrome, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, normalizeDocumentPaperSource, normalizeDocumentParagraphBorder, normalizeDocumentParagraphBorders, normalizeDocumentParagraphId, normalizeDocumentParagraphIdentity, normalizeDocumentParagraphIndent, normalizeDocumentTabStops, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeDocumentTableRowHeightRule, normalizeDocumentTableRowIdentity, normalizeDocumentTableVerticalAlign, normalizeTableColor, normalizedTabPosition, pageTwipsToMillimeters, parseDocumentCharacterFormatting, parseDocumentParagraphBordersElement, parseDocumentParagraphFormatting, parseDocumentParagraphShadingElement, parseDocxThemeReference, patchDocxThemeReferences, positionWorkLiveDocumentCapture, readWorkOfficeDocumentCollaboration as readOfficeDocumentCollaboration, renderDocumentAutoLineHeight, renderDocumentTableBorders, renderDocumentTableCellMarginOverrides, resolveDocumentPageBorders, resolveDocumentPageChrome, resolveDocumentPageMargins, resolveDocumentPageSize, resolveWorkDocumentEditorInput, retainAnchoredDocumentComments, sanitizeDocumentPageChromeHtml, serializeDocumentParagraphFormatting, serializeDocumentTabStops, serializeDocxThemeReference, serializeWorkDocumentNode, setCustomDocumentColumns, supportedDocxBookmarkReferenceInstruction, syncDocumentContentFromHtml, uniqueDocumentImageIdentity, uniqueDocumentParagraphIdentity, updateDocumentColumnWidth, updateDocumentCustomPageMillimeters, updateDocumentGutterPosition, updateDocumentMirrorMargins, updateDocumentPageChromeVariant, updateDocumentPageMarginMillimeters, updateDocumentPageMarginMode, updateDocumentPageOrientation, updateDocumentPaperSizePreset, validateDocumentBookmarkName, workDocumentSchema, workOfficeDocumentCollaborationFragment as officeDocumentCollaborationFragment, work_document_page_margins_twipsToMillimeters, wrapsBesideImage };