@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/styles/run-properties.d.ts

@@ -0,0 +1,93 @@
+import { TextRange } from '../document/text-range';
+import { OpenXmlElement } from '../../core/xml/index';
+import { ThemeFontSlot } from './theme';
+/**
+ * Modeled language tags from `w:lang` (`CT_Language`).
+ *
+ * @private
+ */
+export interface ModeledRunLanguage {
+    readonly val: string | undefined;
+    readonly eastAsia: string | undefined;
+    readonly bidi: string | undefined;
+}
+/**
+ * Underline kind (`ST_Underline` subset used by built-in styles). §17.18.99
+ *
+ * @public
+ */
+export declare type RunUnderlineKind = 'single' | 'words' | 'double' | 'thick' | 'dotted' | 'dottedHeavy' | 'dash' | 'dashedHeavy' | 'dashLong' | 'dashLongHeavy' | 'dotDash' | 'dashDotHeavy' | 'dotDotDash' | 'dashDotDotHeavy' | 'wave' | 'wavyHeavy' | 'wavyDouble' | 'none';
+/** `w:u` payload. §17.3.2.40 (`CT_Underline`). @public */
+export interface ModeledRunUnderline {
+    readonly kind: RunUnderlineKind;
+    /** `@w:color` (`ST_HexColor`, `auto` allowed). */
+    readonly color: string | undefined;
+}
+/** Vertical alignment (`ST_VerticalAlignRun`). §17.18.100 @public */
+export declare type RunVerticalAlignment = 'baseline' | 'superscript' | 'subscript';
+/** Font hint (`ST_Hint`). §17.18.40 @public */
+export declare type RunFontHint = 'default' | 'eastAsia';
+/**
+ * Modeled run properties extracted from a `w:rPr` element. *
+ * @private
+ */
+export interface ModeledRunProperties {
+    readonly bold: boolean | undefined;
+    readonly boldCs: boolean | undefined;
+    readonly italic: boolean | undefined;
+    readonly italicCs: boolean | undefined;
+    /** Font size in points (`w:sz` half-points on the wire). */
+    readonly fontSize: number | undefined;
+    /** Complex-script font size in points (`w:szCs` half-points on the wire). */
+    readonly fontSizeCs: number | undefined;
+    /** Kerning threshold in points (`w:kern` / `CT_HpsMeasure` half-points → pt). */
+    readonly kerning: number | undefined;
+    readonly asciiFont: string | undefined;
+    readonly hAnsiFont: string | undefined;
+    /** Explicit East-Asian font name (`w:rFonts/@w:eastAsia`). */
+    readonly eastAsiaFont: string | undefined;
+    /** Complex-script font name (`w:rFonts/@w:cs`). */
+    readonly csFont: string | undefined;
+    /** Font hint (`w:rFonts/@w:hint`). */
+    readonly fontHint: RunFontHint | undefined;
+    readonly asciiTheme: ThemeFontSlot | undefined;
+    readonly hAnsiTheme: ThemeFontSlot | undefined;
+    readonly eastAsiaTheme: ThemeFontSlot | undefined;
+    readonly csTheme: ThemeFontSlot | undefined;
+    readonly underline: ModeledRunUnderline | undefined;
+    /** Font color (`w:color/@w:val`, `ST_HexColor`; `auto` preserved verbatim). */
+    readonly color: string | undefined;
+    readonly vertAlign: RunVerticalAlignment | undefined;
+    readonly lang: ModeledRunLanguage | undefined;
+}
+export declare const EMPTY_MODELED_RUN_PROPERTIES: ModeledRunProperties;
+export declare function parseModeledRunProperties(rPr: OpenXmlElement | undefined): ModeledRunProperties;
+export declare function mergeModeledRunProperties(base: ModeledRunProperties, override: ModeledRunProperties): ModeledRunProperties;
+/** Parse direct `w:rFonts` from the run's {@link TextRange.characterFormat} fonts record. */
+export declare function parseDirectRunFontProperties(run: TextRange): Pick<ModeledRunProperties, 'asciiFont' | 'hAnsiFont' | 'eastAsiaFont' | 'csFont' | 'fontHint' | 'asciiTheme' | 'hAnsiTheme' | 'eastAsiaTheme' | 'csTheme'>;
+export interface StyleRunDefinition {
+    readonly basedOn: string | undefined;
+    readonly runProperties: ModeledRunProperties;
+}
+export declare function parseStyleRunDefinition(style: OpenXmlElement): StyleRunDefinition;
+/**
+ * Modeled run properties from a `w:docDefaults` element (or any element that nests
+ * `w:rPrDefault/w:rPr`). Prefer {@link DocDefaults.runProperties} when a typed
+ * defaults object is already available.
+ *
+ * @private
+ */
+export declare function parseDocDefaultsRunProperties(docDefaultsRoot: OpenXmlElement | undefined): ModeledRunProperties;
+export declare function effectiveBold(properties: ModeledRunProperties): boolean;
+export declare function effectiveItalic(properties: ModeledRunProperties): boolean;
+/**
+ * Serialize modeled run properties into a `w:rPr` element.
+ *
+ * Emits only defined fields, in `EG_RPrBase` sequence order
+ * (rFonts → b → bCs → i → iCs → color → kern → sz → szCs → u → vertAlign →
+ * lang). Returns `undefined` when no modeled property is set — callers must
+ * not write empty payload containers.
+ *
+ * @private
+ */
+export declare function serializeModeledRunProperties(properties: ModeledRunProperties): OpenXmlElement | undefined;

