@a3s-lab/office 0.9.2 → 0.10.0

package/COLLABORATION_ROADMAP.md

@@ -110,15 +110,17 @@ Redis/NATS fan-out plus a distributed writer/lock policy.
 
 Status: browser collaboration foundation, participant roster, remote
 selection/caret projection, participant navigation, durable review-only
-comment and suggestion modes, immutable suggestion-decision audit, and native
-text/options/bounded structural paragraph/comment/suggestion mutations
-implemented; rich native mutation parity remains pending.
+comment and suggestion modes, character-formatting revisions, immutable
+decision audit, and native text/options/bounded structural
+paragraph/comment/suggestion mutations implemented; rich native mutation
+parity remains pending.
 
 - TipTap is bound to `document.content` through
   `@tiptap/extension-collaboration`; StarterKit undo/redo is disabled and the
   collaboration binding owns local history.
-- Section/page OOXML state, comment anchors, and tracked-change marks converge
-  in the ProseMirror fragment. Document-level page color, tracking mode,
+- Section/page OOXML state, comment anchors, and text or character-formatting
+  tracked-change marks converge in the ProseMirror fragment. Document-level
+  page color, tracking mode,
   comment threads/replies, and bibliography sources use conflict-local typed
   roots instead of a serialized document blob.
 - React, Vue, and Web Component adapters accept the same initialized session.
@@ -166,6 +168,12 @@ implemented; rich native mutation parity remains pending.
   converge, a second conflicting final decision fails closed, old Documents
   without the additive roots remain readable, and a final decision clears
   local history that could otherwise resurrect the decided mark.
+- Character-formatting commands over existing text create one `formatting`
+  change mark with a bounded prior-direct-mark snapshot. Accept removes only
+  the revision wrapper and keeps the new formatting; reject restores the prior
+  bold, italic, underline, strike, sub/superscript, font, size, color,
+  highlight, and grid marks without changing text. Supported DOCX
+  `w:rPrChange` records import into the same model and export natively.
 - Rust, CLI, MCP, and A3S Code expose `document-comment-create`,
   `document-comment-reply`, `document-comment-set-resolved`,
   `document-comment-delete`, `document-suggestion-create`, and
@@ -183,6 +191,12 @@ implemented; rich native mutation parity remains pending.
   content, structure, options, non-suggestion formatting, authorship, order,
   claims, anchors, foreign deletion, or foreign suggestion changes fail before
   the durable store changes.
+- Native Yrs validation admits only the bounded formatting-change schema,
+  preserves it across restart and duplicate/reordered delivery, exposes
+  `formatting` in immutable decision projections, and makes `suggest` updates
+  retain existing formatting revisions byte-semantically. Formatting is a
+  Document change kind, not a native insertion/deletion suggestion kind; the
+  current closed `document-suggestion-*` mutations remain text-only.
 
 Remaining:
 

package/README.md

@@ -47,8 +47,10 @@ workflows, and a separate Rust automation plane.
 - **Collaborate across every editor** with shared Yjs/Yrs content, Awareness
   participants and remote locations, plus browser, CLI, MCP, and A3S Code peers.
   Document reviewers can submit attributed insertions, deletions, and
-  replacements without directly changing canonical text; editors accept or
-  reject each proposal with an immutable shared decision record.
+  replacements without directly changing canonical text. Editors can also
+  track character-formatting revisions, accept the new formatting or restore
+  the exact prior marks, and retain either result in the immutable shared
+  decision audit.
 - **Automate deterministically** through the native CLI, standard MCP server,
   or packaged Office Skill.
 
@@ -148,7 +150,8 @@ The images below are committed visual-regression baselines from the real
   Presentation scene-element and z-order, and PDF annotation, form-value, and
   review changes, including attributable Document selection comments, replies,
   text suggestions, and atomic final decisions, retain browser/native actor
-  attribution, and checkpoint without replacing a whole Office file.
+  attribution, validate browser-created formatting revisions and their audit
+  records, and checkpoint without replacing a whole Office file.
 
 ## Real-time collaboration
 
