@a3s-lab/office 0.26.0 → 0.28.0

package/dist/0~5093.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, docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, docxThemeColor, parseDocxParagraphDefaultCollapsed, 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, normalizeDocumentParagraphIndent, serializeDocumentParagraphFormatting, normalizeDocumentEquation, DOCUMENT_PAGE_BORDER_EDGES, normalizeDocumentTabStops, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, documentWordLineHeightFactor, documentAutoLineHeight, renderDocumentAutoLineHeight, serializeDocxThemeReference, documentParagraphShadingDomAttributes, importedDocumentCharacterFormatting, documentParagraphBordersDomAttributes, createDocumentEquationElement, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, documentEquationText, normalizeDocumentPaperSource, serializeDocumentTabStops } from "./6282.js";
+import { docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, STRICT_WORDPROCESSING_NAMESPACE, docxCharacterSpacingTwipsFromProperties, parseBoundedDocxInteger, xmlAttributeLocalName, docxCharacterScalePercentFromProperties, resolveDocxEmphasisMark, docxCharacterPositionHalfPointsFromProperties, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, parseDocxTwipsMeasure } from "./0~7043.js";
+import { normalizeDocumentEmphasisMark, documentWordLineHeightFactor, normalizeDocumentPageBorders, normalizeDocumentParagraphBorder, documentCharacterPositionDomAttributes, DOCUMENT_PAGE_BORDER_EDGES, normalizeDocumentTabStops, documentTextCaseFromWordFlags, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, documentStrikeDomAttributes, documentAutoLineHeight, documentScriptFontFallbackSlots, normalizeDocumentUnderlineColor, documentScriptFontsDomAttributes, documentKerningDomAttributes, documentCharacterScaleDomAttributes, documentParagraphShadingDomAttributes, serializeDocxThemeReference, documentParagraphBordersDomAttributes, normalizeDocumentScriptFontHint, serializeDocumentParagraphFormatting, normalizeDocumentPaperSource, documentEquationText, normalizeDocumentScriptFonts, documentLegacyTextEffectsDomAttributes, documentLegacyTextEffectsConflict, DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, normalizeDocumentParagraphIndent, documentScriptFontFamily, normalizeDocumentEquation, normalizeDocumentThemeFont, documentCharacterSpacingDomAttributes, renderDocumentAutoLineHeight, documentUnderlineDomAttributes, normalizeDocumentUnderlineStyle, normalizeDocumentFontName, applyDocumentTextCaseStyle, documentHiddenTextDomAttributes, importedDocumentCharacterFormatting, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, createDocumentEquationElement, normalizeDocumentPageGeometry, serializeDocumentTabStops, documentEmphasisMarkDomAttributes, normalizeDocumentPageMargins, documentScriptFontSegments } from "./6282.js";
 function docxCaptionSequenceKind(instruction) {
     const identifier = /^\s*SEQ\s+([^\s\\]+)/i.exec(instruction)?.[1]?.toLowerCase();
     if (!identifier) return null;
@@ -1066,13 +1066,6 @@ const WORD_VERTICAL_ALIGNMENTS = new Set([
     "superscript",
     "subscript"
 ]);
-const WORD_EMPHASIS_MARKS = new Set([
-    'none',
-    'dot',
-    'comma',
-    'circle',
-    'underDot'
-]);
 const WORD_COMBINE_BRACKETS = new Set([
     'none',
     'round',
@@ -1096,8 +1089,6 @@ const MAX_WORD_FONT_NAME_LENGTH = 127;
 const MAX_WORD_LANGUAGE_LENGTH = 85;
 const MAX_WORD_HALF_POINT_SIZE = 1024;
 const MAX_WORD_CHARACTER_SPACING_TWIPS = 31680;
-const MAX_WORD_CHARACTER_SCALE_PERCENT = 600;
-const MAX_WORD_KERNING_THRESHOLD_HALF_POINTS = 3277;
 const MIN_WORD_LINE_BORDER_EIGHTH_POINTS = 2;
 const MAX_WORD_LINE_BORDER_EIGHTH_POINTS = 96;
 const MAX_WORD_BORDER_SPACING_POINTS = 31;
@@ -1561,7 +1552,7 @@ function parseWordRunProperties(properties) {
     const color = parseWordRunColor(children.get('color'));
     const characterSpacingTwips = parseWordRequiredInteger(children.get('spacing'), -MAX_WORD_CHARACTER_SPACING_TWIPS, MAX_WORD_CHARACTER_SPACING_TWIPS);
     const characterScalePercent = parseWordCharacterScale(children.get('w'));
-    const kerningThresholdHalfPoints = parseWordRequiredInteger(children.get('kern'), 0, MAX_WORD_KERNING_THRESHOLD_HALF_POINTS);
+    const kerningThresholdHalfPoints = parseWordRequiredInteger(children.get('kern'), 0, 3277);
     const positionHalfPoints = parseWordPosition(children.get('position'));
     const fontSize = parseWordHalfPointSize(children.get('sz'));
     const fontSizeComplexScript = parseWordHalfPointSize(children.get('szCs'));
@@ -1980,7 +1971,7 @@ function parseWordCharacterScale(element) {
     ]));
     if (!attributes) return null;
     if (!attributes.size) return 100;
-    return wordIntegerValue(attributes.get('val')?.trim() ?? '', 1, MAX_WORD_CHARACTER_SCALE_PERCENT);
+    return wordIntegerValue(attributes.get('val')?.trim() ?? '', 1, 600);
 }
 function parseWordPosition(element) {
     if (!element) return;
@@ -2170,7 +2161,7 @@ function parseWordEmphasisMark(element) {
         'val'
     ]));
     const value = attributes?.get('val')?.trim();