package/src/features/styles/run-properties.js

@@ -0,0 +1,516 @@
+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 '../document/on-off';
+import { pointToHalfPoints, halfPointsToPoint } from '../document/length';
+import { elementChildren, isWml, wmlAttr, wmlElement, wValAttribute, WML, } from '../document/wml';
+import { parseThemeFontSlot } from './theme';
+export var EMPTY_MODELED_RUN_PROPERTIES = {
+    bold: undefined,
+    boldCs: undefined,
+    italic: undefined,
+    italicCs: undefined,
+    fontSize: undefined,
+    fontSizeCs: undefined,
+    kerning: undefined,
+    asciiFont: undefined,
+    hAnsiFont: undefined,
+    eastAsiaFont: undefined,
+    csFont: undefined,
+    fontHint: undefined,
+    asciiTheme: undefined,
+    hAnsiTheme: undefined,
+    eastAsiaTheme: undefined,
+    csTheme: undefined,
+    underline: undefined,
+    color: undefined,
+    vertAlign: undefined,
+    lang: undefined,
+};
+var UNDERLINE_KINDS = new Set([
+    'single', 'words', 'double', 'thick', 'dotted', 'dottedHeavy', 'dash',
+    'dashedHeavy', 'dashLong', 'dashLongHeavy', 'dotDash', 'dashDotHeavy',
+    'dotDotDash', 'dashDotDotHeavy', 'wave', 'wavyHeavy', 'wavyDouble', 'none',
+]);
+var VERTICAL_ALIGNMENTS = new Set([
+    'baseline', 'superscript', 'subscript',
+]);
+var FONT_HINTS = new Set(['default', 'eastAsia']);
+/** `ST_HexColor` (`ST_HexColorAuto` | 6-digit `ST_HexColorRGB`). */
+var HEX_COLOR_PATTERN = /^([0-9A-Fa-f]{6}|auto)$/;
+function parseUnderlineKind(raw) {
+    return raw !== undefined && UNDERLINE_KINDS.has(raw) ? raw : undefined;
+}
+function parseVerticalAlignment(raw) {
+    return raw !== undefined && VERTICAL_ALIGNMENTS.has(raw)
+        ? raw
+        : undefined;
+}
+function parseFontHint(raw) {
+    return raw !== undefined && FONT_HINTS.has(raw) ? raw : undefined;
+}
+function wRFontsAttribute(rFonts, localName) {
+    var found = rFonts.attributes.find(function (attribute) { return attribute.localName === localName && (attribute.namespaceUri === WML || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function wLangAttribute(lang, localName) {
+    var found = lang.attributes.find(function (attribute) { return attribute.localName === localName && (attribute.namespaceUri === WML || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+function parseRFontsElement(rFonts) {
+    var ascii = wRFontsAttribute(rFonts, 'ascii');
+    var hAnsi = wRFontsAttribute(rFonts, 'hAnsi');
+    var eastAsia = wRFontsAttribute(rFonts, 'eastAsia');
+    var cs = wRFontsAttribute(rFonts, 'cs');
+    var asciiTheme = parseThemeFontSlot(wRFontsAttribute(rFonts, 'asciiTheme'));
+    var hAnsiTheme = parseThemeFontSlot(wRFontsAttribute(rFonts, 'hAnsiTheme'));
+    var eastAsiaTheme = parseThemeFontSlot(wRFontsAttribute(rFonts, 'eastAsiaTheme'));
+    var csTheme = parseThemeFontSlot(wRFontsAttribute(rFonts, 'cstheme'));
+    return {
+        asciiFont: ascii !== undefined ? ascii : undefined,
+        hAnsiFont: hAnsi !== undefined ? hAnsi : undefined,
+        eastAsiaFont: eastAsia !== undefined ? eastAsia : undefined,
+        csFont: cs !== undefined ? cs : undefined,
+        fontHint: parseFontHint(wRFontsAttribute(rFonts, 'hint')),
+        asciiTheme: ascii === undefined ? asciiTheme : undefined,
+        hAnsiTheme: hAnsi === undefined ? hAnsiTheme : undefined,
+        eastAsiaTheme: eastAsia === undefined ? eastAsiaTheme : undefined,
+        csTheme: cs === undefined ? csTheme : undefined,
+    };
+}
+function parseLangElement(lang) {
+    var val = wLangAttribute(lang, 'val');
+    var eastAsia = wLangAttribute(lang, 'eastAsia');
+    var bidi = wLangAttribute(lang, 'bidi');
+    if (val === undefined && eastAsia === undefined && bidi === undefined) {
+        return undefined;
+    }
+    return { val: val, eastAsia: eastAsia, bidi: bidi };
+}
+function parseHpsMeasureToLength(element) {
+    var raw = wValAttribute(element);
+    if (raw === undefined || !/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    return halfPointsToPoint(parseInt(raw, 10));
+}
+export function parseModeledRunProperties(rPr) {
+    var e_1, _a;
+    if (rPr === undefined || !isWml(rPr, 'rPr')) {
+        return EMPTY_MODELED_RUN_PROPERTIES;
+    }
+    var bold;
+    var boldCs;
+    var italic;
+    var italicCs;
+    var fontSize;
+    var fontSizeCs;
+    var kerning;
+    var asciiFont;
+    var hAnsiFont;
+    var eastAsiaFont;
+    var csFont;
+    var fontHint;
+    var asciiTheme;
+    var hAnsiTheme;
+    var eastAsiaTheme;
+    var csTheme;
+    var underline;
+    var color;
+    var vertAlign;
+    var lang;
+    try {
+        for (var _b = __values(elementChildren(rPr)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var prop = _c.value;
+            if (!isWml(prop, prop.localName)) {
+                continue;
+            }
+            if (prop.localName === 'rFonts') {
+                var fonts = parseRFontsElement(prop);
+                asciiFont = fonts.asciiFont;
+                hAnsiFont = fonts.hAnsiFont;
+                eastAsiaFont = fonts.eastAsiaFont;
+                csFont = fonts.csFont;
+                fontHint = fonts.fontHint;
+                asciiTheme = fonts.asciiTheme;
+                hAnsiTheme = fonts.hAnsiTheme;
+                eastAsiaTheme = fonts.eastAsiaTheme;
+                csTheme = fonts.csTheme;
+                continue;
+            }
+            if (prop.localName === 'sz') {
+                fontSize = parseHpsMeasureToLength(prop);
+                continue;
+            }
+            if (prop.localName === 'szCs') {
+                fontSizeCs = parseHpsMeasureToLength(prop);
+                continue;
+            }
+            if (prop.localName === 'kern') {
+                kerning = parseHpsMeasureToLength(prop);
+                continue;
+            }
+            if (prop.localName === 'lang') {
+                lang = parseLangElement(prop);
+                continue;
+            }
+            if (prop.localName === 'u') {
+                var kind = parseUnderlineKind(wValAttribute(prop));
+                if (kind !== undefined) {
+                    var uColor = wRFontsAttribute(prop, 'color');
+                    underline = {
+                        kind: kind,
+                        color: uColor !== undefined ? uColor : undefined,
+                    };
+                }
+                continue;
+            }
+            if (prop.localName === 'color') {
+                var val = wValAttribute(prop);
+                if (val !== undefined && HEX_COLOR_PATTERN.test(val)) {
+                    color = val;
+                }
+                continue;
+            }
+            if (prop.localName === 'vertAlign') {
+                vertAlign = parseVerticalAlignment(wValAttribute(prop));
+                continue;
+            }
+            if (prop.localName !== 'b' && prop.localName !== 'i' && prop.localName !== 'bCs' && prop.localName !== 'iCs') {
+                continue;
+            }
+            var flag = parseOnOff(prop);
+            if (flag === undefined) {
+                continue;
+            }
+            if (prop.localName === 'b') {
+                bold = flag;
+            }
+            else if (prop.localName === 'i') {
+                italic = flag;
+            }
+            else if (prop.localName === 'bCs') {
+                boldCs = flag;
+            }
+            else {
+                italicCs = flag;
+            }
+        }
+    }
+    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; }
+    }
+    return {
+        bold: bold,
+        boldCs: boldCs,
+        italic: italic,
+        italicCs: italicCs,
+        fontSize: fontSize,
+        fontSizeCs: fontSizeCs,
+        kerning: kerning,
+        asciiFont: asciiFont,
+        hAnsiFont: hAnsiFont,
+        eastAsiaFont: eastAsiaFont,
+        csFont: csFont,
+        fontHint: fontHint,
+        asciiTheme: asciiTheme,
+        hAnsiTheme: hAnsiTheme,
+        eastAsiaTheme: eastAsiaTheme,
+        csTheme: csTheme,
+        underline: underline,
+        color: color,
+        vertAlign: vertAlign,
+        lang: lang,
+    };
+}
+function mergeFontSlot(baseFont, baseTheme, overrideFont, overrideTheme) {
+    if (overrideFont !== undefined) {
+        return { font: overrideFont, theme: undefined };
+    }
+    if (overrideTheme !== undefined) {
+        return { font: undefined, theme: overrideTheme };
+    }
+    return { font: baseFont, theme: baseTheme };
+}
+/** Character slot merge: explicit name wins over theme slot; absent falls back. */
+function mergeNamedThemeSlot(baseFont, baseTheme, overrideFont, overrideTheme) {
+    if (overrideFont !== undefined) {
+        return { font: overrideFont, theme: undefined };
+    }
+    if (overrideTheme !== undefined) {
+        return { font: undefined, theme: overrideTheme };
+    }
+    return { font: baseFont, theme: baseTheme };
+}
+function mergeLang(base, override) {
+    if (override === undefined) {
+        return base;
+    }
+    if (base === undefined) {
+        return override;
+    }
+    return {
+        val: override.val !== undefined ? override.val : base.val,
+        eastAsia: override.eastAsia !== undefined ? override.eastAsia : base.eastAsia,
+        bidi: override.bidi !== undefined ? override.bidi : base.bidi,
+    };
+}
+export function mergeModeledRunProperties(base, override) {
+    var ascii = mergeFontSlot(base.asciiFont, base.asciiTheme, override.asciiFont, override.asciiTheme);
+    var hAnsi = mergeFontSlot(base.hAnsiFont, base.hAnsiTheme, override.hAnsiFont, override.hAnsiTheme);
+    var eastAsia = mergeNamedThemeSlot(base.eastAsiaFont, base.eastAsiaTheme, override.eastAsiaFont, override.eastAsiaTheme);
+    var cs = mergeNamedThemeSlot(base.csFont, base.csTheme, override.csFont, override.csTheme);
+    return {
+        bold: override.bold !== undefined ? override.bold : base.bold,
+        boldCs: override.boldCs !== undefined ? override.boldCs : base.boldCs,
+        italic: override.italic !== undefined ? override.italic : base.italic,
+        italicCs: override.italicCs !== undefined ? override.italicCs : base.italicCs,
+        fontSize: override.fontSize !== undefined ? override.fontSize : base.fontSize,
+        fontSizeCs: override.fontSizeCs !== undefined ? override.fontSizeCs : base.fontSizeCs,
+        kerning: override.kerning !== undefined ? override.kerning : base.kerning,
+        asciiFont: ascii.font,
+        hAnsiFont: hAnsi.font,
+        eastAsiaFont: eastAsia.font,
+        csFont: cs.font,
+        fontHint: override.fontHint !== undefined ? override.fontHint : base.fontHint,
+        asciiTheme: ascii.theme,
+        hAnsiTheme: hAnsi.theme,
+        eastAsiaTheme: eastAsia.theme,
+        csTheme: cs.theme,
+        underline: override.underline !== undefined ? override.underline : base.underline,
+        color: override.color !== undefined ? override.color : base.color,
+        vertAlign: override.vertAlign !== undefined ? override.vertAlign : base.vertAlign,
+        lang: mergeLang(base.lang, override.lang),
+    };
+}
+/** Parse direct `w:rFonts` from the run's {@link TextRange.characterFormat} fonts record. */
+export function parseDirectRunFontProperties(run) {
+    var fonts = run.characterFormat.fontsRecord();
+    if (fonts === undefined) {
+        return {
+            asciiFont: undefined,
+            hAnsiFont: undefined,
+            eastAsiaFont: undefined,
+            csFont: undefined,
+            fontHint: undefined,
+            asciiTheme: undefined,
+            hAnsiTheme: undefined,
+            eastAsiaTheme: undefined,
+            csTheme: undefined,
+        };
+    }
+    var hintRaw = fonts.hint;
+    var fontHint = hintRaw === 'default' || hintRaw === 'eastAsia' ? hintRaw : undefined;
+    return {
+        asciiFont: fonts.ascii,
+        hAnsiFont: fonts.hAnsi,
+        eastAsiaFont: fonts.eastAsia,
+        csFont: fonts.cs,
+        fontHint: fontHint,
+        asciiTheme: parseThemeFontSlot(fonts.asciiTheme),
+        hAnsiTheme: parseThemeFontSlot(fonts.hAnsiTheme),
+        eastAsiaTheme: parseThemeFontSlot(fonts.eastAsiaTheme),
+        csTheme: parseThemeFontSlot(fonts.cTheme),
+    };
+}
+export function parseStyleRunDefinition(style) {
+    var e_2, _a;
+    var basedOn;
+    var rPr;
+    try {
+        for (var _b = __values(elementChildren(style)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'basedOn')) {
+                basedOn = wValAttribute(child);
+                continue;
+            }
+            if (isWml(child, 'rPr')) {
+                rPr = child;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return {
+        basedOn: basedOn,
+        runProperties: parseModeledRunProperties(rPr),
+    };
+}
+/**
+ * Modeled run properties from a `w:docDefaults` element (or any element that nests
+ * `w:rPrDefault/w:rPr`). Prefer {@link DocDefaults.runProperties} when a typed
+ * defaults object is already available.
+ *
+ * @private
+ */
+export function parseDocDefaultsRunProperties(docDefaultsRoot) {
+    var e_3, _a, e_4, _b;
+    if (docDefaultsRoot === undefined || !isWml(docDefaultsRoot, 'docDefaults')) {
+        return EMPTY_MODELED_RUN_PROPERTIES;
+    }
+    try {
+        for (var _c = __values(elementChildren(docDefaultsRoot)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var defaultsChild = _d.value;
+            if (!isWml(defaultsChild, 'rPrDefault')) {
+                continue;
+            }
+            try {
+                for (var _e = __values(elementChildren(defaultsChild)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var rPrDefaultChild = _f.value;
+                    if (isWml(rPrDefaultChild, 'rPr')) {
+                        return parseModeledRunProperties(rPrDefaultChild);
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return EMPTY_MODELED_RUN_PROPERTIES;
+}
+export function effectiveBold(properties) {
+    return properties.bold != null ? properties.bold : false;
+}
+export function effectiveItalic(properties) {
+    return properties.italic != null ? properties.italic : false;
+}
+// ---------------------------------------------------------------------------
+// Serialization (typed fields → w:rPr children, EG_RPrBase sequence order)
+// ---------------------------------------------------------------------------
+/** Point → `ST_HpsMeasure` half-point string (12 pt → "24"). */
+function serializeHpsMeasure(value) {
+    return String(pointToHalfPoints(value));
+}
+/**
+ * Serialize modeled run properties into a `w:rPr` element.
+ *
+ * Emits only defined fields, in `EG_RPrBase` sequence order
+ * (rFonts → b → bCs → i → iCs → color → kern → sz → szCs → u → vertAlign →
+ * lang). Returns `undefined` when no modeled property is set — callers must
+ * not write empty payload containers.
+ *
+ * @private
+ */
+export function serializeModeledRunProperties(properties) {
+    var children = [];
+    if (properties.asciiFont !== undefined ||
+        properties.hAnsiFont !== undefined ||
+        properties.eastAsiaFont !== undefined ||
+        properties.csFont !== undefined ||
+        properties.fontHint !== undefined ||
+        properties.asciiTheme !== undefined ||
+        properties.hAnsiTheme !== undefined ||
+        properties.eastAsiaTheme !== undefined ||
+        properties.csTheme !== undefined) {
+        var attributes = [];
+        if (properties.asciiFont !== undefined) {
+            attributes.push(wmlAttr('ascii', properties.asciiFont));
+        }
+        if (properties.hAnsiFont !== undefined) {
+            attributes.push(wmlAttr('hAnsi', properties.hAnsiFont));
+        }
+        if (properties.eastAsiaFont !== undefined) {
+            attributes.push(wmlAttr('eastAsia', properties.eastAsiaFont));
+        }
+        if (properties.csFont !== undefined) {
+            attributes.push(wmlAttr('cs', properties.csFont));
+        }
+        if (properties.asciiTheme !== undefined) {
+            attributes.push(wmlAttr('asciiTheme', properties.asciiTheme));
+        }
+        if (properties.hAnsiTheme !== undefined) {
+            attributes.push(wmlAttr('hAnsiTheme', properties.hAnsiTheme));
+        }
+        if (properties.eastAsiaTheme !== undefined) {
+            attributes.push(wmlAttr('eastAsiaTheme', properties.eastAsiaTheme));
+        }
+        if (properties.csTheme !== undefined) {
+            attributes.push(wmlAttr('cstheme', properties.csTheme));
+        }
+        if (properties.fontHint !== undefined) {
+            attributes.push(wmlAttr('hint', properties.fontHint));
+        }
+        children.push(wmlElement('rFonts', { attributes: attributes }));
+    }
+    if (properties.bold !== undefined) {
+        children.push(serializeOnOff('b', properties.bold));
+    }
+    if (properties.boldCs !== undefined) {
+        children.push(serializeOnOff('bCs', properties.boldCs));
+    }
+    if (properties.italic !== undefined) {
+        children.push(serializeOnOff('i', properties.italic));
+    }
+    if (properties.italicCs !== undefined) {
+        children.push(serializeOnOff('iCs', properties.italicCs));
+    }
+    if (properties.color !== undefined) {
+        children.push(wmlElement('color', { attributes: [wmlAttr('val', properties.color)] }));
+    }
+    if (properties.kerning !== undefined) {
+        children.push(wmlElement('kern', { attributes: [wmlAttr('val', serializeHpsMeasure(properties.kerning))] }));
+    }
+    if (properties.fontSize !== undefined) {
+        children.push(wmlElement('sz', { attributes: [wmlAttr('val', serializeHpsMeasure(properties.fontSize))] }));
+    }
+    if (properties.fontSizeCs !== undefined) {
+        children.push(wmlElement('szCs', { attributes: [wmlAttr('val', serializeHpsMeasure(properties.fontSizeCs))] }));
+    }
+    if (properties.underline !== undefined) {
+        var attributes = [wmlAttr('val', properties.underline.kind)];
+        if (properties.underline.color !== undefined) {
+            attributes.push(wmlAttr('color', properties.underline.color));
+        }
+        children.push(wmlElement('u', { attributes: attributes }));
+    }
+    if (properties.vertAlign !== undefined) {
+        children.push(wmlElement('vertAlign', { attributes: [wmlAttr('val', properties.vertAlign)] }));
+    }
+    if (properties.lang !== undefined) {
+        var attributes = [];
+        if (properties.lang.val !== undefined) {
+            attributes.push(wmlAttr('val', properties.lang.val));
+        }
+        if (properties.lang.eastAsia !== undefined) {
+            attributes.push(wmlAttr('eastAsia', properties.lang.eastAsia));
+        }
+        if (properties.lang.bidi !== undefined) {
+            attributes.push(wmlAttr('bidi', properties.lang.bidi));
+        }
+        if (attributes.length > 0) {
+            children.push(wmlElement('lang', { attributes: attributes }));
+        }
+    }
+    if (children.length === 0) {
+        return undefined;
+    }
+    return wmlElement('rPr', { children: children });
+}