@a3s-lab/office 0.25.0 → 0.27.0

package/dist/0~work-docx-export.js

@@ -1,8 +1,8 @@
 import jszip from "jszip";
-import { normalizeDocumentBookmarkName, applyDocumentImageIdentityToElement, DOCUMENT_PAGE_BORDER_EDGES, createDocumentImageIdentityRegistry, normalizeDocumentColumns, normalizeDocumentTableVerticalAlign, uniqueDocumentParagraphIdentity, documentTableColumnPercentagesFromElement, documentTableCellMarginOverridesFromElement, applyDocumentTableRowIdentityToElement, normalizeDocumentBookmarksHtml, documentImageIdentityFromElement, documentTableGeometryFromElement, normalizeDocumentTableRowHeightRule, documentNoteKey, normalizeDocumentParagraphBorders, normalizeDocumentTableBorderWidth, normalizeDocumentParagraphId, normalizeDocumentTableBorderStyle, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, parseDocumentParagraphBordersElement, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentPageChrome, documentPageMarginsForLayout, normalizeDocumentImageLayer, documentBookmarkReferenceInstruction, documentImageCropFromElement, normalizeDocumentPageBorders, documentImageLayerFromElement, parseDocxThemeReference, documentCaptionLabel, documentCaptionKind, applyDocumentParagraphIdentityToElement, isContourImageLayout, normalizeDocumentImageIdentity, normalizeTableColor, documentTableBordersFromElement, documentSections, createDocumentParagraphIdentityRegistry, documentCitationTags, docxDocumentFieldKind, wrapsBesideImage, DocxThemePatchCollector, defaultDocumentImageWrapContour, normalizeDocumentParagraphIdentity, normalizeDocumentPaperSource, documentEquationFromElement, DOCUMENT_PARAGRAPH_BORDER_EDGES, parseDocumentCharacterFormatting, patchDocxThemeReferences, parseDocumentParagraphShadingElement, documentParagraphIdentityFromElement, normalizeDocumentEquation, parseDocumentParagraphFormatting, documentTableRowIdentityFromElement, normalizeDocumentBookmarkNativeId, collectDocumentNotes, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentImageLayoutFromElement, documentPageHorizontalMarginTwips, documentPageGeometryForLayout, normalizeDocumentPageMargins, documentNoteKind } from "./6282.js";
+import { normalizeDocumentBookmarkName, normalizeDocumentEmphasisMark, DOCUMENT_STRIKE_STYLE_ATTRIBUTE, applyDocumentImageIdentityToElement, documentEmphasisMarkFromElement, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE, documentScriptFontSlotFromElement, normalizeDocumentColumns, createDocumentImageIdentityRegistry, serializeDocumentScriptFonts, documentCharacterSpacingTwipsFromElement, uniqueDocumentParagraphIdentity, documentCharacterPositionHalfPointsFromElement, normalizeDocumentTableVerticalAlign, documentTableColumnPercentagesFromElement, normalizeDocumentTextCase, documentTableCellMarginOverridesFromElement, applyDocumentTableRowIdentityToElement, normalizeDocumentBookmarksHtml, documentImageIdentityFromElement, documentTableGeometryFromElement, normalizeDocumentTableRowHeightRule, normalizeDocumentScriptFonts, documentNoteKey, normalizeDocumentHiddenText, normalizeDocumentParagraphBorders, normalizeDocumentTableBorderWidth, normalizeDocumentCharacterSpacingTwips, normalizeDocumentParagraphId, documentStrikeFormattingFromElement, normalizeDocumentTableBorderStyle, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, parseDocumentParagraphBordersElement, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentCharacterScalePercent, documentScriptFontsFromElement, normalizeDocumentUnderlineStyle, documentPageMarginsForLayout, normalizeDocumentPageChrome, normalizeDocumentImageLayer, documentFontNameFromCssFamily, documentKerningThresholdHalfPointsFromElement, documentImageCropFromElement, documentBookmarkReferenceInstruction, normalizeDocumentPageBorders, documentImageLayerFromElement, parseDocumentScriptFonts, documentCaptionLabel, documentCaptionKind, applyDocumentParagraphIdentityToElement, isContourImageLayout, parseDocxThemeReference, normalizeDocumentImageIdentity, normalizeDocumentStrikeStyle, normalizeTableColor, createDocumentParagraphIdentityRegistry, documentCitationTags, docxDocumentFieldKind, documentTableBordersFromElement, documentSections, wrapsBesideImage, normalizeDocumentCharacterPositionHalfPoints, normalizeDocumentKerningThresholdHalfPoints, DocxThemePatchCollector, defaultDocumentImageWrapContour, normalizeDocumentParagraphIdentity, normalizeDocumentPaperSource, documentEquationFromElement, DOCUMENT_PARAGRAPH_BORDER_EDGES, parseDocumentCharacterFormatting, documentScriptFontFamily, documentUnderlineFormattingFromElement, documentParagraphIdentityFromElement, normalizeDocumentEquation, patchDocxThemeReferences, parseDocumentParagraphShadingElement, normalizeDocumentBookmarkNativeId, parseDocumentParagraphFormatting, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentHiddenTextFromElement, documentTableRowIdentityFromElement, documentImageLayoutFromElement, documentScriptFontSlotFromHint, collectDocumentNotes, documentPageHorizontalMarginTwips, documentPageGeometryForLayout, normalizeDocumentScriptFontSlot, normalizeDocumentPageMargins, documentCharacterScalePercentFromElement, documentNoteKind } from "./6282.js";
 import { serializeUtf8Xml, directChildren, xmlNamespacePrefix, parseXml, decodeXmlBytes, descendants, resolvePartTarget, directChild, attribute as work_ooxml_package_attribute } from "./5184.js";
 import { assignDocxNoteIds, patchDocxPageColor, normalizeDocxCommentId, assignDocxCommentThreads } from "./0~4980.js";
