@a3s-lab/office 0.26.0 → 0.28.0

package/dist/6282.js

@@ -7,11 +7,12 @@ import extension_color from "@tiptap/extension-color";
 import { Table, TableCell, TableHeader, TableKit, TableRow, TableView, createTable } from "@tiptap/extension-table";
 import extension_text_align from "@tiptap/extension-text-align";
 import font_size from "@tiptap/extension-text-style/font-size";
-import extension_underline from "@tiptap/extension-underline";
 import starter_kit from "@tiptap/starter-kit";
 import { DOMParser as model_DOMParser, Fragment, Slice } from "@tiptap/pm/model";
 import jszip from "jszip";
 import { closeHistory, isHistoryTransaction } from "@tiptap/pm/history";
+import extension_underline from "@tiptap/extension-underline";
+import extension_strike from "@tiptap/extension-strike";
 import extension_subscript from "@tiptap/extension-subscript";
 import extension_superscript from "@tiptap/extension-superscript";
 import { Decoration, DecorationSet } from "@tiptap/pm/view";
@@ -2297,6 +2298,15 @@ function themePatchTargets(localName) {
             shadeAttribute: 'themeShade'
         }
     ];
+    if ('u' === localName) return [
+        {
+            kind: 'underline',
+            directAttribute: 'color',
+            themeAttribute: 'themeColor',
+            tintAttribute: 'themeTint',
+            shadeAttribute: 'themeShade'
+        }
+    ];
     if ('shd' === localName) return [
         {
             kind: 'fill',
@@ -3581,6 +3591,104 @@ function work_document_page_margins_roundFour(value) {
 function normalizeNegativeZero(value) {
     return Object.is(value, -0) ? 0 : value;
 }
+const DOCUMENT_CHARACTER_SCALE_ATTRIBUTE = 'data-office-character-scale-percent';
+const DOCUMENT_CHARACTER_SCALE_MIN_PERCENT = 1;
+const DOCUMENT_CHARACTER_SCALE_MAX_PERCENT = 600;
+function normalizeDocumentCharacterScalePercent(value) {
+    if (null == value || '' === value) return null;
+    const scale = Number(value);
+    return Number.isSafeInteger(scale) && scale >= DOCUMENT_CHARACTER_SCALE_MIN_PERCENT && scale <= DOCUMENT_CHARACTER_SCALE_MAX_PERCENT ? scale : null;
+}
+function documentCharacterScaleDomAttributes(value) {
+    const scale = normalizeDocumentCharacterScalePercent(value);
+    if (null === scale) return {};
+    return {
+        [DOCUMENT_CHARACTER_SCALE_ATTRIBUTE]: String(scale),
+        style: `font-stretch: ${scale}%`
+    };
+}
+function documentCharacterScalePercentFromElement(element) {
+    if (element.hasAttribute(DOCUMENT_CHARACTER_SCALE_ATTRIBUTE)) return normalizeDocumentCharacterScalePercent(element.getAttribute(DOCUMENT_CHARACTER_SCALE_ATTRIBUTE));
+    return documentCharacterScalePercentFromCss(element.style.fontStretch);
+}
+function documentCharacterScalePercentFromCss(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim().toLowerCase();
+    if (!source || 'normal' === source) return null;
+    const match = /^(\d+(?:\.\d*)?|\.\d+)%$/u.exec(source);
+    if (!match) return null;
+    return normalizeDocumentCharacterScalePercent(Number(match[1]));
+}
+const DOCUMENT_EMPHASIS_MARK_ATTRIBUTE = 'data-office-emphasis-mark';
+const DOCUMENT_EMPHASIS_MARKS = [
+    'none',
+    'dot',
+    'comma',
+    'circle',
+    'underDot'
+];
+const DOCUMENT_EMPHASIS_MARK_SET = new Set(DOCUMENT_EMPHASIS_MARKS);
+function normalizeDocumentEmphasisMark(value) {
+    return 'string' == typeof value && DOCUMENT_EMPHASIS_MARK_SET.has(value) ? value : null;
+}
+function documentEmphasisMarkCss(value) {
+    const emphasisMark = normalizeDocumentEmphasisMark(value);
+    if (!emphasisMark) return '';
+    if ('none' === emphasisMark) return 'text-emphasis-style:none;-webkit-text-emphasis-style:none';
+    const style = 'comma' === emphasisMark ? '","' : 'circle' === emphasisMark ? 'open circle' : 'filled dot';
+    const position = 'underDot' === emphasisMark ? 'under right' : 'over right';
+    return `text-emphasis-style:${style};text-emphasis-position:${position};-webkit-text-emphasis-style:${style};-webkit-text-emphasis-position:${position}`;
+}
+function documentEmphasisMarkDomAttributes(value) {
+    const emphasisMark = normalizeDocumentEmphasisMark(value);
+    if (!emphasisMark) return {};
+    return {
+        [DOCUMENT_EMPHASIS_MARK_ATTRIBUTE]: emphasisMark,
+        style: documentEmphasisMarkCss(emphasisMark)
+    };
+}
+function documentEmphasisMarkFromElement(element) {
+    return element.hasAttribute(DOCUMENT_EMPHASIS_MARK_ATTRIBUTE) ? normalizeDocumentEmphasisMark(element.getAttribute(DOCUMENT_EMPHASIS_MARK_ATTRIBUTE)) : null;
+}
+const DOCUMENT_KERNING_THRESHOLD_ATTRIBUTE = 'data-office-kerning-threshold-half-points';
+const DOCUMENT_KERNING_THRESHOLD_MIN_HALF_POINTS = 0;
+const DOCUMENT_KERNING_THRESHOLD_MAX_HALF_POINTS = 3277;
+const DOCUMENT_DEFAULT_FONT_SIZE_POINTS = 10.5;
+function normalizeDocumentKerningThresholdHalfPoints(value) {
+    const threshold = 'number' == typeof value ? value : 'string' == typeof value && /^\+?\d+$/u.test(value.trim()) ? Number(value.trim()) : NaN;
+    if (!Number.isSafeInteger(threshold) || threshold < DOCUMENT_KERNING_THRESHOLD_MIN_HALF_POINTS || threshold > DOCUMENT_KERNING_THRESHOLD_MAX_HALF_POINTS) return null;
+    return Object.is(threshold, -0) ? 0 : threshold;
+}
+function documentKerningThresholdPoints(value) {
+    const threshold = normalizeDocumentKerningThresholdHalfPoints(value);
+    return null === threshold ? null : threshold / 2;
+}
+function documentKerningIsEffective(thresholdValue, fontSizeValue) {
+    const threshold = normalizeDocumentKerningThresholdHalfPoints(thresholdValue);
+    if (null === threshold) return false;
+    if (0 === threshold) return true;
+    return 2 * documentKerningFontSizePoints(fontSizeValue) >= threshold;
+}
+function documentKerningDomAttributes(thresholdValue, fontSizeValue) {
+    const threshold = normalizeDocumentKerningThresholdHalfPoints(thresholdValue);
+    if (null === threshold) return {};
+    return {
+        [DOCUMENT_KERNING_THRESHOLD_ATTRIBUTE]: String(threshold),
+        style: `font-kerning: ${documentKerningIsEffective(threshold, fontSizeValue) ? 'normal' : 'none'}`
+    };
+}
+function documentKerningThresholdHalfPointsFromElement(element) {
+    return element.hasAttribute(DOCUMENT_KERNING_THRESHOLD_ATTRIBUTE) ? normalizeDocumentKerningThresholdHalfPoints(element.getAttribute(DOCUMENT_KERNING_THRESHOLD_ATTRIBUTE)) : null;
+}
+function documentKerningFontSizePoints(value) {
+    if ('number' == typeof value) return Number.isFinite(value) && value > 0 ? value : DOCUMENT_DEFAULT_FONT_SIZE_POINTS;
+    if ('string' != typeof value) return DOCUMENT_DEFAULT_FONT_SIZE_POINTS;
+    const match = /^(\d+(?:\.\d*)?|\.\d+)(pt|px)?$/iu.exec(value.trim());
+    if (!match) return DOCUMENT_DEFAULT_FONT_SIZE_POINTS;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || amount <= 0) return DOCUMENT_DEFAULT_FONT_SIZE_POINTS;
+    return match[2]?.toLowerCase() === 'px' ? 0.75 * amount : amount;
+}
 const EQUATION_SELECTOR = 'span[data-document-equation]';
 const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
 const MAX_EQUATION_DEPTH = 32;
@@ -3833,13 +3941,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',
@@ -3851,8 +3952,6 @@ const MAX_EQUATION_WORD_FONT_LENGTH = 127;
 const MAX_EQUATION_LANGUAGE_LENGTH = 85;
 const MAX_EQUATION_FONT_SIZE = 512;
 const MAX_EQUATION_CHARACTER_SPACING_TWIPS = 31680;
-const MAX_EQUATION_CHARACTER_SCALE_PERCENT = 600;
-const MAX_EQUATION_KERNING_THRESHOLD_HALF_POINTS = 3277;
 const MIN_EQUATION_WORD_LINE_BORDER_EIGHTH_POINTS = 2;
 const MAX_EQUATION_WORD_LINE_BORDER_EIGHTH_POINTS = 96;
 const MAX_EQUATION_WORD_BORDER_SPACING_POINTS = 31;
@@ -5667,7 +5766,7 @@ function normalizeEquationWordRunProperties(source) {
     const shading = void 0 === source.shading ? void 0 : normalizeEquationWordShading(source.shading);
     const fitText = void 0 === source.fitText ? void 0 : normalizeEquationWordFitText(source.fitText);
     const verticalAlignment = void 0 === source.verticalAlignment ? void 0 : WORD_VERTICAL_ALIGNMENTS.has(source.verticalAlignment) ? source.verticalAlignment : null;
-    const emphasisMark = void 0 === source.emphasisMark ? void 0 : WORD_EMPHASIS_MARKS.has(source.emphasisMark) ? source.emphasisMark : null;
+    const emphasisMark = void 0 === source.emphasisMark ? void 0 : normalizeDocumentEmphasisMark(source.emphasisMark);
     const languages = void 0 === source.languages ? void 0 : normalizeEquationWordLanguages(source.languages);
     const eastAsianLayout = void 0 === source.eastAsianLayout ? void 0 : normalizeEquationWordEastAsianLayout(source.eastAsianLayout);
     const glow = void 0 === source.glow ? void 0 : normalizeEquationWordGlow(source.glow);
@@ -5682,8 +5781,8 @@ function normalizeEquationWordRunProperties(source) {
     const numberSpacing = void 0 === source.numberSpacing ? void 0 : WORD_NUMBER_SPACINGS.has(source.numberSpacing) ? source.numberSpacing : null;
     const stylisticSets = void 0 === source.stylisticSets ? void 0 : normalizeEquationWordStylisticSets(source.stylisticSets);
     const characterSpacingTwips = void 0 === source.characterSpacingTwips ? void 0 : normalizeEquationInteger(source.characterSpacingTwips, -MAX_EQUATION_CHARACTER_SPACING_TWIPS, MAX_EQUATION_CHARACTER_SPACING_TWIPS);
-    const characterScalePercent = void 0 === source.characterScalePercent ? void 0 : normalizeEquationInteger(source.characterScalePercent, 1, MAX_EQUATION_CHARACTER_SCALE_PERCENT);
-    const kerningThresholdHalfPoints = void 0 === source.kerningThresholdHalfPoints ? void 0 : normalizeEquationInteger(source.kerningThresholdHalfPoints, 0, MAX_EQUATION_KERNING_THRESHOLD_HALF_POINTS);
+    const characterScalePercent = void 0 === source.characterScalePercent ? void 0 : 'number' == typeof source.characterScalePercent ? normalizeDocumentCharacterScalePercent(source.characterScalePercent) : null;
+    const kerningThresholdHalfPoints = void 0 === source.kerningThresholdHalfPoints ? void 0 : 'number' == typeof source.kerningThresholdHalfPoints ? normalizeDocumentKerningThresholdHalfPoints(source.kerningThresholdHalfPoints) : null;
     const positionHalfPoints = void 0 === source.positionHalfPoints ? void 0 : normalizeEquationInteger(source.positionHalfPoints, MIN_EQUATION_POSITION_HALF_POINTS, MAX_EQUATION_POSITION_HALF_POINTS);
     const fontSize = void 0 === source.fontSize ? void 0 : normalizeEquationFontSize(source.fontSize);
     const fontSizeComplexScript = void 0 === source.fontSizeComplexScript ? void 0 : normalizeEquationFontSize(source.fontSizeComplexScript);
@@ -6592,11 +6691,7 @@ function wordRunVerticalAlignmentStyles(alignment) {
     return `vertical-align:${"superscript" === alignment ? 'super' : 'sub'};font-size:smaller`;
 }
 function wordRunEmphasisMarkStyles(emphasisMark) {
-    if (!emphasisMark) return '';
-    if ('none' === emphasisMark) return 'text-emphasis-style:none';
-    const style = 'comma' === emphasisMark ? cssString(',') : 'circle' === emphasisMark ? 'open circle' : 'filled dot';
-    const position = 'underDot' === emphasisMark ? 'under right' : 'over right';
-    return `text-emphasis-style:${style};text-emphasis-position:${position}`;
+    return documentEmphasisMarkCss(emphasisMark);
 }
 function wordRunCaseStyles(properties) {
     return [
@@ -6705,6 +6800,207 @@ function validXmlText(source) {
 function work_document_equations_isRecord(source) {
     return Boolean(source) && 'object' == typeof source && !Array.isArray(source);
 }
+const DOCUMENT_CHARACTER_POSITION_ATTRIBUTE = 'data-office-character-position-half-points';
+const DOCUMENT_CHARACTER_POSITION_CSS_PROPERTY = '--work-document-character-position';
+const DOCUMENT_CHARACTER_POSITION_MAX_HALF_POINTS = 3168;
+const DOCUMENT_CHARACTER_POSITION_MIN_HALF_POINTS = -DOCUMENT_CHARACTER_POSITION_MAX_HALF_POINTS;
+function normalizeDocumentCharacterPositionHalfPoints(value) {
+    if (null == value || '' === value) return null;
+    const position = Number(value);
+    if (!Number.isSafeInteger(position) || position < DOCUMENT_CHARACTER_POSITION_MIN_HALF_POINTS || position > DOCUMENT_CHARACTER_POSITION_MAX_HALF_POINTS) return null;
+    return Object.is(position, -0) ? 0 : position;
+}
+function documentCharacterPositionDomAttributes(value) {
+    const position = normalizeDocumentCharacterPositionHalfPoints(value);
+    if (null === position) return {};
+    return {
+        [DOCUMENT_CHARACTER_POSITION_ATTRIBUTE]: String(position),
+        style: `${DOCUMENT_CHARACTER_POSITION_CSS_PROPERTY}: ${formatCharacterPositionPoints(position)}pt`
+    };
+}
+function documentCharacterPositionHalfPointsFromElement(element) {
+    if (element.hasAttribute(DOCUMENT_CHARACTER_POSITION_ATTRIBUTE)) return normalizeDocumentCharacterPositionHalfPoints(element.getAttribute(DOCUMENT_CHARACTER_POSITION_ATTRIBUTE));
+    return documentCharacterPositionHalfPointsFromCss(element.style.getPropertyValue(DOCUMENT_CHARACTER_POSITION_CSS_PROPERTY)) ?? documentCharacterPositionHalfPointsFromCss(element.style.verticalAlign);
+}
+function documentCharacterPositionHalfPointsFromCss(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim().toLowerCase();
+    if (!source || 'baseline' === source) return null;
+    const match = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+))(pt|px)?$/.exec(source);
+    if (!match) return null;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount)) return null;
+    const unit = match[2];
+    if (!unit && 0 !== amount) return null;
+    const halfPoints = Math.round(amount * ('px' === unit ? 1.5 : 2));
+    return normalizeDocumentCharacterPositionHalfPoints(halfPoints);
+}
+function documentCharacterPositionPoints(value) {
+    const position = normalizeDocumentCharacterPositionHalfPoints(value);
+    return null === position ? null : position / 2;
+}
+function formatCharacterPositionPoints(value) {
+    return String(value / 2);
+}
+const DOCUMENT_CHARACTER_SPACING_ATTRIBUTE = 'data-office-character-spacing-twips';
+const DOCUMENT_CHARACTER_SPACING_MAX_TWIPS = 31680;
+const DOCUMENT_CHARACTER_SPACING_MIN_TWIPS = -DOCUMENT_CHARACTER_SPACING_MAX_TWIPS;
+function normalizeDocumentCharacterSpacingTwips(value) {
+    if (null == value || '' === value) return null;
+    const spacing = Number(value);
+    if (!Number.isSafeInteger(spacing) || spacing < DOCUMENT_CHARACTER_SPACING_MIN_TWIPS || spacing > DOCUMENT_CHARACTER_SPACING_MAX_TWIPS) return null;
+    return Object.is(spacing, -0) ? 0 : spacing;
+}
+function documentCharacterSpacingDomAttributes(value) {
+    const spacing = normalizeDocumentCharacterSpacingTwips(value);
+    if (null === spacing) return {};
+    return {
+        [DOCUMENT_CHARACTER_SPACING_ATTRIBUTE]: String(spacing),
+        style: `letter-spacing: ${formatCharacterSpacingPoints(spacing)}pt`
+    };
+}
+function documentCharacterSpacingTwipsFromElement(element) {
+    if (element.hasAttribute(DOCUMENT_CHARACTER_SPACING_ATTRIBUTE)) return normalizeDocumentCharacterSpacingTwips(element.getAttribute(DOCUMENT_CHARACTER_SPACING_ATTRIBUTE));
+    return documentCharacterSpacingTwipsFromCss(element.style.letterSpacing);
+}
+function documentCharacterSpacingTwipsFromCss(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim().toLowerCase();
+    if (!source || 'normal' === source) return null;
+    const match = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+))(pt|px)?$/.exec(source);
+    if (!match) return null;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount)) return null;
+    const unit = match[2];
+    if (!unit && 0 !== amount) return null;
+    const twips = Math.round(amount * ('px' === unit ? 15 : 20));
+    return normalizeDocumentCharacterSpacingTwips(twips);
+}
+function documentCharacterSpacingPoints(value) {
+    const spacing = normalizeDocumentCharacterSpacingTwips(value);
+    return null === spacing ? null : spacing / 20;
+}
+function formatCharacterSpacingPoints(value) {
+    return String(value / 20);
+}
+const DOCUMENT_HIDDEN_TEXT_ATTRIBUTE = 'data-office-hidden-text';
+const documentHiddenTextKeyboardShortcut = 'Mod-Shift-h';
+function normalizeDocumentHiddenText(value) {
+    if (true === value || 'true' === value || '1' === value) return true;
+    if (false === value || 'false' === value || '0' === value) return false;
+    return null;
+}
+function documentHiddenTextFromElement(element) {
+    return normalizeDocumentHiddenText(element.getAttribute(DOCUMENT_HIDDEN_TEXT_ATTRIBUTE));
+}
+function documentHiddenTextDomAttributes(value) {
+    const hiddenText = normalizeDocumentHiddenText(value);
+    return null === hiddenText ? {} : {
+        [DOCUMENT_HIDDEN_TEXT_ATTRIBUTE]: String(hiddenText)
+    };
+}
+const DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE = 'data-office-legacy-text-outline';
+const DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE = 'data-office-legacy-text-shadow';
+const DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE = 'data-office-legacy-text-emboss';
+const DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE = 'data-office-legacy-text-imprint';
+const DOCUMENT_LEGACY_TEXT_EFFECT_NAMES = [
+    'outline',
+    'shadow',
+    'emboss',
+    'imprint'
+];
+const ATTRIBUTE_BY_EFFECT = {
+    outline: DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE,
+    shadow: DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE,
+    emboss: DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE,
+    imprint: DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE
+};
+const TEXT_STYLE_ATTRIBUTE_BY_EFFECT = {
+    outline: 'legacyTextOutline',
+    shadow: 'legacyTextShadow',
+    emboss: 'legacyTextEmboss',
+    imprint: 'legacyTextImprint'
+};
+function normalizeDocumentLegacyTextEffect(value) {
+    if (true === value || 'true' === value || '1' === value) return true;
+    if (false === value || 'false' === value || '0' === value) return false;
+    return null;
+}
+function normalizeDocumentLegacyTextEffects(value) {
+    if (!work_document_legacy_text_effects_isRecord(value)) return null;
+    const allowed = new Set(DOCUMENT_LEGACY_TEXT_EFFECT_NAMES);
+    if (Object.keys(value).some((key)=>!allowed.has(key))) return null;
+    const effects = {};
+    for (const name of DOCUMENT_LEGACY_TEXT_EFFECT_NAMES)if (Object.hasOwn(value, name)) {
+        if ('boolean' != typeof value[name]) return null;
+        effects[name] = value[name];
+    }
+    return documentLegacyTextEffectsConflict(effects) ? null : effects;
+}
+function documentLegacyTextEffectsConflict(effects) {
+    if (true === effects.emboss && (true === effects.outline || true === effects.shadow || true === effects.imprint)) return true;
+    return true === effects.imprint && (true === effects.outline || true === effects.shadow || true === effects.emboss);
+}
+function documentLegacyTextEffectFromElement(element, effect) {
+    return normalizeDocumentLegacyTextEffect(element.getAttribute(ATTRIBUTE_BY_EFFECT[effect]));
+}
+function documentLegacyTextEffectsFromElement(element) {
+    const effects = {};
+    for (const name of DOCUMENT_LEGACY_TEXT_EFFECT_NAMES){
+        const attribute = ATTRIBUTE_BY_EFFECT[name];
+        const value = documentLegacyTextEffectFromElement(element, name);
+        if (element.hasAttribute(attribute) && null === value) return null;
+        if (null !== value) effects[name] = value;
+    }
+    return documentLegacyTextEffectsConflict(effects) ? null : effects;
+}
+function documentLegacyTextEffectsFromTextStyleAttributes(attributes) {
+    const effects = {};
+    for (const name of DOCUMENT_LEGACY_TEXT_EFFECT_NAMES){
+        const rawValue = attributes[TEXT_STYLE_ATTRIBUTE_BY_EFFECT[name]];
+        if (null == rawValue) continue;
+        const value = normalizeDocumentLegacyTextEffect(rawValue);
+        if (null === value) return null;
+        if (null !== value) effects[name] = value;
+    }
+    return documentLegacyTextEffectsConflict(effects) ? null : effects;
+}
+function documentLegacyTextEffectsDomAttributes(value) {
+    const effects = normalizeDocumentLegacyTextEffects(value);
+    if (!effects) return {};
+    return Object.fromEntries(DOCUMENT_LEGACY_TEXT_EFFECT_NAMES.flatMap((name)=>void 0 === effects[name] ? [] : [
+            [
+                ATTRIBUTE_BY_EFFECT[name],
+                String(effects[name])
+            ]
+        ]));
+}
+function documentLegacyTextEffectsCss(value) {
+    const effects = normalizeDocumentLegacyTextEffects(value);
+    if (!effects) return {};
+    if (effects.emboss) return {
+        textShadow: '-0.045em -0.045em 0 rgba(255, 255, 255, 0.9), 0.045em 0.045em 0 rgba(0, 0, 0, 0.52)'
+    };
+    if (effects.imprint) return {
+        textShadow: '0.045em 0.045em 0 rgba(255, 255, 255, 0.9), -0.045em -0.045em 0 rgba(0, 0, 0, 0.52)'
+    };
+    return {
+        ...effects.outline ? {
+            WebkitTextFillColor: 'transparent',
+            WebkitTextStroke: '0.045em currentColor',
+            paintOrder: 'stroke fill'
+        } : {},
+        ...effects.shadow ? {
+            textShadow: '0.08em 0.08em 0 currentColor'
+        } : {}
+    };
+}
+function documentLegacyTextStyleAttributeName(effect) {
+    return TEXT_STYLE_ATTRIBUTE_BY_EFFECT[effect];
+}
+function work_document_legacy_text_effects_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
 const IMAGE_OBJECT_ID_PATTERN = /^[0-9A-F]{8}$/;
 const MAX_DOC_PROPERTIES_ID = 0xffffffff;
 const MAX_WORDPROCESSING_ID = 0x7fffffff;
