@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/document/character-format.js

@@ -0,0 +1,2054 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+import { parseOnOff, serializeOnOff } from './on-off';
+import { halfPoints, halfPointsToPoint, lengthToHalfPoints, pointToTwips, twipsToPoint, } from './length';
+import { elementChildren, isWml, wValAttribute, wmlAttr, wmlElement, } from './wml';
+import { Color, colorFromWire, colorToHexWire, colorToHighlightWire, highlightWireToColor, } from './color';
+import { localeIdFromBcp47, localeIdToBcp47 } from './locale-ids';
+import { SubSuperScript, subSuperScriptFromWire, subSuperScriptToWire } from './sub-super-script';
+import { UnderlineStyle, underlineStyleFromWire, underlineStyleToWire, } from './underline-style';
+export { SubSuperScript } from './sub-super-script';
+var MODELED_RPR = new Set([
+    'rStyle',
+    'rFonts',
+    'b',
+    'bCs',
+    'i',
+    'iCs',
+    'caps',
+    'smallCaps',
+    'strike',
+    'dstrike',
+    'outline',
+    'shadow',
+    'emboss',
+    'imprint',
+    'snapToGrid',
+    'vanish',
+    'webHidden',
+    'noProof',
+    'hidden',
+    'specVanish',
+    'color',
+    'spacing',
+    'w',
+    'kern',
+    'position',
+    'sz',
+    'szCs',
+    'highlight',
+    'u',
+    'vertAlign',
+    'lang',
+    'em',
+    'effect',
+    'shd',
+    'bdr',
+    'cs',
+    'rtl',
+]);
+/** Parked only — Group C / complex. */
+var RPR_EXTRA_ONLY = new Set(['rPrChange', 'oMath', 'eastAsianLayout', 'fitText']);
+var HIGHLIGHT_COLORS = new Set([
+    'black',
+    'blue',
+    'cyan',
+    'darkBlue',
+    'darkCyan',
+    'darkGray',
+    'darkGreen',
+    'darkMagenta',
+    'darkRed',
+    'darkYellow',
+    'green',
+    'lightGray',
+    'magenta',
+    'none',
+    'red',
+    'white',
+    'yellow',
+]);
+var UNDERLINE_STYLES = new Set([
+    'single',
+    'words',
+    'double',
+    'thick',
+    'dotted',
+    'dottedHeavy',
+    'dash',
+    'dashedHeavy',
+    'dashLong',
+    'dashLongHeavy',
+    'dotDash',
+    'dotDashHeavy',
+    'dotDotDash',
+    'dotDotDashHeavy',
+    'wave',
+    'wavyHeavy',
+    'wavyDouble',
+    'none',
+]);
+var EMPHASIS_MARKS = new Set(['none', 'dot', 'comma', 'circle', 'underDot']);
+var TEXT_EFFECTS = new Set([
+    'none',
+    'blinkBackground',
+    'lights',
+    'antsBlack',
+    'antsRed',
+    'shimmer',
+    'sparkle',
+    'movie',
+]);
+function pointToSignedHalfPoints(points) {
+    return Math.round(points * 2);
+}
+function parseDecimalVal(raw) {
+    if (raw === undefined || !/^-?\d+$/.test(raw)) {
+        return undefined;
+    }
+    return Number.parseInt(raw, 10);
+}
+function wmlAttrVal(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) {
+        return a.localName === localName && (a.prefix === 'w' || a.prefix === '');
+    })),
+        __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function emptySnapshot() {
+    return {
+        rPrExtra: [],
+        styleIdValue: undefined,
+        boldValue: undefined,
+        italicValue: undefined,
+        strikeValue: undefined,
+        doubleStrikeValue: undefined,
+        vanishValue: undefined,
+        legacyHiddenValue: undefined,
+        noProofValue: undefined,
+        fontSizeValue: undefined,
+        fontSizeBidiValue: undefined,
+        textColorValue: undefined,
+        textColorTheme: undefined,
+        highlightValue: undefined,
+        shadingValue: undefined,
+        underlineStyleValue: undefined,
+        underlineColorValue: undefined,
+        vertAlignValue: undefined,
+        smallCapsValue: undefined,
+        allCapsValue: undefined,
+        fontsValue: undefined,
+        characterScaleValue: undefined,
+        kerningValue: undefined,
+        characterSpacingValue: undefined,
+        positionValue: undefined,
+        borderValue: undefined,
+        languageValue: undefined,
+        embossValue: undefined,
+        imprintValue: undefined,
+        outlineValue: undefined,
+        shadowValue: undefined,
+        webHiddenValue: undefined,
+        bidiValue: undefined,
+        complexScriptValue: undefined,
+        boldBidiValue: undefined,
+        italicBidiValue: undefined,
+        emphasisValue: undefined,
+        textEffectValue: undefined,
+        specVanishValue: undefined,
+        snapToGridValue: undefined,
+    };
+}
+function validateFontSizePoints(name, value) {
+    if (!(value > 0 && value <= 1638)) {
+        throw new RangeError(name + ' must be in (0, 1638] points, got ' + String(value));
+    }
+}
+function validateSignedExtentPoints(name, value) {
+    if (value < -1584 || value > 1584) {
+        throw new RangeError(name + ' must be in [-1584, 1584] points, got ' + String(value));
+    }
+}
+function ensureFonts(record) {
+    if (record !== undefined) {
+        return record;
+    }
+    return {};
+}
+function fontsRecordIsEmpty(f) {
+    return (f.ascii === undefined &&
+        f.hAnsi === undefined &&
+        f.cs === undefined &&
+        f.eastAsia === undefined &&
+        f.hint === undefined &&
+        f.asciiTheme === undefined &&
+        f.hAnsiTheme === undefined &&
+        f.eastAsiaTheme === undefined &&
+        f.cTheme === undefined);
+}
+function pushOnOff(children, localName, value) {
+    if (value === undefined) {
+        return;
+    }
+    children.push(serializeOnOff(localName, value));
+}
+// ---------------------------------------------------------------------------
+// Parse helpers
+// ---------------------------------------------------------------------------
+function parseHighlight(el) {
+    var raw = wValAttribute(el);
+    if (raw === undefined || !HIGHLIGHT_COLORS.has(raw)) {
+        return undefined;
+    }
+    return raw;
+}
+function parseUnderline(el) {
+    var attr = wmlAttrVal(el, 'val');
+    var raw = attr !== undefined ? attr : 'single';
+    if (!UNDERLINE_STYLES.has(raw)) {
+        return undefined;
+    }
+    var color = wmlAttrVal(el, 'color');
+    if (color !== undefined) {
+        return { style: raw, color: color };
+    }
+    return { style: raw };
+}
+function parseRunFonts(el) {
+    var ascii = wmlAttrVal(el, 'ascii');
+    var hAnsi = wmlAttrVal(el, 'hAnsi');
+    var cs = wmlAttrVal(el, 'cs');
+    var eastAsia = wmlAttrVal(el, 'eastAsia');
+    var hint = wmlAttrVal(el, 'hint');
+    var asciiTheme = wmlAttrVal(el, 'asciiTheme');
+    var hAnsiTheme = wmlAttrVal(el, 'hAnsiTheme');
+    var eastAsiaTheme = wmlAttrVal(el, 'eastAsiaTheme');
+    var cTheme = wmlAttrVal(el, 'cTheme');
+    var out = {};
+    if (ascii !== undefined) {
+        out.ascii = ascii;
+    }
+    if (hAnsi !== undefined) {
+        out.hAnsi = hAnsi;
+    }
+    if (cs !== undefined) {
+        out.cs = cs;
+    }
+    if (eastAsia !== undefined) {
+        out.eastAsia = eastAsia;
+    }
+    if (hint !== undefined) {
+        out.hint = hint;
+    }
+    if (asciiTheme !== undefined) {
+        out.asciiTheme = asciiTheme;
+    }
+    if (hAnsiTheme !== undefined) {
+        out.hAnsiTheme = hAnsiTheme;
+    }
+    if (eastAsiaTheme !== undefined) {
+        out.eastAsiaTheme = eastAsiaTheme;
+    }
+    if (cTheme !== undefined) {
+        out.cTheme = cTheme;
+    }
+    return out;
+}
+function parseCharacterScale(el) {
+    var n = parseDecimalVal(wValAttribute(el));
+    if (n === undefined || n < 1 || n > 600) {
+        return undefined;
+    }
+    return n;
+}
+function parseKerning(el) {
+    var n = parseDecimalVal(wValAttribute(el));
+    if (n === undefined || n < 0) {
+        return undefined;
+    }
+    return n;
+}
+function parseCharacterSpacing(el) {
+    return parseDecimalVal(wValAttribute(el));
+}
+function parsePosition(el) {
+    return parseDecimalVal(wValAttribute(el));
+}
+function parseRunBorder(el) {
+    var style = wmlAttrVal(el, 'val');
+    if (style === undefined) {
+        return undefined;
+    }
+    var color = wmlAttrVal(el, 'color');
+    var sz = parseDecimalVal(wmlAttrVal(el, 'sz'));
+    var space = parseDecimalVal(wmlAttrVal(el, 'space'));
+    if (color !== undefined && sz !== undefined && space !== undefined) {
+        return { style: style, color: color, size: sz, space: space };
+    }
+    if (color !== undefined && sz !== undefined) {
+        return { style: style, color: color, size: sz };
+    }
+    if (color !== undefined && space !== undefined) {
+        return { style: style, color: color, space: space };
+    }
+    if (sz !== undefined && space !== undefined) {
+        return { style: style, size: sz, space: space };
+    }
+    if (color !== undefined) {
+        return { style: style, color: color };
+    }
+    if (sz !== undefined) {
+        return { style: style, size: sz };
+    }
+    if (space !== undefined) {
+        return { style: style, space: space };
+    }
+    return { style: style };
+}
+function parseRunShading(el) {
+    var fill = wmlAttrVal(el, 'fill');
+    var color = wmlAttrVal(el, 'color');
+    var pattern = wmlAttrVal(el, 'val');
+    var out = {};
+    if (fill !== undefined) {
+        out.fill = fill;
+    }
+    if (color !== undefined) {
+        out.color = color;
+    }
+    if (pattern !== undefined) {
+        out.pattern = pattern;
+    }
+    return out;
+}
+function parseRunLanguage(el) {
+    var val = wmlAttrVal(el, 'val');
+    var bidi = wmlAttrVal(el, 'bidi');
+    var eastAsia = wmlAttrVal(el, 'eastAsia');
+    if (val !== undefined && bidi !== undefined && eastAsia !== undefined) {
+        return { latin: val, bidi: bidi, eastAsia: eastAsia };
+    }
+    if (val !== undefined && bidi !== undefined) {
+        return { latin: val, bidi: bidi };
+    }
+    if (val !== undefined && eastAsia !== undefined) {
+        return { latin: val, eastAsia: eastAsia };
+    }
+    if (bidi !== undefined && eastAsia !== undefined) {
+        return { bidi: bidi, eastAsia: eastAsia };
+    }
+    if (val !== undefined) {
+        return { latin: val };
+    }
+    if (bidi !== undefined) {
+        return { bidi: bidi };
+    }
+    if (eastAsia !== undefined) {
+        return { eastAsia: eastAsia };
+    }
+    return {};
+}
+function parseVertAlign(el) {
+    var raw = wValAttribute(el);
+    if (raw === 'baseline' || raw === 'superscript' || raw === 'subscript') {
+        return raw;
+    }
+    return undefined;
+}
+function parseEmphasis(el) {
+    var raw = wValAttribute(el);
+    if (raw === undefined || !EMPHASIS_MARKS.has(raw)) {
+        return undefined;
+    }
+    return raw;
+}
+function parseTextEffect(el) {
+    var raw = wValAttribute(el);
+    if (raw === undefined || !TEXT_EFFECTS.has(raw)) {
+        return undefined;
+    }
+    return raw;
+}
+function parseColorPair(el) {
+    var value = wmlAttrVal(el, 'val');
+    if (value === undefined) {
+        return undefined;
+    }
+    var themeColor = wmlAttrVal(el, 'themeColor');
+    if (themeColor !== undefined) {
+        return { value: value, themeColor: themeColor };
+    }
+    return { value: value };
+}
+/**
+ * Parse `w:rPr` children into a {@link CharacterFormatSnapshot}.
+ * Invalid modeled markup is parked in `rPrExtra` (never throws on load).
+ *
+ * @private
+ */
+export function parseCharacterFormat(rPrElement) {
+    var e_1, _a;
+    var snap = emptySnapshot();
+    var rPrExtra = [];
+    try {
+        for (var _b = __values(elementChildren(rPrElement)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var prop = _c.value;
+            if (!isWml(prop, prop.localName)) {
+                rPrExtra.push(prop);
+                continue;
+            }
+            if (RPR_EXTRA_ONLY.has(prop.localName)) {
+                rPrExtra.push(prop);
+                continue;
+            }
+            if (!MODELED_RPR.has(prop.localName)) {
+                rPrExtra.push(prop);
+                continue;
+            }
+            if (prop.localName === 'rStyle') {
+                snap.styleIdValue = wValAttribute(prop);
+                continue;
+            }
+            if (prop.localName === 'sz') {
+                var raw = wValAttribute(prop);
+                if (raw !== undefined && /^\d+$/.test(raw)) {
+                    snap.fontSizeValue = halfPoints(Number.parseInt(raw, 10));
+                }
+                else {
+                    rPrExtra.push(prop);
+                }
+                continue;
+            }
+            if (prop.localName === 'szCs') {
+                var raw = wValAttribute(prop);
+                if (raw !== undefined && /^\d+$/.test(raw)) {
+                    snap.fontSizeBidiValue = halfPoints(Number.parseInt(raw, 10));
+                }
+                else {
+                    rPrExtra.push(prop);
+                }
+                continue;
+            }
+            if (prop.localName === 'color') {
+                var parsed = parseColorPair(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.textColorValue = parsed.value;
+                    snap.textColorTheme = parsed.themeColor;
+                }
+                continue;
+            }
+            if (prop.localName === 'highlight') {
+                var parsed = parseHighlight(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.highlightValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'shd') {
+                snap.shadingValue = parseRunShading(prop);
+                continue;
+            }
+            if (prop.localName === 'u') {
+                var parsed = parseUnderline(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.underlineStyleValue = parsed.style;
+                    snap.underlineColorValue = parsed.color;
+                }
+                continue;
+            }
+            if (prop.localName === 'vertAlign') {
+                var parsed = parseVertAlign(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.vertAlignValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'rFonts') {
+                snap.fontsValue = parseRunFonts(prop);
+                continue;
+            }
+            if (prop.localName === 'w') {
+                var parsed = parseCharacterScale(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.characterScaleValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'kern') {
+                var parsed = parseKerning(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.kerningValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'spacing') {
+                var parsed = parseCharacterSpacing(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.characterSpacingValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'position') {
+                var parsed = parsePosition(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.positionValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'bdr') {
+                var parsed = parseRunBorder(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.borderValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'lang') {
+                snap.languageValue = parseRunLanguage(prop);
+                continue;
+            }
+            if (prop.localName === 'em') {
+                var parsed = parseEmphasis(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.emphasisValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'effect') {
+                var parsed = parseTextEffect(prop);
+                if (parsed === undefined) {
+                    rPrExtra.push(prop);
+                }
+                else {
+                    snap.textEffectValue = parsed;
+                }
+                continue;
+            }
+            var flag = parseOnOff(prop);
+            if (flag === undefined) {
+                rPrExtra.push(prop);
+                continue;
+            }
+            if (prop.localName === 'b') {
+                snap.boldValue = flag;
+            }
+            else if (prop.localName === 'bCs') {
+                snap.boldBidiValue = flag;
+            }
+            else if (prop.localName === 'i') {
+                snap.italicValue = flag;
+            }
+            else if (prop.localName === 'iCs') {
+                snap.italicBidiValue = flag;
+            }
+            else if (prop.localName === 'strike') {
+                snap.strikeValue = flag;
+            }
+            else if (prop.localName === 'dstrike') {
+                snap.doubleStrikeValue = flag;
+            }
+            else if (prop.localName === 'vanish') {
+                snap.vanishValue = flag;
+            }
+            else if (prop.localName === 'noProof') {
+                snap.noProofValue = flag;
+            }
+            else if (prop.localName === 'smallCaps') {
+                snap.smallCapsValue = flag;
+            }
+            else if (prop.localName === 'caps') {
+                snap.allCapsValue = flag;
+            }
+            else if (prop.localName === 'hidden') {
+                // Legacy element — public `hidden` maps to `w:vanish`. Preserve for RT.
+                snap.legacyHiddenValue = flag;
+            }
+            else if (prop.localName === 'emboss') {
+                snap.embossValue = flag;
+            }
+            else if (prop.localName === 'imprint') {
+                snap.imprintValue = flag;
+            }
+            else if (prop.localName === 'outline') {
+                snap.outlineValue = flag;
+            }
+            else if (prop.localName === 'shadow') {
+                snap.shadowValue = flag;
+            }
+            else if (prop.localName === 'webHidden') {
+                snap.webHiddenValue = flag;
+            }
+            else if (prop.localName === 'cs') {
+                snap.complexScriptValue = flag;
+            }
+            else if (prop.localName === 'rtl') {
+                snap.bidiValue = flag;
+            }
+            else if (prop.localName === 'specVanish') {
+                snap.specVanishValue = flag;
+            }
+            else if (prop.localName === 'snapToGrid') {
+                snap.snapToGridValue = flag;
+            }
+            else {
+                rPrExtra.push(prop);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    snap.rPrExtra = rPrExtra;
+    return snap;
+}
+// ---------------------------------------------------------------------------
+// Serialize helpers
+// ---------------------------------------------------------------------------
+function serializeRunColor(value, themeColor) {
+    var attrs = [wmlAttr('val', value)];
+    if (themeColor !== undefined) {
+        attrs.push(wmlAttr('themeColor', themeColor));
+    }
+    return wmlElement('color', { attributes: attrs });
+}
+function serializeUnderline(style, color) {
+    var attrs = [wmlAttr('val', style)];
+    if (color !== undefined) {
+        attrs.push(wmlAttr('color', color));
+    }
+    return wmlElement('u', { attributes: attrs });
+}
+function ensureLanguage(record) {
+    if (record !== undefined) {
+        return {
+            latin: record.latin,
+            bidi: record.bidi,
+            eastAsia: record.eastAsia,
+        };
+    }
+    return {};
+}
+function languageRecordIsEmpty(lang) {
+    return lang.latin === undefined && lang.bidi === undefined && lang.eastAsia === undefined;
+}
+function setLocaleIdField(current, field, value) {
+    var next = ensureLanguage(current);
+    if (value === undefined) {
+        next[field] = undefined;
+    }
+    else {
+        var tag = localeIdToBcp47(value);
+        next[field] = tag !== undefined ? tag : undefined;
+    }
+    return languageRecordIsEmpty(next) ? undefined : next;
+}
+function getLocaleIdField(current, field) {
+    if (current === undefined) {
+        return undefined;
+    }
+    var tag = current[field];
+    if (tag === undefined) {
+        return undefined;
+    }
+    return localeIdFromBcp47(tag);
+}
+function colorToWireOrUndefined(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return colorToHexWire(value);
+}
+function wireColorToEnum(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return colorFromWire(value);
+}
+function serializeRunFonts(fonts) {
+    var attrs = [];
+    if (fonts.ascii !== undefined) {
+        attrs.push(wmlAttr('ascii', fonts.ascii));
+    }
+    if (fonts.hAnsi !== undefined) {
+        attrs.push(wmlAttr('hAnsi', fonts.hAnsi));
+    }
+    if (fonts.cs !== undefined) {
+        attrs.push(wmlAttr('cs', fonts.cs));
+    }
+    if (fonts.eastAsia !== undefined) {
+        attrs.push(wmlAttr('eastAsia', fonts.eastAsia));
+    }
+    if (fonts.hint !== undefined) {
+        attrs.push(wmlAttr('hint', fonts.hint));
+    }
+    if (fonts.asciiTheme !== undefined) {
+        attrs.push(wmlAttr('asciiTheme', fonts.asciiTheme));
+    }
+    if (fonts.hAnsiTheme !== undefined) {
+        attrs.push(wmlAttr('hAnsiTheme', fonts.hAnsiTheme));
+    }
+    if (fonts.eastAsiaTheme !== undefined) {
+        attrs.push(wmlAttr('eastAsiaTheme', fonts.eastAsiaTheme));
+    }
+    if (fonts.cTheme !== undefined) {
+        attrs.push(wmlAttr('cTheme', fonts.cTheme));
+    }
+    return wmlElement('rFonts', { attributes: attrs });
+}
+function serializeRunBorder(edge) {
+    var attrs = [wmlAttr('val', edge.style)];
+    if (edge.color !== undefined) {
+        attrs.push(wmlAttr('color', edge.color));
+    }
+    if (edge.size !== undefined) {
+        attrs.push(wmlAttr('sz', String(edge.size)));
+    }
+    if (edge.space !== undefined) {
+        attrs.push(wmlAttr('space', String(edge.space)));
+    }
+    return wmlElement('bdr', { attributes: attrs });
+}
+function serializeRunShading(shd) {
+    var attrs = [];
+    if (shd.pattern !== undefined) {
+        attrs.push(wmlAttr('val', shd.pattern));
+    }
+    if (shd.color !== undefined) {
+        attrs.push(wmlAttr('color', shd.color));
+    }
+    if (shd.fill !== undefined) {
+        attrs.push(wmlAttr('fill', shd.fill));
+    }
+    return wmlElement('shd', { attributes: attrs });
+}
+function serializeRunLanguage(lang) {
+    var attrs = [];
+    if (lang.latin !== undefined) {
+        attrs.push(wmlAttr('val', lang.latin));
+    }
+    if (lang.bidi !== undefined) {
+        attrs.push(wmlAttr('bidi', lang.bidi));
+    }
+    if (lang.eastAsia !== undefined) {
+        attrs.push(wmlAttr('eastAsia', lang.eastAsia));
+    }
+    return wmlElement('lang', { attributes: attrs });
+}
+/**
+ * Build `w:rPr` children in Spec §7.2 house order.
+ * @private
+ */
+export function buildRPrChildrenFromSnapshot(snap) {
+    var rPrChildren = [];
+    if (snap.styleIdValue !== undefined) {
+        rPrChildren.push(wmlElement('rStyle', { attributes: [wmlAttr('val', snap.styleIdValue)] }));
+    }
+    if (snap.fontsValue !== undefined && !fontsRecordIsEmpty(snap.fontsValue)) {
+        rPrChildren.push(serializeRunFonts(snap.fontsValue));
+    }
+    pushOnOff(rPrChildren, 'b', snap.boldValue);
+    pushOnOff(rPrChildren, 'bCs', snap.boldBidiValue);
+    pushOnOff(rPrChildren, 'i', snap.italicValue);
+    pushOnOff(rPrChildren, 'iCs', snap.italicBidiValue);
+    pushOnOff(rPrChildren, 'caps', snap.allCapsValue);
+    pushOnOff(rPrChildren, 'smallCaps', snap.smallCapsValue);
+    pushOnOff(rPrChildren, 'strike', snap.strikeValue);
+    pushOnOff(rPrChildren, 'dstrike', snap.doubleStrikeValue);
+    pushOnOff(rPrChildren, 'outline', snap.outlineValue);
+    pushOnOff(rPrChildren, 'shadow', snap.shadowValue);
+    pushOnOff(rPrChildren, 'emboss', snap.embossValue);
+    pushOnOff(rPrChildren, 'imprint', snap.imprintValue);
+    pushOnOff(rPrChildren, 'snapToGrid', snap.snapToGridValue);
+    pushOnOff(rPrChildren, 'vanish', snap.vanishValue);
+    pushOnOff(rPrChildren, 'webHidden', snap.webHiddenValue);
+    pushOnOff(rPrChildren, 'noProof', snap.noProofValue);
+    pushOnOff(rPrChildren, 'hidden', snap.legacyHiddenValue);
+    pushOnOff(rPrChildren, 'specVanish', snap.specVanishValue);
+    if (snap.textColorValue !== undefined) {
+        rPrChildren.push(serializeRunColor(snap.textColorValue, snap.textColorTheme));
+    }
+    if (snap.characterSpacingValue !== undefined) {
+        rPrChildren.push(wmlElement('spacing', {
+            attributes: [wmlAttr('val', String(snap.characterSpacingValue))],
+        }));
+    }
+    if (snap.characterScaleValue !== undefined) {
+        rPrChildren.push(wmlElement('w', { attributes: [wmlAttr('val', String(snap.characterScaleValue))] }));
+    }
+    if (snap.kerningValue !== undefined) {
+        rPrChildren.push(wmlElement('kern', { attributes: [wmlAttr('val', String(snap.kerningValue))] }));
+    }
+    if (snap.positionValue !== undefined) {
+        rPrChildren.push(wmlElement('position', { attributes: [wmlAttr('val', String(snap.positionValue))] }));
+    }
+    if (snap.fontSizeValue !== undefined) {
+        rPrChildren.push(wmlElement('sz', { attributes: [wmlAttr('val', String(snap.fontSizeValue))] }));
+    }
+    if (snap.fontSizeBidiValue !== undefined) {
+        rPrChildren.push(wmlElement('szCs', { attributes: [wmlAttr('val', String(snap.fontSizeBidiValue))] }));
+    }
+    if (snap.highlightValue !== undefined) {
+        rPrChildren.push(wmlElement('highlight', { attributes: [wmlAttr('val', snap.highlightValue)] }));
+    }
+    if (snap.underlineStyleValue !== undefined) {
+        rPrChildren.push(serializeUnderline(snap.underlineStyleValue, snap.underlineColorValue));
+    }
+    if (snap.vertAlignValue !== undefined) {
+        rPrChildren.push(wmlElement('vertAlign', { attributes: [wmlAttr('val', snap.vertAlignValue)] }));
+    }
+    if (snap.languageValue !== undefined) {
+        rPrChildren.push(serializeRunLanguage(snap.languageValue));
+    }
+    if (snap.emphasisValue !== undefined) {
+        rPrChildren.push(wmlElement('em', { attributes: [wmlAttr('val', snap.emphasisValue)] }));
+    }
+    if (snap.textEffectValue !== undefined) {
+        rPrChildren.push(wmlElement('effect', { attributes: [wmlAttr('val', snap.textEffectValue)] }));
+    }
+    if (snap.shadingValue !== undefined) {
+        rPrChildren.push(serializeRunShading(snap.shadingValue));
+    }
+    if (snap.borderValue !== undefined) {
+        rPrChildren.push(serializeRunBorder(snap.borderValue));
+    }
+    pushOnOff(rPrChildren, 'cs', snap.complexScriptValue);
+    pushOnOff(rPrChildren, 'rtl', snap.bidiValue);
+    for (var i = 0; i < snap.rPrExtra.length; i++) {
+        rPrChildren.push(snap.rPrExtra[i]);
+    }
+    return rPrChildren;
+}
+var CHARACTER_FORMAT_DEFAULTS = {
+    bold: false,
+    italic: false,
+    strikethrough: false,
+    doubleStrikethrough: false,
+    allCaps: false,
+    smallCaps: false,
+    hidden: false,
+    emboss: false,
+    engrave: false,
+    outline: false,
+    shadow: false,
+    noProof: false,
+    webHidden: false,
+    fontSize: 10,
+    fontName: 'Times New Roman',
+    fontNameAscii: 'Times New Roman',
+    fontNameNonFarEast: 'Times New Roman',
+    fontNameFarEast: 'Times New Roman',
+    fontNameBidi: 'Times New Roman',
+    underlineStyle: UnderlineStyle.None,
+    underlineColor: Color.Transparent,
+    textColor: Color.Transparent,
+    highlightColor: Color.Transparent,
+    textBackgroundColor: Color.Transparent,
+    subSuperScript: SubSuperScript.None,
+    characterSpacing: 0,
+    position: 0,
+    kerning: 0,
+    scaling: 100,
+    localeId: 1033,
+    localeIdBidi: 1025,
+    localeIdFarEast: 1033,
+    bidi: false,
+    complexScript: false,
+    boldBidi: false,
+    italicBidi: false,
+    fontSizeBidi: 10,
+    emphasisMark: 'none',
+    textEffect: 'none',
+    specVanish: false,
+    snapToGrid: true,
+};
+/**
+ * Character formatting model for a run (`w:rPr`).
+ *
+ * @public
+ */
+var CharacterFormat = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function CharacterFormat(host) {
+        this.rPrExtra = [];
+        this.host = host;
+    }
+    CharacterFormat.prototype.mutate = function () {
+        this.host.notifyCharacterFormatMutation();
+    };
+    CharacterFormat.prototype.effective = function (key) {
+        var resolve = this.host.resolveEffectiveCharacterValue;
+        var value = resolve !== undefined ? resolve.call(this.host, key) : undefined;
+        return value !== undefined ? value : undefined;
+    };
+    CharacterFormat.prototype.effectiveOrDefault = function (key, defaultValue) {
+        var value = this.effective(key);
+        return value !== undefined ? value : defaultValue;
+    };
+    Object.defineProperty(CharacterFormat.prototype, "bold", {
+        // ---- Group A ----
+        /** Direct `w:b` (`CT_OnOff`). `undefined` means absent. */
+        get: function () {
+            if (this.boldValue !== undefined) {
+                return this.boldValue;
+            }
+            return this.effective('bold');
+        },
+        set: function (value) {
+            this.boldValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "italic", {
+        /** Direct `w:i` (`CT_OnOff`). `undefined` means absent. */
+        get: function () {
+            if (this.italicValue !== undefined) {
+                return this.italicValue;
+            }
+            return this.effective('italic');
+        },
+        set: function (value) {
+            this.italicValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "strikethrough", {
+        /** Direct `w:strike` (`CT_OnOff`). Setter clears `doubleStrikethrough` when set true. */
+        get: function () {
+            if (this.strikeValue !== undefined) {
+                return this.strikeValue;
+            }
+            return this.effective('strikethrough');
+        },
+        set: function (value) {
+            this.strikeValue = value;
+            if (value === true) {
+                this.doubleStrikeValue = undefined;
+            }
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "doubleStrikethrough", {
+        /** Direct `w:dstrike`. Setter clears `strikethrough` when set true. */
+        get: function () {
+            if (this.doubleStrikeValue !== undefined) {
+                return this.doubleStrikeValue;
+            }
+            return this.effective('doubleStrikethrough');
+        },
+        set: function (value) {
+            this.doubleStrikeValue = value;
+            if (value === true) {
+                this.strikeValue = undefined;
+            }
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "allCaps", {
+        /** Direct `w:caps`. Setter clears `smallCaps` when set true (not on hydrate). */
+        get: function () {
+            if (this.allCapsValue !== undefined) {
+                return this.allCapsValue;
+            }
+            return this.effective('allCaps');
+        },
+        set: function (value) {
+            this.allCapsValue = value;
+            if (value === true) {
+                this.smallCapsValue = undefined;
+            }
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "smallCaps", {
+        /** Direct `w:smallCaps`. Setter clears `allCaps` when set true (not on hydrate). */
+        get: function () {
+            if (this.smallCapsValue !== undefined) {
+                return this.smallCapsValue;
+            }
+            return this.effective('smallCaps');
+        },
+        set: function (value) {
+            this.smallCapsValue = value;
+            if (value === true) {
+                this.allCapsValue = undefined;
+            }
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "hidden", {
+        /**
+         * Hidden text. Maps to `w:vanish` (Spec §4.1 #7).
+         * `undefined` means absent.
+         */
+        get: function () {
+            if (this.vanishValue !== undefined) {
+                return this.vanishValue;
+            }
+            return this.effective('hidden');
+        },
+        set: function (value) {
+            this.vanishValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "emboss", {
+        /** Direct `w:emboss`. Setter clears engrave/outline/shadow when true (not on hydrate). */
+        get: function () {
+            if (this.embossValue !== undefined) {
+                return this.embossValue;
+            }
+            return this.effective('emboss');
+        },
+        set: function (value) {
+            this.embossValue = value;
+            if (value === true) {
+                this.imprintValue = undefined;
+                this.outlineValue = undefined;
+                this.shadowValue = undefined;
+            }
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "engrave", {
+        /** Direct `w:imprint` (engrave). Member of legacy effect group. */
+        get: function () {
+            if (this.imprintValue !== undefined) {
+                return this.imprintValue;
+            }
+            return this.effective('engrave');
+        },
+        set: function (value) {
+            this.imprintValue = value;
+            if (value === true) {
+                this.embossValue = undefined;
+                this.outlineValue = undefined;
+                this.shadowValue = undefined;
+            }
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "outline", {
+        /** Direct `w:outline`. */
+        get: function () {
+            if (this.outlineValue !== undefined) {
+                return this.outlineValue;
+            }
+            return this.effective('outline');
+        },
+        set: function (value) {
+            this.outlineValue = value;
+            if (value === true) {
+                this.embossValue = undefined;
+                this.imprintValue = undefined;
+                this.shadowValue = undefined;
+            }
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "shadow", {
+        /** Direct `w:shadow`. */
+        get: function () {
+            if (this.shadowValue !== undefined) {
+                return this.shadowValue;
+            }
+            return this.effective('shadow');
+        },
+        set: function (value) {
+            this.shadowValue = value;
+            if (value === true) {
+                this.embossValue = undefined;
+                this.imprintValue = undefined;
+                this.outlineValue = undefined;
+            }
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "noProof", {
+        /** Direct `w:noProof`. */
+        get: function () {
+            if (this.noProofValue !== undefined) {
+                return this.noProofValue;
+            }
+            return this.effective('noProof');
+        },
+        set: function (value) {
+            this.noProofValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "webHidden", {
+        /** Direct `w:webHidden`. */
+        get: function () {
+            if (this.webHiddenValue !== undefined) {
+                return this.webHiddenValue;
+            }
+            return this.effective('webHidden');
+        },
+        set: function (value) {
+            this.webHiddenValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "fontSize", {
+        /** Font size in points (`w:sz` half-points). Range (0, 1638]. */
+        get: function () {
+            if (this.fontSizeValue !== undefined) {
+                return halfPointsToPoint(this.fontSizeValue);
+            }
+            return this.effectiveOrDefault('fontSize', CHARACTER_FORMAT_DEFAULTS.fontSize);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.fontSizeValue = undefined;
+                this.mutate();
+                return;
+            }
+            validateFontSizePoints('fontSize', value);
+            this.fontSizeValue = lengthToHalfPoints(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "fontName", {
+        /**
+         * Font name (`w:rFonts` ascii + hAnsi).
+         * Setter also writes eastAsia/cs only when those slots are already set.
+         */
+        get: function () {
+            if (this.fontsValue !== undefined) {
+                if (this.fontsValue.ascii !== undefined) {
+                    return this.fontsValue.ascii;
+                }
+                if (this.fontsValue.hAnsi !== undefined) {
+                    return this.fontsValue.hAnsi;
+                }
+            }
+            return this.effectiveOrDefault('fontName', CHARACTER_FORMAT_DEFAULTS.fontName);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                if (this.fontsValue === undefined) {
+                    return;
+                }
+                this.fontsValue.ascii = undefined;
+                this.fontsValue.hAnsi = undefined;
+                if (fontsRecordIsEmpty(this.fontsValue)) {
+                    this.fontsValue = undefined;
+                }
+                this.mutate();
+                return;
+            }
+            var fonts = ensureFonts(this.fontsValue);
+            fonts.ascii = value;
+            fonts.hAnsi = value;
+            if (fonts.eastAsia !== undefined) {
+                fonts.eastAsia = value;
+            }
+            if (fonts.cs !== undefined) {
+                fonts.cs = value;
+            }
+            this.fontsValue = fonts;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "fontNameAscii", {
+        /**
+         * @private
+         * `w:rFonts/@w:ascii`
+         */
+        get: function () {
+            if (this.fontsValue !== undefined) {
+                if (this.fontsValue.ascii !== undefined) {
+                    return this.fontsValue.ascii;
+                }
+            }
+            return this.effectiveOrDefault('fontNameAscii', CHARACTER_FORMAT_DEFAULTS.fontNameAscii);
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            var fonts = ensureFonts(this.fontsValue);
+            fonts.ascii = value;
+            this.fontsValue = fontsRecordIsEmpty(fonts) ? undefined : fonts;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "fontNameNonFarEast", {
+        /**
+         * @private
+         * `w:rFonts/@w:hAnsi`
+         */
+        get: function () {
+            if (this.fontsValue !== undefined) {
+                if (this.fontsValue.hAnsi !== undefined) {
+                    return this.fontsValue.hAnsi;
+                }
+            }
+            return this.effectiveOrDefault('fontNameNonFarEast', CHARACTER_FORMAT_DEFAULTS.fontNameNonFarEast);
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            var fonts = ensureFonts(this.fontsValue);
+            fonts.hAnsi = value;
+            this.fontsValue = fontsRecordIsEmpty(fonts) ? undefined : fonts;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "fontNameFarEast", {
+        /**
+         * @private
+         * `w:rFonts/@w:eastAsia`
+         */
+        get: function () {
+            if (this.fontsValue !== undefined) {
+                if (this.fontsValue.eastAsia !== undefined) {
+                    return this.fontsValue.eastAsia;
+                }
+            }
+            return this.effectiveOrDefault('fontNameFarEast', CHARACTER_FORMAT_DEFAULTS.fontNameFarEast);
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            var fonts = ensureFonts(this.fontsValue);
+            fonts.eastAsia = value;
+            this.fontsValue = fontsRecordIsEmpty(fonts) ? undefined : fonts;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "fontNameBidi", {
+        /** Complex-script font (`w:rFonts/@w:cs`). */
+        get: function () {
+            if (this.fontsValue !== undefined) {
+                if (this.fontsValue.cs !== undefined) {
+                    return this.fontsValue.cs;
+                }
+            }
+            return this.effectiveOrDefault('fontNameBidi', CHARACTER_FORMAT_DEFAULTS.fontNameBidi);
+        },
+        set: function (value) {
+            var fonts = ensureFonts(this.fontsValue);
+            fonts.cs = value;
+            this.fontsValue = fontsRecordIsEmpty(fonts) ? undefined : fonts;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "underlineStyle", {
+        /** Underline style (`w:u/@w:val`). */
+        get: function () {
+            if (this.underlineStyleValue !== undefined) {
+                return underlineStyleFromWire(this.underlineStyleValue);
+            }
+            return this.effectiveOrDefault('underlineStyle', CHARACTER_FORMAT_DEFAULTS.underlineStyle);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.underlineStyleValue = undefined;
+                this.underlineColorValue = undefined;
+                this.mutate();
+                return;
+            }
+            this.underlineStyleValue = underlineStyleToWire(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "underlineColor", {
+        /** Underline color (`w:u/@w:color`). */
+        get: function () {
+            if (this.underlineColorValue !== undefined) {
+                var mapped = wireColorToEnum(this.underlineColorValue);
+                return mapped !== undefined ? mapped : Color.Transparent;
+            }
+            var resolved = this.effective('underlineColor');
+            if (resolved === 'transparent') {
+                return Color.Transparent;
+            }
+            return resolved !== undefined ? resolved : CHARACTER_FORMAT_DEFAULTS.underlineColor;
+        },
+        set: function (value) {
+            this.underlineColorValue = colorToWireOrUndefined(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "textColor", {
+        /** Text color (`w:color/@w:val`). Setting clears theme color. */
+        get: function () {
+            if (this.textColorValue !== undefined) {
+                var mapped = wireColorToEnum(this.textColorValue);
+                return mapped !== undefined ? mapped : Color.Transparent;
+            }
+            var resolved = this.effective('textColor');
+            if (resolved === 'transparent') {
+                return Color.Transparent;
+            }
+            return resolved !== undefined ? resolved : CHARACTER_FORMAT_DEFAULTS.textColor;
+        },
+        set: function (value) {
+            this.textColorValue = colorToWireOrUndefined(value);
+            this.textColorTheme = undefined;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "highlightColor", {
+        /** Highlight color (`w:highlight`). */
+        get: function () {
+            if (this.highlightValue !== undefined) {
+                return highlightWireToColor(this.highlightValue);
+            }
+            var resolved = this.effective('highlightColor');
+            if (resolved === 'transparent') {
+                return Color.Transparent;
+            }
+            return resolved !== undefined ? resolved : CHARACTER_FORMAT_DEFAULTS.highlightColor;
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.highlightValue = undefined;
+                this.mutate();
+                return;
+            }
+            this.highlightValue = colorToHighlightWire(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "textBackgroundColor", {
+        /**
+         * Text background (`w:shd/@w:fill`). Authoring writes `val="clear"` + fill.
+         */
+        get: function () {
+            if (this.shadingValue !== undefined && this.shadingValue.fill !== undefined) {
+                var mapped = wireColorToEnum(this.shadingValue.fill);
+                return mapped !== undefined ? mapped : Color.Transparent;
+            }
+            var resolved = this.effective('textBackgroundColor');
+            if (resolved === 'transparent') {
+                return Color.Transparent;
+            }
+            return resolved !== undefined ? resolved : CHARACTER_FORMAT_DEFAULTS.textBackgroundColor;
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.shadingValue = undefined;
+                this.mutate();
+                return;
+            }
+            var fill = colorToHexWire(value);
+            this.shadingValue = { pattern: 'clear', fill: fill };
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "subSuperScript", {
+        /** Sub/superscript (`w:vertAlign`). */
+        get: function () {
+            if (this.vertAlignValue !== undefined) {
+                return subSuperScriptFromWire(this.vertAlignValue);
+            }
+            return this.effectiveOrDefault('subSuperScript', CHARACTER_FORMAT_DEFAULTS.subSuperScript);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.vertAlignValue = undefined;
+                this.mutate();
+                return;
+            }
+            this.vertAlignValue = subSuperScriptToWire(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "characterSpacing", {
+        /** Character spacing in points (`w:spacing` twips). Range ±1584. */
+        get: function () {
+            if (this.characterSpacingValue !== undefined) {
+                return twipsToPoint(this.characterSpacingValue);
+            }
+            return this.effectiveOrDefault('characterSpacing', CHARACTER_FORMAT_DEFAULTS.characterSpacing);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.characterSpacingValue = undefined;
+                this.mutate();
+                return;
+            }
+            validateSignedExtentPoints('characterSpacing', value);
+            this.characterSpacingValue = pointToTwips(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "position", {
+        /** Raised/lowered position in points (`w:position` half-points). Range ±1584. */
+        get: function () {
+            if (this.positionValue !== undefined) {
+                return halfPointsToPoint(this.positionValue);
+            }
+            return this.effectiveOrDefault('position', CHARACTER_FORMAT_DEFAULTS.position);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.positionValue = undefined;
+                this.mutate();
+                return;
+            }
+            validateSignedExtentPoints('position', value);
+            this.positionValue = pointToSignedHalfPoints(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "kerning", {
+        /** Kerning threshold in points (`w:kern` half-points). */
+        get: function () {
+            if (this.kerningValue !== undefined) {
+                return halfPointsToPoint(this.kerningValue);
+            }
+            return this.effectiveOrDefault('kerning', CHARACTER_FORMAT_DEFAULTS.kerning);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.kerningValue = undefined;
+                this.mutate();
+                return;
+            }
+            if (value < 0) {
+                throw new RangeError('kerning must be non-negative, got ' + String(value));
+            }
+            var hp = pointToSignedHalfPoints(value);
+            if (hp < 0) {
+                throw new RangeError('kerning must be non-negative, got ' + String(hp) + ' half-points');
+            }
+            this.kerningValue = hp;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "scaling", {
+        /** Character scale percentage (`w:w`). Integer 1–600. */
+        get: function () {
+            if (this.characterScaleValue !== undefined) {
+                return this.characterScaleValue;
+            }
+            return this.effectiveOrDefault('scaling', CHARACTER_FORMAT_DEFAULTS.scaling);
+        },
+        set: function (value) {
+            if (value !== undefined && (!Number.isInteger(value) || value < 1 || value > 600)) {
+                throw new RangeError('scaling must be an integer 1–600, got ' + String(value));
+            }
+            this.characterScaleValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "border", {
+        /** Character border (`w:bdr`). */
+        get: function () {
+            if (this.borderValue !== undefined) {
+                return this.borderValue;
+            }
+            return this.effective('border');
+        },
+        set: function (value) {
+            this.borderValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "localeId", {
+        /**
+         * Latin locale id (`w:lang/@w:val` as {@link LocaleIDs}).
+         * @public
+         */
+        get: function () {
+            var direct = getLocaleIdField(this.languageValue, 'latin');
+            if (direct !== undefined) {
+                return direct;
+            }
+            return this.effectiveOrDefault('localeId', CHARACTER_FORMAT_DEFAULTS.localeId);
+        },
+        set: function (value) {
+            this.languageValue = setLocaleIdField(this.languageValue, 'latin', value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "localeIdBidi", {
+        /**
+         * Bidirectional locale id (`w:lang/@w:bidi` as {@link LocaleIDs}).
+         * @public
+         */
+        get: function () {
+            var direct = getLocaleIdField(this.languageValue, 'bidi');
+            if (direct !== undefined) {
+                return direct;
+            }
+            return this.effectiveOrDefault('localeIdBidi', CHARACTER_FORMAT_DEFAULTS.localeIdBidi);
+        },
+        set: function (value) {
+            this.languageValue = setLocaleIdField(this.languageValue, 'bidi', value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "localeIdFarEast", {
+        /**
+         * East Asian locale id (`w:lang/@w:eastAsia` as {@link LocaleIDs}).
+         * @public
+         */
+        get: function () {
+            var direct = getLocaleIdField(this.languageValue, 'eastAsia');
+            if (direct !== undefined) {
+                return direct;
+            }
+            return this.effectiveOrDefault('localeIdFarEast', CHARACTER_FORMAT_DEFAULTS.localeIdFarEast);
+        },
+        set: function (value) {
+            this.languageValue = setLocaleIdField(this.languageValue, 'eastAsia', value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "characterStyle", {
+        /** Character style id (`w:rStyle/@w:val`). */
+        get: function () {
+            return this.styleIdValue;
+        },
+        set: function (value) {
+            this.styleIdValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "bidi", {
+        // ---- Group B ----
+        /** Bidirectional (`w:rtl`). */
+        get: function () {
+            if (this.bidiValue !== undefined) {
+                return this.bidiValue;
+            }
+            return this.effective('bidi');
+        },
+        set: function (value) {
+            this.bidiValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "complexScript", {
+        /** Complex script (`w:cs`). */
+        get: function () {
+            if (this.complexScriptValue !== undefined) {
+                return this.complexScriptValue;
+            }
+            return this.effective('complexScript');
+        },
+        set: function (value) {
+            this.complexScriptValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "boldBidi", {
+        /** Bold complex script (`w:bCs`). */
+        get: function () {
+            if (this.boldBidiValue !== undefined) {
+                return this.boldBidiValue;
+            }
+            return this.effective('boldBidi');
+        },
+        set: function (value) {
+            this.boldBidiValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "italicBidi", {
+        /** Italic complex script (`w:iCs`). */
+        get: function () {
+            if (this.italicBidiValue !== undefined) {
+                return this.italicBidiValue;
+            }
+            return this.effective('italicBidi');
+        },
+        set: function (value) {
+            this.italicBidiValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "fontSizeBidi", {
+        /** Complex-script font size in points (`w:szCs`). Range (0, 1638]. */
+        get: function () {
+            if (this.fontSizeBidiValue !== undefined) {
+                return halfPointsToPoint(this.fontSizeBidiValue);
+            }
+            return this.effectiveOrDefault('fontSizeBidi', CHARACTER_FORMAT_DEFAULTS.fontSizeBidi);
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.fontSizeBidiValue = undefined;
+                this.mutate();
+                return;
+            }
+            validateFontSizePoints('fontSizeBidi', value);
+            this.fontSizeBidiValue = lengthToHalfPoints(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "emphasisMark", {
+        /** Emphasis mark (`w:em`). */
+        get: function () {
+            if (this.emphasisValue !== undefined) {
+                return this.emphasisValue;
+            }
+            return this.effectiveOrDefault('emphasisMark', CHARACTER_FORMAT_DEFAULTS.emphasisMark);
+        },
+        set: function (value) {
+            this.emphasisValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "textEffect", {
+        /** Animated text effect (`w:effect`). */
+        get: function () {
+            if (this.textEffectValue !== undefined) {
+                return this.textEffectValue;
+            }
+            return this.effectiveOrDefault('textEffect', CHARACTER_FORMAT_DEFAULTS.textEffect);
+        },
+        set: function (value) {
+            this.textEffectValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "specVanish", {
+        /**
+         * @private
+         * `w:specVanish`
+         */
+        get: function () {
+            if (this.specVanishValue !== undefined) {
+                return this.specVanishValue;
+            }
+            return this.effective('specVanish');
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.specVanishValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterFormat.prototype, "snapToGrid", {
+        /**
+         * @private
+         * `w:snapToGrid`
+         */
+        get: function () {
+            if (this.snapToGridValue !== undefined) {
+                return this.snapToGridValue;
+            }
+            return this.effective('snapToGrid');
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.snapToGridValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Apply a partial delta. Uses setters (exclusivity applies).
+     * @public
+     */
+    CharacterFormat.prototype.assign = function (delta) {
+        if (delta.bold !== undefined) {
+            this.bold = delta.bold;
+        }
+        if (delta.italic !== undefined) {
+            this.italic = delta.italic;
+        }
+        if (delta.strikethrough !== undefined) {
+            this.strikethrough = delta.strikethrough;
+        }
+        if (delta.doubleStrikethrough !== undefined) {
+            this.doubleStrikethrough = delta.doubleStrikethrough;
+        }
+        if (delta.allCaps !== undefined) {
+            this.allCaps = delta.allCaps;
+        }
+        if (delta.smallCaps !== undefined) {
+            this.smallCaps = delta.smallCaps;
+        }
+        if (delta.hidden !== undefined) {
+            this.hidden = delta.hidden;
+        }
+        if (delta.emboss !== undefined) {
+            this.emboss = delta.emboss;
+        }
+        if (delta.engrave !== undefined) {
+            this.engrave = delta.engrave;
+        }
+        if (delta.outline !== undefined) {
+            this.outline = delta.outline;
+        }
+        if (delta.shadow !== undefined) {
+            this.shadow = delta.shadow;
+        }
+        if (delta.noProof !== undefined) {
+            this.noProof = delta.noProof;
+        }
+        if (delta.webHidden !== undefined) {
+            this.webHidden = delta.webHidden;
+        }
+        if (delta.fontSize !== undefined) {
+            this.fontSize = delta.fontSize;
+        }
+        if (delta.fontName !== undefined) {
+            this.fontName = delta.fontName;
+        }
+        if (delta.fontNameBidi !== undefined) {
+            this.fontNameBidi = delta.fontNameBidi;
+        }
+        if (delta.underlineStyle !== undefined) {
+            this.underlineStyle = delta.underlineStyle;
+        }
+        if (delta.underlineColor !== undefined) {
+            this.underlineColor = delta.underlineColor;
+        }
+        if (delta.textColor !== undefined) {
+            this.textColor = delta.textColor;
+        }
+        if (delta.highlightColor !== undefined) {
+            this.highlightColor = delta.highlightColor;
+        }
+        if (delta.textBackgroundColor !== undefined) {
+            this.textBackgroundColor = delta.textBackgroundColor;
+        }
+        if (delta.subSuperScript !== undefined) {
+            this.subSuperScript = delta.subSuperScript;
+        }
+        if (delta.characterSpacing !== undefined) {
+            this.characterSpacing = delta.characterSpacing;
+        }
+        if (delta.position !== undefined) {
+            this.position = delta.position;
+        }
+        if (delta.kerning !== undefined) {
+            this.kerning = delta.kerning;
+        }
+        if (delta.scaling !== undefined) {
+            this.scaling = delta.scaling;
+        }
+        if (delta.border !== undefined) {
+            this.border = delta.border;
+        }
+        if (delta.localeId !== undefined) {
+            this.localeId = delta.localeId;
+        }
+        if (delta.localeIdBidi !== undefined) {
+            this.localeIdBidi = delta.localeIdBidi;
+        }
+        if (delta.localeIdFarEast !== undefined) {
+            this.localeIdFarEast = delta.localeIdFarEast;
+        }
+        if (delta.characterStyle !== undefined) {
+            this.characterStyle = delta.characterStyle;
+        }
+        if (delta.bidi !== undefined) {
+            this.bidi = delta.bidi;
+        }
+        if (delta.complexScript !== undefined) {
+            this.complexScript = delta.complexScript;
+        }
+        if (delta.boldBidi !== undefined) {
+            this.boldBidi = delta.boldBidi;
+        }
+        if (delta.italicBidi !== undefined) {
+            this.italicBidi = delta.italicBidi;
+        }
+        if (delta.fontSizeBidi !== undefined) {
+            this.fontSizeBidi = delta.fontSizeBidi;
+        }
+        if (delta.emphasisMark !== undefined) {
+            this.emphasisMark = delta.emphasisMark;
+        }
+        if (delta.textEffect !== undefined) {
+            this.textEffect = delta.textEffect;
+        }
+    };
+    /**
+     * Clear all typed formatting. Does not clear `rPrExtra`.
+     * @public
+     */
+    CharacterFormat.prototype.clear = function () {
+        this.styleIdValue = undefined;
+        this.boldValue = undefined;
+        this.italicValue = undefined;
+        this.strikeValue = undefined;
+        this.doubleStrikeValue = undefined;
+        this.vanishValue = undefined;
+        this.legacyHiddenValue = undefined;
+        this.noProofValue = undefined;
+        this.fontSizeValue = undefined;
+        this.fontSizeBidiValue = undefined;
+        this.textColorValue = undefined;
+        this.textColorTheme = undefined;
+        this.highlightValue = undefined;
+        this.shadingValue = undefined;
+        this.underlineStyleValue = undefined;
+        this.underlineColorValue = undefined;
+        this.vertAlignValue = undefined;
+        this.smallCapsValue = undefined;
+        this.allCapsValue = undefined;
+        this.fontsValue = undefined;
+        this.characterScaleValue = undefined;
+        this.kerningValue = undefined;
+        this.characterSpacingValue = undefined;
+        this.positionValue = undefined;
+        this.borderValue = undefined;
+        this.languageValue = undefined;
+        this.embossValue = undefined;
+        this.imprintValue = undefined;
+        this.outlineValue = undefined;
+        this.shadowValue = undefined;
+        this.webHiddenValue = undefined;
+        this.bidiValue = undefined;
+        this.complexScriptValue = undefined;
+        this.boldBidiValue = undefined;
+        this.italicBidiValue = undefined;
+        this.emphasisValue = undefined;
+        this.textEffectValue = undefined;
+        this.specVanishValue = undefined;
+        this.snapToGridValue = undefined;
+        this.mutate();
+    };
+    /**
+     * @private
+     * Load snapshot without exclusivity side-effects.
+     */
+    CharacterFormat.prototype.hydrate = function (data) {
+        this.rPrExtra = data.rPrExtra;
+        this.styleIdValue = data.styleIdValue;
+        this.boldValue = data.boldValue;
+        this.italicValue = data.italicValue;
+        this.strikeValue = data.strikeValue;
+        this.doubleStrikeValue = data.doubleStrikeValue;
+        this.vanishValue = data.vanishValue;
+        this.legacyHiddenValue = data.legacyHiddenValue;
+        this.noProofValue = data.noProofValue;
+        this.fontSizeValue = data.fontSizeValue;
+        this.fontSizeBidiValue = data.fontSizeBidiValue;
+        this.textColorValue = data.textColorValue;
+        this.textColorTheme = data.textColorTheme;
+        this.highlightValue = data.highlightValue;
+        this.shadingValue = data.shadingValue;
+        this.underlineStyleValue = data.underlineStyleValue;
+        this.underlineColorValue = data.underlineColorValue;
+        this.vertAlignValue = data.vertAlignValue;
+        this.smallCapsValue = data.smallCapsValue;
+        this.allCapsValue = data.allCapsValue;
+        this.fontsValue = data.fontsValue;
+        this.characterScaleValue = data.characterScaleValue;
+        this.kerningValue = data.kerningValue;
+        this.characterSpacingValue = data.characterSpacingValue;
+        this.positionValue = data.positionValue;
+        this.borderValue = data.borderValue;
+        this.languageValue = data.languageValue;
+        this.embossValue = data.embossValue;
+        this.imprintValue = data.imprintValue;
+        this.outlineValue = data.outlineValue;
+        this.shadowValue = data.shadowValue;
+        this.webHiddenValue = data.webHiddenValue;
+        this.bidiValue = data.bidiValue;
+        this.complexScriptValue = data.complexScriptValue;
+        this.boldBidiValue = data.boldBidiValue;
+        this.italicBidiValue = data.italicBidiValue;
+        this.emphasisValue = data.emphasisValue;
+        this.textEffectValue = data.textEffectValue;
+        this.specVanishValue = data.specVanishValue;
+        this.snapToGridValue = data.snapToGridValue;
+    };
+    /**
+     * @private
+     */
+    CharacterFormat.prototype.snapshot = function () {
+        return {
+            rPrExtra: this.rPrExtra,
+            styleIdValue: this.styleIdValue,
+            boldValue: this.boldValue,
+            italicValue: this.italicValue,
+            strikeValue: this.strikeValue,
+            doubleStrikeValue: this.doubleStrikeValue,
+            vanishValue: this.vanishValue,
+            legacyHiddenValue: this.legacyHiddenValue,
+            noProofValue: this.noProofValue,
+            fontSizeValue: this.fontSizeValue,
+            fontSizeBidiValue: this.fontSizeBidiValue,
+            textColorValue: this.textColorValue,
+            textColorTheme: this.textColorTheme,
+            highlightValue: this.highlightValue,
+            shadingValue: this.shadingValue,
+            underlineStyleValue: this.underlineStyleValue,
+            underlineColorValue: this.underlineColorValue,
+            vertAlignValue: this.vertAlignValue,
+            smallCapsValue: this.smallCapsValue,
+            allCapsValue: this.allCapsValue,
+            fontsValue: this.fontsValue,
+            characterScaleValue: this.characterScaleValue,
+            kerningValue: this.kerningValue,
+            characterSpacingValue: this.characterSpacingValue,
+            positionValue: this.positionValue,
+            borderValue: this.borderValue,
+            languageValue: this.languageValue,
+            embossValue: this.embossValue,
+            imprintValue: this.imprintValue,
+            outlineValue: this.outlineValue,
+            shadowValue: this.shadowValue,
+            webHiddenValue: this.webHiddenValue,
+            bidiValue: this.bidiValue,
+            complexScriptValue: this.complexScriptValue,
+            boldBidiValue: this.boldBidiValue,
+            italicBidiValue: this.italicBidiValue,
+            emphasisValue: this.emphasisValue,
+            textEffectValue: this.textEffectValue,
+            specVanishValue: this.specVanishValue,
+            snapToGridValue: this.snapToGridValue,
+        };
+    };
+    /**
+     * @private
+     * Materialize `w:rPr` children (Spec §7.2 order).
+     */
+    CharacterFormat.prototype.buildRPrChildren = function () {
+        return buildRPrChildrenFromSnapshot(this.snapshot());
+    };
+    /**
+     * @private
+     * Fonts record for style resolver / direct font parse.
+     */
+    CharacterFormat.prototype.fontsRecord = function () {
+        return this.fontsValue;
+    };
+    return CharacterFormat;
+}());
+export { CharacterFormat };