-import { paragraphTabStops, mergeDocxIgnorableExtensionsAtPairs, patchDocxBibliography, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, paragraphAlignment, paragraphSpacingOptions, xmlNamespaceUri, hasNonWhitespaceXmlText, cloneXmlElement, cssColorToHex, DocxParagraphDefaultCollapsedPatchCollector, assertXmlRoot, xmlDeclaredPrefix, paragraphIndent, domDirection, DOCX_WORDPROCESSING_NAMESPACES, paragraphBidirectional, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, patchDocxParagraphDefaultCollapsed, xmlAttributeNamespace, dataBoolean, mergeDocxIgnorableExtensions, parseDocxColorSchemeMappingElement, paragraphPaginationOptions, DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, xmlAttributeLocalName, cssFontSize, paragraphDirectionOptions, cssFontFamily } from "./0~2805.js";
+import { paragraphTabStops, mergeDocxIgnorableExtensionsAtPairs, patchDocxBibliography, docxKerningThresholdValue, docxCharacterPositionValue, docxCharacterScaleValue, docxEmphasisMarkRunOptions, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, paragraphAlignment, paragraphSpacingOptions, xmlNamespaceUri, hasNonWhitespaceXmlText, patchDocxExplicitZeroCharacterSpacing, cloneXmlElement, cssColorToHex, DocxParagraphDefaultCollapsedPatchCollector, assertXmlRoot, xmlDeclaredPrefix, paragraphIndent, domDirection, DOCX_WORDPROCESSING_NAMESPACES, paragraphBidirectional, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, patchDocxParagraphDefaultCollapsed, xmlAttributeNamespace, dataBoolean, mergeDocxIgnorableExtensions, patchDocxExplicitZeroKerningThresholds, parseDocxColorSchemeMappingElement, paragraphPaginationOptions, DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, xmlAttributeLocalName, cssFontSize, paragraphDirectionOptions, cssFontFamily, docxCharacterSpacingValue } from "./0~7043.js";
 import { normalizeDocumentHref } from "./0~work-document-links.js";
 const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 class DocxBookmarkPatchCollector {
@@ -757,6 +757,160 @@ function hasAncestor(element, localName) {
     }
     return false;
 }
