@a3s-lab/office 0.9.2 → 0.10.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,265 @@ 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);
+}
+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);
+    if (!ranges.length) return;
+    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();
+            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
+            }));
+        }
+    }
+    if (identity) transaction.setMeta(pluginKey, {
+        formatting: true
+    });
+}
+function formattingStepRanges(transaction) {
+    if (transaction.steps.some((step)=>step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) 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 +8663,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,6 +8699,13 @@ 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
+                    } : {}
             }
         };
     },
@@ -8446,12 +8716,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 +8765,19 @@ const DocumentChange = Mark.create({
         return [
             new Plugin({
                 key: documentChangePluginKey,
+                filterTransaction: (transaction, state)=>{
+                    trackDocumentFormattingTransaction(transaction, state, changeType, {
+                        isTracking: options.isTracking,
+                        createChange: ()=>{
+                            const identity = options.createChange('formatting');
+                            return {
+                                ...identity,
+                                id: identity.id || createDocumentChangeId()
+                            };
+                        }
+                    }, documentChangePluginKey);
+                    return true;
+                },
                 props: {
                     handleTextInput: (view, from, to, text)=>{
                         if (!options.isTracking()) return false;
@@ -8537,7 +8824,7 @@ function collectDocumentChanges(document1) {
     const changes = new Map();
     document1.descendants((node, position)=>{
         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}`;
@@ -8567,14 +8854,25 @@ 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 = [];
+    if ('reject' === decision && segments.some((segment)=>'formatting' === segment.kind && !parseDocumentCharacterFormatting(segment.before))) return 0;
+    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);
+        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 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);
+    for (const segment of formattingRejections)restoreDocumentCharacterFormatting(tr, state.schema, segment.from, segment.to, segment.before);
+    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.map((segment)=>segment.id)).size : 0;
 }
 function trackedReplacement(transaction, document1, type, from, to, text, createChange) {
@@ -8622,7 +8920,8 @@ 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;
@@ -8653,14 +8952,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 +8974,12 @@ 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 work_document_changes_stringAttribute(value) {
     return 'string' == typeof value ? value : '';
@@ -11405,7 +11706,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,
@@ -16064,9 +16366,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) return value;
     if (shared) invalidSharedSidecars('tracked-change decision kind');
-    invalidInputSidecars('an insertion or deletion tracked-change kind');
+    invalidInputSidecars('an insertion, deletion, or formatting tracked-change kind');
 }
 function decisionAction(value, shared) {
     if ('accept' === value || 'reject' === value) return value;
@@ -16740,10 +17042,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 +17072,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 +17119,7 @@ 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;
 }
 const DOCUMENT_CONTENT_ROOT = 'document.content';
 const MAX_DOCUMENT_COMMENT_HISTORY = 100;
@@ -17468,4 +17771,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, 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 };

package/dist/internal/features/work/work-document-format-change-tracking.d.ts

@@ -0,0 +1,9 @@
+import type { Mark as ProseMirrorMark } from '@tiptap/pm/model';
+import type { EditorState, PluginKey, Transaction } from '@tiptap/pm/state';
+import type { WorkDocumentChangeIdentity } from './work-document-changes';
+interface DocumentFormattingChangeTrackingOptions {
+    isTracking: () => boolean;
+    createChange: () => WorkDocumentChangeIdentity;
+}
+export declare function trackDocumentFormattingTransaction(transaction: Transaction, state: EditorState, type: ProseMirrorMark['type'], options: DocumentFormattingChangeTrackingOptions, pluginKey: PluginKey): void;
+export {};

package/dist/internal/features/work/work-document-format-changes.d.ts

@@ -0,0 +1,28 @@
+import type { Mark, Schema } from '@tiptap/pm/model';
+import type { Transaction } from '@tiptap/pm/state';
+export declare const DOCUMENT_CHARACTER_FORMAT_MARKS: readonly ["bold", "italic", "underline", "strike", "subscript", "superscript", "textStyle", "highlight"];
+export type DocumentCharacterFormatMarkName = (typeof DOCUMENT_CHARACTER_FORMAT_MARKS)[number];
+export interface DocumentCharacterFormatMark {
+    type: DocumentCharacterFormatMarkName;
+    attrs?: Record<string, boolean | number | string>;
+}
+export declare function isDocumentCharacterFormatMark(value: string): boolean;
+export declare function serializeDocumentCharacterFormatting(marks: readonly Mark[]): string;
+export declare function parseDocumentCharacterFormatting(value: unknown): DocumentCharacterFormatMark[] | null;
+export declare function restoreDocumentCharacterFormatting(transaction: Transaction, schema: Schema, from: number, to: number, serialized: unknown): boolean;
+export declare function importedDocumentCharacterFormatting(formatting: {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    subscript?: boolean;
+    superscript?: boolean;
+    fontFamily?: string;
+    wordLineHeightFactor?: number;
+    wordSnapToGrid?: boolean;
+    fontSize?: number;
+    color?: string;
+    backgroundColor?: string;
+    themeColor?: string;
+    themeFill?: string;
+}): string;

package/dist/internal/features/work/work-docx-format-change-export.d.ts

@@ -0,0 +1,17 @@
+interface DocxRunFormattingChangePatch {
+    start: string;
+    end: string;
+    id: number;
+    author: string;
+    date: string;
+    before: string;
+}
+export declare class DocxRunFormattingChangePatchCollector {
+    readonly patches: DocxRunFormattingChangePatch[];
+    register(element: HTMLElement, id: number): {
+        start: string;
+        end: string;
+    } | null;
+}
+export declare function patchDocxRunFormattingChanges(buffer: ArrayBuffer, patches: readonly DocxRunFormattingChangePatch[]): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-docx-run-formatting-import.d.ts

@@ -7,6 +7,8 @@ export interface ImportedDocxRunFormatting {
     italic?: boolean;
     underline?: boolean;
     strike?: boolean;
+    subscript?: boolean;
+    superscript?: boolean;
     fontFamily?: string;
     wordLineHeightFactor?: number;
     wordSnapToGrid?: boolean;
@@ -20,6 +22,13 @@ export interface ImportedDocxRunFormattingMarker {
     startMarker: string;
     endMarker: string;
     formatting: ImportedDocxRunFormatting;
+    change?: ImportedDocxRunFormattingChange;
+}
+export interface ImportedDocxRunFormattingChange {
+    id: string;
+    author: string;
+    date: string;
+    before: string;
 }
 export interface ImportedDocxRunFormattingMarkers {
     runs: ImportedDocxRunFormattingMarker[];
@@ -27,3 +36,4 @@ export interface ImportedDocxRunFormattingMarkers {
 export declare function markDocxRunFormatting(document: Document, styleSource?: DocxParagraphStyleSource, themeSource?: DocxThemeSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxRunFormattingMarkers;
 export declare function applyImportedDocxRunFormattingMarkers(document: Document, markers: ImportedDocxRunFormattingMarkers): void;
 export declare function hasImportedDocxRunFormattingMarkers(markers: ImportedDocxRunFormattingMarkers): boolean;
+export declare function isSupportedDocxRunFormattingChange(change: Element): boolean;

package/dist/internal/features/work/work-types.d.ts

@@ -106,7 +106,7 @@ export interface WorkDocumentContent {
     comments?: WorkDocumentComment[];
     bibliography?: WorkDocumentBibliography;
 }
-export type WorkDocumentChangeKind = 'insertion' | 'deletion';
+export type WorkDocumentChangeKind = 'insertion' | 'deletion' | 'formatting';
 export type WorkDocumentChangeDecisionAction = 'accept' | 'reject';
 /**
  * Immutable audit record created when an editor accepts or rejects one

package/dist/styles.css

@@ -8543,6 +8543,10 @@ button.work-office-collaboration-participant:hover .work-office-collaboration-lo
   border-left-color: var(--a3s-red);
 }
 
+.work-document-change-item.formatting {
+  border-left-color: #6d5bd0;
+}
+
 .work-document-change-summary {
   min-width: 0;
   color: var(--a3s-ink);
@@ -8569,6 +8573,11 @@ button.work-office-collaboration-participant:hover .work-office-collaboration-lo
   background: #fff0ee;
 }
 
+.work-document-change-list .work-document-change-item.formatting .work-document-change-summary > span {
+  color: #5746b5;
+  background: #f0edff;
+}
+
 .work-document-change-summary strong {
   text-overflow: ellipsis;
   white-space: nowrap;
@@ -9066,6 +9075,13 @@ button.work-office-collaboration-participant:hover .work-office-collaboration-lo
   text-decoration-thickness: 1px;
 }
 
+.work-document-editor span[data-document-change][data-change-kind="formatting"], .work-pdf-export-page.document span[data-document-change][data-change-kind="formatting"] {
+  color: inherit;
+  background: #f0edff;
+  border-bottom: 1px dashed #6d5bd0;
+  text-decoration: none;
+}
+
 .work-document-list-tools {
   align-items: center;
   gap: 2px;
@@ -12019,6 +12035,10 @@ button.work-office-collaboration-participant:hover .work-office-collaboration-lo
   color: var(--a3s-red);
 }
 
+.work-document-change-decisions li[data-document-change-kind="formatting"] {
+  border-left: 3px solid #6d5bd0;
+}
+
 .work-document-change-decisions li > strong {
   text-overflow: ellipsis;
   white-space: nowrap;