@a3s-lab/office 0.9.1 → 0.10.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}`;
 }