+const HIDDEN_TEXT_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes|comments)\.xml$/i;
+const WORD_RUN_PROPERTY_ORDER = [
+    'rStyle',
+    'rFonts',
+    'b',
+    'bCs',
+    'i',
+    'iCs',
+    'caps',
+    'smallCaps',
+    'strike',
+    'dstrike',
+    'outline',
+    'shadow',
+    'emboss',
+    'imprint',
+    'noProof',
+    'snapToGrid',
+    'vanish',
+    'webHidden',
+    'color',
+    'spacing',
+    'w',
+    'kern',
+    'position',
+    'sz',
+    'szCs',
+    'highlight',
+    'u',
+    'effect',
+    'bdr',
+    'shd',
+    'fitText',
+    'vertAlign',
+    'rtl',
+    'cs',
+    'em',
+    'lang',
+    'eastAsianLayout',
+    'specVanish',
+    'rPrChange'
+];
+const WORD_RUN_PROPERTY_RANK = new Map(WORD_RUN_PROPERTY_ORDER.map((name, index)=>[
+        name,
+        index
+    ]));
+const VANISH_RANK = WORD_RUN_PROPERTY_RANK.get('vanish') ?? 0;
+class DocxHiddenTextPatchCollector {
+    patches = [];
+    nextMarker = 1;
+    occupied;
+    patchesByMarker = new Map();
+    markersByValueAndStyle = new Map();
+    constructor(source){
+        this.occupied = source;
+    }
+    marker(value, inheritedStyle) {
+        const style = this.originalStyle(inheritedStyle);
+        const key = JSON.stringify([
+            value,
+            style ?? null
+        ]);
+        const existing = this.markersByValueAndStyle.get(key);
+        if (existing) return existing;
+        let marker = '';
+        do {
+            marker = `A3SOfficeHiddenText${value ? 'On' : 'Off'}${String(this.nextMarker).padStart(8, '0')}`;
+            this.nextMarker += 1;
+        }while (this.occupied.includes(marker) || this.patches.some((patch)=>patch.marker === marker))
+        const patch = {
+            marker,
+            value,
+            ...style ? {
+                style
+            } : {}
+        };
+        this.patches.push(patch);
+        this.patchesByMarker.set(marker, patch);
+        this.markersByValueAndStyle.set(key, marker);
+        return marker;
+    }
+    originalStyle(style) {
+        let current = style;
+        const seen = new Set();
+        while(current && !seen.has(current)){
+            seen.add(current);
+            const patch = this.patchesByMarker.get(current);
+            if (!patch) break;
+            current = patch.style;
+        }
+        return current;
+    }
+}
+async function patchDocxHiddenText(buffer, patches) {
+    if (!patches.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const byMarker = new Map(patches.map((patch)=>[
+            patch.marker,
+            patch
+        ]));
+    const applied = new Set();
+    for (const entry of Object.values(archive.files)){
+        if (entry.dir || !HIDDEN_TEXT_PART_PATTERN.test(entry.name)) continue;
+        const document = parseXml(decodeXmlBytes(await entry.async('uint8array'), `generated DOCX ${entry.name}`), `generated DOCX ${entry.name}`);
+        let changed = false;
+        for (const properties of descendants(document, 'rPr')){
+            if (!DOCX_WORDPROCESSING_NAMESPACES.has(properties.namespaceURI ?? '')) continue;
+            const markerStyles = directChildren(properties, 'rStyle').filter((style)=>{
+                if (!DOCX_WORDPROCESSING_NAMESPACES.has(style.namespaceURI ?? '')) return false;
+                const marker = wordValue(style);
+                return null !== marker && byMarker.has(marker);
+            });
+            if (!markerStyles.length) continue;
+            if (1 !== markerStyles.length) throw new Error('Generated DOCX hidden-text marker is duplicated in one run.');
+            const marker = wordValue(markerStyles[0]);
+            const patch = marker ? byMarker.get(marker) : void 0;
+            if (!marker || !patch) continue;
+            const existing = directChildren(properties, 'vanish').filter((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? ''));
+            if (existing.length) throw new Error('Generated DOCX hidden-text marker unexpectedly has a native value.');
+            if (patch.style) setWordValue(markerStyles[0], patch.style);
+            else markerStyles[0].remove();
+            insertHiddenTextProperty(document, properties, patch.value);
+            applied.add(marker);
+            changed = true;
+        }
+        if (changed) archive.file(entry.name, serializeUtf8Xml(document));
+    }
+    const missing = patches.filter((patch)=>!applied.has(patch.marker));
+    if (missing.length) throw new Error(`DOCX hidden-text markers were not emitted: ${missing.map((patch)=>patch.marker).join(', ')}.`);
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function insertHiddenTextProperty(document, properties, value) {
+    const namespace = properties.namespaceURI ?? '';
+    const prefix = properties.prefix || 'w';
+    const vanish = document.createElementNS(namespace, `${prefix}:vanish`);
+    if (!value) vanish.setAttributeNS(namespace, `${prefix}:val`, '0');
+    const next = directChildren(properties).find((child)=>{
+        if (!DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? '')) return true;
+        return (WORD_RUN_PROPERTY_RANK.get(child.localName) ?? 1 / 0) > VANISH_RANK;
+    });
+    properties.insertBefore(vanish, next ?? null);
+}
+function wordValue(element) {
+    const values = Array.from(element.attributes).filter((attribute)=>'val' === xmlAttributeLocalName(attribute) && DOCX_WORDPROCESSING_NAMESPACES.has(xmlAttributeNamespace(element, attribute) ?? ''));
+    return 1 === values.length ? values[0].value : null;
+}
+function setWordValue(element, value) {
+    const namespace = element.namespaceURI ?? '';
+    const prefix = element.prefix || 'w';
+    for (const attribute of Array.from(element.attributes))if ('val' === xmlAttributeLocalName(attribute) && DOCX_WORDPROCESSING_NAMESPACES.has(xmlAttributeNamespace(element, attribute) ?? '')) element.removeAttributeNode(attribute);
+    element.setAttributeNS(namespace, `${prefix}:val`, value);
+}
 const MATH_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/math';
 const work_docx_equation_export_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const WORD_DATE_UTC_NAMESPACE = 'http://schemas.microsoft.com/office/word/2023/wordml/word16du';
@@ -2221,15 +2375,97 @@ function appendFormattingProperties(document, properties, namespace, prefix, ser
     appendBooleanProperty(document, properties, namespace, prefix, byType, 'bold', 'bCs');
     appendBooleanProperty(document, properties, namespace, prefix, byType, 'italic', 'i');
     appendBooleanProperty(document, properties, namespace, prefix, byType, 'italic', 'iCs');
-    if (byType.has('underline')) appendValuedProperty(document, properties, namespace, prefix, 'u', 'single');
-    appendBooleanProperty(document, properties, namespace, prefix, byType, 'strike', 'strike');
+    appendUnderlineProperty(document, properties, namespace, prefix, byType.get('underline'));
+    appendStrikeProperties(document, properties, namespace, prefix, byType.get('strike'));
+    appendTextCaseProperties(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendHiddenTextProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendColorProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendCharacterSpacingProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendCharacterScaleProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendKerningThresholdProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendCharacterPositionProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendFontSizeProperties(document, properties, namespace, prefix, byType.get('textStyle'));
     appendHighlightProperty(document, properties, namespace, prefix, byType.get('highlight'));
     appendSnapToGridProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendVerticalAlignProperty(document, properties, namespace, prefix, byType);
+    appendEmphasisMarkProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+}
+function appendHiddenTextProperty(document, properties, namespace, prefix, mark) {
+    const hiddenText = normalizeDocumentHiddenText(mark?.attrs?.hiddenText);
+    if (null === hiddenText) return;
+    if (hiddenText) properties.append(wordElement(document, namespace, prefix, 'vanish'));
+    else appendValuedProperty(document, properties, namespace, prefix, 'vanish', '0');
+}
+function appendEmphasisMarkProperty(document, properties, namespace, prefix, mark) {
+    const emphasisMark = normalizeDocumentEmphasisMark(mark?.attrs?.emphasisMark);
+    if (null === emphasisMark) return;
+    appendValuedProperty(document, properties, namespace, prefix, 'em', emphasisMark);
+}
+function appendCharacterScaleProperty(document, properties, namespace, prefix, mark) {
+    const scale = normalizeDocumentCharacterScalePercent(mark?.attrs?.characterScalePercent);
+    if (null === scale) return;
+    appendValuedProperty(document, properties, namespace, prefix, 'w', String(scale));
+}
+function appendKerningThresholdProperty(document, properties, namespace, prefix, mark) {
+    const threshold = normalizeDocumentKerningThresholdHalfPoints(mark?.attrs?.kerningThresholdHalfPoints);
+    if (null === threshold) return;
+    appendValuedProperty(document, properties, namespace, prefix, 'kern', String(threshold));
+}
+function appendCharacterPositionProperty(document, properties, namespace, prefix, mark) {
+    const position = normalizeDocumentCharacterPositionHalfPoints(mark?.attrs?.characterPositionHalfPoints);
+    if (null === position) return;
+    appendValuedProperty(document, properties, namespace, prefix, 'position', String(position));
+}
+function appendCharacterSpacingProperty(document, properties, namespace, prefix, mark) {
+    const spacing = normalizeDocumentCharacterSpacingTwips(mark?.attrs?.characterSpacingTwips);
+    if (null === spacing) return;
+    appendValuedProperty(document, properties, namespace, prefix, 'spacing', String(spacing));
 }
 function appendFontProperties(document, properties, namespace, prefix, mark) {
+    const scriptFonts = parseDocumentScriptFonts('string' == typeof mark?.attrs?.scriptFonts ? mark.attrs.scriptFonts : void 0);
+    if (scriptFonts) {
+        const fonts = wordElement(document, namespace, prefix, 'rFonts');
+        for (const [name, value] of [
+            [
+                'ascii',
+                scriptFonts.ascii?.name
+            ],
+            [
+                'hAnsi',
+                scriptFonts.highAnsi?.name
+            ],
+            [
+                'eastAsia',
+                scriptFonts.eastAsia?.name
+            ],
+            [
+                'cs',
+                scriptFonts.complexScript?.name
+            ],
+            [
+                'asciiTheme',
+                scriptFonts.ascii?.theme
+            ],
+            [
+                'hAnsiTheme',
+                scriptFonts.highAnsi?.theme
+            ],
+            [
+                'eastAsiaTheme',
+                scriptFonts.eastAsia?.theme
+            ],
+            [
+                'cstheme',
+                scriptFonts.complexScript?.theme
+            ],
+            [
+                'hint',
+                scriptFonts.hint
+            ]
+        ])if (value) work_docx_format_change_export_setWordAttribute(fonts, namespace, prefix, name, value);
+        properties.append(fonts);
+        return;
+    }
     const family = firstFontFamily(mark?.attrs?.fontFamily);
     if (!family) return;
     const fonts = wordElement(document, namespace, prefix, 'rFonts');
@@ -2241,14 +2477,41 @@ function appendFontProperties(document, properties, namespace, prefix, mark) {
     ])work_docx_format_change_export_setWordAttribute(fonts, namespace, prefix, name, family);
     properties.append(fonts);
 }
+function appendUnderlineProperty(document, properties, namespace, prefix, mark) {
+    if (!mark) return;
+    const style = normalizeDocumentUnderlineStyle(mark.attrs?.underlineStyle) ?? 'single';
+    const color = normalizedHex(mark.attrs?.underlineColor);
+    const theme = themeReference(mark.attrs?.underlineThemeColor);
+    const underline = wordElement(document, namespace, prefix, 'u');
+    work_docx_format_change_export_setWordAttribute(underline, namespace, prefix, 'val', style);
+    const resolved = color ?? normalizedHex(theme?.resolved);
+    if (resolved) work_docx_format_change_export_setWordAttribute(underline, namespace, prefix, 'color', resolved);
+    if (theme) setThemeAttributes(underline, namespace, prefix, theme, 'themeColor');
+    properties.append(underline);
+}
 function appendBooleanProperty(document, properties, namespace, prefix, marks, mark, property) {
     if (marks.has(mark)) properties.append(wordElement(document, namespace, prefix, property));
 }
+function appendStrikeProperties(document, properties, namespace, prefix, mark) {
+    if (!mark) return;
+    const style = normalizeDocumentStrikeStyle(mark.attrs?.strikeStyle) ?? 'single';
+    appendValuedProperty(document, properties, namespace, prefix, 'strike', 'single' === style ? '1' : '0');
+    appendValuedProperty(document, properties, namespace, prefix, 'dstrike', 'double' === style ? '1' : '0');
+}
 function appendValuedProperty(document, properties, namespace, prefix, property, value) {
     const element = wordElement(document, namespace, prefix, property);
     work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'val', value);
     properties.append(element);
 }