@@ -7714,154 +8010,897 @@ function work_document_table_row_identity_transactionMapping(transactions) {
     for (const transaction of transactions)mapping.appendMapping(transaction.mapping);
     return mapping;
 }
-const EMPTY_CONTENT = {
-    headerHtml: '',
-    footerHtml: '',
-    showPageNumber: false
+const DOCUMENT_TEXT_CASE_ATTRIBUTE = 'data-office-text-case';
+const documentTextCaseKeyboardShortcuts = {
+    allCaps: 'Mod-Shift-a',
+    smallCaps: 'Mod-Shift-k'
 };
-const IMAGE_IDENTITY_ATTRIBUTES = [
-    'data-office-image-object-id',
-    'data-office-image-doc-properties-id',
-    'data-office-image-anchor-id',
-    'data-office-image-edit-id'
-];
-const PARAGRAPH_IDENTITY_ATTRIBUTES = [
-    DOCUMENT_PARAGRAPH_ID_ATTRIBUTE,
-    DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE
-];
-const PARAGRAPH_DEFAULT_COLLAPSED_ATTRIBUTE = 'data-office-default-collapsed';
-const PARAGRAPH_BORDERS_ATTRIBUTE = DOCUMENT_PARAGRAPH_BORDERS_ATTRIBUTE;
-const PARAGRAPH_SHADING_ATTRIBUTE = 'data-office-paragraph-shading';
-const TABLE_ROW_IDENTITY_ATTRIBUTES = [
-    DOCUMENT_TABLE_ROW_ID_ATTRIBUTE,
-    DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE
-];
-const EQUATION_ATTRIBUTES = [
-    'aria-label',
-    'class',
-    'contenteditable',
-    'data-document-equation',
-    'data-equation-display',
-    'data-equation-model',
-    'role'
-];
-const MATHML_ATTRIBUTES = new Set([
-    'accent',
-    'accentunder',
-    'align',
-    'bevelled',
-    'columnalign',
-    'depth',
-    'dir',
-    'display',
-    'fence',
-    'height',
-    'lang',
-    'linethickness',
-    'mathbackground',
-    'mathcolor',
-    'mathsize',
-    'mathvariant',
-    'notation',
-    'rowspacing',
-    "scriptlevel",
-    'separator',
-    'style',
-    'width',
-    'xmlns'
+function normalizeDocumentTextCase(value) {
+    return 'none' === value || 'all-caps' === value || 'small-caps' === value ? value : null;
+}
+function documentTextCaseFromWordFlags(allCaps, smallCaps) {
+    if (void 0 === allCaps && void 0 === smallCaps) return null;
+    if (allCaps) return 'all-caps';
+    if (smallCaps) return 'small-caps';
+    return 'none';
+}
+function applyDocumentTextCaseStyle(element, textCase) {
+    element.dataset.officeTextCase = textCase;
+    element.style.textTransform = 'all-caps' === textCase ? 'uppercase' : 'none';
+    element.style.fontVariantCaps = 'small-caps' === textCase ? 'small-caps' : 'normal';
+}
+function documentTextCaseCss(textCase) {
+    return [
+        `text-transform: ${'all-caps' === textCase ? 'uppercase' : 'none'}`,
+        `font-variant-caps: ${'small-caps' === textCase ? 'small-caps' : 'normal'}`
+    ].join('; ');
+}
+const DOCUMENT_SCRIPT_FONTS_ATTRIBUTE = "data-office-script-fonts";
+const DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE = "data-office-script-font-slot";
+const MAX_FONT_NAME_LENGTH = 127;
+const MAX_SERIALIZED_SCRIPT_FONTS_LENGTH = 4096;
+const SCRIPT_FONT_KEYS = new Set([
+    'ascii',
+    'highAnsi',
+    'eastAsia',
+    'complexScript',
+    'hint'
 ]);
-const work_document_page_chrome_MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
-const MATHML_TAGS = new Set([
-    'math',
-    'maligngroup',
-    'malignmark',
-    'menclose',
-    'mfrac',
-    "mmultiscripts",
-    'mo',
-    'mover',
-    'mpadded',
-    'mphantom',
-    "mprescripts",
-    'mroot',
-    'mrow',
-    'msqrt',
-    'msub',
-    'msubsup',
-    'msup',
-    'mstyle',
-    'mtable',
-    'mtd',
-    'mtext',
-    'mtr',
-    'munder',
-    'munderover',
-    'none'
+const SCRIPT_FONT_FACE_KEYS = new Set([
+    'name',
+    'theme',
+    'resolved'
 ]);
-const ALLOWED_TAGS = new Set([
-    'a',
-    'b',
-    'blockquote',
-    'br',
-    'div',
-    'em',
-    'i',
-    'img',
-    'li',
-    'math',
-    'maligngroup',
-    'malignmark',
-    'menclose',
-    'mfrac',
-    "mmultiscripts",
-    'mo',
-    'mover',
-    'mpadded',
-    'mphantom',
-    "mprescripts",
-    'mroot',
-    'mrow',
-    'msqrt',
-    'msub',
-    'msubsup',
-    'msup',
-    'mstyle',
-    'mtable',
-    'mtd',
-    'mtext',
-    'mtr',
-    'munder',
-    'munderover',
-    'none',
-    'ol',
-    'p',
-    's',
-    'span',
-    'strike',
-    'strong',
-    'sub',
-    'sup',
-    'table',
-    'tbody',
-    'td',
-    'th',
-    'thead',
-    'tr',
-    'u',
-    'ul'
+const SCRIPT_FONT_HINTS = new Set([
+    'default',
+    'eastAsia',
+    'cs'
 ]);
-function normalizeDocumentPageChrome(source, legacy = {}) {
-    const defaultContent = normalizePageChromeContent(source?.default, {
-        headerHtml: plainTextToPageChromeHtml(legacy.headerText),
-        footerHtml: plainTextToPageChromeHtml(legacy.footerText),
-        showPageNumber: Boolean(legacy.showPageNumbers)
-    });
-    return {
-        differentFirstPage: Boolean(source?.differentFirstPage),
-        differentOddEvenPages: Boolean(source?.differentOddEvenPages),
-        default: defaultContent,
-        first: normalizePageChromeContent(source?.first, EMPTY_CONTENT),
-        even: normalizePageChromeContent(source?.even, EMPTY_CONTENT)
+const work_document_script_fonts_THEME_FONTS = new Set([
+    'majorEastAsia',
+    'majorBidi',
+    'majorAscii',
+    'majorHAnsi',
+    'minorEastAsia',
+    'minorBidi',
+    'minorAscii',
+    'minorHAnsi'
+]);
+const SLOT_FALLBACK_ORDER = {
+    ascii: [
+        'ascii',
+        'highAnsi',
+        'eastAsia',
+        'complexScript'
+    ],
+    highAnsi: [
+        'highAnsi',
+        'ascii',
+        'eastAsia',
+        'complexScript'
+    ],
+    eastAsia: [
+        'eastAsia',
+        'highAnsi',
+        'ascii',
+        'complexScript'
+    ],
+    complexScript: [
+        'complexScript',
+        'highAnsi',
+        'ascii',
+        'eastAsia'
+    ]
+};
+const NEUTRAL_SCRIPT_CHARACTER = /^[\p{Cc}\p{Cf}\p{M}\p{N}\p{P}\p{S}\p{Z}]$/u;
+function normalizeDocumentScriptFonts(source) {
+    if (!work_document_script_fonts_isRecordWithKeys(source, SCRIPT_FONT_KEYS)) return null;
+    const normalized = {};
+    for (const slot of scriptFontSlots){
+        if (void 0 === source[slot]) continue;
+        const face = normalizeDocumentScriptFontFace(source[slot]);
+        if (!face) return null;
+        normalized[slot] = face;
+    }
+    if (void 0 !== source.hint) {
+        const hint = normalizeDocumentScriptFontHint(source.hint);
+        if (!hint) return null;
+        normalized.hint = hint;
+    }
+    return Object.keys(normalized).length ? normalized : null;
+}
+function serializeDocumentScriptFonts(source) {
+    const fonts = normalizeDocumentScriptFonts(source);
+    return fonts ? JSON.stringify(fonts) : null;
+}
+function parseDocumentScriptFonts(source) {
+    if (!source || source.length > MAX_SERIALIZED_SCRIPT_FONTS_LENGTH) return null;
+    try {
+        return normalizeDocumentScriptFonts(JSON.parse(source));
+    } catch  {
+        return null;
+    }
+}
+function documentScriptFontsFromElement(element) {
+    return parseDocumentScriptFonts(element.getAttribute(DOCUMENT_SCRIPT_FONTS_ATTRIBUTE));
+}
+function documentScriptFontSlotFromElement(element) {
+    return normalizeDocumentScriptFontSlot(element.getAttribute(DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE));
+}
+function documentScriptFontsDomAttributes(source, slot) {
+    const fonts = normalizeDocumentScriptFonts(source);
+    const normalizedSlot = normalizeDocumentScriptFontSlot(slot);
+    if (!fonts) return {};
+    const serialized = serializeDocumentScriptFonts(fonts);
+    if (!serialized) return {};
+    const family = documentScriptFontFamily(fonts, normalizedSlot ?? documentScriptFontSlotFromHint(fonts.hint));
+    return {
+        [DOCUMENT_SCRIPT_FONTS_ATTRIBUTE]: serialized,
+        ...normalizedSlot ? {
+            [DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE]: normalizedSlot
+        } : {},
+        ...family ? {
+            style: `font-family: ${family}`
+        } : {}
+    };
+}
+function documentScriptFontFamily(source, slot) {
+    const fonts = normalizeDocumentScriptFonts(source);
+    if (!fonts) return;
+    const families = [];
+    const seen = new Set();
+    for (const candidate of documentScriptFontFallbackSlots(slot)){
+        const family = documentScriptFontFaceFamily(fonts[candidate]);
+        const key = family?.toLocaleLowerCase();
+        if (!(!family || !key || seen.has(key))) {
+            seen.add(key);
+            families.push(cssFontFamily(family));
+        }
+    }
+    return families.length ? families.join(', ') : void 0;
+}
+function documentScriptFontFallbackSlots(slot) {
+    return SLOT_FALLBACK_ORDER[slot];
+}
+function documentScriptFontFamilyForRendering(source, slot, currentFontFamily) {
+    const projected = documentScriptFontFamily(source, slot);
+    const safeCurrent = safeCssFontFamilyList(currentFontFamily);
+    if (!safeCurrent || !projected) return projected;
+    const currentPrimary = documentFontNameFromCssFamily(safeCurrent);
+    const projectedPrimary = documentFontNameFromCssFamily(projected);
+    return currentPrimary && projectedPrimary && currentPrimary.toLocaleLowerCase() === projectedPrimary.toLocaleLowerCase() ? safeCurrent : projected;
+}
+function documentScriptFontDirectFamily(source, slot) {
+    const fonts = normalizeDocumentScriptFonts(source);
+    return fonts ? documentScriptFontFaceFamily(fonts[slot]) ?? null : null;
+}
+function documentScriptFontsForAllText(fontFamily) {
+    const name = documentFontNameFromCssFamily(fontFamily);
+    if (!name) return null;
+    const face = {
+        name,
+        resolved: name
+    };
+    return {
+        ascii: face,
+        highAnsi: face,
+        eastAsia: face,
+        complexScript: face,
+        hint: 'default'
+    };
+}
+function patchDocumentScriptFonts(source, patch, fallbackFontFamily) {
+    const current = normalizeDocumentScriptFonts(source) ?? documentScriptFontsForAllText(fallbackFontFamily) ?? {};
+    const next = {
+        ...current
+    };
+    if (void 0 !== patch.latin) {
+        const face = directFontFace(patch.latin);
+        if (face) {
+            next.ascii = face;
+            next.highAnsi = face;
+        } else {
+            delete next.ascii;
+            delete next.highAnsi;
+        }
+    }
+    if (void 0 !== patch.eastAsia) {
+        const face = directFontFace(patch.eastAsia);
+        if (face) next.eastAsia = face;
+        else delete next.eastAsia;
+    }
+    if (void 0 !== patch.complexScript) {
+        const face = directFontFace(patch.complexScript);
+        if (face) next.complexScript = face;
+        else delete next.complexScript;
+    }
+    return normalizeDocumentScriptFonts(next);
+}
+function documentScriptFontSegments(text, hint = 'default', forceComplexScript = false) {
+    if (!text) return [];
+    if (forceComplexScript) return [
+        {
+            from: 0,
+            to: text.length,
+            slot: 'complexScript'
+        }
+    ];
+    const characters = [];
+    let offset = 0;
+    for (const character of text){
+        const from = offset;
+        offset += character.length;
+        characters.push({
+            from,
+            to: offset,
+            slot: strongDocumentScriptFontSlot(character)
+        });
+    }
+    const fallback = documentScriptFontSlotFromHint(hint);
+    let previous = null;
+    for(let index = 0; index < characters.length; index += 1){
+        const entry = characters[index];
+        if (!entry) continue;
+        if (entry.slot) {
+            previous = entry.slot;
+            continue;
+        }
+        let next = previous;
+        if (!next) for(let cursor = index + 1; cursor < characters.length; cursor += 1){
+            const candidate = characters[cursor]?.slot;
+            if (candidate) {
+                next = candidate;
+                break;
+            }
+        }
+        entry.slot = next ?? fallback;
+    }
+    const segments = [];
+    for (const entry of characters){
+        const slot = entry.slot ?? fallback;
+        const prior = segments[segments.length - 1];
+        if (prior?.slot === slot && prior.to === entry.from) prior.to = entry.to;
+        else segments.push({
+            from: entry.from,
+            to: entry.to,
+            slot
+        });
+    }
+    return segments;
+}
+function normalizeDocumentScriptFontSlot(value) {
+    return scriptFontSlots.includes(value) ? value : null;
+}
+function normalizeDocumentScriptFontHint(value) {
+    return SCRIPT_FONT_HINTS.has(value) ? value : null;
+}
+function normalizeDocumentThemeFont(value) {
+    return work_document_script_fonts_THEME_FONTS.has(value) ? value : null;
+}
+function documentScriptFontSlotFromHint(hint) {
+    if ('eastAsia' === hint) return 'eastAsia';
+    if ('cs' === hint) return 'complexScript';
+    return 'ascii';
+}
+function documentFontNameFromCssFamily(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim();
+    if (!source) return null;
+    let family = '';
+    const quote = source[0];
+    if ('"' === quote || "'" === quote) {
+        let closed = false;
+        for(let index = 1; index < source.length; index += 1){
+            const character = source[index];
+            if (character === quote) {
+                closed = true;
+                break;
+            }
+            if ('\\' !== character) {
+                family += character;
+                continue;
+            }
+            const decoded = decodeCssEscape(source, index + 1);
+            if (!decoded) return null;
+            family += decoded.value;
+            index = decoded.end - 1;
+        }
+        if (!closed) return null;
+    } else family = source.split(',')[0] ?? '';
+    return normalizeDocumentFontName(family);
+}
+function cssDocumentFontFamily(value) {
+    const family = normalizeDocumentFontName(value);
+    return family ? cssFontFamily(family) : null;
+}
+function normalizeDocumentFontName(value) {
+    if ('string' != typeof value) return null;
+    const normalized = value.trim();
+    return normalized && normalized.length <= MAX_FONT_NAME_LENGTH && !/[\p{Cc}\p{Cs}]/u.test(normalized) ? normalized : null;
+}
+const scriptFontSlots = [
+    'ascii',
+    'highAnsi',
+    'eastAsia',
+    'complexScript'
+];
+function normalizeDocumentScriptFontFace(source) {
+    if (!work_document_script_fonts_isRecordWithKeys(source, SCRIPT_FONT_FACE_KEYS)) return null;
+    const name = void 0 === source.name ? void 0 : normalizeDocumentFontName(source.name);
+    const resolved = void 0 === source.resolved ? void 0 : normalizeDocumentFontName(source.resolved);
+    const theme = void 0 === source.theme ? void 0 : normalizeDocumentThemeFont(source.theme);
+    if (void 0 !== source.name && !name || void 0 !== source.resolved && !resolved || null === theme || !name && !theme && !resolved) return null;
+    return {
+        ...name ? {
+            name
+        } : {},
+        ...theme ? {
+            theme
+        } : {},
+        ...resolved ? {
+            resolved
+        } : {}
+    };
+}
+function directFontFace(value) {
+    if (null === value) return null;
+    const name = documentFontNameFromCssFamily(value) ?? normalizeDocumentFontName(value);
+    return name ? {
+        name,
+        resolved: name
+    } : null;
+}
+function documentScriptFontFaceFamily(face) {
+    return face?.resolved ?? face?.name;
+}
+function strongDocumentScriptFontSlot(character) {
+    if (NEUTRAL_SCRIPT_CHARACTER.test(character)) return null;
+    const codePoint = character.codePointAt(0);
+    if (void 0 === codePoint) return null;
+    if (isComplexScriptCodePoint(codePoint)) return 'complexScript';
+    if (isEastAsianCodePoint(codePoint)) return 'eastAsia';
+    return codePoint <= 0x7f ? 'ascii' : 'highAnsi';
+}
+function isComplexScriptCodePoint(codePoint) {
+    return codePoint >= 0x0590 && codePoint <= 0x08ff || codePoint >= 0x0900 && codePoint <= 0x109f || codePoint >= 0x1780 && codePoint <= 0x18af || codePoint >= 0x1900 && codePoint <= 0x1cff || codePoint >= 0xa800 && codePoint <= 0xa8ff || codePoint >= 0xa980 && codePoint <= 0xa9df || codePoint >= 0xaa00 && codePoint <= 0xaa7f || codePoint >= 0xabc0 && codePoint <= 0xabff || codePoint >= 0xfb1d && codePoint <= 0xfdff || codePoint >= 0xfe70 && codePoint <= 0xfeff || codePoint >= 0x10a00 && codePoint <= 0x10fff || codePoint >= 0x11000 && codePoint <= 0x11fff || codePoint >= 0x1e900 && codePoint <= 0x1edff || 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 cssFontFamily(value) {
+    return /^(?:-?[\p{L}_])[\p{L}\p{N}_-]*$/u.test(value) ? value : `"${Array.from(value, cssStringCharacter).join('')}"`;
+}
+function cssStringCharacter(character) {
+    return /[\\":;{}<>]/u.test(character) ? `\\${character.codePointAt(0)?.toString(16)} ` : character;
+}
+function safeCssFontFamilyList(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim();
+    if (!source || source.length > 1024 || /[;{}]/u.test(source)) return null;
+    const tokens = [];
+    let start = 0;
+    let quote = '';
+    for(let index = 0; index < source.length; index += 1){
+        const character = source[index] ?? '';
+        if (quote) {
+            if ('\\' === character) {
+                index += 1;
+                if (index >= source.length) return null;
+            } else if (character === quote) quote = '';
+            continue;
+        }
+        if ('"' === character || "'" === character) {
+            quote = character;
+            continue;
+        }
+        if (',' === character) {
+            tokens.push(source.slice(start, index).trim());
+            start = index + 1;
+        }
+    }
+    if (quote) return null;
+    tokens.push(source.slice(start).trim());
+    return tokens.length && tokens.every(validCssFontFamilyToken) ? source : null;
+}
+function validCssFontFamilyToken(value) {
+    if (!value) return false;
+    if (value.startsWith('"')) return /^"(?:[^"\\\r\n\f]|\\(?:[\da-f]{1,6}\s?|[^\r\n\f]))*"$/iu.test(value) && null !== documentFontNameFromCssFamily(value);
+    if (value.startsWith("'")) return /^'(?:[^'\\\r\n\f]|\\(?:[\da-f]{1,6}\s?|[^\r\n\f]))*'$/iu.test(value) && null !== documentFontNameFromCssFamily(value);
+    return /[\p{L}_]/u.test(value) && /^[\p{L}_-][\p{L}\p{N}_ -]*$/u.test(value) && !/^(?:inherit|initial|revert(?:-layer)?|unset)$/iu.test(value);
+}
+function decodeCssEscape(source, start) {
+    if (start >= source.length) return null;
+    const hexadecimal = /^[\da-f]{1,6}/i.exec(source.slice(start))?.[0];
+    if (hexadecimal) {
+        const codePoint = Number.parseInt(hexadecimal, 16);
+        if (0 === codePoint || codePoint > 0x10ffff || codePoint >= 0xd800 && codePoint <= 0xdfff) return null;
+        let end = start + hexadecimal.length;
+        if (/\s/u.test(source[end] ?? '')) end += 1;
+        return {
+            value: String.fromCodePoint(codePoint),
+            end
+        };
+    }
+    const value = source[start];
+    return !value || /[\r\n\f]/u.test(value) ? null : {
+        value,
+        end: start + 1
+    };
+}
+function work_document_script_fonts_isRecordWithKeys(value, allowed) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value) && Object.keys(value).every((key)=>allowed.has(key));
+}
+const workDocumentUnderlineStyles = [
+    'none',
+    'single',
+    'words',
+    'double',
+    'thick',
+    'dotted',
+    'dottedHeavy',
+    'dash',
+    'dashedHeavy',
+    'dashLong',
+    'dashLongHeavy',
+    'dotDash',
+    'dashDotHeavy',
+    'dotDotDash',
+    'dashDotDotHeavy',
+    'wave',
+    'wavyHeavy',
+    'wavyDouble'
+];
+const DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE = 'data-office-underline-style';
+const DOCUMENT_UNDERLINE_COLOR_ATTRIBUTE = 'data-office-underline-color';
+const DOCUMENT_UNDERLINE_THEME_COLOR_ATTRIBUTE = 'data-office-underline-theme-color';
+const documentUnderlineKeyboardShortcuts = {
+    double: 'Mod-Shift-d',
+    words: 'Mod-Shift-w'
+};
+const UNDERLINE_STYLE_BY_NORMALIZED_VALUE = new Map(workDocumentUnderlineStyles.map((style)=>[
+        style.toLowerCase(),
+        style
+    ]));
+const HEAVY_UNDERLINE_STYLES = new Set([
+    'thick',
+    'dottedHeavy',
+    'dashedHeavy',
+    'dashLongHeavy',
+    'dashDotHeavy',
+    'dashDotDotHeavy',
+    'wavyHeavy'
+]);
+const DocumentUnderline = extension_underline.extend({
+    addAttributes () {
+        return {
+            underlineStyle: {
+                default: 'single',
+                parseHTML: (element)=>documentUnderlineFormattingFromElement(element)?.style ?? 'single',
+                renderHTML: ()=>({})
+            },
+            underlineColor: {
+                default: null,
+                parseHTML: (element)=>documentUnderlineFormattingFromElement(element)?.color ?? null,
+                renderHTML: ()=>({})
+            },
+            underlineThemeColor: {
+                default: null,
+                parseHTML: (element)=>serializeDocxThemeReference(documentUnderlineFormattingFromElement(element)?.themeColor ?? null) ?? null,
+                renderHTML: ()=>({})
+            }
+        };
+    },
+    renderHTML ({ mark, HTMLAttributes }) {
+        const attributes = documentUnderlineDomAttributes(documentUnderlineFormattingFromMarkAttributes(mark.attrs));
+        return [
+            'u',
+            mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, attributes),
+            0
+        ];
+    },
+    addCommands () {
+        return {
+            setUnderline: ()=>({ commands, editor })=>commands.setMark(this.name, documentUnderlineMarkAttributes(editor, 'single')),
+            toggleUnderline: ()=>({ commands, editor })=>{
+                    const style = 'none' === documentUnderlineStyle(editor) ? 'single' : 'none';
+                    return commands.setMark(this.name, documentUnderlineMarkAttributes(editor, style));
+                },
+            unsetUnderline: ()=>({ commands })=>commands.unsetMark(this.name),
+            setDocumentUnderline: (style, options = {})=>({ commands, editor })=>commands.setMark(this.name, documentUnderlineMarkAttributes(editor, style, options)),
+            setDocumentUnderlineColor: (color, themeColor = null)=>({ commands, editor })=>{
+                    const normalizedColor = normalizeDocumentUnderlineColor(color);
+                    if (null !== color && !normalizedColor) return false;
+                    const style = documentUnderlineStyle(editor);
+                    return commands.setMark(this.name, documentUnderlineMarkAttributes(editor, 'none' === style ? 'single' : style, {
+                        color: normalizedColor,
+                        themeColor
+                    }));
+                },
+            toggleDocumentUnderlineStyle: (style)=>({ commands, editor })=>{
+                    const next = documentUnderlineStyle(editor) === style ? 'none' : style;
+                    return commands.setMark(this.name, documentUnderlineMarkAttributes(editor, next));
+                }
+        };
+    },
+    addKeyboardShortcuts () {
+        return {
+            'Mod-u': ()=>this.editor.commands.toggleUnderline(),
+            'Mod-U': ()=>this.editor.commands.toggleUnderline(),
+            [documentUnderlineKeyboardShortcuts.double]: ()=>this.editor.commands.toggleDocumentUnderlineStyle('double'),
+            [documentUnderlineKeyboardShortcuts.words]: ()=>this.editor.commands.toggleDocumentUnderlineStyle('words')
+        };
+    }
+});
+function normalizeDocumentUnderlineStyle(value) {
+    if ('string' != typeof value) return null;
+    const normalized = value.trim().toLowerCase();
+    if ('0' === normalized || 'false' === normalized || 'off' === normalized) return 'none';
+    return UNDERLINE_STYLE_BY_NORMALIZED_VALUE.get(normalized) ?? null;
+}
+function normalizeDocumentUnderlineColor(value) {
+    if ('string' != typeof value) return null;
+    const source = value.trim();
+    const hex = /^#?([\da-f]{6})$/i.exec(source)?.[1];
+    if (hex) return `#${hex.toLowerCase()}`;
+    const shortHex = /^#([\da-f]{3})$/i.exec(source)?.[1];
+    if (shortHex) return `#${[
+        ...shortHex
+    ].map((channel)=>`${channel}${channel}`).join('').toLowerCase()}`;
+    const rgb = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})(?:\s*,\s*(?:1(?:\.0+)?|0?\.\d+))?\s*\)$/i.exec(source);
+    if (!rgb) return null;
+    const channels = rgb.slice(1, 4).map(Number);
+    if (channels.some((channel)=>channel < 0 || channel > 255)) return null;
+    return `#${channels.map((channel)=>channel.toString(16).padStart(2, '0')).join('')}`;
+}
+function documentUnderlineStyle(editor) {
+    return documentUnderlineFormatting(editor)?.style ?? 'none';
+}
+function documentUnderlineColor(editor) {
+    return documentUnderlineFormatting(editor)?.color ?? null;
+}
+function documentUnderlineFormatting(editor) {
+    if (editor.isDestroyed || !editor.isActive('underline')) return null;
+    return documentUnderlineFormattingFromMarkAttributes(editor.getAttributes('underline'));
+}
+function documentUnderlineFormattingFromElement(element) {
+    const declaredStyle = normalizeDocumentUnderlineStyle(element.getAttribute(DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE));
+    const cssLine = element.style.textDecorationLine.trim().toLowerCase().split(/\s+/);
+    const style = declaredStyle ?? documentUnderlineStyleFromCss(element) ?? ('u' === element.tagName.toLowerCase() ? 'single' : cssLine.includes('none') ? 'none' : null);
+    if (!style) return null;
+    const themeColor = parseDocxThemeReference(element.getAttribute(DOCUMENT_UNDERLINE_THEME_COLOR_ATTRIBUTE));
+    const color = normalizeDocumentUnderlineColor(element.getAttribute(DOCUMENT_UNDERLINE_COLOR_ATTRIBUTE)) ?? normalizeDocumentUnderlineColor(element.style.textDecorationColor) ?? themeColor?.resolved;
+    return {
+        style,
+        ...color ? {
+            color
+        } : {},
+        ...themeColor ? {
+            themeColor
+        } : {}
+    };
+}
+function documentUnderlineDomAttributes(formatting) {
+    const style = normalizeDocumentUnderlineStyle(formatting.style) ?? 'single';
+    const color = normalizeDocumentUnderlineColor(formatting.color);
+    const themeColor = serializeDocxThemeReference(formatting.themeColor ?? null);
+    const declarations = documentUnderlineCssDeclarations({
+        style,
+        ...color ? {
+            color
+        } : {}
+    });
+    return {
+        [DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE]: style,
+        ...color ? {
+            [DOCUMENT_UNDERLINE_COLOR_ATTRIBUTE]: color
+        } : {},
+        ...themeColor ? {
+            [DOCUMENT_UNDERLINE_THEME_COLOR_ATTRIBUTE]: themeColor
+        } : {},
+        style: declarations.join('; ')
+    };
+}
+function documentUnderlineMarkAttributes(editor, style, options = {}) {
+    const current = documentUnderlineFormatting(editor);
+    const color = void 0 === options.color ? current?.color ?? null : normalizeDocumentUnderlineColor(options.color);
+    const requestedTheme = void 0 === options.themeColor ? current?.themeColor ?? null : documentUnderlineThemeReference(options.themeColor);
+    const themeColor = requestedTheme && color === requestedTheme.resolved ? serializeDocxThemeReference(requestedTheme) ?? null : null;
+    return {
+        underlineStyle: style,
+        underlineColor: color,
+        underlineThemeColor: themeColor
+    };
+}
+function documentUnderlineFormattingFromMarkAttributes(attributes) {
+    const style = normalizeDocumentUnderlineStyle(attributes.underlineStyle) ?? 'single';
+    const themeColor = 'string' == typeof attributes.underlineThemeColor ? parseDocxThemeReference(attributes.underlineThemeColor) : null;
+    const color = normalizeDocumentUnderlineColor(attributes.underlineColor) ?? themeColor?.resolved;
+    return {
+        style,
+        ...color ? {
+            color
+        } : {},
+        ...themeColor ? {
+            themeColor
+        } : {}
+    };
+}
+function documentUnderlineThemeReference(value) {
+    if ('string' == typeof value) return parseDocxThemeReference(value);
+    return value ? parseDocxThemeReference(serializeDocxThemeReference(value)) : null;
+}
+function documentUnderlineStyleFromCss(element) {
+    const line = element.style.textDecorationLine.trim().toLowerCase().split(/\s+/);
+    if (line.includes('none')) return 'none';
+    if (!line.includes('underline')) return null;
+    switch(element.style.textDecorationStyle.trim().toLowerCase()){
+        case 'double':
+            return 'double';
+        case 'dotted':
+            return 'dotted';
+        case 'dashed':
+            return 'dash';
+        case 'wavy':
+            return 'wave';
+        default:
+            return 'single';
+    }
+}
+function documentUnderlineCssDeclarations(formatting) {
+    const { style, color } = formatting;
+    if ('none' === style) return [
+        'text-decoration-line: none'
+    ];
+    const declarations = [
+        'text-decoration-line: underline',
+        `text-decoration-style: ${documentUnderlineCssStyle(style)}`,
+        'text-underline-offset: 0.12em',
+        'text-decoration-skip-ink: auto'
+    ];
+    if (color) declarations.push(`text-decoration-color: ${color}`);
+    if (HEAVY_UNDERLINE_STYLES.has(style)) declarations.push('text-decoration-thickness: 0.14em');
+    return declarations;
+}
+function documentUnderlineCssStyle(style) {
+    if ('double' === style) return 'double';
+    if ('dotted' === style || 'dottedHeavy' === style) return 'dotted';
+    if ('dash' === style || 'dashedHeavy' === style || 'dashLong' === style || 'dashLongHeavy' === style || 'dotDash' === style || 'dashDotHeavy' === style || 'dotDotDash' === style || 'dashDotDotHeavy' === style) return 'dashed';
+    if ('wave' === style || 'wavyHeavy' === style || 'wavyDouble' === style) return 'wavy';
+    return 'solid';
+}
+const workDocumentStrikeStyles = [
+    'none',
+    'single',
+    'double'
+];
+const DOCUMENT_STRIKE_STYLE_ATTRIBUTE = 'data-office-strike-style';
+const STRIKE_STYLE_BY_NORMALIZED_VALUE = new Map(workDocumentStrikeStyles.map((style)=>[
+        style,
+        style
+    ]));
+const DocumentStrike = extension_strike.extend({
+    addAttributes () {
+        return {
+            strikeStyle: {
+                default: 'single',
+                parseHTML: (element)=>documentStrikeFormattingFromElement(element)?.style ?? 'single',
+                renderHTML: ()=>({})
+            }
+        };
+    },
+    renderHTML ({ mark, HTMLAttributes }) {
+        return [
+            's',
+            mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, documentStrikeDomAttributes(documentStrikeFormattingFromMarkAttributes(mark.attrs))),
+            0
+        ];
+    },
+    addCommands () {
+        return {
+            setStrike: ()=>({ commands })=>commands.setMark(this.name, {
+                        strikeStyle: 'single'
+                    }),
+            toggleStrike: ()=>({ commands, editor })=>commands.setMark(this.name, {
+                        strikeStyle: 'none' === documentStrikeStyle(editor) ? 'single' : 'none'
+                    }),
+            unsetStrike: ()=>({ commands })=>commands.unsetMark(this.name),
+            setDocumentStrike: (style)=>({ commands })=>commands.setMark(this.name, {
+                        strikeStyle: style
+                    }),
+            toggleDocumentStrikeStyle: (style)=>({ commands, editor })=>commands.setMark(this.name, {
+                        strikeStyle: documentStrikeStyle(editor) === style ? 'none' : style
+                    })
+        };
+    },
+    addKeyboardShortcuts () {
+        return {};
+    }
+});
+function normalizeDocumentStrikeStyle(value) {
+    if ('string' != typeof value) return null;
+    const normalized = value.trim().toLowerCase();
+    if ('0' === normalized || 'false' === normalized || 'off' === normalized) return 'none';
+    return STRIKE_STYLE_BY_NORMALIZED_VALUE.get(normalized) ?? null;
+}
+function documentStrikeStyle(editor) {
+    return documentStrikeFormatting(editor)?.style ?? 'none';
+}
+function documentStrikeFormatting(editor) {
+    if (editor.isDestroyed || !editor.isActive('strike')) return null;
+    return documentStrikeFormattingFromMarkAttributes(editor.getAttributes('strike'));
+}
+function documentStrikeFormattingFromElement(element) {
+    const declared = normalizeDocumentStrikeStyle(element.getAttribute(DOCUMENT_STRIKE_STYLE_ATTRIBUTE));
+    const lines = element.style.textDecorationLine.trim().toLowerCase().split(/\s+/);
+    const style = declared ?? (lines.includes('none') ? 'none' : lines.includes('line-through') ? 'double' === element.style.textDecorationStyle.trim().toLowerCase() ? 'double' : 'single' : [
+        'del',
+        's',
+        'strike'
+    ].includes(element.tagName.toLowerCase()) ? 'single' : null);
+    return style ? {
+        style
+    } : null;
+}
+function documentStrikeDomAttributes(formatting) {
+    const style = normalizeDocumentStrikeStyle(formatting.style) ?? 'single';
+    return {
+        [DOCUMENT_STRIKE_STYLE_ATTRIBUTE]: style,
+        style: 'none' === style ? 'text-decoration-line: none' : `text-decoration-line: line-through; text-decoration-style: ${'double' === style ? 'double' : 'solid'}; text-decoration-skip-ink: none`
+    };
+}
+function documentStrikeFormattingFromMarkAttributes(attributes) {
+    return {
+        style: normalizeDocumentStrikeStyle(attributes.strikeStyle) ?? 'single'
+    };
+}
+const EMPTY_CONTENT = {
+    headerHtml: '',
+    footerHtml: '',
+    showPageNumber: false
+};
+const IMAGE_IDENTITY_ATTRIBUTES = [
+    'data-office-image-object-id',
+    'data-office-image-doc-properties-id',
+    'data-office-image-anchor-id',
+    'data-office-image-edit-id'
+];
+const PARAGRAPH_IDENTITY_ATTRIBUTES = [
+    DOCUMENT_PARAGRAPH_ID_ATTRIBUTE,
+    DOCUMENT_PARAGRAPH_TEXT_ID_ATTRIBUTE
+];
+const PARAGRAPH_DEFAULT_COLLAPSED_ATTRIBUTE = 'data-office-default-collapsed';
+const PARAGRAPH_BORDERS_ATTRIBUTE = DOCUMENT_PARAGRAPH_BORDERS_ATTRIBUTE;
+const PARAGRAPH_SHADING_ATTRIBUTE = 'data-office-paragraph-shading';
+const TABLE_ROW_IDENTITY_ATTRIBUTES = [
+    DOCUMENT_TABLE_ROW_ID_ATTRIBUTE,
+    DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE
+];
+const EQUATION_ATTRIBUTES = [
+    'aria-label',
+    'class',
+    'contenteditable',
+    'data-document-equation',
+    'data-equation-display',
+    'data-equation-model',
+    'role'
+];
+const MATHML_ATTRIBUTES = new Set([
+    'accent',
+    'accentunder',
+    'align',
+    'bevelled',
+    'columnalign',
+    'depth',
+    'dir',
+    'display',
+    'fence',
+    'height',
+    'lang',
+    'linethickness',
+    'mathbackground',
+    'mathcolor',
+    'mathsize',
+    'mathvariant',
+    'notation',
+    'rowspacing',
+    "scriptlevel",
+    'separator',
+    'style',
+    'width',
+    'xmlns'
+]);
+const work_document_page_chrome_MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+const MATHML_TAGS = new Set([
+    'math',
+    'maligngroup',
+    'malignmark',
+    'menclose',
+    'mfrac',
+    "mmultiscripts",
+    'mo',
+    'mover',
+    'mpadded',
+    'mphantom',
+    "mprescripts",
+    'mroot',
+    'mrow',
+    'msqrt',
+    'msub',
+    'msubsup',
+    'msup',
+    'mstyle',
+    'mtable',
+    'mtd',
+    'mtext',
+    'mtr',
+    'munder',
+    'munderover',
+    'none'
+]);
+const ALLOWED_TAGS = new Set([
+    'a',
+    'b',
+    'blockquote',
+    'br',
+    'div',
+    'em',
+    'i',
+    'img',
+    'li',
+    'math',
+    'maligngroup',
+    'malignmark',
+    'menclose',
+    'mfrac',
+    "mmultiscripts",
+    'mo',
+    'mover',
+    'mpadded',
+    'mphantom',
+    "mprescripts",
+    'mroot',
+    'mrow',
+    'msqrt',
+    'msub',
+    'msubsup',
+    'msup',
+    'mstyle',
+    'mtable',
+    'mtd',
+    'mtext',
+    'mtr',
+    'munder',
+    'munderover',
+    'none',
+    'ol',
+    'p',
+    's',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'th',
+    'thead',
+    'tr',
+    'u',
+    'ul'
+]);
+function normalizeDocumentPageChrome(source, legacy = {}) {
+    const defaultContent = normalizePageChromeContent(source?.default, {
+        headerHtml: plainTextToPageChromeHtml(legacy.headerText),
+        footerHtml: plainTextToPageChromeHtml(legacy.footerText),
+        showPageNumber: Boolean(legacy.showPageNumbers)
+    });
+    return {
+        differentFirstPage: Boolean(source?.differentFirstPage),
+        differentOddEvenPages: Boolean(source?.differentOddEvenPages),
+        default: defaultContent,
+        first: normalizePageChromeContent(source?.first, EMPTY_CONTENT),
+        even: normalizePageChromeContent(source?.even, EMPTY_CONTENT)
     };
 }
 function serializeDocumentPageChrome(chrome) {
@@ -7971,6 +9010,29 @@ function sanitizeAttributes(element, tag) {
         'justify'
     ].includes(element.style.textAlign) ? element.style.textAlign : '';
     const color = element.style.color;
+    const scriptFonts = 'span' === tag ? documentScriptFontsFromElement(element) : null;
+    const scriptFontSlot = 'span' === tag ? documentScriptFontSlotFromElement(element) : null;
+    const scriptFontAttributes = scriptFonts ? documentScriptFontsDomAttributes(scriptFonts, scriptFontSlot) : {};
+    const fontFamily = (scriptFonts ? documentScriptFontFamilyForRendering(scriptFonts, scriptFontSlot ?? documentScriptFontSlotFromHint(scriptFonts.hint), element.style.fontFamily) : null) ?? cssDocumentFontFamily(documentFontNameFromCssFamily(element.style.fontFamily));
+    const fontSize = 'span' === tag ? normalizedPageChromeFontSize(element.style.fontSize) : null;
+    const textCase = 'span' === tag ? normalizeDocumentTextCase(element.getAttribute(DOCUMENT_TEXT_CASE_ATTRIBUTE)) : null;
+    const characterSpacing = 'span' === tag ? documentCharacterSpacingTwipsFromElement(element) : null;
+    const characterScale = 'span' === tag ? documentCharacterScalePercentFromElement(element) : null;
+    const characterScaleAttributes = documentCharacterScaleDomAttributes(characterScale);
+    const characterPosition = 'span' === tag ? documentCharacterPositionHalfPointsFromElement(element) : null;
+    const characterPositionAttributes = documentCharacterPositionDomAttributes(characterPosition);
+    const characterSpacingAttributes = documentCharacterSpacingDomAttributes(characterSpacing);
+    const kerningThreshold = 'span' === tag ? documentKerningThresholdHalfPointsFromElement(element) : null;
+    const kerningAttributes = documentKerningDomAttributes(kerningThreshold, fontSize);
+    const emphasisMark = 'span' === tag ? documentEmphasisMarkFromElement(element) : null;
+    const emphasisAttributes = documentEmphasisMarkDomAttributes(emphasisMark);
+    const hiddenText = 'span' === tag ? documentHiddenTextFromElement(element) : null;
+    const legacyTextEffects = 'span' === tag ? documentLegacyTextEffectsFromElement(element) ?? {} : {};
+    const legacyTextEffectAttributes = documentLegacyTextEffectsDomAttributes(legacyTextEffects);
+    const underline = 'u' === tag ? documentUnderlineFormattingFromElement(element) : null;
+    const underlineAttributes = underline ? documentUnderlineDomAttributes(underline) : {};
+    const strike = 's' === tag || 'strike' === tag ? documentStrikeFormattingFromElement(element) : null;
+    const strikeAttributes = strike ? documentStrikeDomAttributes(strike) : {};
     const paragraphShading = 'p' === tag ? parseDocumentParagraphShadingElement(element) : null;
     const shadingAttributes = documentParagraphShadingDomAttributes(paragraphShading);
     const paragraphBorders = 'p' === tag ? parseDocumentParagraphBordersElement(element) : null;
@@ -7979,9 +9041,35 @@ function sanitizeAttributes(element, tag) {
     element.removeAttribute('style');
     element.removeAttribute(PARAGRAPH_BORDERS_ATTRIBUTE);
     element.removeAttribute(PARAGRAPH_SHADING_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_UNDERLINE_COLOR_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_UNDERLINE_THEME_COLOR_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_STRIKE_STYLE_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_CHARACTER_SCALE_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_CHARACTER_POSITION_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_CHARACTER_SPACING_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_KERNING_THRESHOLD_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_EMPHASIS_MARK_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_HIDDEN_TEXT_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_SCRIPT_FONTS_ATTRIBUTE);
+    element.removeAttribute(DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE);
     const styles = [
         textAlign ? `text-align: ${textAlign}` : '',
         color ? `color: ${color}` : '',
+        fontFamily ? `font-family: ${fontFamily}` : '',
+        fontSize ? `font-size: ${fontSize}` : '',
+        textCase ? documentTextCaseCss(textCase) : '',
+        characterScaleAttributes.style ?? '',
+        characterPositionAttributes.style ?? '',
+        characterSpacingAttributes.style ?? '',
+        kerningAttributes.style ?? '',
+        emphasisAttributes.style ?? '',
+        underlineAttributes.style ?? '',
+        strikeAttributes.style ?? '',
         borderAttributes.style ?? '',
         shadingAttributes.style ?? ''
     ].filter(Boolean);
@@ -8014,6 +9102,24 @@ function sanitizeAttributes(element, tag) {
         normalizeParagraphDefaultCollapsedAttribute(element);
     }
     if ('tr' === tag) normalizeTableRowIdentityAttributes(element);
+    if ('u' === tag) {
+        for (const [name, value] of Object.entries(underlineAttributes))if ('style' !== name) element.setAttribute(name, value);
+    }
+    if ('s' === tag || 'strike' === tag) {
+        for (const [name, value] of Object.entries(strikeAttributes))if ('style' !== name) element.setAttribute(name, value);
+    }
+    if ('span' === tag && textCase) element.setAttribute(DOCUMENT_TEXT_CASE_ATTRIBUTE, textCase);
+    else element.removeAttribute(DOCUMENT_TEXT_CASE_ATTRIBUTE);
+    if ('span' === tag && null !== characterSpacing) element.setAttribute(DOCUMENT_CHARACTER_SPACING_ATTRIBUTE, String(characterSpacing));
+    if ('span' === tag && null !== characterScale) element.setAttribute(DOCUMENT_CHARACTER_SCALE_ATTRIBUTE, String(characterScale));
+    if ('span' === tag && null !== characterPosition) element.setAttribute(DOCUMENT_CHARACTER_POSITION_ATTRIBUTE, String(characterPosition));
+    if ('span' === tag && null !== kerningThreshold) element.setAttribute(DOCUMENT_KERNING_THRESHOLD_ATTRIBUTE, String(kerningThreshold));
+    if ('span' === tag && null !== emphasisMark) element.setAttribute(DOCUMENT_EMPHASIS_MARK_ATTRIBUTE, emphasisMark);
+    if ('span' === tag && null !== hiddenText) element.setAttribute(DOCUMENT_HIDDEN_TEXT_ATTRIBUTE, String(hiddenText));
+    if ('span' === tag) for (const [name, value] of Object.entries(legacyTextEffectAttributes))element.setAttribute(name, value);
+    if ('span' === tag && scriptFonts) {
+        for (const [name, value] of Object.entries(scriptFontAttributes))if ('style' !== name) element.setAttribute(name, value);
+    }
     if ('ltr' === direction || 'rtl' === direction) element.setAttribute('dir', direction);
     else element.removeAttribute('dir');
     const allowed = 'span' === tag && 'true' === element.dataset.documentEquation ? new Set(EQUATION_ATTRIBUTES) : 'a' === tag ? new Set([
@@ -8050,10 +9156,41 @@ function sanitizeAttributes(element, tag) {
         'colspan',
         'dir',
         'rowspan',
-        'style'
+        'style',
+        ...'span' === tag ? [
+            DOCUMENT_TEXT_CASE_ATTRIBUTE,
+            DOCUMENT_CHARACTER_SCALE_ATTRIBUTE,
+            DOCUMENT_CHARACTER_POSITION_ATTRIBUTE,
+            DOCUMENT_CHARACTER_SPACING_ATTRIBUTE,
+            DOCUMENT_KERNING_THRESHOLD_ATTRIBUTE,
+            DOCUMENT_EMPHASIS_MARK_ATTRIBUTE,
+            DOCUMENT_HIDDEN_TEXT_ATTRIBUTE,
+            DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE,
+            DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE,
+            DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE,
+            DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE,
+            DOCUMENT_SCRIPT_FONTS_ATTRIBUTE,
+            DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE
+        ] : [],
+        ...'u' === tag ? [
+            DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE,
+            DOCUMENT_UNDERLINE_COLOR_ATTRIBUTE,
+            DOCUMENT_UNDERLINE_THEME_COLOR_ATTRIBUTE
+        ] : [],
+        ...'s' === tag || 'strike' === tag ? [
+            DOCUMENT_STRIKE_STYLE_ATTRIBUTE
+        ] : []
     ]);
     for (const attribute of Array.from(element.attributes))if (!allowed.has(attribute.name.toLowerCase())) element.removeAttribute(attribute.name);
 }
+function normalizedPageChromeFontSize(value) {
+    const match = /^(\d+(?:\.\d*)?|\.\d+)(pt|px)$/iu.exec(value.trim());
+    if (!match) return null;
+    const amount = Number(match[1]);
+    const points = match[2]?.toLowerCase() === 'px' ? 0.75 * amount : amount;
+    if (!Number.isFinite(points) || points <= 0 || points > 512 || !Number.isSafeInteger(2 * points)) return null;
+    return `${Number(points.toFixed(1))}pt`;
+}
 function normalizeTableRowIdentityAttributes(element) {
     const identity = normalizeDocumentTableRowIdentity({
         rowId: element.getAttribute(TABLE_ROW_IDENTITY_ATTRIBUTES[0]),
@@ -8934,20 +10071,39 @@ const CHARACTER_FORMAT_MARK_ORDER = new Map(DOCUMENT_CHARACTER_FORMAT_MARKS.map(
         name,
         index
     ]));
-const MAX_CHARACTER_FORMAT_SNAPSHOT_BYTES = 4096;
+const MAX_CHARACTER_FORMAT_SNAPSHOT_BYTES = 8192;
 const MAX_CHARACTER_FORMAT_ATTRIBUTE_LENGTH = 512;
 const ALLOWED_ATTRIBUTES = {
     bold: new Set(),
     italic: new Set(),
-    underline: new Set(),
-    strike: new Set(),
+    underline: new Set([
+        'underlineColor',
+        'underlineStyle',
+        'underlineThemeColor'
+    ]),
+    strike: new Set([
+        'strikeStyle'
+    ]),
     subscript: new Set(),
     superscript: new Set(),
     textStyle: new Set([
+        'characterScalePercent',
+        'characterPositionHalfPoints',
+        'characterSpacingTwips',
         'color',
         'fontFamily',
         'fontSize',
+        'emphasisMark',
+        'kerningThresholdHalfPoints',
+        'hiddenText',
+        'legacyTextOutline',
+        'legacyTextShadow',
+        'legacyTextEmboss',
+        'legacyTextImprint',
+        "scriptFonts",
+        "scriptFontSlot",
         'themeColor',
+        'textCase',
         'wordLineHeightFactor',
         'wordSnapToGrid'
     ]),
@@ -9009,18 +10165,43 @@ function importedDocumentCharacterFormatting(formatting) {
     for (const name of [
         'bold',
         'italic',
-        'underline',
-        'strike',
         "subscript",
         "superscript"
     ])if (formatting[name]) marks.push({
         type: name
     });
+    if (formatting.strike) marks.push({
+        type: 'strike',
+        attrs: {
+            strikeStyle: formatting.strike.style
+        }
+    });
+    if (formatting.underline) marks.push({
+        type: 'underline',
+        attrs: compactAttributes({
+            underlineColor: formatting.underline.color,
+            underlineStyle: formatting.underline.style,
+            underlineThemeColor: serializeDocxThemeReference(formatting.underline.themeColor ?? null)
+        })
+    });
     const textStyle = compactAttributes({
+        characterScalePercent: formatting.characterScalePercent,
+        characterPositionHalfPoints: formatting.characterPositionHalfPoints,
+        characterSpacingTwips: formatting.characterSpacingTwips,
+        kerningThresholdHalfPoints: formatting.kerningThresholdHalfPoints,
+        emphasisMark: formatting.emphasisMark,
+        hiddenText: formatting.hiddenText,
+        legacyTextOutline: formatting.legacyTextOutline,
+        legacyTextShadow: formatting.legacyTextShadow,
+        legacyTextEmboss: formatting.legacyTextEmboss,
+        legacyTextImprint: formatting.legacyTextImprint,
         color: formatting.color,
         fontFamily: formatting.fontFamily,
+        scriptFonts: serializeDocumentScriptFonts(formatting.scriptFonts) ?? void 0,
+        scriptFontSlot: formatting.scriptFontSlot,
         fontSize: void 0 === formatting.fontSize ? void 0 : `${formatting.fontSize}pt`,
         themeColor: formatting.themeColor,
+        textCase: formatting.textCase,
         wordLineHeightFactor: formatting.wordLineHeightFactor,
         wordSnapToGrid: formatting.wordSnapToGrid
     });
@@ -9048,9 +10229,72 @@ function normalizeCharacterFormatMark(value) {
     if (void 0 !== source && !work_document_format_changes_isRecord(source)) return null;
     const attrs = {};
     for (const [key, candidate] of Object.entries(source ?? {}))if (allowed.has(key) && null != candidate) {
+        if ('textStyle' === type && 'characterSpacingTwips' === key) {
+            const spacing = normalizeDocumentCharacterSpacingTwips(candidate);
+            if (null === spacing) return null;
+            attrs[key] = spacing;
+            continue;
+        }
+        if ('textStyle' === type && 'characterPositionHalfPoints' === key) {
+            const position = normalizeDocumentCharacterPositionHalfPoints(candidate);
+            if (null === position) return null;
+            attrs[key] = position;
+            continue;
+        }
+        if ('textStyle' === type && 'characterScalePercent' === key) {
+            const scale = normalizeDocumentCharacterScalePercent(candidate);
+            if (null === scale) return null;
+            attrs[key] = scale;
+            continue;
+        }
+        if ('textStyle' === type && 'kerningThresholdHalfPoints' === key) {
+            const threshold = normalizeDocumentKerningThresholdHalfPoints(candidate);
+            if (null === threshold) return null;
+            attrs[key] = threshold;
+            continue;
+        }
+        if ('textStyle' === type && 'emphasisMark' === key) {
+            const emphasisMark = normalizeDocumentEmphasisMark(candidate);
+            if (null === emphasisMark) return null;
+            attrs[key] = emphasisMark;
+            continue;
+        }
+        if ('textStyle' === type && 'hiddenText' === key) {
+            const hiddenText = normalizeDocumentHiddenText(candidate);
+            if (null === hiddenText) return null;
+            attrs[key] = hiddenText;
+            continue;
+        }
+        if ('textStyle' === type && [
+            'legacyTextOutline',
+            'legacyTextShadow',
+            'legacyTextEmboss',
+            'legacyTextImprint'
+        ].includes(key)) {
+            const effect = normalizeDocumentLegacyTextEffect(candidate);
+            if (null === effect) return null;
+            attrs[key] = effect;
+            continue;
+        }
+        if ('textStyle' === type && "scriptFonts" === key) {
+            const fonts = 'string' == typeof candidate ? serializeDocumentScriptFonts(parseDocumentScriptFonts(candidate)) : serializeDocumentScriptFonts(normalizeDocumentScriptFonts(candidate));
+            if (!fonts) return null;
+            attrs[key] = fonts;
+            continue;
+        }
+        if ('textStyle' === type && "scriptFontSlot" === key) {
+            const slot = normalizeDocumentScriptFontSlot(candidate);
+            if (!slot) return null;
+            attrs[key] = slot;
+            continue;
+        }
         if ('string' == typeof candidate) {
-            if (!candidate.length || candidate.length > MAX_CHARACTER_FORMAT_ATTRIBUTE_LENGTH) return null;
-            attrs[key] = candidate;
+            if (!candidate.length) continue;
+            if ('textStyle' === type && 'textCase' === key && !normalizeDocumentTextCase(candidate)) return null;
+            if (candidate.length > MAX_CHARACTER_FORMAT_ATTRIBUTE_LENGTH) return null;
+            const normalized = normalizeCharacterFormatStringAttribute(type, key, candidate);
+            if (!normalized) return null;
+            attrs[key] = normalized;
             continue;
         }
         if ('boolean' == typeof candidate) {
@@ -9063,6 +10307,12 @@ function normalizeCharacterFormatMark(value) {
         }
         return null;
     }
+    if ('textStyle' === type && documentLegacyTextEffectsConflict({
+        outline: 'boolean' == typeof attrs.legacyTextOutline ? attrs.legacyTextOutline : void 0,
+        shadow: 'boolean' == typeof attrs.legacyTextShadow ? attrs.legacyTextShadow : void 0,
+        emboss: 'boolean' == typeof attrs.legacyTextEmboss ? attrs.legacyTextEmboss : void 0,
+        imprint: 'boolean' == typeof attrs.legacyTextImprint ? attrs.legacyTextImprint : void 0
+    })) return null;
     const keys = Object.keys(attrs).sort();
     const normalizedAttributes = keys.length ? Object.fromEntries(keys.map((key)=>[
             key,
@@ -9075,6 +10325,14 @@ function normalizeCharacterFormatMark(value) {
         } : {}
     };
 }
+function normalizeCharacterFormatStringAttribute(type, key, value) {
+    if ('strike' === type) return 'strikeStyle' === key ? normalizeDocumentStrikeStyle(value) : null;
+    if ('underline' !== type) return value;
+    if ('underlineStyle' === key) return normalizeDocumentUnderlineStyle(value);
+    if ('underlineColor' === key) return normalizeDocumentUnderlineColor(value);
+    if ('underlineThemeColor' === key) return serializeDocxThemeReference(parseDocxThemeReference(value)) ?? null;
+    return null;
+}
 function compareCharacterFormatMarks(left, right) {
     return (CHARACTER_FORMAT_MARK_ORDER.get(left.type) ?? Number.MAX_SAFE_INTEGER) - (CHARACTER_FORMAT_MARK_ORDER.get(right.type) ?? Number.MAX_SAFE_INTEGER);
 }
@@ -9083,6 +10341,7 @@ function createCharacterFormatMark(type, value) {
 }
 function compactAttributes(value) {
     const entries = Object.entries(value).filter((entry)=>void 0 !== entry[1]);
+    entries.sort(([left], [right])=>left < right ? -1 : left > right ? 1 : 0);
     return entries.length ? Object.fromEntries(entries) : void 0;
 }
 function work_document_format_changes_isRecord(value) {
@@ -9919,6 +11178,70 @@ function createDocumentChangeId() {
     const random = "u" > typeof crypto && 'function' == typeof crypto.randomUUID ? crypto.randomUUID() : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
     return `change-${random}`;
 }
+const DocumentCharacterFormatting = Extension.create({
+    name: 'documentCharacterFormatting',
+    addCommands () {
+        return {
+            setDocumentCharacterScale: (characterScalePercent)=>({ commands })=>{
+                    const scale = normalizeDocumentCharacterScalePercent(characterScalePercent);
+                    return null === scale ? false : commands.setMark('textStyle', {
+                        characterScalePercent: scale
+                    });
+                },
+            setDocumentCharacterPosition: (characterPositionHalfPoints)=>({ commands })=>{
+                    const position = normalizeDocumentCharacterPositionHalfPoints(characterPositionHalfPoints);
+                    return null === position ? false : commands.setMark('textStyle', {
+                        characterPositionHalfPoints: position
+                    });
+                },
+            setDocumentCharacterSpacing: (characterSpacingTwips)=>({ commands })=>{
+                    const spacing = normalizeDocumentCharacterSpacingTwips(characterSpacingTwips);
+                    return null === spacing ? false : commands.setMark('textStyle', {
+                        characterSpacingTwips: spacing
+                    });
+                },
+            setDocumentKerningThreshold: (kerningThresholdHalfPoints)=>({ commands })=>{
+                    const threshold = normalizeDocumentKerningThresholdHalfPoints(kerningThresholdHalfPoints);
+                    return null === threshold ? false : commands.setMark('textStyle', {
+                        kerningThresholdHalfPoints: threshold
+                    });
+                },
+            unsetDocumentKerningThreshold: ()=>({ chain })=>chain().setMark('textStyle', {
+                        kerningThresholdHalfPoints: null
+                    }).removeEmptyTextStyle().run(),
+            setDocumentEmphasisMark: (emphasisMark)=>({ commands })=>{
+                    const mark = normalizeDocumentEmphasisMark(emphasisMark);
+                    return null === mark ? false : commands.setMark('textStyle', {
+                        emphasisMark: mark
+                    });
+                },
+            unsetDocumentEmphasisMark: ()=>({ chain })=>chain().setMark('textStyle', {
+                        emphasisMark: null
+                    }).removeEmptyTextStyle().run(),
+            setDocumentHiddenText: (hiddenText)=>({ commands })=>'boolean' == typeof hiddenText ? commands.setMark('textStyle', {
+                        hiddenText
+                    }) : false,
+            unsetDocumentHiddenText: ()=>({ chain })=>chain().setMark('textStyle', {
+                        hiddenText: null
+                    }).removeEmptyTextStyle().run(),
+            toggleDocumentHiddenText: ()=>({ commands, editor })=>commands.setDocumentHiddenText(!(normalizeDocumentHiddenText(editor.getAttributes('textStyle').hiddenText) ?? false)),
+            setDocumentTextCase: (textCase)=>({ chain })=>chain().focus().setMark('textStyle', {
+                        textCase
+                    }).run(),
+            toggleDocumentTextCase: (textCase)=>({ commands, editor })=>{
+                    const current = normalizeDocumentTextCase(editor.getAttributes('textStyle').textCase) ?? 'none';
+                    return commands.setDocumentTextCase(current === textCase ? 'none' : textCase);
+                }
+        };
+    },
+    addKeyboardShortcuts () {
+        return {
+            [documentTextCaseKeyboardShortcuts.allCaps]: ()=>this.editor.commands.toggleDocumentTextCase('all-caps'),
+            [documentTextCaseKeyboardShortcuts.smallCaps]: ()=>this.editor.commands.toggleDocumentTextCase('small-caps'),
+            [documentHiddenTextKeyboardShortcut]: ()=>this.editor.commands.toggleDocumentHiddenText()
+        };
+    }
+});
 const DocumentSubscript = extension_subscript.extend({
     excludes: "superscript",
     addCommands () {
@@ -14584,6 +15907,7 @@ function documentTextLayoutContent(node) {
     return supported ? content.join('') : null;
 }
 function collectDocumentTextLayoutRuns(element, expectedText, fonts, loadedFontIds, paragraphStyle = documentTextParagraphStyle(getComputedStyle(element))) {
+    if (element.matches(`[${DOCUMENT_HIDDEN_TEXT_ATTRIBUTE}="true"]`) || element.querySelector(`[${DOCUMENT_HIDDEN_TEXT_ATTRIBUTE}="true"]`)) return null;
     if (!paragraphStyle) return null;
     const tokens = documentTextLayoutDomTokens(element);
     if (!tokens) return null;
@@ -14591,7 +15915,7 @@ function collectDocumentTextLayoutRuns(element, expectedText, fonts, loadedFontI
     const runs = [];
     let utf16Offset = 0;
     for (const token of tokens){
-        const runStyle = documentTextLayoutRunStyle(getComputedStyle(token.styleElement), fonts, loadedFontIds, paragraphStyle, token.styleElement === element);
+        const runStyle = documentTextLayoutRunStyle(getComputedStyle(token.styleElement), fonts, loadedFontIds, paragraphStyle, token.styleElement, token.styleElement === element);
         if (!runStyle) return null;
         const startUtf16 = utf16Offset;
         utf16Offset += token.text.length;
@@ -14643,10 +15967,10 @@ function documentTextParagraphStyle(style) {
         whiteSpace: 'break-spaces' === style.whiteSpace ? 'breakSpaces' : 'normal'
     };
 }
-function documentTextLayoutRunStyle(style, fonts, loadedFontIds, paragraphStyle, paragraphRoot) {
+function documentTextLayoutRunStyle(style, fonts, loadedFontIds, paragraphStyle, element, paragraphRoot) {
     const direction = 'rtl' === style.direction ? 'rtl' : 'ltr';
     const whiteSpace = 'break-spaces' === style.whiteSpace ? 'breakSpaces' : 'normal';
-    if (direction !== paragraphStyle.direction || whiteSpace !== paragraphStyle.whiteSpace || !cssValueIs(style.whiteSpace, 'normal', 'break-spaces') || !cssValueIs(style.overflowWrap, 'normal', 'anywhere', 'break-word') || !cssValueIs(style.wordBreak, 'normal') || !cssValueIs(style.hyphens, 'manual', 'none') || !cssValueIs(style.wordSpacing, 'normal', '0', '0px') || !cssValueIs(style.textTransform, 'none') || !cssValueIs(style.fontVariationSettings, 'normal') || !cssValueIs(style.fontVariantCaps, 'normal') || !cssValueIs(style.fontVariantEastAsian, 'normal') || !cssValueIs(style.fontVariantNumeric, 'normal') || !cssValueIs(style.fontVariantPosition, 'normal') || !cssValueIs(style.fontStretch, 'normal', '100%') || !cssValueIs(style.verticalAlign, 'baseline') || !cssValueIs(style.unicodeBidi, 'normal') && !(paragraphRoot && 'isolate' === style.unicodeBidi)) return null;
+    if (direction !== paragraphStyle.direction || whiteSpace !== paragraphStyle.whiteSpace || !cssValueIs(style.whiteSpace, 'normal', 'break-spaces') || !cssValueIs(style.overflowWrap, 'normal', 'anywhere', 'break-word') || !cssValueIs(style.wordBreak, 'normal') || !cssValueIs(style.hyphens, 'manual', 'none') || !cssValueIs(style.wordSpacing, 'normal', '0', '0px') || !cssValueIs(style.textTransform, 'none') || !cssValueIs(style.fontVariationSettings, 'normal') || !cssValueIs(style.fontVariantCaps, 'normal') || !cssValueIs(style.fontVariantEastAsian, 'normal') || !cssValueIs(style.fontVariantNumeric, 'normal') || !cssValueIs(style.fontVariantPosition, 'normal') || !cssValueIs(style.fontStretch, 'normal', '100%') || !documentTextEmphasisAllowsKernel(style, element) || !cssValueIs(style.verticalAlign, 'baseline') || !cssValueIs(style.unicodeBidi, 'normal') && !(paragraphRoot && 'isolate' === style.unicodeBidi)) return null;
     const fontStyle = style.fontStyle && 'normal' !== style.fontStyle ? 'italic' === style.fontStyle ? 'italic' : null : 'normal';
     if (!fontStyle) return null;
     const families = cssFontFamilies(style.fontFamily);
@@ -14719,6 +16043,19 @@ function documentTextLayoutRunStyleKey(style) {
 function cssValueIs(value, ...supported) {
     return !value || supported.includes(value);
 }
+function documentTextEmphasisAllowsKernel(style, element) {
+    for(let current = element; current; current = current.parentElement){
+        if (!current.hasAttribute(DOCUMENT_EMPHASIS_MARK_ATTRIBUTE)) continue;
+        const emphasisMark = normalizeDocumentEmphasisMark(current.getAttribute(DOCUMENT_EMPHASIS_MARK_ATTRIBUTE));
+        if (null !== emphasisMark) {
+            if ('none' !== emphasisMark) return false;
+            break;
+        }
+    }
+    const standard = style.getPropertyValue('text-emphasis-style').trim();
+    const webkit = style.getPropertyValue('-webkit-text-emphasis-style').trim();
+    return (!standard || 'none' === standard) && (!webkit || 'none' === webkit);
+}
 function cssLigatures(style) {
     const variant = style.fontVariantLigatures;
     if (variant && 'normal' !== variant && 'none' !== variant) return null;
@@ -16182,34 +17519,396 @@ const DocumentSection = core_Node.create({
             ] : []
         ].join(';');
         return [
-            'section',
-            mergeAttributes(HTMLAttributes, documentSectionDomAttributes(layout, id), {
-                class: 'work-document-section',
-                style
-            }),
-            0
+            'section',
+            mergeAttributes(HTMLAttributes, documentSectionDomAttributes(layout, id), {
+                class: 'work-document-section',
+                style
+            }),
+            0
+        ];
+    }
+});
+function work_document_section_node_hiddenAttribute(defaultValue) {
+    return {
+        default: defaultValue,
+        rendered: false
+    };
+}
+function numberAttribute(element, name, fallback) {
+    const value = Number(element.dataset[name]);
+    return Number.isFinite(value) ? value : fallback;
+}
+function nullableNumberAttribute(element, name) {
+    const source = element.dataset[name];
+    if (!source?.trim()) return null;
+    const value = Number(source);
+    return Number.isFinite(value) ? value : null;
+}
+function sectionBreakAttribute(value) {
+    if ('continuous' === value || 'evenPage' === value || 'oddPage' === value || 'nextColumn' === value) return value;
+    return 'nextPage';
+}
+const DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT = 1.15;
+const DOCUMENT_WORD_LINE_HEIGHT_FACTORS = new Map([
+    [
+        'arial',
+        1.15
+    ],
+    [
+        'times new roman',
+        1.15
+    ],
+    [
+        'calibri',
+        1.2207
+    ],
+    [
+        'segoe ui',
+        1.3301
+    ],
+    [
+        'microsoft yahei',
+        1.7143
+    ],
+    [
+        'microsoft yahei ui',
+        1.7143
+    ],
+    [
+        'simsun',
+        1.2976
+    ],
+    [
+        'simhei',
+        1.2976
+    ],
+    [
+        'fangsong',
+        1.2976
+    ],
+    [
+        'kaiti',
+        1.2976
+    ],
+    [
+        'dengxian',
+        1.3548
+    ]
+]);
+function documentWordLineHeightFactor(fontFamily) {
+    if ('string' != typeof fontFamily) return DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT;
+    const family = firstCssFontFamily(fontFamily).toLocaleLowerCase();
+    return DOCUMENT_WORD_LINE_HEIGHT_FACTORS.get(family) ?? DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT;
+}
+function normalizedDocumentWordLineHeightFactor(value) {
+    if (null == value || '' === value) return null;
+    const factor = Number(value);
+    if (!Number.isFinite(factor) || factor < 0.5 || factor > 4) return null;
+    return Number(factor.toFixed(4));
+}
+const DocumentTextStyle = TextStyle.extend({
+    parseHTML () {
+        return [
+            ...this.parent?.() ?? [],
+            {
+                tag: `span[${DOCUMENT_HIDDEN_TEXT_ATTRIBUTE}]`,
+                consuming: false
+            },
+            ...[
+                DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE,
+                DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE,
+                DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE,
+                DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE
+            ].map((attribute)=>({
+                    tag: `span[${attribute}]`,
+                    consuming: false
+                }))
+        ];
+    },
+    addCommands () {
+        return {
+            ...this.parent?.() ?? {},
+            removeEmptyTextStyle: ()=>({ tr })=>{
+                    const { from, to } = tr.selection;
+                    tr.doc.nodesBetween(from, to, (node, position)=>{
+                        if (!node.isText) return true;
+                        const mark = node.marks.find((candidate)=>candidate.type === this.type && documentTextStyleAttributesAreEmpty(candidate.attrs));
+                        if (mark) tr.removeMark(Math.max(position, from), Math.min(position + node.nodeSize, to), mark);
+                        return false;
+                    });
+                    return true;
+                }
+        };
+    },
+    addAttributes () {
+        return {
+            characterScalePercent: {
+                default: null,
+                parseHTML: (element)=>documentCharacterScalePercentFromElement(element),
+                renderHTML: (attributes)=>documentCharacterScaleDomAttributes(normalizeDocumentCharacterScalePercent(attributes.characterScalePercent))
+            },
+            characterPositionHalfPoints: {
+                default: null,
+                parseHTML: (element)=>documentCharacterPositionHalfPointsFromElement(element),
+                renderHTML: (attributes)=>documentCharacterPositionDomAttributes(normalizeDocumentCharacterPositionHalfPoints(attributes.characterPositionHalfPoints))
+            },
+            characterSpacingTwips: {
+                default: null,
+                parseHTML: (element)=>documentCharacterSpacingTwipsFromElement(element),
+                renderHTML: (attributes)=>documentCharacterSpacingDomAttributes(normalizeDocumentCharacterSpacingTwips(attributes.characterSpacingTwips))
+            },
+            emphasisMark: {
+                default: null,
+                parseHTML: (element)=>documentEmphasisMarkFromElement(element),
+                renderHTML: (attributes)=>documentEmphasisMarkDomAttributes(normalizeDocumentEmphasisMark(attributes.emphasisMark))
+            },
+            hiddenText: {
+                default: null,
+                parseHTML: (element)=>documentHiddenTextFromElement(element),
+                renderHTML: (attributes)=>documentHiddenTextDomAttributes(attributes.hiddenText)
+            },
+            legacyTextOutline: legacyTextEffectAttribute('outline'),
+            legacyTextShadow: legacyTextEffectAttribute('shadow'),
+            legacyTextEmboss: legacyTextEffectAttribute('emboss'),
+            legacyTextImprint: legacyTextEffectAttribute('imprint'),
+            kerningThresholdHalfPoints: {
+                default: null,
+                parseHTML: (element)=>documentKerningThresholdHalfPointsFromElement(element),
+                renderHTML: (attributes)=>documentKerningDomAttributes(normalizeDocumentKerningThresholdHalfPoints(attributes.kerningThresholdHalfPoints), attributes.fontSize)
+            },
+            scriptFonts: {
+                default: null,
+                parseHTML: (element)=>serializeDocumentScriptFonts(parseDocumentScriptFonts(element.dataset.officeScriptFonts)),
+                renderHTML: (attributes)=>{
+                    const domAttributes = documentScriptFontsDomAttributes('string' == typeof attributes.scriptFonts ? parseDocumentScriptFonts(attributes.scriptFonts) : attributes.scriptFonts, attributes.scriptFontSlot);
+                    delete domAttributes.style;
+                    return domAttributes;
+                }
+            },
+            scriptFontSlot: {
+                default: null,
+                parseHTML: (element)=>normalizeDocumentScriptFontSlot(element.dataset.officeScriptFontSlot),
+                renderHTML: ()=>({})
+            },
+            wordLineHeightFactor: {
+                default: null,
+                parseHTML: (element)=>normalizedDocumentWordLineHeightFactor(element.dataset.officeWordLineHeightFactor ?? element.style.getPropertyValue('--work-document-word-line-height-factor')),
+                renderHTML: (attributes)=>{
+                    const factor = normalizedDocumentWordLineHeightFactor(attributes.wordLineHeightFactor);
+                    if (null === factor) return {};
+                    return {
+                        'data-office-word-line-height-factor': String(factor),
+                        style: `--work-document-word-line-height-factor: ${factor}`
+                    };
+                }
+            },
+            wordSnapToGrid: {
+                default: null,
+                parseHTML: (element)=>normalizedBoolean(element.dataset.officeWordSnapToGrid),
+                renderHTML: (attributes)=>{
+                    const value = normalizedBoolean(attributes.wordSnapToGrid);
+                    return null === value ? {} : {
+                        'data-office-word-snap-to-grid': String(value)
+                    };
+                }
+            },
+            themeColor: themeReferenceAttribute('officeThemeColor'),
+            textCase: {
+                default: null,
+                parseHTML: (element)=>normalizeDocumentTextCase(element.dataset.officeTextCase),
+                renderHTML: (attributes)=>{
+                    const textCase = normalizeDocumentTextCase(attributes.textCase);
+                    return textCase ? {
+                        [DOCUMENT_TEXT_CASE_ATTRIBUTE]: textCase,
+                        style: documentTextCaseCss(textCase)
+                    } : {};
+                }
+            }
+        };
+    }
+});
+function legacyTextEffectAttribute(effect) {
+    return {
+        default: null,
+        parseHTML: (element)=>documentLegacyTextEffectFromElement(element, effect),
+        renderHTML: (attributes)=>{
+            const value = normalizeDocumentLegacyTextEffect(attributes[documentLegacyTextStyleAttributeName(effect)]);
+            return null === value ? {} : documentLegacyTextEffectsDomAttributes({
+                [effect]: value
+            });
+        }
+    };
+}
+function documentTextStyleAttributesAreEmpty(attributes) {
+    return Object.values(attributes).every((value)=>null == value || '' === value);
+}
+const DocumentHighlight = extension_highlight.extend({
+    addKeyboardShortcuts () {
+        return {};
+    },
+    addAttributes () {
+        return {
+            ...this.parent?.(),
+            themeFill: themeReferenceAttribute('officeThemeFill')
+        };
+    },
+    parseHTML () {
+        return [
+            ...this.parent?.() ?? [],
+            {
+                tag: 'span[data-office-theme-fill]'
+            },
+            {
+                tag: 'span[style*="background-color"]'
+            }
         ];
     }
 });
-function work_document_section_node_hiddenAttribute(defaultValue) {
+const DocumentFontFamily = font_family.extend({
+    addCommands () {
+        return {
+            setFontFamily: (fontFamily)=>({ chain })=>{
+                    const scriptFonts = serializeDocumentScriptFonts(documentScriptFontsForAllText(fontFamily));
+                    return chain().setMark('textStyle', {
+                        fontFamily,
+                        scriptFonts,
+                        scriptFontSlot: null,
+                        wordLineHeightFactor: documentWordLineHeightFactor(fontFamily)
+                    }).run();
+                },
+            unsetFontFamily: ()=>({ chain })=>chain().setMark('textStyle', {
+                        fontFamily: null,
+                        scriptFonts: null,
+                        scriptFontSlot: null,
+                        wordLineHeightFactor: null
+                    }).removeEmptyTextStyle().run()
+        };
+    }
+});
+function firstCssFontFamily(value) {
+    const source = value.trim();
+    if (!source) return '';
+    const quote = source[0];
+    if ('"' === quote || "'" === quote) {
+        const end = source.indexOf(quote, 1);
+        if (end > 0) return source.slice(1, end).trim();
+    }
+    return (source.split(',')[0] ?? source).trim().replace(/^(['"])(.*)\1$/, '$2');
+}
+function normalizedBoolean(value) {
+    if (true === value || 'true' === value || '1' === value) return true;
+    if (false === value || 'false' === value || '0' === value) return false;
+    return null;
+}
+function themeReferenceAttribute(datasetKey) {
     return {
-        default: defaultValue,
-        rendered: false
+        default: null,
+        parseHTML: (element)=>serializeDocxThemeReference(parseDocxThemeReference(element.dataset[datasetKey])) ?? null,
+        renderHTML: (attributes)=>{
+            const value = serializeDocxThemeReference(parseDocxThemeReference('string' == typeof attributes['officeThemeColor' === datasetKey ? 'themeColor' : 'themeFill'] ? String(attributes['officeThemeColor' === datasetKey ? 'themeColor' : 'themeFill']) : null));
+            return value ? {
+                [`data-${toKebabCase(datasetKey)}`]: value
+            } : {};
+        }
     };
 }
-function numberAttribute(element, name, fallback) {
-    const value = Number(element.dataset[name]);
-    return Number.isFinite(value) ? value : fallback;
+function toKebabCase(value) {
+    return value.replace(/[A-Z]/g, (character)=>`-${character.toLowerCase()}`);
 }
-function nullableNumberAttribute(element, name) {
-    const source = element.dataset[name];
-    if (!source?.trim()) return null;
-    const value = Number(source);
-    return Number.isFinite(value) ? value : null;
+const SCRIPT_FONT_NORMALIZATION_META = 'documentScriptFontNormalization';
+const documentScriptFontPluginKey = new PluginKey('documentScriptFontNormalization');
+const DocumentScriptFontFormatting = Extension.create({
+    name: 'documentScriptFontFormatting',
+    addProseMirrorPlugins () {
+        return [
+            new Plugin({
+                key: documentScriptFontPluginKey,
+                view (view) {
+                    const transaction = normalizeDocumentScriptFontMarks(view.state);
+                    if (transaction) view.dispatch(transaction);
+                    return {};
+                },
+                appendTransaction (transactions, _oldState, newState) {
+                    if (!transactions.some((transaction)=>transaction.docChanged) || transactions.some((transaction)=>transaction.getMeta(SCRIPT_FONT_NORMALIZATION_META))) return null;
+                    return normalizeDocumentScriptFontMarks(newState, changedDocumentRanges(transactions, newState), true);
+                }
+            })
+        ];
+    }
+});
+function normalizeDocumentScriptFontMarks(state, ranges, includeInHistory = false) {
+    const textStyle = state.schema.marks.textStyle;
+    if (!textStyle) return null;
+    const updates = [];
+    const visited = new Set();
+    const visit = (node, position)=>{
+        if (!node.isText || !node.text || visited.has(position)) return;
+        visited.add(position);
+        const current = node.marks.find((mark)=>mark.type === textStyle);
+        const fonts = parseDocumentScriptFonts(current?.attrs.scriptFonts);
+        if (!current || !fonts) return;
+        const serialized = serializeDocumentScriptFonts(fonts);
+        if (!serialized) return;
+        for (const segment of documentScriptFontSegments(node.text, fonts.hint)){
+            const family = documentScriptFontFamilyForRendering(fonts, segment.slot, current.attrs.fontFamily);
+            const attributes = {
+                ...current.attrs,
+                scriptFonts: serialized,
+                scriptFontSlot: segment.slot,
+                ...family ? {
+                    fontFamily: family,
+                    wordLineHeightFactor: documentWordLineHeightFactor(family)
+                } : {}
+            };
+            const next = textStyle.create(attributes);
+            if (!current.eq(next)) updates.push({
+                from: position + segment.from,
+                to: position + segment.to,
+                current,
+                next
+            });
+        }
+    };
+    if (ranges?.length) for (const range of ranges)state.doc.nodesBetween(range.from, range.to, visit);
+    else state.doc.descendants(visit);
+    if (!updates.length) return null;
+    const transaction = state.tr;
+    for (const update of updates){
+        transaction.removeMark(update.from, update.to, update.current);
+        transaction.addMark(update.from, update.to, update.next);
+    }
+    transaction.setMeta(SCRIPT_FONT_NORMALIZATION_META, true);
+    if (!includeInHistory) transaction.setMeta('addToHistory', false);
+    return transaction;
 }
-function sectionBreakAttribute(value) {
-    if ('continuous' === value || 'evenPage' === value || 'oddPage' === value || 'nextColumn' === value) return value;
-    return 'nextPage';
+function changedDocumentRanges(transactions, state) {
+    const maximum = state.doc.content.size;
+    const ranges = [];
+    for (const transaction of transactions)for (const map of transaction.mapping.maps)map.forEach((_oldFrom, _oldTo, newFrom, newTo)=>{
+        ranges.push(expandedRange(newFrom, newTo, maximum));
+    });
+    ranges.push(expandedRange(state.selection.from, state.selection.to, maximum));
+    return mergeRanges(ranges);
+}
+function expandedRange(from, to, maximum) {
+    return {
+        from: Math.max(0, Math.min(maximum, Math.min(from, to) - 2)),
+        to: Math.max(0, Math.min(maximum, Math.max(from, to) + 2))
+    };
+}
+function mergeRanges(ranges) {
+    const ordered = [
+        ...ranges
+    ].filter((range)=>range.to >= range.from).sort((left, right)=>left.from - right.from || left.to - right.to);
+    const merged = [];
+    for (const range of ordered){
+        const previous = merged[merged.length - 1];
+        if (previous && range.from <= previous.to) previous.to = Math.max(previous.to, range.to);
+        else merged.push({
+            ...range
+        });
+    }
+    return merged;
 }
 const DOCUMENT_TAB_SELECTOR = 'span[data-document-tab]';
 const DOCUMENT_TAB_BLOCK_SELECTOR = 'p, h1, h2, h3, h4, h5, h6';
@@ -18244,156 +19943,6 @@ function commonNullableValue(values) {
     if (!values.length || values.some((value)=>null === value)) return null;
     return values.every((value)=>value === values[0]) ? values[0] : null;
 }
-const DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT = 1.15;
-const DOCUMENT_WORD_LINE_HEIGHT_FACTORS = new Map([
-    [
-        'arial',
-        1.15
-    ],
-    [
-        'times new roman',
-        1.15
-    ],
-    [
-        'calibri',
-        1.2207
-    ],
-    [
-        'segoe ui',
-        1.3301
-    ],
-    [
-        'microsoft yahei',
-        1.7143
-    ],
-    [
-        'microsoft yahei ui',
-        1.7143
-    ],
-    [
-        'simsun',
-        1.2976
-    ],
-    [
-        'simhei',
-        1.2976
-    ],
-    [
-        'fangsong',
-        1.2976
-    ],
-    [
-        'kaiti',
-        1.2976
-    ],
-    [
-        'dengxian',
-        1.3548
-    ]
-]);
-function documentWordLineHeightFactor(fontFamily) {
-    if ('string' != typeof fontFamily) return DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT;
-    const family = firstCssFontFamily(fontFamily).toLocaleLowerCase();
-    return DOCUMENT_WORD_LINE_HEIGHT_FACTORS.get(family) ?? DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT;
-}
-function normalizedDocumentWordLineHeightFactor(value) {
-    if (null == value || '' === value) return null;
-    const factor = Number(value);
-    if (!Number.isFinite(factor) || factor < 0.5 || factor > 4) return null;
-    return Number(factor.toFixed(4));
-}
-const DocumentTextStyle = TextStyle.extend({
-    addAttributes () {
-        return {
-            wordLineHeightFactor: {
-                default: null,
-                parseHTML: (element)=>normalizedDocumentWordLineHeightFactor(element.dataset.officeWordLineHeightFactor ?? element.style.getPropertyValue('--work-document-word-line-height-factor')),
-                renderHTML: (attributes)=>{
-                    const factor = normalizedDocumentWordLineHeightFactor(attributes.wordLineHeightFactor);
-                    if (null === factor) return {};
-                    return {
-                        'data-office-word-line-height-factor': String(factor),
-                        style: `--work-document-word-line-height-factor: ${factor}`
-                    };
-                }
-            },
-            wordSnapToGrid: {
-                default: null,
-                parseHTML: (element)=>normalizedBoolean(element.dataset.officeWordSnapToGrid),
-                renderHTML: (attributes)=>{
-                    const value = normalizedBoolean(attributes.wordSnapToGrid);
-                    return null === value ? {} : {
-                        'data-office-word-snap-to-grid': String(value)
-                    };
-                }
-            },
-            themeColor: themeReferenceAttribute('officeThemeColor')
-        };
-    }
-});
-const DocumentHighlight = extension_highlight.extend({
-    addAttributes () {
-        return {
-            ...this.parent?.(),
-            themeFill: themeReferenceAttribute('officeThemeFill')
-        };
-    },
-    parseHTML () {
-        return [
-            ...this.parent?.() ?? [],
-            {
-                tag: 'span[data-office-theme-fill]'
-            },
-            {
-                tag: 'span[style*="background-color"]'
-            }
-        ];
-    }
-});
-const DocumentFontFamily = font_family.extend({
-    addCommands () {
-        return {
-            setFontFamily: (fontFamily)=>({ chain })=>chain().setMark('textStyle', {
-                        fontFamily,
-                        wordLineHeightFactor: documentWordLineHeightFactor(fontFamily)
-                    }).run(),
-            unsetFontFamily: ()=>({ chain })=>chain().setMark('textStyle', {
-                        fontFamily: null,
-                        wordLineHeightFactor: null
-                    }).removeEmptyTextStyle().run()
-        };
-    }
-});
-function firstCssFontFamily(value) {
-    const source = value.trim();
-    if (!source) return '';
-    const quote = source[0];
-    if ('"' === quote || "'" === quote) {
-        const end = source.indexOf(quote, 1);
-        if (end > 0) return source.slice(1, end).trim();
-    }
-    return (source.split(',')[0] ?? source).trim().replace(/^(['"])(.*)\1$/, '$2');
-}
-function normalizedBoolean(value) {
-    if (true === value || 'true' === value || '1' === value) return true;
-    if (false === value || 'false' === value || '0' === value) return false;
-    return null;
-}
-function themeReferenceAttribute(datasetKey) {
-    return {
-        default: null,
-        parseHTML: (element)=>serializeDocxThemeReference(parseDocxThemeReference(element.dataset[datasetKey])) ?? null,
-        renderHTML: (attributes)=>{
-            const value = serializeDocxThemeReference(parseDocxThemeReference('string' == typeof attributes['officeThemeColor' === datasetKey ? 'themeColor' : 'themeFill'] ? String(attributes['officeThemeColor' === datasetKey ? 'themeColor' : 'themeFill']) : null));
-            return value ? {
-                [`data-${toKebabCase(datasetKey)}`]: value
-            } : {};
-        }
-    };
-}
-function toKebabCase(value) {
-    return value.replace(/[A-Z]/g, (character)=>`-${character.toLowerCase()}`);
-}
 function createWorkDocumentExtensions(options = {}) {
     const changeExtension = DocumentChange.configure({
         ...options.isTracking ? {
@@ -18430,6 +19979,7 @@ function createWorkDocumentExtensions(options = {}) {
                 openOnClick: false
             },
             underline: false,
+            strike: false,
             bulletList: false,
             orderedList: false,
             trailingNode: {
@@ -18462,7 +20012,9 @@ function createWorkDocumentExtensions(options = {}) {
         commentExtension,
         DocumentNoteReference,
         DocumentNote,
-        extension_underline,
+        DocumentUnderline,
+        DocumentStrike,
+        DocumentCharacterFormatting,
         DocumentSubscript,
         DocumentSuperscript,
         DocumentImage.configure({
@@ -18491,6 +20043,7 @@ function createWorkDocumentExtensions(options = {}) {
         DocumentTableFormatting,
         DocumentTableSizing,
         DocumentTextStyle,
+        DocumentScriptFontFormatting,
         DocumentFontFamily,
         font_size,
         extension_color,
@@ -20313,4 +21866,4 @@ function registerDocumentPageSurfaceGeometry(element, provider) {
 function documentPageSurfaceGeometryForElement(element) {
     return documentPageSurfaceProviders.get(element)?.() ?? null;
 }
-export { DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DEFAULT_DOCUMENT_TABLE_GEOMETRY, DOCUMENT_BOOKMARK_DUPLICATE_MESSAGE, DOCUMENT_CHUNK_HYDRATION_META, DOCUMENT_CHUNK_PAGINATION_META, DOCUMENT_CHUNK_VISIBLE_IDS_META, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PAGE_MARGIN_KEYS, DOCUMENT_PARAGRAPH_BORDER_EDGES, DOCUMENT_PARAGRAPH_BORDER_STYLES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, DOCUMENT_TABLE_STYLE_OPTIONS, DocumentEquation, DocumentImage, DocumentParagraphFormatting, DocumentParagraphIdentity, DocumentSubscript, DocumentSuperscript, DocumentTableRowIdentity, DocxThemePatchCollector, MAX_DOCUMENT_IMAGE_RELATIVE_HEIGHT, MAX_DOCUMENT_NUMBERING_START, activeDocumentBookmark, activeDocumentSection, activeDocumentTableStyle, applyDocumentImageCropToElement, applyDocumentImageIdentityToElement, applyDocumentImageLayerToElement, applyDocumentImageWrapContourToElement, applyDocumentPageGeometry, applyDocumentParagraphIdentityToElement, applyDocumentTableGeometryToElement, applyDocumentTableRowIdentityToElement, canChangeDocumentIndent, canInsertDocumentComment, canSetDocumentTableRowRepeatHeader, clampDocumentMargin, collectDocumentChanges, collectDocumentCommentAnchors, collectDocumentNotes, collectDocumentTextLayoutParagraphs, createDocumentBibliography, createDocumentEquationElement, createDocumentImageIdentityRegistry, createDocumentNoteElement, createDocumentParagraphIdentityRegistry, createSchemaDerivedWorkDocumentModel, createSchemaValidatedWorkDocumentModel, createWorkDocumentExtensions, createWorkDocumentModel, createWorkDocumentModelFromContent, createWorkOfficeDocumentCollaborationBinding as createOfficeDocumentCollaborationBinding, defaultDocumentImageWrapContour, documentAutoLineHeight, documentBookmarkNameExists, documentBookmarkReferenceInstruction, documentBulletListStyle, documentCaptionKind, documentCaptionLabel, documentChunkMountedIds, documentCitationCount, documentCitationInstruction, documentCitationStyle, documentCitationStyleDetails, documentCitationTags, documentCitationTagsFromInstruction, documentCommentDraftRange, documentCommentViews, documentContentLayoutProperties, documentEquationFromElement, documentEquationText, documentImageCropFromElement, documentImageIdentityFromElement, documentImageLayerFromElement, documentImageLayoutFromElement, documentImageLayoutOptions, documentImagePositionFromElement, documentImageProperties, documentImageWrapContourFromElement, documentInitialSectionLayout, documentLazyHtmlChunkFragment, documentLazyHtmlProjection, documentLazyHtmlProjectionFingerprint, documentModelForContent, documentModelForHtml, documentModelHasTrustedInitialIntegrityFeatures, documentModelUsesWindowing, documentNoteKey, documentNoteKind, documentOrderedListState, documentPageBordersVisible, documentPageChromeLegacyFields, documentPageGeometryForLayout, documentPageHorizontalMarginTwips, documentPageMarginBody, documentPageMarginsForLayout, documentPageMetrics, documentPageSurfaceGeometryForElement, documentPaperSizeForGeometry, documentParagraphBordersDomAttributes, documentParagraphDirection, documentParagraphIdentityFromElement, documentParagraphIndent, documentParagraphPagination, documentParagraphShadingDomAttributes, documentParagraphSpacing, documentParagraphTabStops, documentSectionById, documentSectionDomAttributes, documentSections, documentTabLeaderLabel, documentTableBordersFromElement, documentTableCellFormat, documentTableCellMarginOverridesFromElement, documentTableColumnPercentagesFromElement, documentTableGeometryFromElement, documentTableHorizontalAlignment, documentTableRowIdentityFromElement, documentTableRowOptions, documentTableSizing, documentTextLayoutBatches, documentTextStatistics, documentTransactionsOnlyHydrateChunks, documentWordLineHeightFactor, docxBookmarkReferenceTarget, docxDocumentFieldKind, editorDocumentBookmarkReferenceTargets, editorDocumentCaptionTargets, importedDocumentCharacterFormatting, initializeWorkOfficeDocumentCollaboration as initializeOfficeDocumentCollaboration, invalidateDocumentLazyHtmlProjection, isContourImageLayout, isDocumentParagraphArtBorderStyle, isValidDocumentCitationTag, materializeLazyDocumentEditorRoot, materializeWorkDocumentContent, measureDocumentLayoutBlocksIncrementally, millimetersToPixels, mountWorkLiveDocumentCapture, nextDocumentTabAlignment, normalizeDocumentBookmarkName, normalizeDocumentBookmarkNativeId, normalizeDocumentBookmarkReferencesHtml, normalizeDocumentBookmarksHtml, normalizeDocumentCaptionsHtml, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentEquation, normalizeDocumentFieldsHtml, normalizeDocumentHtml, normalizeDocumentImageAlignment, normalizeDocumentImageCrop, normalizeDocumentImageIdentity, normalizeDocumentImageLayer, normalizeDocumentImageLayoutOptions, normalizeDocumentImagePosition, normalizeDocumentImageWrapContour, normalizeDocumentImageWrapSide, normalizeDocumentNotesHtml, normalizeDocumentPageBorders, normalizeDocumentPageChrome, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, normalizeDocumentPaperSource, normalizeDocumentParagraphBorder, normalizeDocumentParagraphBorders, normalizeDocumentParagraphId, normalizeDocumentParagraphIdentity, normalizeDocumentParagraphIndent, normalizeDocumentTabStops, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeDocumentTableRowHeightRule, normalizeDocumentTableRowIdentity, normalizeDocumentTableVerticalAlign, normalizeTableColor, normalizedTabPosition, pageTwipsToMillimeters, parseDocumentCharacterFormatting, parseDocumentParagraphBordersElement, parseDocumentParagraphFormatting, parseDocumentParagraphShadingElement, parseDocxThemeReference, patchDocumentLazyHtmlProjection, patchDocxThemeReferences, positionWorkLiveDocumentCapture, readWorkOfficeDocumentCollaboration as readOfficeDocumentCollaboration, registerDocumentPageSurfaceGeometry, renderDocumentAutoLineHeight, renderDocumentTableBorders, renderDocumentTableCellMarginOverrides, resolveDocumentPageBorders, resolveDocumentPageChrome, resolveDocumentPageMargins, resolveDocumentPageSize, resolveWorkDocumentEditorInput, retainAnchoredDocumentComments, sanitizeDocumentPageChromeHtml, selectedDocumentChunkId, serializeDocumentParagraphFormatting, serializeDocumentTabStops, serializeDocxThemeReference, serializeWorkDocumentNode, setCustomDocumentColumns, supportedDocxBookmarkReferenceInstruction, syncDocumentContentFromHtml, transferChangedDocumentTextStatistics, uniqueDocumentImageIdentity, uniqueDocumentParagraphIdentity, updateDocumentColumnWidth, updateDocumentCustomPageMillimeters, updateDocumentGutterPosition, updateDocumentMirrorMargins, updateDocumentPageChromeVariant, updateDocumentPageMarginMillimeters, updateDocumentPageMarginMode, updateDocumentPageOrientation, updateDocumentPaperSizePreset, validateDocumentBookmarkName, windowDocumentModel, workDocumentSchema, workOfficeDocumentCollaborationFragment as officeDocumentCollaborationFragment, work_document_page_margins_twipsToMillimeters, wrapsBesideImage };
+export { DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DEFAULT_DOCUMENT_TABLE_GEOMETRY, DOCUMENT_BOOKMARK_DUPLICATE_MESSAGE, DOCUMENT_CHUNK_HYDRATION_META, DOCUMENT_CHUNK_PAGINATION_META, DOCUMENT_CHUNK_VISIBLE_IDS_META, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE, DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE, DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE, DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PAGE_MARGIN_KEYS, DOCUMENT_PARAGRAPH_BORDER_EDGES, DOCUMENT_PARAGRAPH_BORDER_STYLES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, DOCUMENT_STRIKE_STYLE_ATTRIBUTE, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, DOCUMENT_TABLE_STYLE_OPTIONS, DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE, DocumentCharacterFormatting, DocumentEquation, DocumentFontFamily, DocumentImage, DocumentParagraphFormatting, DocumentParagraphIdentity, DocumentScriptFontFormatting, DocumentStrike, DocumentSubscript, DocumentSuperscript, DocumentTableRowIdentity, DocumentTextStyle, DocumentUnderline, DocxThemePatchCollector, MAX_DOCUMENT_IMAGE_RELATIVE_HEIGHT, MAX_DOCUMENT_NUMBERING_START, activeDocumentBookmark, activeDocumentSection, activeDocumentTableStyle, applyDocumentImageCropToElement, applyDocumentImageIdentityToElement, applyDocumentImageLayerToElement, applyDocumentImageWrapContourToElement, applyDocumentPageGeometry, applyDocumentParagraphIdentityToElement, applyDocumentTableGeometryToElement, applyDocumentTableRowIdentityToElement, applyDocumentTextCaseStyle, canChangeDocumentIndent, canInsertDocumentComment, canSetDocumentTableRowRepeatHeader, clampDocumentMargin, collectDocumentChanges, collectDocumentCommentAnchors, collectDocumentNotes, collectDocumentTextLayoutParagraphs, createDocumentBibliography, createDocumentEquationElement, createDocumentImageIdentityRegistry, createDocumentNoteElement, createDocumentParagraphIdentityRegistry, createSchemaDerivedWorkDocumentModel, createSchemaValidatedWorkDocumentModel, createWorkDocumentExtensions, createWorkDocumentModel, createWorkDocumentModelFromContent, createWorkOfficeDocumentCollaborationBinding as createOfficeDocumentCollaborationBinding, cssDocumentFontFamily, defaultDocumentImageWrapContour, documentAutoLineHeight, documentBookmarkNameExists, documentBookmarkReferenceInstruction, documentBulletListStyle, documentCaptionKind, documentCaptionLabel, documentCharacterPositionDomAttributes, documentCharacterPositionHalfPointsFromElement, documentCharacterPositionPoints, documentCharacterScaleDomAttributes, documentCharacterScalePercentFromElement, documentCharacterSpacingDomAttributes, documentCharacterSpacingPoints, documentCharacterSpacingTwipsFromElement, documentChunkMountedIds, documentCitationCount, documentCitationInstruction, documentCitationStyle, documentCitationStyleDetails, documentCitationTags, documentCitationTagsFromInstruction, documentCommentDraftRange, documentCommentViews, documentContentLayoutProperties, documentEmphasisMarkDomAttributes, documentEmphasisMarkFromElement, documentEquationFromElement, documentEquationText, documentFontNameFromCssFamily, documentHiddenTextDomAttributes, documentHiddenTextFromElement, documentHiddenTextKeyboardShortcut, documentImageCropFromElement, documentImageIdentityFromElement, documentImageLayerFromElement, documentImageLayoutFromElement, documentImageLayoutOptions, documentImagePositionFromElement, documentImageProperties, documentImageWrapContourFromElement, documentInitialSectionLayout, documentKerningDomAttributes, documentKerningIsEffective, documentKerningThresholdHalfPointsFromElement, documentKerningThresholdPoints, documentLazyHtmlChunkFragment, documentLazyHtmlProjection, documentLazyHtmlProjectionFingerprint, documentLegacyTextEffectsConflict, documentLegacyTextEffectsCss, documentLegacyTextEffectsDomAttributes, documentLegacyTextEffectsFromElement, documentLegacyTextEffectsFromTextStyleAttributes, documentModelForContent, documentModelForHtml, documentModelHasTrustedInitialIntegrityFeatures, documentModelUsesWindowing, documentNoteKey, documentNoteKind, documentOrderedListState, documentPageBordersVisible, documentPageChromeLegacyFields, documentPageGeometryForLayout, documentPageHorizontalMarginTwips, documentPageMarginBody, documentPageMarginsForLayout, documentPageMetrics, documentPageSurfaceGeometryForElement, documentPaperSizeForGeometry, documentParagraphBordersDomAttributes, documentParagraphDirection, documentParagraphIdentityFromElement, documentParagraphIndent, documentParagraphPagination, documentParagraphShadingDomAttributes, documentParagraphSpacing, documentParagraphTabStops, documentScriptFontDirectFamily, documentScriptFontFallbackSlots, documentScriptFontFamily, documentScriptFontFamilyForRendering, documentScriptFontSegments, documentScriptFontSlotFromElement, documentScriptFontSlotFromHint, documentScriptFontsDomAttributes, documentScriptFontsFromElement, documentSectionById, documentSectionDomAttributes, documentSections, documentStrikeDomAttributes, documentStrikeFormattingFromElement, documentStrikeStyle, documentTabLeaderLabel, documentTableBordersFromElement, documentTableCellFormat, documentTableCellMarginOverridesFromElement, documentTableColumnPercentagesFromElement, documentTableGeometryFromElement, documentTableHorizontalAlignment, documentTableRowIdentityFromElement, documentTableRowOptions, documentTableSizing, documentTextCaseFromWordFlags, documentTextCaseKeyboardShortcuts, documentTextLayoutBatches, documentTextStatistics, documentTransactionsOnlyHydrateChunks, documentUnderlineColor, documentUnderlineDomAttributes, documentUnderlineFormattingFromElement, documentUnderlineKeyboardShortcuts, documentUnderlineStyle, documentWordLineHeightFactor, docxBookmarkReferenceTarget, docxDocumentFieldKind, editorDocumentBookmarkReferenceTargets, editorDocumentCaptionTargets, importedDocumentCharacterFormatting, initializeWorkOfficeDocumentCollaboration as initializeOfficeDocumentCollaboration, invalidateDocumentLazyHtmlProjection, isContourImageLayout, isDocumentParagraphArtBorderStyle, isValidDocumentCitationTag, materializeLazyDocumentEditorRoot, materializeWorkDocumentContent, measureDocumentLayoutBlocksIncrementally, millimetersToPixels, mountWorkLiveDocumentCapture, nextDocumentTabAlignment, normalizeDocumentBookmarkName, normalizeDocumentBookmarkNativeId, normalizeDocumentBookmarkReferencesHtml, normalizeDocumentBookmarksHtml, normalizeDocumentCaptionsHtml, normalizeDocumentCharacterPositionHalfPoints, normalizeDocumentCharacterScalePercent, normalizeDocumentCharacterSpacingTwips, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentEmphasisMark, normalizeDocumentEquation, normalizeDocumentFieldsHtml, normalizeDocumentFontName, normalizeDocumentHiddenText, normalizeDocumentHtml, normalizeDocumentImageAlignment, normalizeDocumentImageCrop, normalizeDocumentImageIdentity, normalizeDocumentImageLayer, normalizeDocumentImageLayoutOptions, normalizeDocumentImagePosition, normalizeDocumentImageWrapContour, normalizeDocumentImageWrapSide, normalizeDocumentKerningThresholdHalfPoints, normalizeDocumentLegacyTextEffect, normalizeDocumentLegacyTextEffects, normalizeDocumentNotesHtml, normalizeDocumentPageBorders, normalizeDocumentPageChrome, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, normalizeDocumentPaperSource, normalizeDocumentParagraphBorder, normalizeDocumentParagraphBorders, normalizeDocumentParagraphId, normalizeDocumentParagraphIdentity, normalizeDocumentParagraphIndent, normalizeDocumentScriptFontHint, normalizeDocumentScriptFontSlot, normalizeDocumentScriptFonts, normalizeDocumentStrikeStyle, normalizeDocumentTabStops, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeDocumentTableRowHeightRule, normalizeDocumentTableRowIdentity, normalizeDocumentTableVerticalAlign, normalizeDocumentTextCase, normalizeDocumentThemeFont, normalizeDocumentUnderlineColor, normalizeDocumentUnderlineStyle, normalizeTableColor, normalizedTabPosition, pageTwipsToMillimeters, parseDocumentCharacterFormatting, parseDocumentParagraphBordersElement, parseDocumentParagraphFormatting, parseDocumentParagraphShadingElement, parseDocumentScriptFonts, parseDocxThemeReference, patchDocumentLazyHtmlProjection, patchDocumentScriptFonts, patchDocxThemeReferences, positionWorkLiveDocumentCapture, readWorkOfficeDocumentCollaboration as readOfficeDocumentCollaboration, registerDocumentPageSurfaceGeometry, renderDocumentAutoLineHeight, renderDocumentTableBorders, renderDocumentTableCellMarginOverrides, resolveDocumentPageBorders, resolveDocumentPageChrome, resolveDocumentPageMargins, resolveDocumentPageSize, resolveWorkDocumentEditorInput, retainAnchoredDocumentComments, sanitizeDocumentPageChromeHtml, selectedDocumentChunkId, serializeDocumentParagraphFormatting, serializeDocumentScriptFonts, serializeDocumentTabStops, serializeDocxThemeReference, serializeWorkDocumentNode, setCustomDocumentColumns, supportedDocxBookmarkReferenceInstruction, syncDocumentContentFromHtml, transferChangedDocumentTextStatistics, uniqueDocumentImageIdentity, uniqueDocumentParagraphIdentity, updateDocumentColumnWidth, updateDocumentCustomPageMillimeters, updateDocumentGutterPosition, updateDocumentMirrorMargins, updateDocumentPageChromeVariant, updateDocumentPageMarginMillimeters, updateDocumentPageMarginMode, updateDocumentPageOrientation, updateDocumentPaperSizePreset, validateDocumentBookmarkName, windowDocumentModel, workDocumentSchema, workOfficeDocumentCollaborationFragment as officeDocumentCollaborationFragment, work_document_page_margins_twipsToMillimeters, wrapsBesideImage };