@a3s-lab/office 0.26.0 → 0.28.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, DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE, normalizeDocumentHiddenText, normalizeDocumentParagraphBorders, documentLegacyTextEffectsConflict, normalizeDocumentTableBorderWidth, normalizeDocumentCharacterSpacingTwips, normalizeDocumentParagraphId, documentStrikeFormattingFromElement, normalizeDocumentTableBorderStyle, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, parseDocumentParagraphBordersElement, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentCharacterScalePercent, documentScriptFontsFromElement, normalizeDocumentUnderlineStyle, documentPageMarginsForLayout, normalizeDocumentPageChrome, normalizeDocumentImageLayer, documentFontNameFromCssFamily, documentBookmarkReferenceInstruction, documentImageCropFromElement, documentKerningThresholdHalfPointsFromElement, normalizeDocumentPageBorders, documentImageLayerFromElement, normalizeDocumentLegacyTextEffects, documentCaptionLabel, documentCaptionKind, applyDocumentParagraphIdentityToElement, DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE, isContourImageLayout, parseDocumentScriptFonts, normalizeDocumentStrikeStyle, parseDocxThemeReference, createDocumentParagraphIdentityRegistry, documentCitationTags, docxDocumentFieldKind, normalizeDocumentImageIdentity, normalizeTableColor, documentTableBordersFromElement, wrapsBesideImage, normalizeDocumentCharacterPositionHalfPoints, normalizeDocumentKerningThresholdHalfPoints, DocxThemePatchCollector, defaultDocumentImageWrapContour, documentSections, normalizeDocumentParagraphIdentity, normalizeDocumentPaperSource, DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE, documentEquationFromElement, DOCUMENT_PARAGRAPH_BORDER_EDGES, documentLegacyTextEffectsFromElement, parseDocumentCharacterFormatting, documentScriptFontFamily, documentParagraphIdentityFromElement, DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE, normalizeDocumentEquation, documentUnderlineFormattingFromElement, normalizeDocumentBookmarkNativeId, patchDocxThemeReferences, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentHiddenTextFromElement, parseDocumentParagraphShadingElement, documentImageLayoutFromElement, documentScriptFontSlotFromHint, parseDocumentParagraphFormatting, documentPageHorizontalMarginTwips, documentTableRowIdentityFromElement, collectDocumentNotes, documentPageGeometryForLayout, normalizeDocumentScriptFontSlot, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, documentCharacterScalePercentFromElement, normalizeDocumentPageMargins, normalizeDocumentLegacyTextEffect, 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,285 @@ function hasAncestor(element, localName) {
     }
     return false;
 }