+function appendTextCaseProperties(document, properties, namespace, prefix, mark) {
+    const textCase = mark?.attrs?.textCase;
+    if ('all-caps' === textCase) properties.append(wordElement(document, namespace, prefix, 'caps'));
+    else if ('small-caps' === textCase) properties.append(wordElement(document, namespace, prefix, 'smallCaps'));
+    else if ('none' === textCase) {
+        appendValuedProperty(document, properties, namespace, prefix, 'caps', '0');
+        appendValuedProperty(document, properties, namespace, prefix, 'smallCaps', '0');
+    }
+}
 function appendColorProperty(document, properties, namespace, prefix, mark) {
     const color = normalizedHex(mark?.attrs?.color);
     const theme = themeReference(mark?.attrs?.themeColor);
@@ -7283,6 +7546,131 @@ function docxParagraphPartPaths(pathsByLower, contentTypes) {
 function isObfuscatedFontContentType(type) {
     return type?.trim().toLowerCase() === 'application/vnd.openxmlformats-officedocument.obfuscatedfont';
 }
+const RUN_FONT_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes|comments)\.xml$/i;
+const WORD_FONT_ATTRIBUTE_NAMES = new Set([
+    'ascii',
+    'hAnsi',
+    'eastAsia',
+    'cs',
+    'asciiTheme',
+    'hAnsiTheme',
+    'eastAsiaTheme',
+    'cstheme',
+    'hint'
+]);
+class DocxRunFontsPatchCollector {
+    patches = [];
+    nextMarker = 1;
+    occupied;
+    markersByFonts = new Map();
+    constructor(source){
+        this.occupied = source;
+    }
+    marker(source, slot, currentFontFamily) {
+        const fonts = normalizeDocumentScriptFonts(source);
+        const normalizedSlot = normalizeDocumentScriptFontSlot(slot) ?? documentScriptFontSlotFromHint(fonts?.hint);
+        const expected = fonts ? documentScriptFontFamily(fonts, normalizedSlot) : void 0;
+        const current = documentFontNameFromCssFamily(currentFontFamily);
+        if (!fonts || (expected ? documentFontNameFromCssFamily(expected)?.toLocaleLowerCase() !== current?.toLocaleLowerCase() : Boolean(currentFontFamily.trim()))) return null;
+        const key = serializeDocumentScriptFonts(fonts);
+        if (!key) return null;
+        const existing = this.markersByFonts.get(key);
+        if (existing) return existing;
+        let marker = '';
+        do {
+            marker = `A3SOfficeRunFonts${String(this.nextMarker).padStart(8, '0')}`;
+            this.nextMarker += 1;
+        }while (this.occupied.includes(marker) || this.patches.some((patch)=>patch.marker === marker))
+        this.patches.push({
+            marker,
+            fonts
+        });
+        this.markersByFonts.set(key, marker);
+        return marker;
+    }
+}
+async function patchDocxRunFonts(buffer, patches) {
+    if (!patches.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const byMarker = new Map(patches.map((patch)=>[
+            patch.marker,
+            patch.fonts
+        ]));
+    const applied = new Set();
+    for (const entry of Object.values(archive.files)){
+        if (entry.dir || !RUN_FONT_PART_PATTERN.test(entry.name)) continue;
+        const document = parseXml(decodeXmlBytes(await entry.async('uint8array'), `generated DOCX ${entry.name}`), `generated DOCX ${entry.name}`);
+        let changedPart = false;
+        for (const element of descendants(document, 'rFonts')){
+            if (!DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '')) continue;
+            const marker = wordFontAttribute(element, 'ascii');
+            if (!marker) continue;
+            const fonts = byMarker.get(marker);
+            if (fonts) {
+                replaceWordFontAttributes(element, fonts);
+                applied.add(marker);
+                changedPart = true;
+            }
+        }
+        if (changedPart) archive.file(entry.name, serializeUtf8Xml(document));
+    }
+    const missing = patches.filter((patch)=>!applied.has(patch.marker));
+    if (missing.length) throw new Error(`DOCX run-font markers were not emitted: ${missing.map((patch)=>patch.marker).join(', ')}.`);
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function replaceWordFontAttributes(element, fonts) {
+    for (const item of Array.from(element.attributes))if (item.namespaceURI !== work_docx_settings_xml_XMLNS_NAMESPACE && WORD_FONT_ATTRIBUTE_NAMES.has(xmlAttributeLocalName(item)) && DOCX_WORDPROCESSING_NAMESPACES.has(xmlAttributeNamespace(element, item) ?? '')) element.removeAttributeNode(item);
+    const values = [
+        [
+            'ascii',
+            fonts.ascii?.name
+        ],
+        [
+            'hAnsi',
+            fonts.highAnsi?.name
+        ],
+        [
+            'eastAsia',
+            fonts.eastAsia?.name
+        ],
+        [
+            'cs',
+            fonts.complexScript?.name
+        ],
+        [
+            'asciiTheme',
+            fonts.ascii?.theme
+        ],
+        [
+            'hAnsiTheme',
+            fonts.highAnsi?.theme
+        ],
+        [
+            'eastAsiaTheme',
+            fonts.eastAsia?.theme
+        ],
+        [
+            'cstheme',
+            fonts.complexScript?.theme
+        ],
+        [
+            'hint',
+            fonts.hint
+        ]
+    ];
+    for (const [name, value] of values)if (value) setWordFontAttribute(element, name, value);
+}
+function wordFontAttribute(element, name) {
+    const values = Array.from(element.attributes).filter((item)=>xmlAttributeLocalName(item) === name && DOCX_WORDPROCESSING_NAMESPACES.has(xmlAttributeNamespace(element, item) ?? ''));
+    return 1 === values.length ? values[0]?.value ?? null : null;
+}
+function setWordFontAttribute(element, name, value) {
+    const namespace = element.namespaceURI ?? '';
+    const prefix = element.prefix || 'w';
+    element.setAttributeNS(namespace, `${prefix}:${name}`, value);
+}
 async function createDocxBlob(content, sourcePackage) {
     const docx = await import("docx");
     const normalizedContent = {
@@ -7317,7 +7705,11 @@ async function createDocxBlob(content, sourcePackage) {
         paragraphIdentityPatches: new DocxParagraphIdentityPatchCollector(JSON.stringify(normalizedContent)),
         equationPatches: new DocxEquationPatchCollector(JSON.stringify(normalizedContent)),
         formattingChangePatches: new DocxRunFormattingChangePatchCollector(),
-        paragraphFormattingChangePatches: new DocxParagraphFormattingChangePatchCollector()
+        runFontPatches: new DocxRunFontsPatchCollector(JSON.stringify(normalizedContent)),
+        hiddenTextPatches: new DocxHiddenTextPatchCollector(JSON.stringify(normalizedContent)),
+        paragraphFormattingChangePatches: new DocxParagraphFormattingChangePatchCollector(),
+        hasExplicitZeroCharacterSpacing: false,
+        hasExplicitZeroKerningThreshold: false
     };
     const commentRecords = createDocxCommentRecords(commentThreads, docx, noteContext.commentIds);
     const sections = [];
@@ -7364,7 +7756,11 @@ async function createDocxBlob(content, sourcePackage) {
         }
     });
     const packed = await docx.Packer.toBlob(document);
-    const formattingChangesPatched = await patchDocxRunFormattingChanges(await packed.arrayBuffer(), noteContext.formattingChangePatches.patches);
+    const characterSpacingPatched = noteContext.hasExplicitZeroCharacterSpacing ? await patchDocxExplicitZeroCharacterSpacing(await packed.arrayBuffer()) : await packed.arrayBuffer();
+    const kerningPatched = noteContext.hasExplicitZeroKerningThreshold ? await patchDocxExplicitZeroKerningThresholds(characterSpacingPatched) : characterSpacingPatched;
+    const runFontsPatched = await patchDocxRunFonts(kerningPatched, noteContext.runFontPatches.patches);
+    const hiddenTextPatched = await patchDocxHiddenText(runFontsPatched, noteContext.hiddenTextPatches.patches);
+    const formattingChangesPatched = await patchDocxRunFormattingChanges(hiddenTextPatched, noteContext.formattingChangePatches.patches);
     const noteImageRelationshipsPatched = await patchDocxNoteImageRelationships(formattingChangesPatched);
     const commentMetadataPatched = await patchDocxCommentMetadata(noteImageRelationshipsPatched, commentThreads);
     const numberingPatched = await patchDocxNumberingRestartRules(commentMetadataPatched, noteContext.numberingRestartRules);
@@ -7624,22 +8020,50 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
             fill: backgroundColor
         } : inherited.shading;
         const themeFillMarker = noteContext.themePatches.marker('fill', parseDocxThemeReference(node.dataset.officeThemeFill), resolvedShading?.fill ? `#${resolvedShading.fill}` : null);
+        const explicitTextCase = normalizeDocumentTextCase(node.dataset.officeTextCase);
+        const explicitCharacterSpacing = documentCharacterSpacingTwipsFromElement(node);
+        const explicitCharacterScale = documentCharacterScalePercentFromElement(node);
+        const explicitKerningThreshold = documentKerningThresholdHalfPointsFromElement(node);
+        const explicitEmphasisMark = documentEmphasisMarkFromElement(node);
+        const explicitHiddenText = documentHiddenTextFromElement(node);
+        const explicitCharacterPosition = documentCharacterPositionHalfPointsFromElement(node);
+        if (0 === explicitCharacterSpacing) noteContext.hasExplicitZeroCharacterSpacing = true;
+        if (0 === explicitKerningThreshold) noteContext.hasExplicitZeroKerningThreshold = true;
+        const characterSpacing = null === explicitCharacterSpacing ? inherited.characterSpacing : docxCharacterSpacingValue(explicitCharacterSpacing);
+        const scale = null === explicitCharacterScale ? inherited.scale : docxCharacterScaleValue(explicitCharacterScale);
+        const kern = null === explicitKerningThreshold ? inherited.kern : docxKerningThresholdValue(explicitKerningThreshold);
+        const position = null === explicitCharacterPosition ? inherited.position : docxCharacterPositionValue(explicitCharacterPosition);
+        const emphasisMark = null === explicitEmphasisMark ? inherited.emphasisMark : docxEmphasisMarkRunOptions(explicitEmphasisMark);
+        const textCaseOptions = docxTextCaseRunOptions(explicitTextCase, inherited);
+        const hiddenTextStyle = null === explicitHiddenText ? inherited.style : noteContext.hiddenTextPatches.marker(explicitHiddenText, inherited.style);
+        const underline = docxUnderlineRunOptions(node, inherited.underline, noteContext.themePatches);
+        const strike = docxStrikeRunOptions(node, inherited);
+        const scriptFontMarker = noteContext.runFontPatches.marker(documentScriptFontsFromElement(node), documentScriptFontSlotFromElement(node), node.style.fontFamily);
         const style = {
             ...inherited,
+            style: hiddenTextStyle,
             bold: inherited.bold || 'strong' === tag || 'b' === tag,
             italics: inherited.italics || 'em' === tag || 'i' === tag,
-            underline: inherited.underline || 'u' === tag ? {} : void 0,
-            strike: inherited.strike || 's' === tag || 'strike' === tag,
+            underline,
+            ...strike,
             subScript: inherited.subScript || 'sub' === tag,
             superScript: inherited.superScript || 'sup' === tag,
             color: themeColorMarker ?? resolvedColor,
-            font: cssFontFamily(node.style.fontFamily) ?? inherited.font,
+            font: scriptFontMarker ? {
+                ascii: scriptFontMarker
+            } : cssFontFamily(node.style.fontFamily) ?? inherited.font,
             size: cssFontSize(node.style.fontSize) ?? inherited.size,
+            characterSpacing,
+            scale,
+            kern,
+            position,
+            emphasisMark,
             shading: themeFillMarker ? {
                 fill: themeFillMarker
             } : resolvedShading,
             snapToGrid: dataBoolean(node.dataset.officeWordSnapToGrid) ?? inherited.snapToGrid,
-            rightToLeft: void 0 === direction ? inherited.rightToLeft : 'rtl' === direction
+            rightToLeft: void 0 === direction ? inherited.rightToLeft : 'rtl' === direction,
+            ...textCaseOptions
         };
         if ('br' === tag) return [
             new docx.TextRun({
@@ -7692,6 +8116,64 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
     for (const node of root.childNodes)runs.push(...await visit(node, inheritedDirection));
     return runs;
 }
+function docxStrikeRunOptions(element, inherited) {
+    if (element.hasAttribute(DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE) && !element.hasAttribute(DOCUMENT_STRIKE_STYLE_ATTRIBUTE)) return {
+        doubleStrike: inherited.doubleStrike,
+        strike: inherited.strike
+    };
+    const formatting = documentStrikeFormattingFromElement(element);
+    if (!formatting) return {
+        doubleStrike: inherited.doubleStrike,
+        strike: inherited.strike
+    };
+    return {
+        doubleStrike: 'double' === formatting.style,
+        strike: 'single' === formatting.style
+    };
+}
+function docxUnderlineRunOptions(element, inherited, themePatches) {
+    if (element.hasAttribute(DOCUMENT_STRIKE_STYLE_ATTRIBUTE) && !element.hasAttribute(DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE)) return inherited;
+    const formatting = documentUnderlineFormattingFromElement(element);
+    if (!formatting) return inherited;
+    const color = docxUnderlineColor(formatting, themePatches);
+    return {
+        type: formatting.style,
+        ...color ? {
+            color
+        } : {}
+    };
+}
+function docxUnderlineColor(formatting, themePatches) {
+    const direct = formatting.color ? cssColorToHex(formatting.color) : void 0;
+    return themePatches.marker('underline', formatting.themeColor ?? null, direct ? `#${direct}` : null) ?? direct;
+}
+function docxTextCaseRunOptions(explicitTextCase, inherited) {
+    if (null === explicitTextCase) {
+        if (void 0 !== inherited.smallCaps) return {
+            allCaps: void 0,
+            smallCaps: inherited.smallCaps
+        };
+        return void 0 === inherited.allCaps ? {} : {
+            allCaps: inherited.allCaps,
+            smallCaps: void 0
+        };
+    }
+    if ('all-caps' === explicitTextCase) return {
+        allCaps: true,
+        smallCaps: void 0
+    };
+    if ('small-caps' === explicitTextCase) return {
+        allCaps: void 0,
+        smallCaps: true
+    };
+    return inherited.smallCaps ? {
+        allCaps: void 0,
+        smallCaps: false
+    } : {
+        allCaps: false,
+        smallCaps: void 0
+    };
+}
 function docxTextRevision(element, kind, context) {
     const id = docxRevisionId(element, context);
     const sourceDate = element.dataset.changeDate?.trim() ?? '';