@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/document/run.js

@@ -0,0 +1,768 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+};
+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 { DetachedObjectError, DocxError, SecurityError } from '../../core/errors/docx-error';
+import { serializeFeatureRunLeaf, tryParseFeatureRunLeaf, } from '../../core/registry/run-leaf-handlers';
+import { DEFAULT_RESOURCE_LIMITS } from '../../core/security/limits';
+import { assertNever } from './assert-never';
+import { CharacterFormat, parseCharacterFormat, } from './character-format';
+import { elementChildren, isWml, textContent, wmlAttr, wmlElement, xmlSpaceIsPreserve, xmlSpacePreserve, } from './wml';
+// ---------------------------------------------------------------------------
+// Break leaf — ECMA-376-1 §17.3.3.1–2; CT_Br / ST_BrType / ST_BrClear
+// ---------------------------------------------------------------------------
+/**
+ * Break kind for `w:br` (`ST_BrType` plus the Line default).
+ *
+ * OOXML has no `@w:type="line"` value: a line break is a bare `w:br` (type omitted).
+ * Text-wrapping breaks use `@w:type="textWrapping"` and are modeled as
+ * {@link BreakType.TextWrappingBreak} (preferred) or as {@link BreakType.Line}
+ * with a non-{@link BreakClearType.None} clear (compat authoring form).
+ *
+ * Citation: ECMA-376-1 §17.3.3.1–2; transitional `wml.xsd` `CT_Br` / `ST_BrType`.
+ *
+ * @public
+ */
+var BreakType = {
+    /**
+     * Page break.
+     *
+     * Maps to `w:br` with `@w:type="page"`. Ends the current page and continues
+     * on the next page of the same section.
+     */
+    Page: 'page',
+    /**
+     * Column break.
+     *
+     * Maps to `w:br` with `@w:type="column"`. Ends the current column and continues
+     * in the next column of a multi-column section.
+     */
+    Column: 'column',
+    /**
+     * Line break (Shift+Enter / soft break).
+     *
+     * Maps to a bare `w:br` with `@w:type` omitted (there is no `ST_BrType` value
+     * `"line"`). When authored with a non-{@link BreakClearType.None} clear, the
+     * library emits `@w:type="textWrapping"` plus `@w:clear` for compatibility
+     * with the older Line+clear form.
+     */
+    Line: 'line',
+    /**
+     * Text-wrapping break.
+     *
+     * Maps to `w:br` with `@w:type="textWrapping"`. Optional
+     * {@link BreakClearType} (default {@link BreakClearType.None}) maps to
+     * `@w:clear` and controls which side of floating content the break clears.
+     */
+    TextWrappingBreak: 'textWrapping',
+};
+/**
+ * Text-wrapping clear for a line or text-wrapping break (`ST_BrClear`).
+ *
+ * Valid with {@link BreakType.TextWrappingBreak} or {@link BreakType.Line}.
+ * Default for {@link Run.appendBreak} / {@link Run.insertBreakAt} is
+ * {@link BreakClearType.None}. Non-`None` values on {@link BreakType.Page} or
+ * {@link BreakType.Column} throw {@link DocxError} `content/invalid-break`.
+ *
+ * Citation: ECMA-376-1 §17.3.3.2; transitional `wml.xsd` `ST_BrClear`.
+ *
+ * @public
+ */
+var BreakClearType = {
+    /**
+     * No clear (`ST_BrClear` `none`).
+     *
+     * Default. Does not emit `@w:clear` on write. On load, absent `@w:clear` and
+     * `@w:clear="none"` both surface as this value.
+     */
+    None: 'none',
+    /**
+     * Clear left (`@w:clear="left"`).
+     *
+     * Restart text after floating objects on the left.
+     */
+    Left: 'left',
+    /**
+     * Clear right (`@w:clear="right"`).
+     *
+     * Restart text after floating objects on the right.
+     */
+    Right: 'right',
+    /**
+     * Clear all (`@w:clear="all"`).
+     *
+     * Restart text after floating objects on both sides.
+     */
+    All: 'all',
+};
+function needsXmlSpacePreserve(text) {
+    return text.startsWith(' ') || text.endsWith(' ') || text.includes('  ') || text.includes('\n');
+}
+/**
+ * WordprocessingML run (`w:r`).
+ *
+ * Character formatting lives on {@link Run.characterFormat} only
+ * (`docs/specs/run-character-format.md` Rev 2 / TASK-9019).
+ *
+ * @public
+ */
+var Run = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function Run(owner) {
+        this.owner = owner;
+        this.extraAttributes = [];
+        this.leaves = [];
+    }
+    Object.defineProperty(Run.prototype, "characterFormat", {
+        /**
+         * Character formatting for this run (`w:rPr`). Lazily constructed; never null.
+         * @public
+         */
+        get: function () {
+            if (this.characterFormatField === undefined) {
+                this.characterFormatField = new CharacterFormat(this);
+            }
+            return this.characterFormatField;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    Run.prototype.notifyCharacterFormatMutation = function () {
+        this.mutate();
+    };
+    /**
+     * @private
+     */
+    Run.prototype.detach = function () {
+        this.owner = undefined;
+    };
+    /**
+     * @private
+     */
+    Run.prototype.attach = function (owner) {
+        this.owner = owner;
+    };
+    Run.prototype.mutate = function () {
+        if (this.owner === undefined) {
+            throw new DetachedObjectError('This run is no longer in a document');
+        }
+        this.owner.assertAttached(this);
+    };
+    Object.defineProperty(Run.prototype, "items", {
+        /** Text, tab, break, symbol, feature, and opaque leaves in order. */
+        get: function () {
+            return this.leaves;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+   * Replace inner content; used by feature modules. */
+    Run.prototype.setLeaves = function (leaves) {
+        this.mutate();
+        this.leaves = leaves;
+    };
+    /**
+     * Append a symbol character (`w:sym`) to this run.
+     *
+     * @param font - Symbol font name (`w:font`), for example `"Wingdings"`.
+     * @param char - `ST_ShortHexNumber` hex digits for `w:char` (four hex digits, e.g. `"F0FC"`).
+     * @returns This run for chaining.
+     *
+     * @example
+     * ```ts
+     * const run = paragraph.appendRun();
+     * run.appendSymbol('Wingdings', 'F0FC');
+     * ```
+     *
+     * @public
+     */
+    Run.prototype.appendSymbol = function (font, char) {
+        this.mutate();
+        this.leaves.push({ type: 'sym', font: font, char: char });
+        return this;
+    };
+    /**
+     * Append a break (`w:br`) to this run.
+     *
+     * Mapping (ECMA-376-1 §17.3.3.1–2; `ST_BrType` has no `"line"` value):
+     * - {@link BreakType.Page} → `@w:type="page"`
+     * - {@link BreakType.Column} → `@w:type="column"`
+     * - {@link BreakType.Line} with {@link BreakClearType.None} → bare `<w:br/>` (type omitted)
+     * - {@link BreakType.Line} with non-`None` clear → `@w:type="textWrapping"` + `@w:clear` (compat)
+     * - {@link BreakType.TextWrappingBreak} → `@w:type="textWrapping"` (+ `@w:clear` when not `None`)
+     *
+     * @param type - Break kind.
+     * @param clear - Text-wrapping clear; default {@link BreakClearType.None}.
+     *   Only meaningful for Line / TextWrappingBreak.
+     * @returns The break leaf view (not `this`).
+     * @throws {@link DocxError} `content/invalid-break` if a non-`None` clear is set on Page or Column.
+     *
+     * @example
+     * ```ts
+     * run.appendBreak(BreakType.Page);
+     * run.appendBreak(BreakType.TextWrappingBreak, BreakClearType.All);
+     * run.appendBreak(BreakType.Line, BreakClearType.All); // compat form
+     * ```
+     *
+     * @public
+     */
+    Run.prototype.appendBreak = function (type, clear) {
+        if (clear === void 0) { clear = BreakClearType.None; }
+        this.mutate();
+        var leaf = createBreakLeaf(type, clear);
+        this.leaves.push(leaf);
+        return toBreakLeafView(leaf);
+    };
+    /**
+     * Insert a break (`w:br`) at a leaf index in this run.
+     *
+     * Index is the position in {@link Run.items} (`0…content.length` inclusive).
+     *
+     * @param index - Leaf index at which to insert.
+     * @param type - Break kind.
+     * @param clear - Text-wrapping clear; default {@link BreakClearType.None}.
+     *   Only meaningful for Line / TextWrappingBreak.
+     * @returns The break leaf view.
+     * @throws RangeError if `index` is out of range.
+     * @throws {@link DocxError} `content/invalid-break` if a non-`None` clear is set on Page or Column.
+     *
+     * @public
+     */
+    Run.prototype.insertBreakAt = function (index, type, clear) {
+        if (clear === void 0) { clear = BreakClearType.None; }
+        this.mutate();
+        if (index < 0 || index > this.leaves.length) {
+            throw new RangeError("Break leaf index " + String(index) + " is out of range");
+        }
+        var leaf = createBreakLeaf(type, clear);
+        this.leaves.splice(index, 0, leaf);
+        return toBreakLeafView(leaf);
+    };
+    Object.defineProperty(Run.prototype, "text", {
+        /**
+         * Concatenated `w:t` text. Setter replaces all run leaves with a single text leaf.
+         */
+        get: function () {
+            var e_1, _a;
+            var out = '';
+            try {
+                for (var _b = __values(this.leaves), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var leaf = _c.value;
+                    if (leaf.type === 'text') {
+                        out += leaf.text;
+                    }
+                }
+            }
+            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 out;
+        },
+        set: function (value) {
+            this.mutate();
+            if (value.length > DEFAULT_RESOURCE_LIMITS.textNodeLength) {
+                throw new SecurityError('security/limit-exceeded', 'w:t exceeds the text node length limit');
+            }
+            this.leaves = [{ type: 'text', text: value, xmlSpacePreserve: needsXmlSpacePreserve(value) }];
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * Advanced hatch: `w:r` tree. Unstable; prefer semantic properties.
+     */
+    Run.prototype.toOpenXml = function () {
+        return serializeRun(this);
+    };
+    /**
+     * @private
+     */
+    Run.fromXml = function (el, owner) {
+        return parseRun(el, owner);
+    };
+    /**
+     * @private
+     */
+    Run.prototype.hydrate = function (data) {
+        this.extraAttributes = data.extraAttributes;
+        this.leaves = data.leaves;
+        var _extraAttributes = data.extraAttributes, _leaves = data.leaves, characterFormatData = __rest(data, ["extraAttributes", "leaves"]);
+        void _extraAttributes;
+        void _leaves;
+        this.characterFormat.hydrate(characterFormatData);
+    };
+    /**
+     * @private
+     */
+    Run.prototype.snapshot = function () {
+        var cf = this.characterFormat.snapshot();
+        return {
+            extraAttributes: this.extraAttributes,
+            leaves: this.leaves,
+            rPrExtra: cf.rPrExtra,
+            styleIdValue: cf.styleIdValue,
+            boldValue: cf.boldValue,
+            italicValue: cf.italicValue,
+            strikeValue: cf.strikeValue,
+            doubleStrikeValue: cf.doubleStrikeValue,
+            vanishValue: cf.vanishValue,
+            legacyHiddenValue: cf.legacyHiddenValue,
+            noProofValue: cf.noProofValue,
+            fontSizeValue: cf.fontSizeValue,
+            fontSizeBidiValue: cf.fontSizeBidiValue,
+            textColorValue: cf.textColorValue,
+            textColorTheme: cf.textColorTheme,
+            highlightValue: cf.highlightValue,
+            shadingValue: cf.shadingValue,
+            underlineStyleValue: cf.underlineStyleValue,
+            underlineColorValue: cf.underlineColorValue,
+            vertAlignValue: cf.vertAlignValue,
+            smallCapsValue: cf.smallCapsValue,
+            allCapsValue: cf.allCapsValue,
+            fontsValue: cf.fontsValue,
+            characterScaleValue: cf.characterScaleValue,
+            kerningValue: cf.kerningValue,
+            characterSpacingValue: cf.characterSpacingValue,
+            positionValue: cf.positionValue,
+            borderValue: cf.borderValue,
+            languageValue: cf.languageValue,
+            embossValue: cf.embossValue,
+            imprintValue: cf.imprintValue,
+            outlineValue: cf.outlineValue,
+            shadowValue: cf.shadowValue,
+            webHiddenValue: cf.webHiddenValue,
+            bidiValue: cf.bidiValue,
+            complexScriptValue: cf.complexScriptValue,
+            boldBidiValue: cf.boldBidiValue,
+            italicBidiValue: cf.italicBidiValue,
+            emphasisValue: cf.emphasisValue,
+            textEffectValue: cf.textEffectValue,
+            specVanishValue: cf.specVanishValue,
+            snapToGridValue: cf.snapToGridValue,
+        };
+    };
+    return Run;
+}());
+// ---------------------------------------------------------------------------
+// Parse
+// ---------------------------------------------------------------------------
+function parseRun(el, owner) {
+    var e_2, _a;
+    var run = new Run(owner);
+    var extraAttributes = el.attributes;
+    var leaves = [];
+    var characterFormatData;
+    try {
+        for (var _b = __values(elementChildren(el)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'rPr')) {
+                characterFormatData = parseCharacterFormat(child);
+                continue;
+            }
+            leaves.push(parseLeaf(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; }
+    }
+    if (characterFormatData !== undefined) {
+        run.hydrate({
+            extraAttributes: extraAttributes,
+            leaves: leaves,
+            rPrExtra: characterFormatData.rPrExtra,
+            styleIdValue: characterFormatData.styleIdValue,
+            boldValue: characterFormatData.boldValue,
+            italicValue: characterFormatData.italicValue,
+            strikeValue: characterFormatData.strikeValue,
+            doubleStrikeValue: characterFormatData.doubleStrikeValue,
+            vanishValue: characterFormatData.vanishValue,
+            legacyHiddenValue: characterFormatData.legacyHiddenValue,
+            noProofValue: characterFormatData.noProofValue,
+            fontSizeValue: characterFormatData.fontSizeValue,
+            fontSizeBidiValue: characterFormatData.fontSizeBidiValue,
+            textColorValue: characterFormatData.textColorValue,
+            textColorTheme: characterFormatData.textColorTheme,
+            highlightValue: characterFormatData.highlightValue,
+            shadingValue: characterFormatData.shadingValue,
+            underlineStyleValue: characterFormatData.underlineStyleValue,
+            underlineColorValue: characterFormatData.underlineColorValue,
+            vertAlignValue: characterFormatData.vertAlignValue,
+            smallCapsValue: characterFormatData.smallCapsValue,
+            allCapsValue: characterFormatData.allCapsValue,
+            fontsValue: characterFormatData.fontsValue,
+            characterScaleValue: characterFormatData.characterScaleValue,
+            kerningValue: characterFormatData.kerningValue,
+            characterSpacingValue: characterFormatData.characterSpacingValue,
+            positionValue: characterFormatData.positionValue,
+            borderValue: characterFormatData.borderValue,
+            languageValue: characterFormatData.languageValue,
+            embossValue: characterFormatData.embossValue,
+            imprintValue: characterFormatData.imprintValue,
+            outlineValue: characterFormatData.outlineValue,
+            shadowValue: characterFormatData.shadowValue,
+            webHiddenValue: characterFormatData.webHiddenValue,
+            bidiValue: characterFormatData.bidiValue,
+            complexScriptValue: characterFormatData.complexScriptValue,
+            boldBidiValue: characterFormatData.boldBidiValue,
+            italicBidiValue: characterFormatData.italicBidiValue,
+            emphasisValue: characterFormatData.emphasisValue,
+            textEffectValue: characterFormatData.textEffectValue,
+            specVanishValue: characterFormatData.specVanishValue,
+            snapToGridValue: characterFormatData.snapToGridValue,
+        });
+    }
+    else {
+        run.hydrate({
+            extraAttributes: extraAttributes,
+            leaves: leaves,
+            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,
+        });
+    }
+    return run;
+}
+function parseLeaf(child) {
+    if (isWml(child, 't')) {
+        var text = textContent(child);
+        return {
+            type: 'text',
+            text: text,
+            xmlSpacePreserve: xmlSpaceIsPreserve(child) || needsXmlSpacePreserve(text),
+        };
+    }
+    if (isWml(child, 'tab')) {
+        return { type: 'tab' };
+    }
+    if (isWml(child, 'br')) {
+        return parseBreakLeaf(child);
+    }
+    if (isWml(child, 'cr')) {
+        return { type: 'cr' };
+    }
+    if (isWml(child, 'sym')) {
+        return parseSymLeaf(child);
+    }
+    var feature = tryParseFeatureRunLeaf(child);
+    if (feature !== undefined) {
+        return { type: 'feature', featureId: feature.featureId, value: feature.value };
+    }
+    return { type: 'opaque', xml: child };
+}
+/**
+ * Parse `w:br` (`CT_Br`: optional `w:type`, `w:clear`).
+ * Citation: ECMA-376-1 §17.3.3.1–2; transitional `wml.xsd` `CT_Br` / `ST_BrType` / `ST_BrClear`.
+ */
+function parseBreakLeaf(child) {
+    var e_3, _a;
+    var breakType = BreakType.Line;
+    var clear;
+    var knownType = false;
+    var knownClear = false;
+    var typeRaw = wmlAttrValLocal(child, 'type');
+    if (typeRaw === 'page') {
+        breakType = BreakType.Page;
+        knownType = true;
+    }
+    else if (typeRaw === 'column') {
+        breakType = BreakType.Column;
+        knownType = true;
+    }
+    else if (typeRaw === 'textWrapping') {
+        breakType = BreakType.TextWrappingBreak;
+        knownType = true;
+    }
+    else if (typeRaw === undefined) {
+        // Default line break — type omitted.
+        knownType = true;
+    }
+    else if (typeRaw === 'line') {
+        // Non-schema value some producers emit; treat as Line and do not re-emit type="line".
+        breakType = BreakType.Line;
+        knownType = true;
+    }
+    var clearRaw = wmlAttrValLocal(child, 'clear');
+    if (breakType === BreakType.Line || breakType === BreakType.TextWrappingBreak) {
+        if (clearRaw === 'left') {
+            clear = BreakClearType.Left;
+            knownClear = true;
+        }
+        else if (clearRaw === 'right') {
+            clear = BreakClearType.Right;
+            knownClear = true;
+        }
+        else if (clearRaw === 'all') {
+            clear = BreakClearType.All;
+            knownClear = true;
+        }
+        else if (clearRaw === 'none') {
+            // Public view: BreakClearType.None. Preserve attribute in extras for round-trip.
+            knownClear = false;
+        }
+    }
+    var extras = [];
+    try {
+        for (var _b = __values(child.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var attr = _c.value;
+            var isWmlAttr = attr.prefix === 'w' || attr.prefix === '';
+            if (isWmlAttr && attr.localName === 'type') {
+                if (knownType) {
+                    continue;
+                }
+                extras.push(attr);
+                continue;
+            }
+            if (isWmlAttr && attr.localName === 'clear') {
+                if (knownClear) {
+                    continue;
+                }
+                extras.push(attr);
+                continue;
+            }
+            extras.push(attr);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    if (clear !== undefined) {
+        return { type: 'break', breakType: breakType, clear: clear, extras: extras };
+    }
+    return { type: 'break', breakType: breakType, extras: extras };
+}
+/**
+ * Serialize break leaf. Never emits `@w:type="line"`.
+ * TextWrappingBreak → `textWrapping` (+ clear when not none).
+ * Line + non-none clear → `textWrapping` + clear (compat); Line alone → bare `w:br`.
+ */
+function serializeBreakLeaf(leaf) {
+    var e_4, _a;
+    var attributes = [];
+    if (leaf.breakType === BreakType.Page) {
+        attributes.push(wmlAttr('type', 'page'));
+    }
+    else if (leaf.breakType === BreakType.Column) {
+        attributes.push(wmlAttr('type', 'column'));
+    }
+    else if (leaf.breakType === BreakType.TextWrappingBreak) {
+        attributes.push(wmlAttr('type', 'textWrapping'));
+        if (leaf.clear !== undefined) {
+            attributes.push(wmlAttr('clear', leaf.clear));
+        }
+    }
+    else if (leaf.clear !== undefined) {
+        // Line + clear ⇒ textWrapping (compat authoring form); never type="line".
+        attributes.push(wmlAttr('type', 'textWrapping'));
+        attributes.push(wmlAttr('clear', leaf.clear));
+    }
+    try {
+        // Line without clear: omit @w:type (default line break).
+        for (var _b = __values(leaf.extras), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var extra = _c.value;
+            attributes.push(extra);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return wmlElement('br', { attributes: attributes });
+}
+function isWrappingBreakType(type) {
+    return type === BreakType.Line || type === BreakType.TextWrappingBreak;
+}
+function createBreakLeaf(type, clear) {
+    if (clear === void 0) { clear = BreakClearType.None; }
+    if (clear !== BreakClearType.None && !isWrappingBreakType(type)) {
+        throw new DocxError('content/invalid-break', 'w:br @w:clear is only valid with a line / text-wrapping break');
+    }
+    // Explicit clear tokens so TS 3.3 keeps Exclude<BreakClearType, None> (no as const narrowing).
+    if (clear === BreakClearType.Left || clear === BreakClearType.Right || clear === BreakClearType.All) {
+        return { type: 'break', breakType: type, clear: clear, extras: [] };
+    }
+    return { type: 'break', breakType: type, extras: [] };
+}
+function toBreakLeafView(leaf) {
+    return {
+        type: 'break',
+        breakType: leaf.breakType,
+        clear: leaf.clear != null ? leaf.clear : BreakClearType.None,
+    };
+}
+/**
+ * Parse `w:sym` (`CT_Sym`: optional `w:font`, `w:char` as `ST_ShortHexNumber`).
+ * Unknown attributes → opaque whole element. Missing font/char or malformed char → opaque.
+ * Citation: ECMA-376-1 §17.3.3.30; transitional `wml.xsd` `CT_Sym` / `ST_ShortHexNumber`.
+ */
+function parseSymLeaf(child) {
+    var e_5, _a;
+    try {
+        for (var _b = __values(child.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var attr = _c.value;
+            if (attr.localName === 'font' || attr.localName === 'char') {
+                if (attr.prefix !== 'w' && attr.prefix !== '') {
+                    return { type: 'opaque', xml: child };
+                }
+                continue;
+            }
+            // Any other attribute (including non-wml font/char lookalikes handled above) stays opaque.
+            return { type: 'opaque', xml: child };
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    if (child.children.length > 0) {
+        return { type: 'opaque', xml: child };
+    }
+    var font = wmlAttrValLocal(child, 'font');
+    var char = wmlAttrValLocal(child, 'char');
+    if (font === undefined || char === undefined) {
+        return { type: 'opaque', xml: child };
+    }
+    // ST_ShortHexNumber = xsd:hexBinary length 2 → exactly four hex digits.
+    if (!/^[0-9A-Fa-f]{4}$/.test(char)) {
+        return { type: 'opaque', xml: child };
+    }
+    return { type: 'sym', font: font, char: char };
+}
+function serializeLeaf(leaf) {
+    switch (leaf.type) {
+        case 'text': {
+            var attributes = leaf.xmlSpacePreserve ? [xmlSpacePreserve()] : [];
+            return wmlElement('t', {
+                attributes: attributes,
+                children: [{ kind: 'text', value: leaf.text }],
+            });
+        }
+        case 'tab':
+            return wmlElement('tab');
+        case 'break':
+            return serializeBreakLeaf(leaf);
+        case 'cr':
+            return wmlElement('cr');
+        case 'sym':
+            return wmlElement('sym', {
+                attributes: [wmlAttr('font', leaf.font), wmlAttr('char', leaf.char)],
+            });
+        case 'feature':
+            return serializeFeatureRunLeaf(leaf);
+        case 'opaque':
+            return leaf.xml;
+        default:
+            return assertNever(leaf, 'run leaf');
+    }
+}
+function wmlAttrValLocal(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);
+}
+/**
+ * Serialize a run. `w:rPr` children come from {@link CharacterFormat.buildRPrChildren}
+ * (Spec §7.2 order).
+ */
+function serializeRun(run) {
+    var e_6, _a;
+    var snap = run.snapshot();
+    var rPrChildren = run.characterFormat.buildRPrChildren();
+    var children = [];
+    if (rPrChildren.length > 0) {
+        children.push(wmlElement('rPr', { children: rPrChildren }));
+    }
+    try {
+        for (var _b = __values(snap.leaves), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var leaf = _c.value;
+            children.push(serializeLeaf(leaf));
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return wmlElement('r', { attributes: snap.extraAttributes, children: children });
+}