-    return attributes?.size === 1 && WORD_EMPHASIS_MARKS.has(value) ? value : null;
+    return attributes?.size === 1 ? normalizeDocumentEmphasisMark(value) : null;
 }
 function parseWordLanguages(element) {
     if (!element) return;
@@ -4082,6 +4073,129 @@ function nextEquationMarker(state) {
     state.occupiedText += marker;
     return marker;
 }
+const ON_VALUES = new Set([
+    '1',
+    'on',
+    'true'
+]);
+const OFF_VALUES = new Set([
+    '0',
+    'off',
+    'false'
+]);
+function inspectDocxHiddenText(properties) {
+    if (!properties) return {
+        status: 'absent'
+    };
+    const localMatches = work_ooxml_package_directChildren(properties, 'vanish');
+    if (!localMatches.length) return {
+        status: 'absent'
+    };
+    const nativeMatches = localMatches.filter((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? ''));
+    if (1 !== localMatches.length || 1 !== nativeMatches.length) return {
+        status: 'invalid'
+    };
+    const vanish = nativeMatches[0];
+    if (work_ooxml_package_directChildren(vanish).length || Array.from(vanish.childNodes).some((node)=>(node.nodeType === Node.TEXT_NODE || node.nodeType === Node.CDATA_SECTION_NODE) && Boolean(node.textContent?.trim()))) return {
+        status: 'invalid'
+    };
+    const attributes = Array.from(vanish.attributes).filter((attribute)=>xmlAttributeNamespace(vanish, attribute) !== work_docx_settings_xml_XMLNS_NAMESPACE && 'xmlns' !== attribute.name && !attribute.name.startsWith('xmlns:'));
+    if (!attributes.length) return {
+        status: 'valid',
+        value: true
+    };
+    if (1 !== attributes.length || 'val' !== xmlAttributeLocalName(attributes[0]) || !DOCX_WORDPROCESSING_NAMESPACES.has(xmlAttributeNamespace(vanish, attributes[0]) ?? '')) return {
+        status: 'invalid'
+    };
+    const value = attributes[0].value;
+    if (ON_VALUES.has(value)) return {
+        status: 'valid',
+        value: true
+    };
+    if (OFF_VALUES.has(value)) return {
+        status: 'valid',
+        value: false
+    };
+    return {
+        status: 'invalid'
+    };
+}
+function docxHiddenTextFromProperties(properties) {
+    const inspection = inspectDocxHiddenText(properties);
+    return 'valid' === inspection.status ? inspection.value : void 0;
+}
+function resolveDocxHiddenText(propertySources) {
+    let hiddenText;
+    for (const properties of propertySources){
+        const candidate = docxHiddenTextFromProperties(properties);
+        if (void 0 !== candidate) hiddenText = candidate;
+    }
+    return hiddenText;
+}
+const work_docx_legacy_text_effects_ON_VALUES = new Set([
+    '1',
+    'on',
+    'true'
+]);
+const work_docx_legacy_text_effects_OFF_VALUES = new Set([
+    '0',
+    'off',
+    'false'
+]);
+function inspectDocxLegacyTextEffects(properties) {
+    if (!properties) return {
+        status: 'absent'
+    };
+    const effects = {};
+    let present = false;
+    for (const name of DOCUMENT_LEGACY_TEXT_EFFECT_NAMES){
+        const localMatches = work_ooxml_package_directChildren(properties, name);
+        if (!localMatches.length) continue;
+        present = true;
+        const nativeMatches = localMatches.filter((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? ''));
+        if (1 !== localMatches.length || 1 !== nativeMatches.length) return {
+            status: 'invalid'
+        };
+        const value = inspectOnOffLeaf(nativeMatches[0]);
+        if (null === value) return {
+            status: 'invalid'
+        };
+        effects[name] = value;
+    }
+    if (!present) return {
+        status: 'absent'
+    };
+    return documentLegacyTextEffectsConflict(effects) ? {
+        status: 'invalid'
+    } : {
+        status: 'valid',
+        value: effects
+    };
+}
+function resolveDocxLegacyTextEffects(propertySources) {
+    const effects = {};
+    let present = false;
+    for (const properties of propertySources){
+        const inspection = inspectDocxLegacyTextEffects(properties);
+        if ('invalid' === inspection.status) return;
+        if ('valid' === inspection.status) {
+            Object.assign(effects, inspection.value);
+            present = true;
+            if (documentLegacyTextEffectsConflict(effects)) return;
+        }
+    }
+    return present ? effects : void 0;
+}
+function inspectOnOffLeaf(element) {
+    if (work_ooxml_package_directChildren(element).length || Array.from(element.childNodes).some((node)=>(node.nodeType === Node.TEXT_NODE || node.nodeType === Node.CDATA_SECTION_NODE) && Boolean(node.textContent?.trim()))) return null;
+    const attributes = Array.from(element.attributes).filter((attribute)=>xmlAttributeNamespace(element, attribute) !== work_docx_settings_xml_XMLNS_NAMESPACE && 'xmlns' !== attribute.name && !attribute.name.startsWith('xmlns:'));
+    if (!attributes.length) return true;
+    if (1 !== attributes.length || 'val' !== xmlAttributeLocalName(attributes[0]) || !DOCX_WORDPROCESSING_NAMESPACES.has(xmlAttributeNamespace(element, attributes[0]) ?? '')) return null;
+    const value = attributes[0].value;
+    if (work_docx_legacy_text_effects_ON_VALUES.has(value)) return true;
+    if (work_docx_legacy_text_effects_OFF_VALUES.has(value)) return false;
+    return null;
+}
 const MAX_STYLE_INHERITANCE_DEPTH = 64;
 function createDocxParagraphStyleResolver(stylesDocument) {
     if (!stylesDocument) return {
@@ -4640,14 +4754,14 @@ function parseBorderColor(attributes, theme) {
         if (!semanticValue) return null;
         return {
             value: semanticValue,
-            theme: themeReference(themeName, semanticValue, tint, shade)
+            theme: work_docx_paragraph_borders_import_themeReference(themeName, semanticValue, tint, shade)
         };
     }
     if ('none' === themeName) {
         const value = color ?? 'auto';
         return {
             value,
-            theme: themeReference(themeName, 'auto' === value ? '#000000' : value, tint, shade)
+            theme: work_docx_paragraph_borders_import_themeReference(themeName, 'auto' === value ? '#000000' : value, tint, shade)
         };
     }
     if (!color) return null;
@@ -4655,7 +4769,7 @@ function parseBorderColor(attributes, theme) {
         value: color
     };
 }
-function themeReference(theme, resolved, tint, shade) {
+function work_docx_paragraph_borders_import_themeReference(theme, resolved, tint, shade) {
     return {
         theme,
         resolved,
@@ -5084,6 +5198,66 @@ function work_docx_paragraph_shading_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
+function importedDocxUnderline(element, theme) {
+    const rawStyle = work_ooxml_package_attribute(element, 'val');
+    const style = null === rawStyle ? 'single' : normalizeDocumentUnderlineStyle(rawStyle) ?? 'single';
+    const themeName = work_ooxml_package_attribute(element, 'themeColor')?.trim();
+    const tint = normalizedByteHex(work_ooxml_package_attribute(element, 'themeTint'));
+    const shade = normalizedByteHex(work_ooxml_package_attribute(element, 'themeShade'));
+    const themed = theme && themeName ? docxThemeColor(theme, themeName, tint, shade) : void 0;
+    const direct = normalizeDocumentUnderlineColor(work_ooxml_package_attribute(element, 'color'));
+    const color = themed ? `#${themed}` : direct;
+    const themeColor = themeName && color ? underlineThemeReference(themeName, color, tint, shade) : void 0;
+    return {
+        style,
+        ...color ? {
+            color
+        } : {},
+        ...themeColor ? {
+            themeColor
+        } : {}
+    };
+}
+function underlineThemeReference(theme, resolved, tint, shade) {
+    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 importedDocxStrikeFlags(properties) {
+    return {
+        ...importedFlag(directChild(properties, 'strike'), 'single'),
+        ...importedFlag(directChild(properties, 'dstrike'), 'double')
+    };
+}
+function importedDocxStrike(properties) {
+    const flags = importedDocxStrikeFlags(properties);
+    return resolvedDocxStrikeFormatting(flags.single, flags.double);
+}
+function resolvedDocxStrikeFormatting(single, double, materializeNone = false) {
+    if (void 0 === single && void 0 === double && !materializeNone) return;
+    const style = double ? 'double' : single ? 'single' : 'none';
+    return {
+        style
+    };
+}
+function importedFlag(element, name) {
+    if (!element) return {};
+    const value = work_ooxml_package_attribute(element, 'val')?.trim().toLowerCase();
+    return {
+        [name]: '0' !== value && 'false' !== value && 'off' !== value
+    };
+}
 const PAGE_BORDER_EDGE_SET = new Set(DOCUMENT_PAGE_BORDER_EDGES);
 const PAGE_BORDER_ATTRIBUTES = new Set([
     'zOrder',
@@ -5231,64 +5405,6 @@ function hasNonWhitespaceText(element) {
 function work_docx_page_borders_import_isNamespaceDeclaration(attribute) {
     return attribute.namespaceURI === work_docx_settings_xml_XMLNS_NAMESPACE || 'xmlns' === attribute.name || attribute.name.startsWith('xmlns:');
 }
-const STRICT_WORDPROCESSING_NAMESPACE = 'http://purl.oclc.org/ooxml/wordprocessingml/main';
-const UNIVERSAL_TWIP_RATIOS = {
-    mm: [
-        7200n,
-        127n
-    ],
-    cm: [
-        72000n,
-        127n
-    ],
-    in: [
-        1440n,
-        1n
-    ],
-    pt: [
-        20n,
-        1n
-    ],
-    pc: [
-        240n,
-        1n
-    ],
-    pi: [
-        240n,
-        1n
-    ]
-};
-function parseDocxTwipsMeasure(source, options) {
-    const integer = parseBoundedDocxInteger(source, {
-        minimum: options.minimum,
-        maximum: options.maximum,
-        signed: options.signed
-    });
-    if (null !== integer) return integer;
-    return options.strict ? parseStrictUniversalTwips(source, options) : null;
-}
-function parseBoundedDocxInteger(source, options) {
-    if (source.length > 32) return null;
-    const pattern = options.signed ? /^[+-]?\d+$/u : /^\+?\d+$/u;
-    if (!pattern.test(source)) return null;
-    const value = Number(source);
-    return Number.isSafeInteger(value) && value >= options.minimum && value <= options.maximum ? Object.is(value, -0) ? 0 : value : null;
-}
-function parseStrictUniversalTwips(source, options) {
-    if (source.length > 64) return null;
-    const match = /^(-?)(\d+)(?:\.(\d+))?(mm|cm|in|pt|pc|pi)$/u.exec(source);
-    if (!match) return null;
-    const [, sign, whole = '', fraction = '', unit = ''] = match;
-    if (!options.signed && sign) return null;
-    const conversion = UNIVERSAL_TWIP_RATIOS[unit];
-    if (!conversion) return null;
-    const denominator = 10n ** BigInt(fraction.length) * conversion[1];
-    const numerator = BigInt(`${whole}${fraction}`) * conversion[0] * (sign ? -1n : 1n);
-    if (numerator % denominator !== 0n) return null;
-    const twips = numerator / denominator;
-    if (twips < BigInt(options.minimum) || twips > BigInt(options.maximum)) return null;
-    return Number(twips);
-}
 const PAGE_MARGIN_ATTRIBUTE_SET = new Set([
     'top',
     'right',
@@ -6599,6 +6715,151 @@ function work_docx_paragraph_format_change_import_textNodes(root) {
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
+const FONT_ATTRIBUTES = new Set([
+    'ascii',
+    'hAnsi',
+    'eastAsia',
+    'cs',
+    'asciiTheme',
+    'hAnsiTheme',
+    'eastAsiaTheme',
+    'cstheme',
+    'hint'
+]);
+const EMPTY_THEME = {
+    colors: new Map(),
+    fonts: new Map()
+};
+function inspectDocxRunFonts(properties, theme = EMPTY_THEME) {
+    if (!properties) return {
+        status: 'absent'
+    };
+    const candidates = work_ooxml_package_directChildren(properties, 'rFonts');
+    if (!candidates.length) return {
+        status: 'absent'
+    };
+    if (1 !== candidates.length) return {
+        status: 'invalid'
+    };
+    const value = parseDocxRunFontsElement(candidates[0], theme);
+    return void 0 === value ? {
+        status: 'invalid'
+    } : {
+        status: 'valid',
+        value
+    };
+}
+function resolveDocxRunFonts(propertySources, theme) {
+    const resolved = {};
+    let found = false;
+    for (const properties of propertySources){
+        const inspection = inspectDocxRunFonts(properties, theme);
+        if ('valid' !== inspection.status || !inspection.value) continue;
+        found = true;
+        const next = inspection.value;
+        for (const slot of [
+            'ascii',
+            'highAnsi',
+            'eastAsia',
+            'complexScript'
+        ])if (next[slot]) resolved[slot] = next[slot];
+        if (next.hint) resolved.hint = next.hint;
+    }
+    return found ? normalizeDocumentScriptFonts(resolved) : null;
+}
+function parseDocxRunFontsElement(element, theme = EMPTY_THEME) {
+    if (!element || 'rFonts' !== element.localName || !DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '') || work_ooxml_package_directChildren(element).length || Array.from(element.childNodes).some((node)=>node.nodeType === Node.TEXT_NODE && node.textContent?.trim())) return;
+    const attributes = new Map();
+    for (const item of Array.from(element.attributes)){
+        if (item.namespaceURI === work_docx_settings_xml_XMLNS_NAMESPACE || 'xmlns' === item.name || item.name.startsWith('xmlns:')) continue;
+        const name = xmlAttributeLocalName(item);
+        if (!FONT_ATTRIBUTES.has(name) || !DOCX_WORDPROCESSING_NAMESPACES.has(xmlAttributeNamespace(element, item) ?? '') || attributes.has(name)) return;
+        attributes.set(name, item.value);
+    }
+    const ascii = fontFace(attributes.get('ascii'), attributes.get('asciiTheme'), theme);
+    const highAnsi = fontFace(attributes.get('hAnsi'), attributes.get('hAnsiTheme'), theme);
+    const eastAsia = fontFace(attributes.get('eastAsia'), attributes.get('eastAsiaTheme'), theme);
+    const complexScript = fontFace(attributes.get('cs'), attributes.get('cstheme'), theme);
+    const hintValue = attributes.get('hint');
+    const hint = void 0 === hintValue ? void 0 : normalizeDocumentScriptFontHint(hintValue);
+    if (void 0 === ascii || void 0 === highAnsi || void 0 === eastAsia || void 0 === complexScript || null === hint) return;
+    return normalizeDocumentScriptFonts({
+        ...ascii ? {
+            ascii
+        } : {},
+        ...highAnsi ? {
+            highAnsi
+        } : {},
+        ...eastAsia ? {
+            eastAsia
+        } : {},
+        ...complexScript ? {
+            complexScript
+        } : {},
+        ...hint ? {
+            hint
+        } : {}
+    });
+}
+function fontFace(directSource, themeSource, theme) {
+    const name = void 0 === directSource ? void 0 : normalizeDocumentFontName(directSource);
+    const themeReference = void 0 === themeSource ? void 0 : normalizeDocumentThemeFont(themeSource);
+    if (void 0 !== directSource && !name || null === themeReference) return;
+    if (!name && !themeReference) return null;
+    const themedFamily = themeReference ? docxThemeFont(theme, themeReference) : void 0;
+    const resolved = themedFamily ?? name;
+    return {
+        ...name ? {
+            name
+        } : {},
+        ...themeReference ? {
+            theme: themeReference
+        } : {},
+        ...resolved ? {
+            resolved
+        } : {}
+    };
+}
+function directDocxRunText(run) {
+    return directDocxRunTextElements(run).map((child)=>child.textContent ?? '').join('');
+}
+function markSegmentedDocxRunFormatting(run, state, segments, formattingFor, changeFor, createMarkers) {
+    let runOffset = 0;
+    for (const textElement of directDocxRunTextElements(run)){
+        const source = textElement.textContent ?? '';
+        const elementFrom = runOffset;
+        const elementTo = elementFrom + source.length;
+        runOffset = elementTo;
+        if (!source) continue;
+        const replacement = [];
+        for (const segment of segments){
+            const from = Math.max(elementFrom, segment.from);
+            const to = Math.min(elementTo, segment.to);
+            if (to <= from) continue;
+            const text = source.slice(from - elementFrom, to - elementFrom);
+            const formatting = formattingFor(text, segment.slot);
+            const change = changeFor(text, segment.slot);
+            if (!Object.keys(formatting).length && !change) {
+                replacement.push(text);
+                continue;
+            }
+            const { startMarker, endMarker } = createMarkers();
+            replacement.push(startMarker, text, endMarker);
+            state.markers.runs.push({
+                startMarker,
+                endMarker,
+                formatting,
+                ...change ? {
+                    change
+                } : {}
+            });
+        }
+        textElement.textContent = replacement.join('');
+    }
+}
+function directDocxRunTextElements(run) {
+    return Array.from(run.children).filter((child)=>'t' === child.localName || 'delText' === child.localName);
+}
 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;
@@ -6610,6 +6871,17 @@ const SUPPORTED_RUN_PROPERTY_CHANGE_CHILDREN = new Set([
     'u',
     'strike',
     'dstrike',
+    'outline',
+    'shadow',
+    'emboss',
+    'imprint',
+    'caps',
+    'smallCaps',
+    'vanish',
+    'spacing',
+    'w',
+    'kern',
+    'position',
     'rFonts',
     'sz',
     'szCs',
@@ -6619,28 +6891,47 @@ const SUPPORTED_RUN_PROPERTY_CHANGE_CHILDREN = new Set([
     'snapToGrid',
     'cs',
     'rtl',
+    'em',
     'vertAlign'
 ]);
-function markDocxRunFormatting(document, styleSource, themeSource, tableStyleSource) {
-    const runs = [];
+function createImportedDocxRunFormattingMarkerState(documents) {
+    return {
+        markers: {
+            runs: []
+        },
+        nextMarker: 1,
+        occupiedText: documents.map((document)=>document.documentElement.textContent ?? '').join('')
+    };
+}
+function markDocxRunFormattingIntoState(document, state, styleSource, themeSource, tableStyleSource) {
     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 runText = directDocxRunText(run);
+        if (!runText) 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);
+        const contextualProperties = docxTableRunPropertySources(run, tableStyles);
+        const propertySources = docxRunPropertySources(paragraphProperties, runProperties, styles, contextualProperties);
+        const scriptFonts = resolveDocxRunFonts(propertySources, theme);
+        const forceComplexScript = propertySourcesUseComplexScript(propertySources);
+        const scriptSegments = documentScriptFontSegments(runText, scriptFonts?.hint, forceComplexScript);
+        const formattingFor = (text, scriptFontSlot)=>resolvedRunFormatting(propertySources, theme, text, scriptFontSlot, scriptFonts);
+        const changeFor = (text, scriptFontSlot)=>importedRunFormattingChange(runProperties, paragraphProperties, styles, contextualProperties, theme, text, scriptFontSlot);
+        if (scriptSegments.length > 1) {
+            markSegmentedDocxRunFormatting(run, state, scriptSegments, formattingFor, changeFor, ()=>nextRunFormattingMarkers(state));
+            continue;
+        }
+        const scriptFontSlot = scriptSegments[0]?.slot;
+        const formatting = formattingFor(runText, scriptFontSlot);
+        const change = changeFor(runText, scriptFontSlot);
         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}__`;
+        const { startMarker, endMarker } = nextRunFormattingMarkers(state);
         insertRunMarkers(document, run, runProperties, startMarker, endMarker);
-        runs.push({
+        state.markers.runs.push({
             startMarker,
             endMarker,
             formatting,
@@ -6649,9 +6940,6 @@ function markDocxRunFormatting(document, styleSource, themeSource, tableStyleSou
             } : {}
         });
     }
-    return {
-        runs
-    };
 }
 function applyImportedDocxRunFormattingMarkers(document, markers) {
     const replacements = new Map();
@@ -6664,13 +6952,24 @@ function applyImportedDocxRunFormattingMarkers(document, markers) {
         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) ?? '');
+    document.body.innerHTML = document.body.innerHTML.replace(RUN_FORMATTING_MARKER_PATTERN, (marker)=>replacements.get(marker) ?? marker);
+}
+function nextRunFormattingMarkers(state) {
+    while(true){
+        const index = state.nextMarker;
+        state.nextMarker += 1;
+        const startMarker = `__A3S_WORK_RUN_START_${index}__`;
+        const endMarker = `__A3S_WORK_RUN_END_${index}__`;
+        if (!state.occupiedText.includes(startMarker) && !state.occupiedText.includes(endMarker)) return {
+            startMarker,
+            endMarker
+        };
+    }
 }
 function hasImportedDocxRunFormattingMarkers(markers) {
     return markers.runs.length > 0;
 }
-function resolvedRunFormatting(propertySources, theme, runText) {
-    const fonts = {};
+function resolvedRunFormatting(propertySources, theme, runText, requestedFontSlot, resolvedScriptFonts = resolveDocxRunFonts(propertySources, theme)) {
     let fontSize;
     let complexFontSize;
     let color;
@@ -6683,20 +6982,35 @@ function resolvedRunFormatting(propertySources, theme, runText) {
     let complexItalic;
     let underline;
     let strike;
+    let doubleStrike;
     let subscript;
     let superscript;
     let snapToGrid;
     let complexScriptFormatting;
     let rightToLeft;
-    let fontHint;
+    let allCaps;
+    let smallCaps;
+    let characterScalePercent;
+    let characterPositionHalfPoints;
+    let characterSpacingTwips;
+    const kerningThresholdHalfPoints = resolveDocxKerningThresholdHalfPoints(propertySources);
+    const emphasisMark = resolveDocxEmphasisMark(propertySources);
+    const hiddenText = resolveDocxHiddenText(propertySources);
+    const legacyTextEffects = resolveDocxLegacyTextEffects(propertySources);
     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'));
+        underline = overriddenValue(underline, underlineProperty(properties, theme));
+        const importedStrike = importedDocxStrikeFlags(properties);
+        strike = overriddenBoolean(strike, importedStrike.single);
+        doubleStrike = overriddenBoolean(doubleStrike, importedStrike.double);
+        allCaps = overriddenBoolean(allCaps, onOffProperty(properties, 'caps'));
+        smallCaps = overriddenBoolean(smallCaps, onOffProperty(properties, 'smallCaps'));
+        characterSpacingTwips = overriddenValue(characterSpacingTwips, docxCharacterSpacingTwipsFromProperties(properties));
+        characterScalePercent = overriddenValue(characterScalePercent, docxCharacterScalePercentFromProperties(properties));
+        characterPositionHalfPoints = overriddenValue(characterPositionHalfPoints, docxCharacterPositionHalfPointsFromProperties(properties));
         const verticalAlign = directChild(properties, 'vertAlign');
         if (verticalAlign) {
             const value = work_docx_run_formatting_import_wordAttribute(verticalAlign, 'val')?.trim().toLowerCase();
@@ -6710,14 +7024,6 @@ function resolvedRunFormatting(propertySources, theme, runText) {
         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 = work_docx_run_formatting_import_numericAttribute(directChild(properties, 'sz'), 'val');
         if (void 0 !== size && size > 0) fontSize = Math.min(512, size / 2);
         const complexSize = work_docx_run_formatting_import_numericAttribute(directChild(properties, 'szCs'), 'val');
@@ -6760,19 +7066,15 @@ function resolvedRunFormatting(propertySources, theme, runText) {
             }
         }
     }
-    const fontSlot = true === complexScriptFormatting || true === rightToLeft ? 'complex' : docxFontSlotForText(runText, fontHint);
-    const usesComplexFormatting = 'complex' === fontSlot;
+    const fontSlot = true === complexScriptFormatting || true === rightToLeft ? 'complexScript' : requestedFontSlot ?? documentScriptFontSegments(runText, resolvedScriptFonts?.hint)[0]?.slot ?? 'ascii';
+    const usesComplexFormatting = 'complexScript' === 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 fontFamily = documentScriptFontFamily(resolvedScriptFonts, fontSlot) ?? defaultThemeFontFamily(theme, fontSlot);
     const hasRunPropertySource = propertySources.length > 0;
+    const resolvedStrike = resolvedDocxStrikeFormatting(strike, doubleStrike, hasRunPropertySource);
+    const textCase = documentTextCaseFromWordFlags(allCaps, smallCaps);
     return {
         ...void 0 !== resolvedBold || hasRunPropertySource ? {
             bold: resolvedBold ?? false
@@ -6781,10 +7083,12 @@ function resolvedRunFormatting(propertySources, theme, runText) {
             italic: resolvedItalic ?? false
         } : {},
         ...void 0 !== underline || hasRunPropertySource ? {
-            underline: underline ?? false
+            underline: underline ?? {
+                style: 'none'
+            }
         } : {},
-        ...void 0 !== strike || hasRunPropertySource ? {
-            strike: strike ?? false
+        ...resolvedStrike ? {
+            strike: resolvedStrike
         } : {},
         ...void 0 !== subscript ? {
             subscript
@@ -6792,10 +7096,44 @@ function resolvedRunFormatting(propertySources, theme, runText) {
         ...void 0 !== superscript ? {
             superscript
         } : {},
+        ...void 0 !== characterScalePercent ? {
+            characterScalePercent
+        } : {},
+        ...void 0 !== characterPositionHalfPoints ? {
+            characterPositionHalfPoints
+        } : {},
+        ...void 0 !== characterSpacingTwips ? {
+            characterSpacingTwips
+        } : {},
+        ...void 0 !== kerningThresholdHalfPoints ? {
+            kerningThresholdHalfPoints
+        } : {},
+        ...void 0 !== emphasisMark ? {
+            emphasisMark
+        } : {},
+        ...void 0 !== hiddenText ? {
+            hiddenText
+        } : {},
+        ...legacyTextEffects?.outline !== void 0 ? {
+            legacyTextOutline: legacyTextEffects.outline
+        } : {},
+        ...legacyTextEffects?.shadow !== void 0 ? {
+            legacyTextShadow: legacyTextEffects.shadow
+        } : {},
+        ...legacyTextEffects?.emboss !== void 0 ? {
+            legacyTextEmboss: legacyTextEffects.emboss
+        } : {},
+        ...legacyTextEffects?.imprint !== void 0 ? {
+            legacyTextImprint: legacyTextEffects.imprint
+        } : {},
         ...fontFamily ? {
             fontFamily,
             wordLineHeightFactor: documentWordLineHeightFactor(fontFamily)
         } : {},
+        ...resolvedScriptFonts ? {
+            scriptFonts: resolvedScriptFonts,
+            scriptFontSlot: fontSlot
+        } : {},
         ...void 0 !== resolvedFontSize ? {
             fontSize: resolvedFontSize
         } : {},
@@ -6813,6 +7151,9 @@ function resolvedRunFormatting(propertySources, theme, runText) {
         } : {},
         ...themeFill ? {
             themeFill
+        } : {},
+        ...textCase ? {
+            textCase
         } : {}
     };
 }
@@ -6832,8 +7173,38 @@ 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';
+    const underlineEnabled = void 0 !== formatting.underline && 'none' !== formatting.underline.style;
+    const strikeEnabled = void 0 !== formatting.strike && 'none' !== formatting.strike.style;
+    if ((formatting.underline?.style === 'none' || formatting.strike?.style === 'none') && !underlineEnabled && !strikeEnabled) span.style.textDecorationLine = 'none';
     if (formatting.fontFamily) span.style.fontFamily = formatting.fontFamily;
+    if (formatting.scriptFonts) for (const [name, value] of Object.entries(documentScriptFontsDomAttributes(formatting.scriptFonts, formatting.scriptFontSlot)))if ('style' === name) span.style.cssText += `; ${value}`;
+    else span.setAttribute(name, value);
+    if (void 0 !== formatting.characterSpacingTwips) for (const [name, value] of Object.entries(documentCharacterSpacingDomAttributes(formatting.characterSpacingTwips)))if ('style' === name) span.style.cssText += `; ${value}`;
+    else span.setAttribute(name, value);
+    if (void 0 !== formatting.characterScalePercent) for (const [name, value] of Object.entries(documentCharacterScaleDomAttributes(formatting.characterScalePercent)))if ('style' === name) span.style.cssText += `; ${value}`;
+    else span.setAttribute(name, value);
+    if (void 0 !== formatting.kerningThresholdHalfPoints) for (const [name, value] of Object.entries(documentKerningDomAttributes(formatting.kerningThresholdHalfPoints, formatting.fontSize)))if ('style' === name) span.style.cssText += `; ${value}`;
+    else span.setAttribute(name, value);
+    if (void 0 !== formatting.characterPositionHalfPoints) for (const [name, value] of Object.entries(documentCharacterPositionDomAttributes(formatting.characterPositionHalfPoints)))if ('style' === name) span.style.cssText += `; ${value}`;
+    else span.setAttribute(name, value);
+    if (void 0 !== formatting.emphasisMark) for (const [name, value] of Object.entries(documentEmphasisMarkDomAttributes(formatting.emphasisMark)))if ('style' === name) span.style.cssText += `; ${value}`;
+    else span.setAttribute(name, value);
+    if (void 0 !== formatting.hiddenText) for (const [name, value] of Object.entries(documentHiddenTextDomAttributes(formatting.hiddenText)))span.setAttribute(name, value);
+    const legacyTextEffects = {
+        ...void 0 !== formatting.legacyTextOutline ? {
+            outline: formatting.legacyTextOutline
+        } : {},
+        ...void 0 !== formatting.legacyTextShadow ? {
+            shadow: formatting.legacyTextShadow
+        } : {},
+        ...void 0 !== formatting.legacyTextEmboss ? {
+            emboss: formatting.legacyTextEmboss
+        } : {},
+        ...void 0 !== formatting.legacyTextImprint ? {
+            imprint: formatting.legacyTextImprint
+        } : {}
+    };
+    for (const [name, value] of Object.entries(documentLegacyTextEffectsDomAttributes(legacyTextEffects)))span.setAttribute(name, value);
     if (void 0 !== formatting.wordLineHeightFactor) {
         const factor = formatLineHeightFactor(formatting.wordLineHeightFactor);
         span.dataset.officeWordLineHeightFactor = factor;
@@ -6847,38 +7218,69 @@ function formattingMarkup(document, formatting) {
     if (formatting.backgroundColor) span.style.backgroundColor = formatting.backgroundColor;
     const themeFill = serializeDocxThemeReference(formatting.themeFill ?? null);
     if (themeFill) span.dataset.officeThemeFill = themeFill;
+    if (formatting.textCase) applyDocumentTextCaseStyle(span, formatting.textCase);
     const html = span.outerHTML;
-    const tags = [
+    const wrappers = [
         ...formatting.bold ? [
-            'strong'
+            {
+                start: '<strong>',
+                end: '</strong>'
+            }
         ] : [],
         ...formatting.italic ? [
-            'em'
+            {
+                start: '<em>',
+                end: '</em>'
+            }
         ] : [],
         ...formatting.underline ? [
-            'u'
+            underlineFormattingWrapper(document, formatting.underline)
         ] : [],
         ...formatting.strike ? [
-            's'
+            strikeFormattingWrapper(document, formatting.strike)
         ] : [],
         ...formatting.subscript ? [
-            'sub'
+            {
+                start: '<sub>',
+                end: '</sub>'
+            }
         ] : [],
         ...formatting.superscript ? [
-            'sup'
+            {
+                start: '<sup>',
+                end: '</sup>'
+            }
         ] : []
     ];
     return {
-        start: `${html.slice(0, html.indexOf('>') + 1)}${tags.map((tag)=>`<${tag}>`).join('')}`,
+        start: `${html.slice(0, html.indexOf('>') + 1)}${wrappers.map((wrapper)=>wrapper.start).join('')}`,
         end: `${[
-            ...tags
-        ].reverse().map((tag)=>`</${tag}>`).join('')}</span>`
+            ...wrappers
+        ].reverse().map((wrapper)=>wrapper.end).join('')}</span>`
+    };
+}
+function underlineFormattingWrapper(document, formatting) {
+    const underline = document.createElement('u');
+    for (const [name, value] of Object.entries(documentUnderlineDomAttributes(formatting)))underline.setAttribute(name, value);
+    const html = underline.outerHTML;
+    return {
+        start: html.slice(0, html.indexOf('>') + 1),
+        end: '</u>'
+    };
+}
+function strikeFormattingWrapper(document, formatting) {
+    const strike = document.createElement('s');
+    for (const [name, value] of Object.entries(documentStrikeDomAttributes(formatting)))strike.setAttribute(name, value);
+    const html = strike.outerHTML;
+    return {
+        start: html.slice(0, html.indexOf('>') + 1),
+        end: '</s>'
     };
 }
-function importedRunFormattingChange(runProperties, paragraphProperties, styles, contextualProperties, theme, runText) {
+function importedRunFormattingChange(runProperties, paragraphProperties, styles, contextualProperties, theme, runText, requestedFontSlot) {
     const parsed = supportedRunFormattingChange(runProperties);
     if (!parsed) return;
-    const beforeFormatting = resolvedRunFormatting(docxRunPropertySources(paragraphProperties, parsed.properties, styles, contextualProperties), theme, runText);
+    const beforeFormatting = resolvedRunFormatting(docxRunPropertySources(paragraphProperties, parsed.properties, styles, contextualProperties), theme, runText, requestedFontSlot);
     return {
         id: `docx-format-change-${parsed.id}`,
         author: parsed.author,
@@ -6886,7 +7288,14 @@ function importedRunFormattingChange(runProperties, paragraphProperties, styles,
         before: importedDocumentCharacterFormatting({
             ...beforeFormatting,
             themeColor: serializeDocxThemeReference(beforeFormatting.themeColor ?? null),
-            themeFill: serializeDocxThemeReference(beforeFormatting.themeFill ?? null)
+            themeFill: serializeDocxThemeReference(beforeFormatting.themeFill ?? null),
+            scriptFonts: beforeFormatting.scriptFonts,
+            scriptFontSlot: beforeFormatting.scriptFontSlot,
+            textCase: beforeFormatting.textCase,
+            legacyTextOutline: beforeFormatting.legacyTextOutline,
+            legacyTextShadow: beforeFormatting.legacyTextShadow,
+            legacyTextEmboss: beforeFormatting.legacyTextEmboss,
+            legacyTextImprint: beforeFormatting.legacyTextImprint
         })
     };
 }
@@ -6942,8 +7351,8 @@ function work_docx_run_formatting_import_normalizeRevisionDate(value) {
 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));
+    const tint = work_docx_run_formatting_import_normalizedByteHex(work_docx_run_formatting_import_wordAttribute(element, tintName));
+    const shade = work_docx_run_formatting_import_normalizedByteHex(work_docx_run_formatting_import_wordAttribute(element, shadeName));
     return {
         theme,
         resolved,
@@ -6955,27 +7364,35 @@ function work_docx_run_formatting_import_themeReference(element, themeName, tint
         } : {}
     };
 }
-function normalizedByteHex(value) {
+function work_docx_run_formatting_import_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 overriddenValue(current, next) {
+    return void 0 === next ? current : next;
+}
+function propertySourcesUseComplexScript(propertySources) {
+    let complexScript;
+    let rightToLeft;
+    for (const properties of propertySources){
+        complexScript = overriddenBoolean(complexScript, onOffProperty(properties, 'cs'));
+        rightToLeft = overriddenBoolean(rightToLeft, onOffProperty(properties, 'rtl'));
+    }
+    return true === complexScript || true === rightToLeft;
+}
 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) {
+function underlineProperty(properties, theme) {
     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('');
+    return importedDocxUnderline(element, theme);
 }
 function work_docx_run_formatting_import_closestAncestor(element, localName) {
     let current = element.parentElement;
@@ -6985,69 +7402,14 @@ function work_docx_run_formatting_import_closestAncestor(element, localName) {
     }
     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'
-        ]
+function defaultThemeFontFamily(theme, preferred) {
+    const fonts = {
+        ascii: docxThemeFont(theme, 'minorAscii'),
+        highAnsi: docxThemeFont(theme, 'minorHAnsi'),
+        eastAsia: docxThemeFont(theme, 'minorEastAsia'),
+        complexScript: docxThemeFont(theme, 'minorBidi')
     };
-    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;
+    return uniqueFonts(documentScriptFontFallbackSlots(preferred).map((slot)=>fonts[slot]));
 }
 function uniqueFonts(values) {
     const fonts = [
@@ -7096,4 +7458,4 @@ function work_docx_run_formatting_import_formatNumber(value) {
 function formatLineHeightFactor(value) {
     return Number(value.toFixed(4)).toString();
 }
-export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphAlignmentMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphFormattingChangeMarkers, applyImportedDocxParagraphIndentMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxParagraphSpacingMarkers, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxRunFormattingMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxTableCellStyleLayers, docxTablePropertySources, hasImportedDocxParagraphAlignmentMarkers, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphIndentMarkers, hasImportedDocxParagraphPaginationMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphTabStopMarkers, hasImportedDocxRunFormattingMarkers, hasInvalidDocxFieldStructure, inspectDocxEquation, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormatting, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxParagraphBordersForParagraph, resolveDocxTableStyleResolver };
+export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphAlignmentMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphFormattingChangeMarkers, applyImportedDocxParagraphIndentMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxParagraphSpacingMarkers, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxRunFormattingMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, createImportedDocxRunFormattingMarkerState, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxRunPropertySources, docxTableCellStyleLayers, docxTablePropertySources, docxTableRunPropertySources, hasImportedDocxParagraphAlignmentMarkers, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphIndentMarkers, hasImportedDocxParagraphPaginationMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphTabStopMarkers, hasImportedDocxRunFormattingMarkers, hasInvalidDocxFieldStructure, importedDocxStrike, importedDocxUnderline, inspectDocxEquation, inspectDocxHiddenText, inspectDocxLegacyTextEffects, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, inspectDocxRunFonts, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormattingIntoState, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxHiddenText, resolveDocxLegacyTextEffects, resolveDocxParagraphBordersForParagraph, resolveDocxTableStyleResolver };