+const DOCX_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 DOCX_RUN_PROPERTY_RANK = new Map(DOCX_RUN_PROPERTY_ORDER.map((name, index)=>[
+        name,
+        index
+    ]));
+const HIDDEN_TEXT_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes|comments)\.xml$/i;
+const VANISH_RANK = DOCX_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;
+    }
+    lookup(marker) {
+        return marker ? this.patchesByMarker.get(marker) : void 0;
+    }
+    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 (DOCX_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 LEGACY_TEXT_EFFECTS_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes|comments)\.xml$/i;
+class DocxLegacyTextEffectsPatchCollector {
+    patches = [];
+    nextMarker = 1;
+    occupied;
+    patchesByMarker = new Map();
+    markersByEffectsAndStyle = new Map();
+    constructor(source){
+        this.occupied = source;
+    }
+    marker(value, inheritedStyle) {
+        const effects = normalizeDocumentLegacyTextEffects(value);
+        if (!effects || !Object.keys(effects).length) throw new Error('Document contains invalid legacy text effects.');
+        const style = this.originalStyle(inheritedStyle);
+        const key = JSON.stringify([
+            DOCUMENT_LEGACY_TEXT_EFFECT_NAMES.map((name)=>effects[name] ?? null),
+            style ?? null
+        ]);
+        const existing = this.markersByEffectsAndStyle.get(key);
+        if (existing) return existing;
+        let marker = '';
+        do {
+            marker = `A3SOfficeLegacyTextEffects${String(this.nextMarker).padStart(8, '0')}`;
+            this.nextMarker += 1;
+        }while (this.occupied.includes(marker) || this.patches.some((patch)=>patch.marker === marker))
+        const patch = {
+            marker,
+            effects,
+            ...style ? {
+                style
+            } : {}
+        };
+        this.patches.push(patch);
+        this.patchesByMarker.set(marker, patch);
+        this.markersByEffectsAndStyle.set(key, marker);
+        return marker;
+    }
+    lookup(marker) {
+        return marker ? this.patchesByMarker.get(marker) : void 0;
+    }
+    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 patchDocxLegacyTextEffects(buffer, patches) {
+    if (!patches.length) return buffer;
+    const byMarker = new Map();
+    for (const patch of patches){
+        const effects = normalizeDocumentLegacyTextEffects(patch.effects);
+        if (!patch.marker || !effects || !Object.keys(effects).length || byMarker.has(patch.marker)) throw new Error('Document contains invalid legacy text-effect patches.');
+        byMarker.set(patch.marker, {
+            ...patch,
+            effects
+        });
+    }
+    const archive = await jszip.loadAsync(buffer);
+    const applied = new Set();
+    for (const entry of Object.values(archive.files)){
+        if (entry.dir || !LEGACY_TEXT_EFFECTS_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 = work_docx_legacy_text_effects_export_wordValue(style);
+                return null !== marker && byMarker.has(marker);
+            });
+            if (!markerStyles.length) continue;
+            if (1 !== markerStyles.length) throw new Error('Generated DOCX legacy text-effect marker is duplicated in one run.');
+            const marker = work_docx_legacy_text_effects_export_wordValue(markerStyles[0]);
+            const patch = marker ? byMarker.get(marker) : void 0;
+            if (marker && patch) {
+                if (DOCUMENT_LEGACY_TEXT_EFFECT_NAMES.some((name)=>directChildren(properties, name).length > 0)) throw new Error('Generated DOCX legacy text-effect marker unexpectedly has a native value.');
+                if (patch.style) work_docx_legacy_text_effects_export_setWordValue(markerStyles[0], patch.style);
+                else markerStyles[0].remove();
+                for (const name of DOCUMENT_LEGACY_TEXT_EFFECT_NAMES){
+                    const value = patch.effects[name];
+                    if (void 0 !== value) insertLegacyTextEffectProperty(document, properties, name, 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 legacy text-effect markers were not emitted: ${missing.map((patch)=>patch.marker).join(', ')}.`);
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function insertLegacyTextEffectProperty(document, properties, name, value) {
+    const namespace = properties.namespaceURI ?? '';
+    const prefix = properties.prefix || 'w';
+    const effect = document.createElementNS(namespace, `${prefix}:${name}`);
+    if (!value) effect.setAttributeNS(namespace, `${prefix}:val`, '0');
+    const rank = DOCX_RUN_PROPERTY_RANK.get(name) ?? 0;
+    const next = directChildren(properties).find((child)=>{
+        if (!DOCX_WORDPROCESSING_NAMESPACES.has(child.namespaceURI ?? '')) return true;
+        return (DOCX_RUN_PROPERTY_RANK.get(child.localName) ?? 1 / 0) > rank;
+    });
+    properties.insertBefore(effect, next ?? null);
+}
+function work_docx_legacy_text_effects_export_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 work_docx_legacy_text_effects_export_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 +2500,129 @@ 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');
+    appendTextCaseProperties(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendStrikeProperties(document, properties, namespace, prefix, byType.get('strike'));
+    appendLegacyTextEffectsProperties(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendSnapToGridProperty(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'));
+    appendUnderlineProperty(document, properties, namespace, prefix, byType.get('underline'));
     appendVerticalAlignProperty(document, properties, namespace, prefix, byType);
+    appendEmphasisMarkProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+}
+function appendLegacyTextEffectsProperties(document, properties, namespace, prefix, mark) {
+    const effects = {};
+    const attributes = [
+        [
+            'outline',
+            'legacyTextOutline'
+        ],
+        [
+            'shadow',
+            'legacyTextShadow'
+        ],
+        [
+            'emboss',
+            'legacyTextEmboss'
+        ],
+        [
+            'imprint',
+            'legacyTextImprint'
+        ]
+    ];
+    for (const [effect, attribute] of attributes){
+        const value = normalizeDocumentLegacyTextEffect(mark?.attrs?.[attribute]);
+        if (null !== value) effects[effect] = value;
+    }
+    if (documentLegacyTextEffectsConflict(effects)) throw new Error('Document contains conflicting legacy text effects.');
+    for (const name of DOCUMENT_LEGACY_TEXT_EFFECT_NAMES){
+        const value = effects[name];
+        if (void 0 !== value) if (value) properties.append(wordElement(document, namespace, prefix, name));
+        else appendValuedProperty(document, properties, namespace, prefix, name, '0');
+    }
+}
+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 +2634,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 +7703,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 +7862,13 @@ 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)),
+        legacyTextEffectsPatches: new DocxLegacyTextEffectsPatchCollector(JSON.stringify(normalizedContent)),
+        usedNativeTextEffectMarkers: new Set(),
+        paragraphFormattingChangePatches: new DocxParagraphFormattingChangePatchCollector(),
+        hasExplicitZeroCharacterSpacing: false,
+        hasExplicitZeroKerningThreshold: false
     };
     const commentRecords = createDocxCommentRecords(commentThreads, docx, noteContext.commentIds);
     const sections = [];
@@ -7364,7 +7915,12 @@ 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.filter((patch)=>noteContext.usedNativeTextEffectMarkers.has(patch.marker)));
+    const legacyTextEffectsPatched = await patchDocxLegacyTextEffects(hiddenTextPatched, noteContext.legacyTextEffectsPatches.patches.filter((patch)=>noteContext.usedNativeTextEffectMarkers.has(patch.marker)));
+    const formattingChangesPatched = await patchDocxRunFormattingChanges(legacyTextEffectsPatched, noteContext.formattingChangePatches.patches);
     const noteImageRelationshipsPatched = await patchDocxNoteImageRelationships(formattingChangesPatched);
     const commentMetadataPatched = await patchDocxCommentMetadata(noteImageRelationshipsPatched, commentThreads);
     const numberingPatched = await patchDocxNumberingRestartRules(commentMetadataPatched, noteContext.numberingRestartRules);
@@ -7391,6 +7947,60 @@ async function createDocxBlob(content, sourcePackage) {
         type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
     });
 }
+function docxNativeTextEffectState(style, context) {
+    let current = style;
+    let hiddenText;
+    const legacyTextEffects = {};
+    const seen = new Set();
+    while(current && !seen.has(current)){
+        seen.add(current);
+        const hiddenPatch = context.hiddenTextPatches.lookup(current);
+        if (hiddenPatch) {
+            hiddenText ??= hiddenPatch.value;
+            current = hiddenPatch.style;
+            continue;
+        }
+        const legacyPatch = context.legacyTextEffectsPatches.lookup(current);
+        if (legacyPatch) {
+            for (const [name, value] of Object.entries(legacyPatch.effects)){
+                const effect = name;
+                if (void 0 === legacyTextEffects[effect]) legacyTextEffects[effect] = value;
+            }
+            current = legacyPatch.style;
+            continue;
+        }
+        break;
+    }
+    return {
+        ...current ? {
+            baseStyle: current
+        } : {},
+        ...void 0 !== hiddenText ? {
+            hiddenText
+        } : {},
+        legacyTextEffects
+    };
+}
+function markDocxNativeTextEffectStyleUsed(style, context) {
+    let current = style;
+    const seen = new Set();
+    while(current && !seen.has(current)){
+        seen.add(current);
+        const hiddenPatch = context.hiddenTextPatches.lookup(current);
+        if (hiddenPatch) {
+            context.usedNativeTextEffectMarkers.add(current);
+            current = hiddenPatch.style;
+            continue;
+        }
+        const legacyPatch = context.legacyTextEffectsPatches.lookup(current);
+        if (legacyPatch) {
+            context.usedNativeTextEffectMarkers.add(current);
+            current = legacyPatch.style;
+            continue;
+        }
+        break;
+    }
+}
 function work_docx_export_sectionProperties(layout, docx) {
     const landscape = 'landscape' === layout.orientation;
     const dimensions = documentPageGeometryForLayout(layout);
@@ -7560,6 +8170,7 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
     const visit = async (node, inherited = {}, revision)=>{
         if (node.nodeType === Node.TEXT_NODE) {
             if (!node.textContent) return [];
+            markDocxNativeTextEffectStyleUsed(inherited.style, noteContext);
             if (revision?.kind === 'insertion') return [
                 new docx.InsertedTextRun({
                     ...inherited,
@@ -7624,29 +8235,80 @@ 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 hasExplicitLegacyTextEffects = 'span' === tag && [
+            DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE,
+            DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE,
+            DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE,
+            DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE
+        ].some((attribute)=>node.hasAttribute(attribute));
+        const explicitLegacyTextEffects = hasExplicitLegacyTextEffects ? documentLegacyTextEffectsFromElement(node) : {};
+        if (hasExplicitLegacyTextEffects && !explicitLegacyTextEffects) throw new Error('Document contains invalid legacy text effects.');
+        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 inheritedNativeTextEffects = docxNativeTextEffectState(inherited.style, noteContext);
+        const legacyTextEffects = {
+            ...inheritedNativeTextEffects.legacyTextEffects,
+            ...explicitLegacyTextEffects ?? {}
+        };
+        if (documentLegacyTextEffectsConflict(legacyTextEffects)) throw new Error('Document contains conflicting legacy text effects.');
+        const hiddenText = null === explicitHiddenText ? inheritedNativeTextEffects.hiddenText : explicitHiddenText;
+        let nativeTextEffectStyle = inherited.style;
+        if (hasExplicitLegacyTextEffects || null !== explicitHiddenText) {
+            nativeTextEffectStyle = inheritedNativeTextEffects.baseStyle;
+            if (Object.keys(legacyTextEffects).length) nativeTextEffectStyle = noteContext.legacyTextEffectsPatches.marker(legacyTextEffects, nativeTextEffectStyle);
+            if (void 0 !== hiddenText) nativeTextEffectStyle = noteContext.hiddenTextPatches.marker(hiddenText, nativeTextEffectStyle);
+        }
+        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: nativeTextEffectStyle,
             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({
-                ...style,
-                break: 1
-            })
-        ];
+        if ('br' === tag) {
+            markDocxNativeTextEffectStyleUsed(style.style, noteContext);
+            return [
+                new docx.TextRun({
+                    ...style,
+                    break: 1
+                })
+            ];
+        }
         if ('img' === tag) return [
             await imageToDocx(node, docx, noteContext.imageCropPatches, noteContext.imageWrapPatches, noteContext.imageLayerPatches, noteContext.imageIdentityPatches)
         ];
@@ -7692,6 +8354,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() ?? '';