@@ -171,9 +174,13 @@ deletions, and replacements while canonical text, structure, formatting,
 options, comments, and other actors' suggestions remain protected. An `edit`
 participant accepts or rejects a proposal and appends the final actor-attributed
 decision to the immutable `document.change-decisions` audit trail. The A3S Boot
-service validates both comment and suggestion semantics under the durable room
-lock before it persists or broadcasts caller-supplied Yjs bytes. `suggest` on
-non-Document formats remains receive-only.
+service also persists `edit`-mode character-formatting revisions and validates
+their bounded prior-format snapshot before broadcast. Accept keeps the new
+bold, italic, underline, strike, vertical position, font, size, color, or
+highlight; reject restores the prior direct marks without deleting the text.
+Authenticated `suggest` updates must preserve those formatting revisions and
+cannot rewrite their identity or snapshot. `suggest` on non-Document formats
+remains receive-only.
 See the bilingual [real-time collaboration guide](https://a3s-lab.github.io/Office/docs/components/collaboration.html)
 for React, Vue, Web Component, reconnect, security, and native-agent setup.
 The repository also ships a runnable
@@ -196,6 +203,8 @@ bun run playground
 
 Then open the local URL printed by the development server. For a zero-install
 tour, use the [live Playground](https://a3s-lab.github.io/Office/).
+Choose **体验格式修订**, open **审阅**, then **查看修订（1）** to inspect the
+Formatting card and exercise accept or reject semantics.
 
 ### Embed a controlled React editor
 
@@ -1327,6 +1336,7 @@ without hard-coded return URLs.
 
 - [Live Playground](https://a3s-lab.github.io/Office/)
 - [Documentation center](https://a3s-lab.github.io/Office/docs/)
+- [A3S Office 0.10.0 documentation](https://a3s-lab.github.io/Office/docs/0.10.0/)
 - [A3S Office 0.9.2 documentation](https://a3s-lab.github.io/Office/docs/0.9.2/)
 - [A3S Office 0.9.1 documentation](https://a3s-lab.github.io/Office/docs/0.9.1/)
 - [A3S Office 0.9.0 documentation](https://a3s-lab.github.io/Office/docs/0.9.0/)

package/dist/{0~7754.js → 0~4705.js}

@@ -1,6 +1,6 @@
 import { descendants, directChildren as work_ooxml_package_directChildren, xmlNamespacePrefix, directChild, attribute as work_ooxml_package_attribute, childPath } from "./5184.js";
-import { xmlAttributeLocalName, docxThemeColor, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, xmlAttributeNamespace } from "./0~2805.js";
-import { DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, normalizeDocumentPageBorders, normalizeDocumentParagraphBorder, normalizeDocumentEquation, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, documentParagraphShadingDomAttributes, documentParagraphBordersDomAttributes, createDocumentEquationElement, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, documentEquationText, normalizeDocumentPaperSource } from "./8928.js";
+import { xmlAttributeLocalName, docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, docxThemeColor, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, xmlAttributeNamespace } from "./0~2805.js";
+import { DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, normalizeDocumentPageBorders, normalizeDocumentParagraphBorder, normalizeDocumentEquation, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, serializeDocxThemeReference, documentParagraphShadingDomAttributes, importedDocumentCharacterFormatting, documentParagraphBordersDomAttributes, createDocumentEquationElement, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, documentEquationText, normalizeDocumentPaperSource, documentWordLineHeightFactor } from "./8928.js";
 function docxFieldInstructions(root) {
     return docxFieldOccurrences(root).map((field)=>field.instruction);
 }
@@ -5650,4 +5650,501 @@ function work_docx_paragraph_shading_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphShadingMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxParagraphPropertySources, docxRunPropertySources, docxTableCellStyleLayers, docxTableParagraphPropertySources, docxTablePropertySources, docxTableRunPropertySources, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphShadingMarkers, hasInvalidDocxFieldStructure, inspectDocxEquation, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, markDocxPackageEquations, markDocxParagraphBorders, markDocxParagraphShading, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxParagraphBordersForParagraph, resolveDocxParagraphStyleResolver, resolveDocxTableStyleResolver };
+const work_docx_run_formatting_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_run_formatting_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+const RUN_FORMATTING_MARKER_PATTERN = /__A3S_WORK_RUN_(?:START|END)_\d+__/g;
+const SUPPORTED_RUN_PROPERTY_CHANGE_CHILDREN = new Set([
+    'b',
+    'bCs',
+    'i',
+    'iCs',
+    'u',
+    'strike',
+    'dstrike',
+    'rFonts',
+    'sz',
+    'szCs',
+    'color',
+    'highlight',
+    'shd',
+    'snapToGrid',
+    'cs',
+    'rtl',
+    'vertAlign'
+]);
+function markDocxRunFormatting(document, styleSource, themeSource, tableStyleSource) {
+    const runs = [];
+    const styles = resolveDocxParagraphStyleResolver(styleSource);
+    const theme = work_docx_theme_resolveDocxThemeResolver(themeSource);
+    const tableStyles = resolveDocxTableStyleResolver(tableStyleSource);
+    for (const run of descendants(document, 'r')){
+        const runText = directRunText(run);
+        if (!runText || runText.includes('__A3S_')) continue;
+        const paragraph = work_docx_run_formatting_import_closestAncestor(run, 'p');
+        if (!paragraph) continue;
+        const paragraphProperties = directChild(paragraph, 'pPr');
+        const runProperties = directChild(run, 'rPr');
+        const formatting = resolvedRunFormatting(docxRunPropertySources(paragraphProperties, runProperties, styles, docxTableRunPropertySources(run, tableStyles)), theme, runText);
+        const change = importedRunFormattingChange(runProperties, paragraphProperties, styles, docxTableRunPropertySources(run, tableStyles), theme, runText);
+        if (!Object.keys(formatting).length && !change) continue;
+        const index = runs.length + 1;
+        const startMarker = `__A3S_WORK_RUN_START_${index}__`;
+        const endMarker = `__A3S_WORK_RUN_END_${index}__`;
+        insertRunMarkers(document, run, runProperties, startMarker, endMarker);
+        runs.push({
+            startMarker,
+            endMarker,
+            formatting,
+            ...change ? {
+                change
+            } : {}
+        });
+    }
+    return {
+        runs
+    };
+}
+function applyImportedDocxRunFormattingMarkers(document, markers) {
+    const replacements = new Map();
+    for (const marker of markers.runs){
+        const markup = formattingMarkup(document, marker.formatting);
+        const change = marker.change ? formattingChangeMarkup(document, marker.change) : {
+            start: '',
+            end: ''
+        };
+        replacements.set(marker.startMarker, `${change.start}${markup.start}`);
+        replacements.set(marker.endMarker, `${markup.end}${change.end}`);
+    }
+    document.body.innerHTML = document.body.innerHTML.replace(RUN_FORMATTING_MARKER_PATTERN, (marker)=>replacements.get(marker) ?? '');
+}
+function hasImportedDocxRunFormattingMarkers(markers) {
+    return markers.runs.length > 0;
+}
+function resolvedRunFormatting(propertySources, theme, runText) {
+    const fonts = {};
+    let fontSize;
+    let complexFontSize;
+    let color;
+    let backgroundColor;
+    let themeColor;
+    let themeFill;
+    let bold;
+    let complexBold;
+    let italic;
+    let complexItalic;
+    let underline;
+    let strike;
+    let subscript;
+    let superscript;
+    let snapToGrid;
+    let complexScriptFormatting;
+    let rightToLeft;
+    let fontHint;
+    for (const properties of propertySources){
+        bold = overriddenBoolean(bold, onOffProperty(properties, 'b'));
+        complexBold = overriddenBoolean(complexBold, onOffProperty(properties, 'bCs'));
+        italic = overriddenBoolean(italic, onOffProperty(properties, 'i'));
+        complexItalic = overriddenBoolean(complexItalic, onOffProperty(properties, 'iCs'));
+        underline = overriddenBoolean(underline, underlineProperty(properties));
+        strike = overriddenBoolean(strike, onOffProperty(properties, 'strike'));
+        strike = overriddenBoolean(strike, onOffProperty(properties, 'dstrike'));
+        const verticalAlign = directChild(properties, 'vertAlign');
+        if (verticalAlign) {
+            const value = work_docx_run_formatting_import_wordAttribute(verticalAlign, 'val')?.trim().toLowerCase();
+            subscript = "subscript" === value;
+            superscript = "superscript" === value;
+            if ('baseline' === value) {
+                subscript = false;
+                superscript = false;
+            }
+        }
+        snapToGrid = overriddenBoolean(snapToGrid, onOffProperty(properties, 'snapToGrid'));
+        complexScriptFormatting = overriddenBoolean(complexScriptFormatting, onOffProperty(properties, 'cs'));
+        rightToLeft = overriddenBoolean(rightToLeft, onOffProperty(properties, 'rtl'));
+        const runFonts = directChild(properties, 'rFonts');
+        if (runFonts) {
+            fontHint = resolvedFontHint(runFonts) ?? fontHint;
+            assignFont(fonts, 'ascii', resolvedFont(runFonts, 'ascii', 'asciiTheme', theme));
+            assignFont(fonts, 'hAnsi', resolvedFont(runFonts, 'hAnsi', 'hAnsiTheme', theme));
+            assignFont(fonts, 'eastAsia', resolvedFont(runFonts, 'eastAsia', 'eastAsiaTheme', theme));
+            assignFont(fonts, 'complex', resolvedFont(runFonts, 'cs', 'cstheme', theme));
+        }
+        const size = numericAttribute(directChild(properties, 'sz'), 'val');
+        if (void 0 !== size && size > 0) fontSize = Math.min(512, size / 2);
+        const complexSize = numericAttribute(directChild(properties, 'szCs'), 'val');
+        if (void 0 !== complexSize && complexSize > 0) complexFontSize = Math.min(512, complexSize / 2);
+        const colorElement = directChild(properties, 'color');
+        if (colorElement) {
+            const value = work_docx_run_formatting_import_wordAttribute(colorElement, 'val')?.trim();
+            const themed = docxThemeColor(theme, work_docx_run_formatting_import_wordAttribute(colorElement, 'themeColor'), work_docx_run_formatting_import_wordAttribute(colorElement, 'themeTint'), work_docx_run_formatting_import_wordAttribute(colorElement, 'themeShade'));
+            if (themed) {
+                color = `#${themed}`;
+                themeColor = work_docx_run_formatting_import_themeReference(colorElement, 'themeColor', 'themeTint', 'themeShade', color);
+            } else if (value?.toLowerCase() === 'auto') {
+                color = 'inherit';
+                themeColor = void 0;
+            } else if (value && /^[0-9a-f]{6}$/i.test(value)) {
+                color = `#${value.toLowerCase()}`;
+                themeColor = void 0;
+            }
+        }
+        const highlight = directChild(properties, 'highlight');
+        if (highlight) {
+            const value = work_docx_run_formatting_import_wordAttribute(highlight, 'val')?.trim().toLowerCase();
+            if (value) {
+                backgroundColor = wordHighlightColor(value);
+                themeFill = void 0;
+            }
+        } else {
+            const shading = directChild(properties, 'shd');
+            const fill = shading ? work_docx_run_formatting_import_wordAttribute(shading, 'fill')?.trim() : void 0;
+            const themed = shading ? docxThemeColor(theme, work_docx_run_formatting_import_wordAttribute(shading, 'themeFill'), work_docx_run_formatting_import_wordAttribute(shading, 'themeFillTint'), work_docx_run_formatting_import_wordAttribute(shading, 'themeFillShade')) : void 0;
+            if (themed) {
+                backgroundColor = `#${themed}`;
+                themeFill = work_docx_run_formatting_import_themeReference(shading, 'themeFill', 'themeFillTint', 'themeFillShade', backgroundColor);
+            } else if (fill?.toLowerCase() === 'auto') {
+                backgroundColor = 'transparent';
+                themeFill = void 0;
+            } else if (fill && /^[0-9a-f]{6}$/i.test(fill)) {
+                backgroundColor = `#${fill.toLowerCase()}`;
+                themeFill = void 0;
+            }
+        }
+    }
+    const fontSlot = true === complexScriptFormatting || true === rightToLeft ? 'complex' : docxFontSlotForText(runText, fontHint);
+    const usesComplexFormatting = 'complex' === fontSlot;
+    const resolvedBold = usesComplexFormatting ? complexBold ?? bold : bold;
+    const resolvedItalic = usesComplexFormatting ? complexItalic ?? italic : italic;
+    const resolvedFontSize = usesComplexFormatting ? complexFontSize ?? fontSize : fontSize;
+    let fontFamily = uniqueFonts(orderedFonts(fonts, fontSlot));
+    if (!fontFamily) fontFamily = uniqueFonts(orderedFonts({
+        ascii: docxThemeFont(theme, 'minorAscii'),
+        hAnsi: docxThemeFont(theme, 'minorHAnsi'),
+        eastAsia: docxThemeFont(theme, 'minorEastAsia'),
+        complex: docxThemeFont(theme, 'minorBidi')
+    }, fontSlot));
+    const hasRunPropertySource = propertySources.length > 0;
+    return {
+        ...void 0 !== resolvedBold || hasRunPropertySource ? {
+            bold: resolvedBold ?? false
+        } : {},
+        ...void 0 !== resolvedItalic || hasRunPropertySource ? {
+            italic: resolvedItalic ?? false
+        } : {},
+        ...void 0 !== underline || hasRunPropertySource ? {
+            underline: underline ?? false
+        } : {},
+        ...void 0 !== strike || hasRunPropertySource ? {
+            strike: strike ?? false
+        } : {},
+        ...void 0 !== subscript ? {
+            subscript
+        } : {},
+        ...void 0 !== superscript ? {
+            superscript
+        } : {},
+        ...fontFamily ? {
+            fontFamily,
+            wordLineHeightFactor: documentWordLineHeightFactor(fontFamily)
+        } : {},
+        ...void 0 !== resolvedFontSize ? {
+            fontSize: resolvedFontSize
+        } : {},
+        ...void 0 !== snapToGrid ? {
+            wordSnapToGrid: snapToGrid
+        } : {},
+        ...color ? {
+            color
+        } : {},
+        ...backgroundColor ? {
+            backgroundColor
+        } : {},
+        ...themeColor ? {
+            themeColor
+        } : {},
+        ...themeFill ? {
+            themeFill
+        } : {}
+    };
+}
+function insertRunMarkers(document, run, properties, startMarker, endMarker) {
+    const start = markerText(document, startMarker);
+    const end = markerText(document, endMarker);
+    run.insertBefore(start, properties?.nextSibling ?? run.firstChild);
+    run.append(end);
+}
+function markerText(document, marker) {
+    const text = document.createElementNS(work_docx_run_formatting_import_WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_run_formatting_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = marker;
+    return text;
+}
+function formattingMarkup(document, formatting) {
+    const span = document.createElement('span');
+    if (false === formatting.bold) span.style.fontWeight = 'normal';
+    if (false === formatting.italic) span.style.fontStyle = 'normal';
+    if ((false === formatting.underline || false === formatting.strike) && !formatting.underline && !formatting.strike) span.style.textDecorationLine = 'none';
+    if (formatting.fontFamily) span.style.fontFamily = formatting.fontFamily;
+    if (void 0 !== formatting.wordLineHeightFactor) {
+        const factor = formatLineHeightFactor(formatting.wordLineHeightFactor);
+        span.dataset.officeWordLineHeightFactor = factor;
+        span.style.setProperty('--work-document-word-line-height-factor', factor);
+    }
+    if (void 0 !== formatting.wordSnapToGrid) span.dataset.officeWordSnapToGrid = String(formatting.wordSnapToGrid);
+    if (void 0 !== formatting.fontSize) span.style.fontSize = `${formatNumber(formatting.fontSize)}pt`;
+    if (formatting.color) span.style.color = formatting.color;
+    const themeColor = serializeDocxThemeReference(formatting.themeColor ?? null);
+    if (themeColor) span.dataset.officeThemeColor = themeColor;
+    if (formatting.backgroundColor) span.style.backgroundColor = formatting.backgroundColor;
+    const themeFill = serializeDocxThemeReference(formatting.themeFill ?? null);
+    if (themeFill) span.dataset.officeThemeFill = themeFill;
+    const html = span.outerHTML;
+    const tags = [
+        ...formatting.bold ? [
+            'strong'
+        ] : [],
+        ...formatting.italic ? [
+            'em'
+        ] : [],
+        ...formatting.underline ? [
+            'u'
+        ] : [],
+        ...formatting.strike ? [
+            's'
+        ] : [],
+        ...formatting.subscript ? [
+            'sub'
+        ] : [],
+        ...formatting.superscript ? [
+            'sup'
+        ] : []
+    ];
+    return {
+        start: `${html.slice(0, html.indexOf('>') + 1)}${tags.map((tag)=>`<${tag}>`).join('')}`,
+        end: `${[
+            ...tags
+        ].reverse().map((tag)=>`</${tag}>`).join('')}</span>`
+    };
+}
+function importedRunFormattingChange(runProperties, paragraphProperties, styles, contextualProperties, theme, runText) {
+    const parsed = supportedRunFormattingChange(runProperties);
+    if (!parsed) return;
+    const beforeFormatting = resolvedRunFormatting(docxRunPropertySources(paragraphProperties, parsed.properties, styles, contextualProperties), theme, runText);
+    return {
+        id: `docx-format-change-${parsed.id}`,
+        author: parsed.author,
+        date: normalizeRevisionDate(parsed.date),
+        before: importedDocumentCharacterFormatting({
+            ...beforeFormatting,
+            themeColor: serializeDocxThemeReference(beforeFormatting.themeColor ?? null),
+            themeFill: serializeDocxThemeReference(beforeFormatting.themeFill ?? null)
+        })
+    };
+}
+function isSupportedDocxRunFormattingChange(change) {
+    return Boolean(supportedRunFormattingChangeElement(change));
+}
+function supportedRunFormattingChange(runProperties) {
+    if (!runProperties) return null;
+    const changes = Array.from(runProperties.children).filter((child)=>'rPrChange' === child.localName);
+    return 1 === changes.length ? supportedRunFormattingChangeElement(changes[0]) : null;
+}
+function supportedRunFormattingChangeElement(change) {
+    if ('rPrChange' !== change.localName || !DOCX_WORDPROCESSING_NAMESPACES.has(change.namespaceURI ?? '')) return null;
+    const properties = Array.from(change.children).filter((child)=>'rPr' === child.localName && DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? ''));
+    if (1 !== properties.length || 1 !== change.children.length) return null;
+    const source = properties[0];
+    const names = new Set();
+    for (const child of Array.from(source.children)){
+        if (!DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? '') || !SUPPORTED_RUN_PROPERTY_CHANGE_CHILDREN.has(child.localName) || names.has(child.localName)) return null;
+        names.add(child.localName);
+    }
+    const id = work_ooxml_package_attribute(change, 'id')?.trim() ?? '';
+    const author = work_ooxml_package_attribute(change, 'author')?.trim() ?? '';
+    const date = work_ooxml_package_attribute(change, 'date');
+    if (!/^\+?\d{1,10}$/.test(id) || !author || author.length > 255) return null;
+    if (date && !Number.isFinite(Date.parse(date))) return null;
+    return {
+        id,
+        author,
+        date,
+        properties: source
+    };
+}
+function formattingChangeMarkup(document, change) {
+    const span = document.createElement('span');
+    span.dataset.documentChange = 'true';
+    span.dataset.changeKind = 'formatting';
+    span.dataset.changeId = change.id;
+    span.dataset.changeAuthor = change.author;
+    span.dataset.changeDate = change.date;
+    span.dataset.changeBefore = change.before;
+    const html = span.outerHTML;
+    return {
+        start: html.slice(0, html.indexOf('>') + 1),
+        end: '</span>'
+    };
+}
+function normalizeRevisionDate(value) {
+    if (!value) return '';
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : '';
+}
+function work_docx_run_formatting_import_themeReference(element, themeName, tintName, shadeName, resolved) {
+    const theme = work_docx_run_formatting_import_wordAttribute(element, themeName)?.trim();
+    if (!theme) return;
+    const tint = normalizedByteHex(work_docx_run_formatting_import_wordAttribute(element, tintName));
+    const shade = normalizedByteHex(work_docx_run_formatting_import_wordAttribute(element, shadeName));
+    return {
+        theme,
+        resolved,
+        ...tint ? {
+            tint
+        } : {},
+        ...shade ? {
+            shade
+        } : {}
+    };
+}
+function normalizedByteHex(value) {
+    const normalized = value?.trim().toUpperCase();
+    return normalized && /^[0-9A-F]{2}$/.test(normalized) ? normalized : void 0;
+}
+function overriddenBoolean(current, next) {
+    return void 0 === next ? current : next;
+}
+function onOffProperty(properties, propertyName) {
+    const element = directChild(properties, propertyName);
+    if (!element) return;
+    const value = work_docx_run_formatting_import_wordAttribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value;
+}
+function underlineProperty(properties) {
+    const element = directChild(properties, 'u');
+    if (!element) return;
+    const value = work_docx_run_formatting_import_wordAttribute(element, 'val')?.trim().toLowerCase();
+    return '0' !== value && 'false' !== value && 'off' !== value && 'none' !== value;
+}
+function directRunText(run) {
+    return Array.from(run.children).filter((child)=>'t' === child.localName || 'delText' === child.localName).map((child)=>child.textContent ?? '').join('');
+}
+function work_docx_run_formatting_import_closestAncestor(element, localName) {
+    let current = element.parentElement;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function assignFont(fonts, key, value) {
+    const normalized = value?.trim();
+    if (normalized) fonts[key] = normalized;
+}
+function resolvedFontHint(element) {
+    const hint = work_docx_run_formatting_import_wordAttribute(element, 'hint')?.trim().toLowerCase();
+    if ('eastasia' === hint) return 'eastAsia';
+    if ('cs' === hint) return 'complex';
+    if ('default' === hint) return 'ascii';
+}
+function orderedFonts(fonts, preferred) {
+    const order = {
+        ascii: [
+            'ascii',
+            'hAnsi',
+            'eastAsia',
+            'complex'
+        ],
+        hAnsi: [
+            'hAnsi',
+            'ascii',
+            'eastAsia',
+            'complex'
+        ],
+        eastAsia: [
+            'eastAsia',
+            'hAnsi',
+            'ascii',
+            'complex'
+        ],
+        complex: [
+            'complex',
+            'hAnsi',
+            'ascii',
+            'eastAsia'
+        ]
+    };
+    return order[preferred].map((slot)=>fonts[slot]);
+}
+function docxFontSlotForText(text, hint) {
+    for (const character of text){
+        const codePoint = character.codePointAt(0);
+        if (!(void 0 === codePoint || isNeutralCodePoint(codePoint))) {
+            if (isComplexScriptCodePoint(codePoint)) return 'complex';
+            if (isEastAsianCodePoint(codePoint)) return 'eastAsia';
+            return codePoint <= 0x7f ? 'ascii' : 'hAnsi';
+        }
+    }
+    return hint ?? 'ascii';
+}
+function isNeutralCodePoint(codePoint) {
+    return codePoint <= 0x20 || codePoint <= 0x7f && !(codePoint >= 0x41 && codePoint <= 0x5a || codePoint >= 0x61 && codePoint <= 0x7a) || codePoint >= 0x300 && codePoint <= 0x36f || codePoint >= 0x2000 && codePoint <= 0x206f;
+}
+function isComplexScriptCodePoint(codePoint) {
+    return codePoint >= 0x0590 && codePoint <= 0x08ff || codePoint >= 0xfb1d && codePoint <= 0xfdff || codePoint >= 0xfe70 && codePoint <= 0xfeff || codePoint >= 0x1ee00 && codePoint <= 0x1eeff;
+}
+function isEastAsianCodePoint(codePoint) {
+    return codePoint >= 0x1100 && codePoint <= 0x11ff || codePoint >= 0x2e80 && codePoint <= 0xa4cf || codePoint >= 0xac00 && codePoint <= 0xd7af || codePoint >= 0xf900 && codePoint <= 0xfaff || codePoint >= 0xfe10 && codePoint <= 0xfe6f || codePoint >= 0xff00 && codePoint <= 0xffef || codePoint >= 0x20000 && codePoint <= 0x323af;
+}
+function resolvedFont(element, explicitName, themeName, theme) {
+    const explicit = work_docx_run_formatting_import_wordAttribute(element, explicitName);
+    if (explicit?.trim()) return explicit;
+    return docxThemeFont(theme, work_docx_run_formatting_import_wordAttribute(element, themeName)) ?? null;
+}
+function uniqueFonts(values) {
+    const fonts = [
+        ...new Set(values.filter((value)=>!!value))
+    ];
+    return fonts.length ? fonts.map(cssFontFamily).join(', ') : void 0;
+}
+function cssFontFamily(value) {
+    return /[\s"',]/.test(value) ? `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"` : value;
+}
+function numericAttribute(element, name) {
+    if (!element) return;
+    const raw = work_docx_run_formatting_import_wordAttribute(element, name);
+    if (null === raw || !raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function work_docx_run_formatting_import_wordAttribute(element, name) {
+    return work_ooxml_package_attribute(element, name) ?? work_ooxml_package_attribute(element, `w:${name}`);
+}
+function wordHighlightColor(value) {
+    const colors = {
+        black: '#000000',
+        blue: '#0000ff',
+        cyan: '#00ffff',
+        darkblue: '#000080',
+        darkcyan: '#008080',
+        darkgray: '#808080',
+        darkgreen: '#008000',
+        darkmagenta: '#800080',
+        darkred: '#800000',
+        darkyellow: '#808000',
+        green: '#00ff00',
+        lightgray: '#c0c0c0',
+        magenta: '#ff00ff',
+        none: 'transparent',
+        red: '#ff0000',
+        white: '#ffffff',
+        yellow: '#ffff00'
+    };
+    return colors[value] ?? 'transparent';
+}
+function formatNumber(value) {
+    return Number(value.toFixed(2)).toString();
+}
+function formatLineHeightFactor(value) {
+    return Number(value.toFixed(4)).toString();
+}
+export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxRunFormattingMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxParagraphPropertySources, docxTableCellStyleLayers, docxTableParagraphPropertySources, docxTablePropertySources, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxRunFormattingMarkers, hasInvalidDocxFieldStructure, inspectDocxEquation, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxRunFormattingChange, markDocxPackageEquations, markDocxParagraphBorders, markDocxParagraphShading, markDocxRunFormatting, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxParagraphBordersForParagraph, resolveDocxParagraphStyleResolver, resolveDocxTableStyleResolver };

package/dist/0~document-editor.js

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