@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

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

@@ -0,0 +1,2807 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { pointToTwips, twipsToPoint } from './length';
+import { objectValues } from '../../core/compat/object-compat';
+import { DocxError } from '../../core/errors/docx-error';
+import { alignmentFromJc, jcForNewAlignment } from './alignment';
+import { colorToHexWire } from './color';
+import { parseOnOff, serializeOnOff } from './on-off';
+import { BorderStyle as BorderStyleEnum } from './page-setup';
+import { elementChildren, isWml, wValAttribute, wmlAttr, wmlElement, } from './wml';
+import { cnfStyleIsEmpty, normalizeCnfStyle, parseCnfStyle, serializeCnfStyle, } from '../tables/tbl-pr';
+/**
+ * Tab stop justification / alignment (`ST_TabJc`). §17.18.83
+ *
+ * Prefer named members such as {@link TabJustification.Left} in authoring APIs.
+ * Wire tokens are the member values and are unchanged for serialization.
+ *
+ * @public
+ */
+export var TabJustification = {
+    Left: 'left',
+    Center: 'center',
+    Right: 'right',
+    Decimal: 'decimal',
+    Bar: 'bar',
+    Clear: 'clear',
+    Num: 'num',
+    Start: 'start',
+    End: 'end',
+};
+/**
+ * Tab stop leader character (`ST_TabTlc`). §17.18.84
+ *
+ * Prefer named members such as {@link TabLeader.Dot} / {@link TabLeader.NoLeader}.
+ * Wire tokens are the member values and are unchanged for serialization.
+ *
+ * @public
+ */
+export var TabLeader = {
+    NoLeader: 'none',
+    Dot: 'dot',
+    Heavy: 'heavy',
+    Hyphen: 'hyphen',
+    MiddleDot: 'middleDot',
+    Single: 'single',
+};
+/**
+ * Mutable DocIO-style tab-stop entry backed by {@link TabStop} storage.
+ * Distinct from run-level `w:r/w:tab` ({@link import('./text-range').Tab}).
+ *
+ * @public
+ */
+var ParagraphTabStop = /** @class */ (function () {
+    /**
+     * @public
+     */
+    function ParagraphTabStop(position, justification, leader) {
+        if (position === void 0) { position = 0; }
+        if (justification === void 0) { justification = TabJustification.Left; }
+        if (leader === void 0) { leader = TabLeader.NoLeader; }
+        this.positionValue = position;
+        this.justificationValue = justification;
+        this.leaderValue = leader;
+    }
+    Object.defineProperty(ParagraphTabStop.prototype, "position", {
+        /** Position in points. */
+        get: function () {
+            return this.positionValue;
+        },
+        set: function (value) {
+            this.positionValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphTabStop.prototype, "justification", {
+        /** Alignment / justification (`@w:val`). */
+        get: function () {
+            return this.justificationValue;
+        },
+        set: function (value) {
+            this.justificationValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphTabStop.prototype, "alignment", {
+        /** Alias of {@link ParagraphTabStop.justification}. */
+        get: function () {
+            return this.justificationValue;
+        },
+        set: function (value) {
+            this.justificationValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphTabStop.prototype, "leader", {
+        /** Leader character. */
+        get: function () {
+            return this.leaderValue;
+        },
+        set: function (value) {
+            this.leaderValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** @private */
+    ParagraphTabStop.prototype.toBagStop = function () {
+        var stop = {
+            position: this.positionValue,
+            alignment: this.justificationValue,
+        };
+        if (this.leaderValue !== TabLeader.NoLeader) {
+            return { position: this.positionValue, alignment: this.justificationValue, leader: this.leaderValue };
+        }
+        return stop;
+    };
+    /** @private */
+    ParagraphTabStop.fromTabStop = function (stop) {
+        return new ParagraphTabStop(stop.position, stop.alignment, stop.leader !== undefined ? stop.leader : TabLeader.NoLeader);
+    };
+    return ParagraphTabStop;
+}());
+export { ParagraphTabStop };
+/**
+ * Live collection over paragraph tab stops. Mirrors bag {@link ParagraphFormat.tabStops}.
+ *
+ * @public
+ */
+var TabCollection = /** @class */ (function () {
+    /** @private */
+    function TabCollection(owner) {
+        this.owner = owner;
+    }
+    Object.defineProperty(TabCollection.prototype, "count", {
+        /** Number of tab stops. */
+        get: function () {
+            var stops = this.owner.tabStops;
+            return stops !== undefined ? stops.length : 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Tab stop at index, or `undefined`.
+     */
+    TabCollection.prototype.item = function (index) {
+        var stops = this.owner.tabStops;
+        if (stops === undefined || index < 0 || index >= stops.length) {
+            return undefined;
+        }
+        return ParagraphTabStop.fromTabStop(stops[index]);
+    };
+    /**
+     * Add a tab stop (points / justification / leader).
+     * Prefer {@link TabCollection.addTab} for DocIO-aligned naming.
+     */
+    TabCollection.prototype.add = function (position, justification, leader) {
+        return this.addTab(position, justification, leader);
+    };
+    /**
+     * DocIO-aligned add. Zero-arg adds a default left stop at position `0`.
+     *
+     * @example
+     * ```ts
+     * pf.tabs.addTab();
+     * pf.tabs.addTab(36);
+     * pf.tabs.addTab(72, TabJustification.Right, TabLeader.Dot);
+     * ```
+     */
+    TabCollection.prototype.addTab = function (position, justification, leader) {
+        var entry = new ParagraphTabStop(position !== undefined ? position : 0, justification !== undefined ? justification : TabJustification.Left, leader !== undefined ? leader : TabLeader.NoLeader);
+        var current = this.owner.tabStops;
+        var next = current !== undefined ? current.slice() : [];
+        next.push(entry.toBagStop());
+        this.owner.tabStops = next;
+        return entry;
+    };
+    /**
+     * Remove the tab stop at `index` (`0…count-1`).
+     * @throws RangeError when the index is out of range.
+     */
+    TabCollection.prototype.removeAt = function (index) {
+        var stops = this.owner.tabStops;
+        if (stops === undefined || index < 0 || index >= stops.length) {
+            throw new RangeError('TabCollection.removeAt: index out of range');
+        }
+        if (stops.length === 1) {
+            this.owner.tabStops = undefined;
+            return;
+        }
+        var next = stops.slice();
+        next.splice(index, 1);
+        this.owner.tabStops = next;
+    };
+    /**
+     * Remove the first tab stop whose position equals `position` (points).
+     * No-op when no matching stop exists.
+     */
+    TabCollection.prototype.removeByPosition = function (position) {
+        var stops = this.owner.tabStops;
+        if (stops === undefined) {
+            return;
+        }
+        var found = -1;
+        for (var i = 0; i < stops.length; i++) {
+            if (stops[i].position === position) {
+                found = i;
+                break;
+            }
+        }
+        if (found < 0) {
+            return;
+        }
+        this.removeAt(found);
+    };
+    /** Remove all tab stops. */
+    TabCollection.prototype.clear = function () {
+        this.owner.tabStops = undefined;
+    };
+    return TabCollection;
+}());
+export { TabCollection };
+/**
+ * Live single paragraph border edge (`w:pBdr` child).
+ *
+ * @public
+ */
+var ParagraphBorderFace = /** @class */ (function () {
+    /** @private */
+    function ParagraphBorderFace(owner, edge) {
+        this.owner = owner;
+        this.edge = edge;
+    }
+    ParagraphBorderFace.prototype.read = function () {
+        var bag = this.owner.readBordersBag();
+        return bag !== undefined ? bag[this.edge] : undefined;
+    };
+    ParagraphBorderFace.prototype.write = function (next) {
+        var existing = this.owner.readBordersBag();
+        var bag = existing !== undefined ? __assign({}, existing) : {};
+        if (next === undefined) {
+            delete bag[this.edge];
+        }
+        else {
+            bag[this.edge] = next;
+        }
+        var empty = bag.top === undefined
+            && bag.left === undefined
+            && bag.bottom === undefined
+            && bag.right === undefined
+            && bag.between === undefined
+            && bag.bar === undefined;
+        this.owner.writeBordersBag(empty ? undefined : bag);
+    };
+    Object.defineProperty(ParagraphBorderFace.prototype, "borderType", {
+        /** Line style. */
+        get: function () {
+            var e = this.read();
+            return e !== undefined ? e.style : 'none';
+        },
+        set: function (value) {
+            var cur = this.read();
+            this.write({
+                style: value,
+                color: cur !== undefined ? cur.color : undefined,
+                size: cur !== undefined ? cur.size : undefined,
+                space: cur !== undefined ? cur.space : undefined,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBorderFace.prototype, "color", {
+        /** Hex RGB or `'auto'`. Setter also accepts a {@link Color} enum value. */
+        get: function () {
+            var e = this.read();
+            return e !== undefined && e.color !== undefined ? e.color : 'auto';
+        },
+        set: function (value) {
+            var cur = this.read();
+            this.write({
+                style: cur !== undefined ? cur.style : 'single',
+                color: borderColorToWire(value),
+                size: cur !== undefined ? cur.size : undefined,
+                space: cur !== undefined ? cur.space : undefined,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBorderFace.prototype, "lineWidth", {
+        /** Thickness in points (public); stored as eighths of a point. */
+        get: function () {
+            var e = this.read();
+            return e !== undefined && e.size !== undefined ? e.size / 8 : 0;
+        },
+        set: function (value) {
+            var cur = this.read();
+            this.write({
+                style: cur !== undefined ? cur.style : 'single',
+                color: cur !== undefined ? cur.color : undefined,
+                size: Math.round(value * 8),
+                space: cur !== undefined ? cur.space : undefined,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBorderFace.prototype, "space", {
+        /** Space from text in points. */
+        get: function () {
+            var e = this.read();
+            return e !== undefined && e.space !== undefined ? e.space : 0;
+        },
+        set: function (value) {
+            var cur = this.read();
+            this.write({
+                style: cur !== undefined ? cur.style : 'single',
+                color: cur !== undefined ? cur.color : undefined,
+                size: cur !== undefined ? cur.size : undefined,
+                space: value,
+            });
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ParagraphBorderFace;
+}());
+export { ParagraphBorderFace };
+/**
+ * Live paragraph borders with per-edge access. Whole-bag assign/clear via
+ * {@link ParagraphFormat.setBorders}.
+ *
+ * @public
+ */
+var ParagraphBordersFace = /** @class */ (function () {
+    /** @private */
+    function ParagraphBordersFace(owner) {
+        this.owner = owner;
+    }
+    Object.defineProperty(ParagraphBordersFace.prototype, "top", {
+        get: function () {
+            if (this.topFace === undefined) {
+                this.topFace = new ParagraphBorderFace(this.owner, 'top');
+            }
+            return this.topFace;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "left", {
+        get: function () {
+            if (this.leftFace === undefined) {
+                this.leftFace = new ParagraphBorderFace(this.owner, 'left');
+            }
+            return this.leftFace;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "bottom", {
+        get: function () {
+            if (this.bottomFace === undefined) {
+                this.bottomFace = new ParagraphBorderFace(this.owner, 'bottom');
+            }
+            return this.bottomFace;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "right", {
+        get: function () {
+            if (this.rightFace === undefined) {
+                this.rightFace = new ParagraphBorderFace(this.owner, 'right');
+            }
+            return this.rightFace;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "between", {
+        get: function () {
+            if (this.betweenFace === undefined) {
+                this.betweenFace = new ParagraphBorderFace(this.owner, 'between');
+            }
+            return this.betweenFace;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "bar", {
+        get: function () {
+            if (this.barFace === undefined) {
+                this.barFace = new ParagraphBorderFace(this.owner, 'bar');
+            }
+            return this.barFace;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "borderType", {
+        /** Stamp line style onto all outer edges. */
+        set: function (value) {
+            this.top.borderType = value;
+            this.left.borderType = value;
+            this.bottom.borderType = value;
+            this.right.borderType = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "color", {
+        /** Stamp color onto all outer edges (hex/`'auto'` or {@link Color}). */
+        set: function (value) {
+            this.top.color = value;
+            this.left.color = value;
+            this.bottom.color = value;
+            this.right.color = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "lineWidth", {
+        /** Stamp line width (points) onto all outer edges. */
+        set: function (value) {
+            this.top.lineWidth = value;
+            this.left.lineWidth = value;
+            this.bottom.lineWidth = value;
+            this.right.lineWidth = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphBordersFace.prototype, "space", {
+        /** Stamp space from text (points) onto all outer edges. */
+        set: function (value) {
+            this.top.space = value;
+            this.left.space = value;
+            this.bottom.space = value;
+            this.right.space = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ParagraphBordersFace;
+}());
+export { ParagraphBordersFace };
+/**
+ * Normalize border color input to wire hex / `'auto'`.
+ * @private
+ */
+function borderColorToWire(value) {
+    if (typeof value === 'number') {
+        var hex = colorToHexWire(value);
+        return hex.length > 0 ? hex : 'auto';
+    }
+    return value;
+}
+/**
+ * Normalize shading fill/pattern-color input to wire hex / `'auto'`.
+ * {@link Color} enum values become OOXML hex; {@link Color.Transparent}
+ * maps to `'auto'`. Plain strings pass through for load-path compatibility.
+ * @private
+ */
+function shadingColorToWire(value) {
+    if (typeof value === 'number') {
+        var hex = colorToHexWire(value);
+        return hex.length > 0 ? hex : 'auto';
+    }
+    return value;
+}
+/** @private Legal `ST_TextDirection` tokens (12, wml.xsd 798–813). */
+var TEXT_DIRECTIONS = new Set([
+    'lr',
+    'rl',
+    'tb',
+    'tbV',
+    'rlV',
+    'lrV',
+    'btLr',
+    'lrTb',
+    'lrTbV',
+    'tbLrV',
+    'tbRl',
+    'tbRlV',
+]);
+/** @private Legal `ST_TextAlignment` tokens (wml.xsd 817–825). */
+var BASELINE_ALIGNMENTS = new Set([
+    'auto',
+    'top',
+    'center',
+    'baseline',
+    'bottom',
+]);
+/** @private Shading patterns accepted for authored writes (§17.18.78 subset). */
+var SHADING_PATTERNS = new Set([
+    'clear', 'solid', 'horzStripe', 'vertStripe', 'reverseDiagStripe', 'diagStripe',
+    'horzCross', 'diagCross', 'thinHorzStripe', 'thinVertStripe', 'thinReverseDiagStripe',
+    'thinDiagStripe', 'thinHorzCross', 'thinDiagCross', 'pct5', 'pct10', 'pct12', 'pct15',
+    'pct20', 'pct25', 'pct30', 'pct35', 'pct37', 'pct40', 'pct45', 'pct50', 'pct55',
+    'pct60', 'pct62', 'pct65', 'pct70', 'pct75', 'pct80', 'pct85', 'pct87', 'pct90', 'pct95',
+]);
+/**
+ * @private
+ * Known `ST_Border` wire tokens for paragraph borders — derived from the
+ * page-setup `BorderStyle` enum so the set stays single-sourced.
+ */
+var BORDER_STYLES = new Set(objectValues(BorderStyleEnum));
+/**
+ * @private
+ * Empty snapshot factory.
+ */
+export function emptyParagraphFormatSnapshot() {
+    return {
+        pPrExtra: [],
+        jcRaw: undefined,
+        keepNextValue: undefined,
+        keepLinesValue: undefined,
+        pageBreakBeforeValue: undefined,
+        pageBreakAfterValue: undefined,
+        widowControlValue: undefined,
+        bidiValue: undefined,
+        outlineLevelValue: undefined,
+        indentsValue: undefined,
+        spacingValue: undefined,
+        tabStopsValue: undefined,
+        bordersValue: undefined,
+        shadingValue: undefined,
+        suppressAutoHyphensValue: undefined,
+        suppressLineNumbersValue: undefined,
+        contextualSpacingValue: undefined,
+        mirrorIndentsValue: undefined,
+        adjustRightIndentValue: undefined,
+        textDirectionValue: undefined,
+        textDirectionRaw: undefined,
+        baselineAlignmentValue: undefined,
+        baselineAlignmentRaw: undefined,
+        snapToGridValue: undefined,
+        wordWrapValue: undefined,
+        overflowPunctuationValue: undefined,
+        autoSpaceDEValue: undefined,
+        autoSpaceDNValue: undefined,
+        kinsokuValue: undefined,
+        topLinePunctuationValue: undefined,
+    };
+}
+// ---------------------------------------------------------------------------
+// Validation helpers (ADR D9 taxonomy: RangeError for numeric ranges,
+// DocxError('content/…') for tokens; unknown loaded values never throw).
+// ---------------------------------------------------------------------------
+function validateSignedExtentPoints(name, value) {
+    if (value < -1584 || value > 1584) {
+        throw new RangeError(name + ' must be in [-1584, 1584] points, got ' + String(value));
+    }
+}
+function validateNonNegativeExtentPoints(name, value) {
+    if (value < 0 || value > 1584) {
+        throw new RangeError(name + ' must be in [0, 1584] points, got ' + String(value));
+    }
+}
+function validateLineSpacingPoints(value) {
+    if (value < 0.7 || value > 1584) {
+        throw new RangeError('lineSpacing must be in [0.7, 1584] points, got ' + String(value));
+    }
+}
+function validateOutlineLevel(value) {
+    if (!isFinite(value) || Math.floor(value) !== value || value < 0 || value > 9) {
+        throw new RangeError('outlineLevel must be an integer 0–9, got ' + String(value));
+    }
+}
+function validateHexColor(name, value) {
+    if (!/^[0-9A-Fa-f]{6}$/.test(value) && value !== 'auto') {
+        throw new DocxError('content/invalid-shading-pattern', name + ' must be a six-digit hex color (RRGGBB) or "auto", got "' + value + '"');
+    }
+}
+/** Ensure the internal indents record exists (does not notify). */
+function ensureIndents(record) {
+    return record === undefined ? {} : record;
+}
+function indentsRecordIsEmpty(record) {
+    return record.left === undefined
+        && record.right === undefined
+        && record.firstLine === undefined
+        && record.hanging === undefined
+        && record.start === undefined
+        && record.end === undefined
+        && record.leftChars === undefined
+        && record.rightChars === undefined
+        && record.firstLineChars === undefined
+        && record.hangingChars === undefined;
+}
+/** Ensure the internal spacing record exists (does not notify). */
+function ensureSpacing(record) {
+    return record === undefined ? {} : record;
+}
+function spacingRecordIsEmpty(record) {
+    return record.before === undefined
+        && record.after === undefined
+        && record.line === undefined
+        && record.lineRule === undefined
+        && record.beforeAutospacing === undefined
+        && record.afterAutospacing === undefined
+        && record.beforeLines === undefined
+        && record.afterLines === undefined;
+}
+var PARAGRAPH_FORMAT_DEFAULTS = {
+    horizontalAlignment: 'start',
+    keepFollow: false,
+    keepLines: false,
+    pageBreakBefore: false,
+    pageBreakAfter: false,
+    widowControl: true,
+    bidi: false,
+    outlineLevel: 9,
+    leftIndent: 0,
+    rightIndent: 0,
+    firstLineIndent: 0,
+    beforeSpacing: 0,
+    afterSpacing: 0,
+    beforeAutospacing: false,
+    afterAutospacing: false,
+    beforeLines: 0,
+    afterLines: 0,
+    lineSpacing: 12,
+    lineSpacingRule: 'auto',
+    lineSpacingCount: 1,
+    backColor: '',
+    foreColor: '',
+    suppressAutoHyphens: false,
+    suppressLineNumbers: false,
+    contextualSpacing: false,
+    mirrorIndents: false,
+    adjustRightIndent: false,
+    baselineAlignment: 'auto',
+    snapToGrid: true,
+    wordWrap: true,
+    overflowPunctuation: true,
+    autoSpaceDE: false,
+    autoSpaceDN: false,
+};
+/**
+ * Direct paragraph formatting (`w:p/w:pPr`) — the only public
+ * paragraph-formatting surface. One live instance per
+ * {@link Paragraph}, lazily created via `paragraph.paragraphFormat`,
+ * never null. Mirrors the .NET DocIO `WParagraphFormat` flat property
+ * surface (ADR `docs/adr/2026-09-24-paragraph-format-facade.md`).
+ *
+ * @example
+ * ```ts
+ * paragraph.paragraphFormat.beforeSpacing = 18;
+ * paragraph.paragraphFormat.lineSpacing = 10;
+ * paragraph.paragraphFormat.firstLineIndent = 10;   // negative = hanging
+ * paragraph.paragraphFormat.backColor = 'D3D3D3';
+ * paragraph.paragraphFormat.horizontalAlignment = 'end';
+ * ```
+ *
+ * @public
+ */
+var ParagraphFormat = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ParagraphFormat(host) {
+        this.pPrExtra = [];
+        this.host = host;
+    }
+    ParagraphFormat.prototype.mutate = function () {
+        this.host.notifyParagraphFormatMutation();
+    };
+    ParagraphFormat.prototype.effective = function (key) {
+        var resolve = this.host.resolveEffectiveParagraphValue;
+        var value = resolve !== undefined ? resolve.call(this.host, key) : undefined;
+        return value !== undefined ? value : undefined;
+    };
+    ParagraphFormat.prototype.effectiveOrDefault = function (key, defaultValue) {
+        var value = this.effective(key);
+        return value !== undefined ? value : defaultValue;
+    };
+    Object.defineProperty(ParagraphFormat.prototype, "horizontalAlignment", {
+        // ---- Group A: alignment (§2) ----
+        /**
+         * Horizontal alignment of the paragraph (`w:jc`). `undefined` = inherit.
+         *
+         * Loaded directional `left`/`right` wording is surfaced as the neutral
+         * `start`/`end` without rewriting the stored value on a no-op save;
+         * unknown `w:jc` values (distribute-family) round-trip verbatim and this
+         * getter returns `undefined` for them.
+         *
+         * @public
+         */
+        get: function () {
+            if (this.jcRaw !== undefined) {
+                var value = alignmentFromJc(this.jcRaw);
+                if (value !== undefined) {
+                    return value;
+                }
+            }
+            return this.effective('horizontalAlignment');
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.jcRaw = undefined;
+                this.mutate();
+                return;
+            }
+            var current = this.jcRaw === undefined ? undefined : alignmentFromJc(this.jcRaw);
+            if (current === value) {
+                return;
+            }
+            this.jcRaw = jcForNewAlignment(value);
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "keepFollow", {
+        // ---- Group A: keeps and breaks (§9) ----
+        /** Keep paragraph with the next (`w:keepNext`). `undefined` = inherit. */
+        get: function () {
+            if (this.keepNextValue !== undefined) {
+                return this.keepNextValue;
+            }
+            return this.effective('keepFollow');
+        },
+        set: function (value) {
+            this.keepNextValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "keepLines", {
+        /** Keep all lines of the paragraph on one page (`w:keepLines`). */
+        get: function () {
+            if (this.keepLinesValue !== undefined) {
+                return this.keepLinesValue;
+            }
+            return this.effective('keepLines');
+        },
+        set: function (value) {
+            this.keepLinesValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "pageBreakBefore", {
+        /** Force this paragraph onto a new page (`w:pageBreakBefore`). */
+        get: function () {
+            if (this.pageBreakBeforeValue !== undefined) {
+                return this.pageBreakBeforeValue;
+            }
+            return this.effective('pageBreakBefore');
+        },
+        set: function (value) {
+            this.pageBreakBeforeValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "pageBreakAfter", {
+        /**
+         * DocIO-aligned page-break-after flag.
+         *
+         * There is no ECMA-376 `w:pageBreakAfter` on `w:pPr` (see
+         * `docs/specs/paragraph-formatting.md` § deliberate omissions). The typed flag
+         * is still stored for assign / clear / style resolve. On serialize, when the
+         * direct value is `true`, body writers emit a **following** paragraph whose
+         * only content is `w:r/w:br/@w:type="page"` after the content `w:p` — without
+         * inventing a non-schema pPr child and without placing the break run inside
+         * the content paragraph.
+         */
+        get: function () {
+            if (this.pageBreakAfterValue !== undefined) {
+                return this.pageBreakAfterValue;
+            }
+            return this.effective('pageBreakAfter');
+        },
+        set: function (value) {
+            this.pageBreakAfterValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "widowControl", {
+        /** Widow/orphan line control (`w:widowControl`). */
+        get: function () {
+            if (this.widowControlValue !== undefined) {
+                return this.widowControlValue;
+            }
+            return this.effective('widowControl');
+        },
+        set: function (value) {
+            this.widowControlValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "bidi", {
+        /** Right-to-left base flow (`w:bidi`). */
+        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(ParagraphFormat.prototype, "outlineLevel", {
+        /**
+         * Outline/navigation level (`w:outlineLvl`): 0–8 = Heading 1–9,
+         * 9 = body text. `undefined` = inherit. Authoring an integer outside
+         * 0–9 throws `RangeError` (no silent clamp).
+         */
+        get: function () {
+            if (this.outlineLevelValue !== undefined) {
+                return this.outlineLevelValue;
+            }
+            return this.effective('outlineLevel');
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.outlineLevelValue = undefined;
+                this.mutate();
+                return;
+            }
+            validateOutlineLevel(value);
+            this.outlineLevelValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "leftIndent", {
+        // ---- Group A: indents (§7; ADR D1/D2/D3) ----
+        /**
+         * Left-of-flow indent in points (`w:ind/@w:left` authored; loaded
+         * `@w:start` preserved). Signed: negative values are legal outdents.
+         * Range ±1584 points; out-of-range throws `RangeError`.
+         * Setting a value drops a loaded `start`/`leftChars` twin (ADR D11).
+         */
+        get: function () {
+            if (this.indentsValue !== undefined) {
+                if (this.indentsValue.left !== undefined) {
+                    return twipsToPoint(this.indentsValue.left);
+                }
+                if (this.indentsValue.start !== undefined) {
+                    return twipsToPoint(this.indentsValue.start);
+                }
+            }
+            return this.effective('leftIndent');
+        },
+        set: function (value) {
+            var indents = ensureIndents(this.indentsValue);
+            if (value === undefined) {
+                indents.left = undefined;
+                this.indentsValue = indentsRecordIsEmpty(indents) ? undefined : indents;
+                this.mutate();
+                return;
+            }
+            validateSignedExtentPoints('leftIndent', value);
+            indents.left = Math.round(value * 20);
+            // Authored write supersedes loaded twins (ADR D11).
+            indents.start = undefined;
+            indents.leftChars = undefined;
+            this.indentsValue = indentsRecordIsEmpty(indents) ? undefined : indents;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "rightIndent", {
+        /**
+         * Right-of-flow indent in points (`@w:right` authored; loaded `@w:end`
+         * preserved). Signed; range ±1584 points. Setting a value drops a loaded
+         * `end`/`rightChars` twin.
+         */
+        get: function () {
+            if (this.indentsValue !== undefined) {
+                if (this.indentsValue.right !== undefined) {
+                    return twipsToPoint(this.indentsValue.right);
+                }
+                if (this.indentsValue.end !== undefined) {
+                    return twipsToPoint(this.indentsValue.end);
+                }
+            }
+            return this.effective('rightIndent');
+        },
+        set: function (value) {
+            var indents = ensureIndents(this.indentsValue);
+            if (value === undefined) {
+                indents.right = undefined;
+                this.indentsValue = indentsRecordIsEmpty(indents) ? undefined : indents;
+                this.mutate();
+                return;
+            }
+            validateSignedExtentPoints('rightIndent', value);
+            indents.right = Math.round(value * 20);
+            indents.end = undefined;
+            indents.rightChars = undefined;
+            this.indentsValue = indentsRecordIsEmpty(indents) ? undefined : indents;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "firstLineIndent", {
+        /**
+         * First-line indent in points, **signed** (ADR D3): positive = first-line
+         * indent (`@w:firstLine`); negative = hanging indent (`@w:hanging`,
+         * emitted as the absolute twips). Range ±1584 points. Setting a value
+         * drops a loaded `firstLineChars` twin. Loading a legacy `w:ind` that
+         * carries both `@w:firstLine` and `@w:hanging` is deterministic
+         * (firstLine wins) — the pair cannot be co-authored through this API.
+         */
+        get: function () {
+            if (this.indentsValue !== undefined) {
+                if (this.indentsValue.firstLine !== undefined) {
+                    return twipsToPoint(this.indentsValue.firstLine);
+                }
+                if (this.indentsValue.hanging !== undefined) {
+                    return -twipsToPoint(this.indentsValue.hanging);
+                }
+            }
+            return this.effective('firstLineIndent');
+        },
+        set: function (value) {
+            var indents = ensureIndents(this.indentsValue);
+            if (value === undefined) {
+                indents.firstLine = undefined;
+                indents.hanging = undefined;
+                this.indentsValue = indentsRecordIsEmpty(indents) ? undefined : indents;
+                this.mutate();
+                return;
+            }
+            validateSignedExtentPoints('firstLineIndent', value);
+            if (value < 0) {
+                indents.firstLine = undefined;
+                indents.hanging = Math.round(-value * 20);
+            }
+            else {
+                indents.firstLine = Math.round(value * 20);
+                indents.hanging = undefined;
+            }
+            indents.firstLineChars = undefined;
+            this.indentsValue = indentsRecordIsEmpty(indents) ? undefined : indents;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "beforeSpacing", {
+        // ---- Group A: spacing (§8; ADR D4) ----
+        /**
+         * Space above the paragraph in points (`@w:before`). Range 0–1584.
+         * User-set clears an explicit `beforeAutospacing` (set-path only, never
+         * on load). Setting a value drops a loaded `@w:beforeLines` twin.
+         */
+        get: function () {
+            if (this.spacingValue !== undefined && this.spacingValue.before !== undefined) {
+                return twipsToPoint(this.spacingValue.before);
+            }
+            return this.effective('beforeSpacing');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            if (value === undefined) {
+                spacing.before = undefined;
+                this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+                this.mutate();
+                return;
+            }
+            validateNonNegativeExtentPoints('beforeSpacing', value);
+            spacing.before = Math.round(value * 20);
+            if (spacing.beforeAutospacing === true) {
+                spacing.beforeAutospacing = undefined;
+            }
+            spacing.beforeLines = undefined;
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "afterSpacing", {
+        /**
+         * Space below the paragraph in points (`@w:after`). Range 0–1584.
+         * User-set clears an explicit `afterAutospacing` and drops a loaded
+         * `@w:afterLines` twin.
+         */
+        get: function () {
+            if (this.spacingValue !== undefined && this.spacingValue.after !== undefined) {
+                return twipsToPoint(this.spacingValue.after);
+            }
+            return this.effective('afterSpacing');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            if (value === undefined) {
+                spacing.after = undefined;
+                this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+                this.mutate();
+                return;
+            }
+            validateNonNegativeExtentPoints('afterSpacing', value);
+            spacing.after = Math.round(value * 20);
+            if (spacing.afterAutospacing === true) {
+                spacing.afterAutospacing = undefined;
+            }
+            spacing.afterLines = undefined;
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "beforeAutospacing", {
+        /** Automatic spacing above (`@w:beforeAutospacing`). */
+        get: function () {
+            if (this.spacingValue !== undefined && this.spacingValue.beforeAutospacing !== undefined) {
+                return this.spacingValue.beforeAutospacing;
+            }
+            return this.effective('beforeAutospacing');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            spacing.beforeAutospacing = value;
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "afterAutospacing", {
+        /** Automatic spacing below (`@w:afterAutospacing`). */
+        get: function () {
+            if (this.spacingValue !== undefined && this.spacingValue.afterAutospacing !== undefined) {
+                return this.spacingValue.afterAutospacing;
+            }
+            return this.effective('afterAutospacing');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            spacing.afterAutospacing = value;
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "beforeLines", {
+        /**
+         * Line-grid spacing above in hundredths of a line (`@w:beforeLines`),
+         * round-trip slot for the East-Asian line-grid authoring style. Authored
+         * `beforeSpacing` drops a loaded twin.
+         */
+        get: function () {
+            if (this.spacingValue !== undefined && this.spacingValue.beforeLines !== undefined) {
+                return this.spacingValue.beforeLines;
+            }
+            return this.effective('beforeLines');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            spacing.beforeLines = value;
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "afterLines", {
+        /** Line-grid spacing below in hundredths of a line (`@w:afterLines`). */
+        get: function () {
+            if (this.spacingValue !== undefined && this.spacingValue.afterLines !== undefined) {
+                return this.spacingValue.afterLines;
+            }
+            return this.effective('afterLines');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            spacing.afterLines = value;
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "lineSpacing", {
+        /**
+         * Fixed/minimum line spacing in points (`@w:line` with
+         * `lineSpacingRule` `'atLeast'` or `'exact'`). Range 0.7–1584 points.
+         * Setting it clears {@link lineSpacingCount} — both are views of one
+         * `@line` slot (ADR D4).
+         */
+        get: function () {
+            if (this.spacingValue !== undefined && this.spacingValue.line !== undefined
+                && this.spacingValue.lineRule !== 'auto') {
+                return twipsToPoint(this.spacingValue.line);
+            }
+            return this.effective('lineSpacing');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            if (value === undefined) {
+                spacing.line = undefined;
+                if (spacing.lineRule === 'exact' || spacing.lineRule === 'atLeast') {
+                    spacing.lineRule = undefined;
+                }
+                this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+                this.mutate();
+                return;
+            }
+            validateLineSpacingPoints(value);
+            spacing.line = Math.round(value * 20);
+            // ADR D4: points view leaves auto-count; default rule is exact unless
+            // the author already chose atLeast.
+            spacing.lineRule = spacing.lineRule === 'atLeast' ? 'atLeast' : 'exact';
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "lineSpacingRule", {
+        /**
+         * Interpretation rule for `@w:line`: `'auto'` (multiple of single
+         * spacing — use {@link lineSpacingCount}), `'exact'` (exactly the given
+         * height), `'atLeast'` (at least the given height). Default when
+         * `lineSpacing` is authored without a rule: `'exact'`.
+         */
+        get: function () {
+            if (this.spacingValue !== undefined && this.spacingValue.lineRule !== undefined) {
+                return this.spacingValue.lineRule;
+            }
+            return this.effective('lineSpacingRule');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            spacing.lineRule = value;
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "lineSpacingCount", {
+        /**
+         * Multiple-of-single line spacing (authoring view over
+         * `@line = round(n × 240)` + `@lineRule="auto"`), e.g. `1.5` or `2`.
+         * Range 0–100; mutually clears with {@link lineSpacing} (ADR D4).
+         * Getter returns `n` only when the stored rule is `'auto'` and `@line`
+         * is set; otherwise `undefined` (effective style may still resolve).
+         */
+        get: function () {
+            if (this.spacingValue !== undefined
+                && this.spacingValue.lineRule === 'auto'
+                && this.spacingValue.line !== undefined) {
+                return this.spacingValue.line / 240;
+            }
+            return this.effective('lineSpacingCount');
+        },
+        set: function (value) {
+            var spacing = ensureSpacing(this.spacingValue);
+            if (value === undefined) {
+                if (spacing.lineRule === 'auto') {
+                    spacing.line = undefined;
+                    spacing.lineRule = undefined;
+                }
+                this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+                this.mutate();
+                return;
+            }
+            if (value < 0 || value > 100) {
+                throw new RangeError('lineSpacingCount must be in [0, 100], got ' + String(value));
+            }
+            spacing.line = Math.round(value * 240);
+            spacing.lineRule = 'auto';
+            this.spacingValue = spacingRecordIsEmpty(spacing) ? undefined : spacing;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "tabStops", {
+        // ---- Group A: tabs (§11), borders (§12), shading (§13) ----
+        /**
+         * Custom tab stops (`w:tabs`), assigned whole as an array. `undefined`
+         * clears explicit stops (style/default resolution may still supply some).
+         */
+        get: function () {
+            if (this.tabStopsValue !== undefined) {
+                return this.tabStopsValue;
+            }
+            return this.effective('tabStops');
+        },
+        set: function (value) {
+            this.tabStopsValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "tabs", {
+        /**
+         * Live DocIO-style tab-stop collection. Mutates the same storage as
+         * {@link ParagraphFormat.tabStops}.
+         */
+        get: function () {
+            if (this.tabsCollection === undefined) {
+                this.tabsCollection = new TabCollection(this);
+            }
+            return this.tabsCollection;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "borders", {
+        /**
+         * Live paragraph borders (`w:pBdr`) facade — always a
+         * {@link ParagraphBordersFace} (aggregate `borderType` / `color` /
+         * `lineWidth` / `space`, plus `top` / `left` / `bottom` / `right` /
+         * `horizontal` / `vertical`). Never `undefined` and never a plain bag.
+         *
+         * Whole-bag replace or clear: {@link ParagraphFormat.setBorders}.
+         */
+        get: function () {
+            if (this.bordersFace === undefined) {
+                this.bordersFace = new ParagraphBordersFace(this);
+            }
+            return this.bordersFace;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Replace or clear the whole paragraph-borders bag (`w:pBdr`).
+     * Pass `undefined` to clear authored borders. Per-edge edits use
+     * {@link ParagraphFormat.borders}.
+     */
+    ParagraphFormat.prototype.setBorders = function (value) {
+        this.bordersValue = value;
+        this.mutate();
+    };
+    /**
+     * @private
+     * Direct bag read for facades / serializers (avoids face getter recursion).
+     */
+    ParagraphFormat.prototype.readBordersBag = function () {
+        if (this.bordersValue !== undefined) {
+            return this.bordersValue;
+        }
+        return this.effective('borders');
+    };
+    /**
+     * @private
+     */
+    ParagraphFormat.prototype.writeBordersBag = function (value) {
+        this.bordersValue = value;
+        this.mutate();
+    };
+    Object.defineProperty(ParagraphFormat.prototype, "backColor", {
+        /**
+         * Background fill color (`w:shd/@w:fill`).
+         *
+         * - **Get (runtime)**: OOXML wire string — hex `RRGGBB`, `'auto'`, or the
+         *   default `''` when unset. Loaded wire values are preserved (never a
+         *   {@link Color} enum).
+         * - **Set**: hex string / `'auto'`, a {@link Color} enum value (converted to
+         *   hex immediately), or `undefined` to clear the authored fill.
+         *
+         * TypeScript 3.3 requires identical get/set types, so the declared type is
+         * `string | Color | undefined`; the getter always returns a string.
+         */
+        get: function () {
+            if (this.shadingValue !== undefined && this.shadingValue.fill !== undefined) {
+                return this.shadingValue.fill;
+            }
+            return this.effectiveOrDefault('backColor', PARAGRAPH_FORMAT_DEFAULTS.backColor);
+        },
+        set: function (value) {
+            var shading = this.shadingValue === undefined ? {} : __assign({}, this.shadingValue);
+            if (value === undefined) {
+                shading.fill = undefined;
+            }
+            else {
+                var wire = shadingColorToWire(value);
+                validateHexColor('backColor', wire);
+                shading.fill = wire;
+            }
+            this.shadingValue = shadingHasEntries(shading) ? shading : undefined;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "foreColor", {
+        /**
+         * Pattern foreground color (`w:shd/@w:color`).
+         *
+         * - **Get (runtime)**: OOXML wire string — hex `RRGGBB`, `'auto'`, or the
+         *   default `''` when unset. Loaded wire values are preserved (never a
+         *   {@link Color} enum).
+         * - **Set**: hex string / `'auto'`, a {@link Color} enum value (converted to
+         *   hex immediately), or `undefined` to clear.
+         *
+         * TypeScript 3.3 requires identical get/set types, so the declared type is
+         * `string | Color | undefined`; the getter always returns a string.
+         */
+        get: function () {
+            if (this.shadingValue !== undefined && this.shadingValue.color !== undefined) {
+                return this.shadingValue.color;
+            }
+            return this.effectiveOrDefault('foreColor', PARAGRAPH_FORMAT_DEFAULTS.foreColor);
+        },
+        set: function (value) {
+            var shading = this.shadingValue === undefined ? {} : __assign({}, this.shadingValue);
+            if (value === undefined) {
+                shading.color = undefined;
+            }
+            else {
+                var wire = shadingColorToWire(value);
+                validateHexColor('foreColor', wire);
+                shading.color = wire;
+            }
+            this.shadingValue = shadingHasEntries(shading) ? shading : undefined;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "shadingPattern", {
+        /**
+         * Shading pattern (`w:shd/@w:val`). Authoring an out-of-subset token
+         * throws `DocxError('content/invalid-shading-pattern', …)`; unknown
+         * loaded tokens round-trip via the parked-element path (never throw).
+         */
+        get: function () {
+            if (this.shadingValue !== undefined && this.shadingValue.pattern !== undefined) {
+                return this.shadingValue.pattern;
+            }
+            return this.effective('shadingPattern');
+        },
+        set: function (value) {
+            var shading = this.shadingValue === undefined ? {} : __assign({}, this.shadingValue);
+            if (value === undefined) {
+                shading.pattern = undefined;
+            }
+            else {
+                if (!SHADING_PATTERNS.has(value)) {
+                    throw new DocxError('content/invalid-shading-pattern', 'shadingPattern must be an ST_Shd pattern token, got "' + value + '"');
+                }
+                shading.pattern = value;
+            }
+            this.shadingValue = shadingHasEntries(shading) ? shading : undefined;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "suppressAutoHyphens", {
+        // ---- Group A: misc on/off flags ----
+        /**
+         * Suppress automatic hyphenation for this paragraph
+         * (`w:suppressAutoHyphens`, ECMA-376-1 §17.3.1.34 — the only
+         * hyphenation element; ADR D5). Foreign `w:suppressHyphenation` markup
+         * (not an ECMA-376 element) parks verbatim in `pPrExtra`.
+         */
+        get: function () {
+            if (this.suppressAutoHyphensValue !== undefined) {
+                return this.suppressAutoHyphensValue;
+            }
+            return this.effectiveOrDefault('suppressAutoHyphens', PARAGRAPH_FORMAT_DEFAULTS.suppressAutoHyphens);
+        },
+        set: function (value) {
+            this.suppressAutoHyphensValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "suppressLineNumbers", {
+        /** Exclude this paragraph from line numbering (`w:suppressLineNumbers`). */
+        get: function () {
+            if (this.suppressLineNumbersValue !== undefined) {
+                return this.suppressLineNumbersValue;
+            }
+            return this.effectiveOrDefault('suppressLineNumbers', PARAGRAPH_FORMAT_DEFAULTS.suppressLineNumbers);
+        },
+        set: function (value) {
+            this.suppressLineNumbersValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "contextualSpacing", {
+        /** Ignore before/after spacing between same-style paragraphs (`w:contextualSpacing`). */
+        get: function () {
+            if (this.contextualSpacingValue !== undefined) {
+                return this.contextualSpacingValue;
+            }
+            return this.effectiveOrDefault('contextualSpacing', PARAGRAPH_FORMAT_DEFAULTS.contextualSpacing);
+        },
+        set: function (value) {
+            this.contextualSpacingValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "mirrorIndents", {
+        /** Treat left/right indents as inside/outside for mirrored margins (`w:mirrorIndents`). */
+        get: function () {
+            if (this.mirrorIndentsValue !== undefined) {
+                return this.mirrorIndentsValue;
+            }
+            return this.effectiveOrDefault('mirrorIndents', PARAGRAPH_FORMAT_DEFAULTS.mirrorIndents);
+        },
+        set: function (value) {
+            this.mirrorIndentsValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "adjustRightIndent", {
+        /** Auto-adjust right indent against the document grid (`w:adjustRightInd`). */
+        get: function () {
+            if (this.adjustRightIndentValue !== undefined) {
+                return this.adjustRightIndentValue;
+            }
+            return this.effectiveOrDefault('adjustRightIndent', PARAGRAPH_FORMAT_DEFAULTS.adjustRightIndent);
+        },
+        set: function (value) {
+            this.adjustRightIndentValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "textDirection", {
+        // ---- Group A: text direction (§15; ADR D11: 12 tokens) ----
+        /**
+         * Physical text flow direction (`w:textDirection`,
+         * `ST_TextDirection` — all 12 tokens). Unknown loaded tokens round-trip
+         * verbatim (raw slot) and the getter returns `undefined` for them;
+         * authoring an invalid token throws
+         * `DocxError('content/invalid-text-direction', …)`.
+         */
+        get: function () {
+            if (this.textDirectionValue !== undefined) {
+                return this.textDirectionValue;
+            }
+            return this.effective('textDirection');
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.textDirectionValue = undefined;
+                this.textDirectionRaw = undefined;
+                this.mutate();
+                return;
+            }
+            if (!TEXT_DIRECTIONS.has(value)) {
+                throw new DocxError('content/invalid-text-direction', 'textDirection must be an ST_TextDirection token, got "' + value + '"');
+            }
+            this.textDirectionValue = value;
+            this.textDirectionRaw = undefined;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "baselineAlignment", {
+        // ---- Group B: baseline alignment (§16; ADR D6) ----
+        /**
+         * How characters of different sizes align vertically on a line
+         * (`w:textAlignment`, `ST_TextAlignment`). Unknown loaded tokens
+         * round-trip verbatim and the getter returns `undefined` for them;
+         * authoring an invalid token throws
+         * `DocxError('content/invalid-baseline-alignment', …)`.
+         */
+        get: function () {
+            if (this.baselineAlignmentValue !== undefined) {
+                return this.baselineAlignmentValue;
+            }
+            return this.effective('baselineAlignment');
+        },
+        set: function (value) {
+            if (value === undefined) {
+                this.baselineAlignmentValue = undefined;
+                this.baselineAlignmentRaw = undefined;
+                this.mutate();
+                return;
+            }
+            if (!BASELINE_ALIGNMENTS.has(value)) {
+                throw new DocxError('content/invalid-baseline-alignment', 'baselineAlignment must be an ST_TextAlignment token, got "' + value + '"');
+            }
+            this.baselineAlignmentValue = value;
+            this.baselineAlignmentRaw = undefined;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "snapToGrid", {
+        // ---- Group B: East-Asian / grid flags ----
+        /** Use document grid line pitch (`w:snapToGrid`). */
+        get: function () {
+            if (this.snapToGridValue !== undefined) {
+                return this.snapToGridValue;
+            }
+            return this.effectiveOrDefault('snapToGrid', PARAGRAPH_FORMAT_DEFAULTS.snapToGrid);
+        },
+        set: function (value) {
+            this.snapToGridValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "wordWrap", {
+        /** Break lines on word level (`w:wordWrap`). */
+        get: function () {
+            if (this.wordWrapValue !== undefined) {
+                return this.wordWrapValue;
+            }
+            return this.effectiveOrDefault('wordWrap', PARAGRAPH_FORMAT_DEFAULTS.wordWrap);
+        },
+        set: function (value) {
+            this.wordWrapValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "overflowPunctuation", {
+        /** Allow trailing punctuation to extend beyond the line (`w:overflowPunct`). */
+        get: function () {
+            if (this.overflowPunctuationValue !== undefined) {
+                return this.overflowPunctuationValue;
+            }
+            return this.effectiveOrDefault('overflowPunctuation', PARAGRAPH_FORMAT_DEFAULTS.overflowPunctuation);
+        },
+        set: function (value) {
+            this.overflowPunctuationValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "autoSpaceDE", {
+        /** Auto space between East-Asian and Latin text (`w:autoSpaceDE`). */
+        get: function () {
+            if (this.autoSpaceDEValue !== undefined) {
+                return this.autoSpaceDEValue;
+            }
+            return this.effectiveOrDefault('autoSpaceDE', PARAGRAPH_FORMAT_DEFAULTS.autoSpaceDE);
+        },
+        set: function (value) {
+            this.autoSpaceDEValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "autoSpaceDN", {
+        /** Auto space between East-Asian text and numbers (`w:autoSpaceDN`). */
+        get: function () {
+            if (this.autoSpaceDNValue !== undefined) {
+                return this.autoSpaceDNValue;
+            }
+            return this.effectiveOrDefault('autoSpaceDN', PARAGRAPH_FORMAT_DEFAULTS.autoSpaceDN);
+        },
+        set: function (value) {
+            this.autoSpaceDNValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "kinsoku", {
+        // ---- Group B: internal round-trip members (@private) ----
+        /**
+         * @private
+         * `w:kinsoku` — East-Asian line-breaking rules (round-trip only).
+         */
+        get: function () {
+            return this.kinsokuValue;
+        },
+        /** @private */
+        set: function (value) {
+            this.kinsokuValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParagraphFormat.prototype, "topLinePunctuation", {
+        /**
+         * @private
+         * `w:topLinePunct` — punctuation at line start preference (round-trip only).
+         */
+        get: function () {
+            return this.topLinePunctuationValue;
+        },
+        /** @private */
+        set: function (value) {
+            this.topLinePunctuationValue = value;
+            this.mutate();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * Raw loaded `w:textDirection/@w:val` for tokens outside the public union.
+     */
+    ParagraphFormat.prototype.textDirectionRawValue = function () {
+        return this.textDirectionRaw;
+    };
+    /**
+     * @private
+     * Raw loaded `w:textAlignment/@w:val` for tokens outside the public union.
+     */
+    ParagraphFormat.prototype.baselineAlignmentRawValue = function () {
+        return this.baselineAlignmentRaw;
+    };
+    // ---- Lifecycle ----
+    /**
+     * Apply a partial delta. Uses setters — cross-property effects
+     * (autospacing clearing, mutual line-slot clearing) apply.
+     * @public
+     */
+    ParagraphFormat.prototype.assign = function (delta) {
+        if (delta.horizontalAlignment !== undefined) {
+            this.horizontalAlignment = delta.horizontalAlignment;
+        }
+        if (delta.keepFollow !== undefined) {
+            this.keepFollow = delta.keepFollow;
+        }
+        if (delta.keepLines !== undefined) {
+            this.keepLines = delta.keepLines;
+        }
+        if (delta.pageBreakBefore !== undefined) {
+            this.pageBreakBefore = delta.pageBreakBefore;
+        }
+        if (delta.pageBreakAfter !== undefined) {
+            this.pageBreakAfter = delta.pageBreakAfter;
+        }
+        if (delta.widowControl !== undefined) {
+            this.widowControl = delta.widowControl;
+        }
+        if (delta.bidi !== undefined) {
+            this.bidi = delta.bidi;
+        }
+        if (delta.outlineLevel !== undefined) {
+            this.outlineLevel = delta.outlineLevel;
+        }
+        if (delta.leftIndent !== undefined) {
+            this.leftIndent = delta.leftIndent;
+        }
+        if (delta.rightIndent !== undefined) {
+            this.rightIndent = delta.rightIndent;
+        }
+        if (delta.firstLineIndent !== undefined) {
+            this.firstLineIndent = delta.firstLineIndent;
+        }
+        if (delta.beforeSpacing !== undefined) {
+            this.beforeSpacing = delta.beforeSpacing;
+        }
+        if (delta.afterSpacing !== undefined) {
+            this.afterSpacing = delta.afterSpacing;
+        }
+        if (delta.beforeAutospacing !== undefined) {
+            this.beforeAutospacing = delta.beforeAutospacing;
+        }
+        if (delta.afterAutospacing !== undefined) {
+            this.afterAutospacing = delta.afterAutospacing;
+        }
+        if (delta.beforeLines !== undefined) {
+            this.beforeLines = delta.beforeLines;
+        }
+        if (delta.afterLines !== undefined) {
+            this.afterLines = delta.afterLines;
+        }
+        if (delta.lineSpacing !== undefined) {
+            this.lineSpacing = delta.lineSpacing;
+        }
+        if (delta.lineSpacingRule !== undefined) {
+            this.lineSpacingRule = delta.lineSpacingRule;
+        }
+        if (delta.lineSpacingCount !== undefined) {
+            this.lineSpacingCount = delta.lineSpacingCount;
+        }
+        if (delta.tabStops !== undefined) {
+            this.tabStops = delta.tabStops;
+        }
+        if (delta.borders !== undefined) {
+            this.setBorders(delta.borders);
+        }
+        if (delta.backColor !== undefined) {
+            this.backColor = delta.backColor;
+        }
+        if (delta.foreColor !== undefined) {
+            this.foreColor = delta.foreColor;
+        }
+        if (delta.shadingPattern !== undefined) {
+            this.shadingPattern = delta.shadingPattern;
+        }
+        if (delta.suppressAutoHyphens !== undefined) {
+            this.suppressAutoHyphens = delta.suppressAutoHyphens;
+        }
+        if (delta.suppressLineNumbers !== undefined) {
+            this.suppressLineNumbers = delta.suppressLineNumbers;
+        }
+        if (delta.contextualSpacing !== undefined) {
+            this.contextualSpacing = delta.contextualSpacing;
+        }
+        if (delta.mirrorIndents !== undefined) {
+            this.mirrorIndents = delta.mirrorIndents;
+        }
+        if (delta.adjustRightIndent !== undefined) {
+            this.adjustRightIndent = delta.adjustRightIndent;
+        }
+        if (delta.textDirection !== undefined) {
+            this.textDirection = delta.textDirection;
+        }
+        if (delta.baselineAlignment !== undefined) {
+            this.baselineAlignment = delta.baselineAlignment;
+        }
+        if (delta.snapToGrid !== undefined) {
+            this.snapToGrid = delta.snapToGrid;
+        }
+        if (delta.wordWrap !== undefined) {
+            this.wordWrap = delta.wordWrap;
+        }
+        if (delta.overflowPunctuation !== undefined) {
+            this.overflowPunctuation = delta.overflowPunctuation;
+        }
+        if (delta.autoSpaceDE !== undefined) {
+            this.autoSpaceDE = delta.autoSpaceDE;
+        }
+        if (delta.autoSpaceDN !== undefined) {
+            this.autoSpaceDN = delta.autoSpaceDN;
+        }
+    };
+    /**
+     * Clear all typed formatting. Does not clear `pPrExtra`.
+     * @public
+     */
+    ParagraphFormat.prototype.clear = function () {
+        this.jcRaw = undefined;
+        this.keepNextValue = undefined;
+        this.keepLinesValue = undefined;
+        this.pageBreakBeforeValue = undefined;
+        this.pageBreakAfterValue = undefined;
+        this.widowControlValue = undefined;
+        this.bidiValue = undefined;
+        this.outlineLevelValue = undefined;
+        this.indentsValue = undefined;
+        this.spacingValue = undefined;
+        this.tabStopsValue = undefined;
+        this.bordersValue = undefined;
+        this.shadingValue = undefined;
+        this.suppressAutoHyphensValue = undefined;
+        this.suppressLineNumbersValue = undefined;
+        this.contextualSpacingValue = undefined;
+        this.mirrorIndentsValue = undefined;
+        this.adjustRightIndentValue = undefined;
+        this.textDirectionValue = undefined;
+        this.textDirectionRaw = undefined;
+        this.baselineAlignmentValue = undefined;
+        this.baselineAlignmentRaw = undefined;
+        this.snapToGridValue = undefined;
+        this.wordWrapValue = undefined;
+        this.overflowPunctuationValue = undefined;
+        this.autoSpaceDEValue = undefined;
+        this.autoSpaceDNValue = undefined;
+        this.kinsokuValue = undefined;
+        this.topLinePunctuationValue = undefined;
+        this.mutate();
+    };
+    /**
+     * @private
+     * Load a snapshot without set-path cross-property effects.
+     */
+    ParagraphFormat.prototype.hydrate = function (data) {
+        this.pPrExtra = data.pPrExtra;
+        this.jcRaw = data.jcRaw;
+        this.keepNextValue = data.keepNextValue;
+        this.keepLinesValue = data.keepLinesValue;
+        this.pageBreakAfterValue = data.pageBreakAfterValue;
+        this.pageBreakBeforeValue = data.pageBreakBeforeValue;
+        this.widowControlValue = data.widowControlValue;
+        this.bidiValue = data.bidiValue;
+        this.outlineLevelValue = data.outlineLevelValue;
+        this.indentsValue = data.indentsValue;
+        this.spacingValue = data.spacingValue;
+        this.tabStopsValue = data.tabStopsValue;
+        this.bordersValue = data.bordersValue;
+        this.shadingValue = data.shadingValue;
+        this.suppressAutoHyphensValue = data.suppressAutoHyphensValue;
+        this.suppressLineNumbersValue = data.suppressLineNumbersValue;
+        this.contextualSpacingValue = data.contextualSpacingValue;
+        this.mirrorIndentsValue = data.mirrorIndentsValue;
+        this.adjustRightIndentValue = data.adjustRightIndentValue;
+        this.textDirectionValue = data.textDirectionValue;
+        this.textDirectionRaw = data.textDirectionRaw;
+        this.baselineAlignmentValue = data.baselineAlignmentValue;
+        this.baselineAlignmentRaw = data.baselineAlignmentRaw;
+        this.snapToGridValue = data.snapToGridValue;
+        this.wordWrapValue = data.wordWrapValue;
+        this.overflowPunctuationValue = data.overflowPunctuationValue;
+        this.autoSpaceDEValue = data.autoSpaceDEValue;
+        this.autoSpaceDNValue = data.autoSpaceDNValue;
+        this.kinsokuValue = data.kinsokuValue;
+        this.topLinePunctuationValue = data.topLinePunctuationValue;
+    };
+    /**
+     * @private
+     */
+    ParagraphFormat.prototype.snapshot = function () {
+        return {
+            pPrExtra: this.pPrExtra,
+            jcRaw: this.jcRaw,
+            keepNextValue: this.keepNextValue,
+            keepLinesValue: this.keepLinesValue,
+            pageBreakAfterValue: this.pageBreakAfterValue,
+            pageBreakBeforeValue: this.pageBreakBeforeValue,
+            widowControlValue: this.widowControlValue,
+            bidiValue: this.bidiValue,
+            outlineLevelValue: this.outlineLevelValue,
+            indentsValue: this.indentsValue,
+            spacingValue: this.spacingValue,
+            tabStopsValue: this.tabStopsValue,
+            bordersValue: this.bordersValue,
+            shadingValue: this.shadingValue,
+            suppressAutoHyphensValue: this.suppressAutoHyphensValue,
+            suppressLineNumbersValue: this.suppressLineNumbersValue,
+            contextualSpacingValue: this.contextualSpacingValue,
+            mirrorIndentsValue: this.mirrorIndentsValue,
+            adjustRightIndentValue: this.adjustRightIndentValue,
+            textDirectionValue: this.textDirectionValue,
+            textDirectionRaw: this.textDirectionRaw,
+            baselineAlignmentValue: this.baselineAlignmentValue,
+            baselineAlignmentRaw: this.baselineAlignmentRaw,
+            snapToGridValue: this.snapToGridValue,
+            wordWrapValue: this.wordWrapValue,
+            overflowPunctuationValue: this.overflowPunctuationValue,
+            autoSpaceDEValue: this.autoSpaceDEValue,
+            autoSpaceDNValue: this.autoSpaceDNValue,
+            kinsokuValue: this.kinsokuValue,
+            topLinePunctuationValue: this.topLinePunctuationValue,
+        };
+    };
+    /**
+     * @private
+     * Parked children (`framePr`, `pPrChange`, unknowns, foreign invalid markup).
+     * Mark `w:rPr` is owned by {@link Paragraph.breakCharacterFormat}, not parked here.
+     * Read/write for the paragraph-owned serializer.
+     */
+    ParagraphFormat.prototype.extraChildren = function () {
+        return this.pPrExtra;
+    };
+    /**
+     * @private
+     * Paragraph conditional formatting membership (`w:pPr/w:cnfStyle`).
+     */
+    ParagraphFormat.prototype.readCnfStyle = function () {
+        for (var i = 0; i < this.pPrExtra.length; i += 1) {
+            var child = this.pPrExtra[i];
+            if (isWml(child, 'cnfStyle')) {
+                var state = parseCnfStyle(child);
+                return cnfStyleIsEmpty(state) ? undefined : state;
+            }
+        }
+        return undefined;
+    };
+    /**
+     * @private
+     * Write or clear paragraph `w:cnfStyle` in parked extra children.
+     * `undefined` removes the element; a supplied state always writes
+     * (including all-false normalized form).
+     */
+    ParagraphFormat.prototype.writeCnfStyle = function (state) {
+        // Table updateConditionalFormatting may run before every paragraph is
+        // body-attached; mutate only when the host is already bound.
+        try {
+            this.mutate();
+        }
+        catch (_e) {
+            // Detached dual-hold: still update parked cnfStyle markup.
+        }
+        var existing;
+        var existingIndex = -1;
+        for (var i = 0; i < this.pPrExtra.length; i += 1) {
+            var child = this.pPrExtra[i];
+            if (isWml(child, 'cnfStyle')) {
+                existing = child;
+                existingIndex = i;
+                break;
+            }
+        }
+        if (state === undefined) {
+            if (existingIndex >= 0) {
+                this.pPrExtra.splice(existingIndex, 1);
+            }
+            return;
+        }
+        var written = serializeCnfStyle(normalizeCnfStyle(state), existing);
+        if (existingIndex >= 0) {
+            this.pPrExtra[existingIndex] = written;
+        }
+        else {
+            this.pPrExtra.push(written);
+        }
+    };
+    /**
+     * @private
+     * Materialize `w:pPr` children owned by this format (CT_PPrBase order).
+     * Does not emit `pStyle` / `numPr` / `rPr` / `sectPr` — those stay on {@link Paragraph}.
+     */
+    ParagraphFormat.prototype.buildPPrChildren = function (inject) {
+        return buildPPrChildrenFromSnapshot(this.snapshot(), inject);
+    };
+    return ParagraphFormat;
+}());
+export { ParagraphFormat };
+/** @private `true` when the shading record carries any authored entry. */
+function shadingHasEntries(shading) {
+    return shading.fill !== undefined
+        || shading.color !== undefined
+        || shading.pattern !== undefined;
+}
+/**
+ * Modeled `w:pPr` children owned by {@link ParagraphFormat}.
+ * `pStyle` / `numPr` / `sectPr` stay on {@link Paragraph}.
+ * Foreign non-schema `suppressHyphenation` is NOT modeled (parked).
+ * @private
+ */
+var MODELED_PPR = new Set([
+    'keepNext',
+    'keepLines',
+    'pageBreakBefore',
+    'widowControl',
+    'bidi',
+    'jc',
+    'outlineLvl',
+    'ind',
+    'spacing',
+    'tabs',
+    'pBdr',
+    'shd',
+    'suppressLineNumbers',
+    'suppressAutoHyphens',
+    'contextualSpacing',
+    'textDirection',
+    'textAlignment',
+    'adjustRightInd',
+    'overflowPunct',
+    'autoSpaceDE',
+    'autoSpaceDN',
+    'snapToGrid',
+    'wordWrap',
+    'mirrorIndents',
+    'kinsoku',
+    'topLinePunct',
+]);
+/**
+ * Schema-known children that stay parked in `pPrExtra` (deferred features /
+ * markup-compat). Drain into schema slots on serialize.
+ * Mark `w:rPr` is owned by {@link Paragraph.breakCharacterFormat} (not parked).
+ * @private
+ */
+var PPR_EXTRA_ONLY = new Set([
+    'framePr',
+    'suppressOverlap',
+    'textboxTightWrap',
+    'divId',
+    'cnfStyle',
+    'pPrChange',
+]);
+var TAB_ALIGNMENTS = new Set([
+    'left',
+    'center',
+    'right',
+    'decimal',
+    'bar',
+    'clear',
+    'num',
+    'start',
+    'end',
+]);
+var TAB_LEADERS = new Set([
+    'none',
+    'dot',
+    'heavy',
+    'hyphen',
+    'middleDot',
+    'underscore',
+]);
+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 parseSignedTwipsAttr(el, attrName) {
+    return parseDecimalVal(wmlAttrVal(el, attrName));
+}
+function parseNonNegTwipsAttr(el, attrName) {
+    var n = parseDecimalVal(wmlAttrVal(el, attrName));
+    if (n === undefined || n < 0) {
+        return undefined;
+    }
+    return n;
+}
+function parseOnOffAttr(el, attrName) {
+    var raw = wmlAttrVal(el, attrName);
+    if (raw === '1' || raw === 'true') {
+        return true;
+    }
+    if (raw === '0' || raw === 'false') {
+        return false;
+    }
+    return undefined;
+}
+/**
+ * Parse `w:ind` into a wire-twips {@link ParagraphIndentsRecord}.
+ * Preserves `@start`/`@end`/`*Chars` for D2 round-trip.
+ * @private
+ */
+export function parseIndentsRecord(el) {
+    var ind = {};
+    var left = parseSignedTwipsAttr(el, 'left');
+    var right = parseSignedTwipsAttr(el, 'right');
+    var firstLine = parseNonNegTwipsAttr(el, 'firstLine');
+    var hanging = parseNonNegTwipsAttr(el, 'hanging');
+    var start = parseSignedTwipsAttr(el, 'start');
+    var end = parseSignedTwipsAttr(el, 'end');
+    var leftChars = parseNonNegTwipsAttr(el, 'leftChars');
+    var rightChars = parseNonNegTwipsAttr(el, 'rightChars');
+    var firstLineChars = parseNonNegTwipsAttr(el, 'firstLineChars');
+    var hangingChars = parseNonNegTwipsAttr(el, 'hangingChars');
+    if (left !== undefined) {
+        ind.left = left;
+    }
+    if (right !== undefined) {
+        ind.right = right;
+    }
+    if (firstLine !== undefined) {
+        ind.firstLine = firstLine;
+    }
+    if (hanging !== undefined) {
+        ind.hanging = hanging;
+    }
+    if (start !== undefined) {
+        ind.start = start;
+    }
+    if (end !== undefined) {
+        ind.end = end;
+    }
+    if (leftChars !== undefined) {
+        ind.leftChars = leftChars;
+    }
+    if (rightChars !== undefined) {
+        ind.rightChars = rightChars;
+    }
+    if (firstLineChars !== undefined) {
+        ind.firstLineChars = firstLineChars;
+    }
+    if (hangingChars !== undefined) {
+        ind.hangingChars = hangingChars;
+    }
+    if (indentsRecordIsEmpty(ind)) {
+        return undefined;
+    }
+    return ind;
+}
+/**
+ * Parse `w:spacing` into a wire-unit {@link ParagraphSpacingRecord}.
+ * Preserves `@beforeLines`/`@afterLines` for round-trip.
+ * @private
+ */
+export function parseSpacingRecord(el) {
+    var sp = {};
+    var before = parseNonNegTwipsAttr(el, 'before');
+    var after = parseNonNegTwipsAttr(el, 'after');
+    var line = parseNonNegTwipsAttr(el, 'line');
+    var lineRuleRaw = wmlAttrVal(el, 'lineRule');
+    var lineRule = lineRuleRaw === 'auto' || lineRuleRaw === 'exact' || lineRuleRaw === 'atLeast'
+        ? lineRuleRaw
+        : undefined;
+    var beforeAutospacing = parseOnOffAttr(el, 'beforeAutospacing');
+    var afterAutospacing = parseOnOffAttr(el, 'afterAutospacing');
+    var beforeLines = parseSignedTwipsAttr(el, 'beforeLines');
+    var afterLines = parseSignedTwipsAttr(el, 'afterLines');
+    if (before !== undefined) {
+        sp.before = before;
+    }
+    if (after !== undefined) {
+        sp.after = after;
+    }
+    if (line !== undefined) {
+        sp.line = line;
+    }
+    if (lineRule !== undefined) {
+        sp.lineRule = lineRule;
+    }
+    if (beforeAutospacing !== undefined) {
+        sp.beforeAutospacing = beforeAutospacing;
+    }
+    if (afterAutospacing !== undefined) {
+        sp.afterAutospacing = afterAutospacing;
+    }
+    if (beforeLines !== undefined) {
+        sp.beforeLines = beforeLines;
+    }
+    if (afterLines !== undefined) {
+        sp.afterLines = afterLines;
+    }
+    if (spacingRecordIsEmpty(sp)) {
+        return undefined;
+    }
+    return sp;
+}
+function parseTabs(el) {
+    var e_1, _a;
+    var __ts33_1;
+    var stops = [];
+    try {
+        for (var _b = __values(elementChildren(el)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, 'tab')) {
+                continue;
+            }
+            var posRaw = wmlAttrVal(child, 'pos');
+            var n = parseDecimalVal(posRaw);
+            if (n === undefined) {
+                continue;
+            }
+            var val = ((__ts33_1 = wmlAttrVal(child, 'val')), __ts33_1 != null ? __ts33_1 : 'left');
+            var alignment = TAB_ALIGNMENTS.has(val)
+                ? val
+                : 'left';
+            var leaderRaw = wmlAttrVal(child, 'leader');
+            var leader = leaderRaw !== undefined && TAB_LEADERS.has(leaderRaw)
+                ? leaderRaw
+                : undefined;
+            stops.push(__assign({ position: twipsToPoint(n), alignment: alignment }, (leader !== undefined ? { leader: leader } : {})));
+        }
+    }
+    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 stops;
+}
+function parseBorderEdge(el) {
+    var styleRaw = wmlAttrVal(el, 'val');
+    if (styleRaw === undefined) {
+        return undefined;
+    }
+    // Known tokens match BorderStyle (BORDER_STYLES is single-sourced from the
+    // page-setup BorderStyle enum). Unknown loaded ST_Border values are still
+    // stored so serialize can round-trip; load never throws (ADR D9).
+    var style = BORDER_STYLES.has(styleRaw)
+        ? styleRaw
+        : styleRaw;
+    var colorRaw = wmlAttrVal(el, 'color');
+    var szRaw = wmlAttrVal(el, 'sz');
+    var sz = szRaw !== undefined ? parseDecimalVal(szRaw) : undefined;
+    var spaceRaw = wmlAttrVal(el, 'space');
+    var space = spaceRaw !== undefined ? parseDecimalVal(spaceRaw) : undefined;
+    return __assign({ style: style }, (colorRaw !== undefined ? { color: colorRaw } : {}), (sz !== undefined ? { size: sz } : {}), (space !== undefined ? { space: space } : {}));
+}
+function parsePBdr(el) {
+    var e_2, _a;
+    var top;
+    var left;
+    var bottom;
+    var right;
+    var between;
+    var bar;
+    try {
+        for (var _b = __values(elementChildren(el)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, child.localName)) {
+                continue;
+            }
+            var edge = parseBorderEdge(child);
+            if (edge === undefined) {
+                continue;
+            }
+            if (child.localName === 'top') {
+                top = edge;
+            }
+            else if (child.localName === 'left') {
+                left = edge;
+            }
+            else if (child.localName === 'bottom') {
+                bottom = edge;
+            }
+            else if (child.localName === 'right') {
+                right = edge;
+            }
+            else if (child.localName === 'between') {
+                between = edge;
+            }
+            else if (child.localName === 'bar') {
+                bar = edge;
+            }
+        }
+    }
+    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 __assign({}, (top !== undefined ? { top: top } : {}), (left !== undefined ? { left: left } : {}), (bottom !== undefined ? { bottom: bottom } : {}), (right !== undefined ? { right: right } : {}), (between !== undefined ? { between: between } : {}), (bar !== undefined ? { bar: bar } : {}));
+}
+function parseShd(el) {
+    var fillRaw = wmlAttrVal(el, 'fill');
+    var colorRaw = wmlAttrVal(el, 'color');
+    var valRaw = wmlAttrVal(el, 'val');
+    var pattern = valRaw !== undefined && SHADING_PATTERNS.has(valRaw)
+        ? valRaw
+        : undefined;
+    return __assign({}, (fillRaw !== undefined ? { fill: fillRaw } : {}), (colorRaw !== undefined ? { color: colorRaw } : {}), (pattern !== undefined ? { pattern: pattern } : {}));
+}
+/**
+ * Parse `w:pPr` children into a {@link ParagraphFormatSnapshot}.
+ * Invalid / unmodeled markup is parked in `pPrExtra` (never throws on load).
+ * Does not consume `pStyle` / `numPr` / `rPr` / `sectPr` — callers handle those.
+ *
+ * @private
+ */
+export function parseParagraphFormat(pPrElement) {
+    var e_3, _a;
+    var snap = emptyParagraphFormatSnapshot();
+    var pPrExtra = [];
+    try {
+        for (var _b = __values(elementChildren(pPrElement)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var prop = _c.value;
+            // Paragraph-owned children — skip (caller already handled, or ignore if orphan).
+            if (isWml(prop, 'pStyle') || isWml(prop, 'numPr') || isWml(prop, 'rPr') || isWml(prop, 'sectPr')) {
+                continue;
+            }
+            if (!isWml(prop, prop.localName)) {
+                pPrExtra.push(prop);
+                continue;
+            }
+            if (PPR_EXTRA_ONLY.has(prop.localName)) {
+                pPrExtra.push(prop);
+                continue;
+            }
+            // D5: foreign non-schema `w:suppressHyphenation` parks; never models.
+            if (prop.localName === 'suppressHyphenation') {
+                pPrExtra.push(prop);
+                continue;
+            }
+            if (!MODELED_PPR.has(prop.localName)) {
+                pPrExtra.push(prop);
+                continue;
+            }
+            if (prop.localName === 'jc') {
+                snap.jcRaw = wValAttribute(prop);
+                continue;
+            }
+            if (prop.localName === 'outlineLvl') {
+                var raw = wValAttribute(prop);
+                if (raw !== undefined && /^-?\d+$/.test(raw)) {
+                    snap.outlineLevelValue = Number.parseInt(raw, 10);
+                }
+                else {
+                    pPrExtra.push(prop);
+                }
+                continue;
+            }
+            if (prop.localName === 'ind') {
+                var parsed = parseIndentsRecord(prop);
+                if (parsed === undefined) {
+                    pPrExtra.push(prop);
+                }
+                else {
+                    snap.indentsValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'spacing') {
+                var parsed = parseSpacingRecord(prop);
+                if (parsed === undefined) {
+                    pPrExtra.push(prop);
+                }
+                else {
+                    snap.spacingValue = parsed;
+                }
+                continue;
+            }
+            if (prop.localName === 'tabs') {
+                snap.tabStopsValue = parseTabs(prop);
+                continue;
+            }
+            if (prop.localName === 'pBdr') {
+                snap.bordersValue = parsePBdr(prop);
+                continue;
+            }
+            if (prop.localName === 'shd') {
+                snap.shadingValue = parseShd(prop);
+                continue;
+            }
+            if (prop.localName === 'textDirection') {
+                var raw = wValAttribute(prop);
+                if (raw === undefined) {
+                    pPrExtra.push(prop);
+                    continue;
+                }
+                if (TEXT_DIRECTIONS.has(raw)) {
+                    snap.textDirectionValue = raw;
+                    snap.textDirectionRaw = undefined;
+                }
+                else {
+                    // Unknown token: keep raw for RT; typed getter returns undefined.
+                    snap.textDirectionValue = undefined;
+                    snap.textDirectionRaw = raw;
+                }
+                continue;
+            }
+            if (prop.localName === 'textAlignment') {
+                var raw = wValAttribute(prop);
+                if (raw === undefined) {
+                    pPrExtra.push(prop);
+                    continue;
+                }
+                if (BASELINE_ALIGNMENTS.has(raw)) {
+                    snap.baselineAlignmentValue = raw;
+                    snap.baselineAlignmentRaw = undefined;
+                }
+                else {
+                    snap.baselineAlignmentValue = undefined;
+                    snap.baselineAlignmentRaw = raw;
+                }
+                continue;
+            }
+            var flag = parseOnOff(prop);
+            if (flag === undefined) {
+                pPrExtra.push(prop);
+                continue;
+            }
+            if (prop.localName === 'keepNext') {
+                snap.keepNextValue = flag;
+            }
+            else if (prop.localName === 'keepLines') {
+                snap.keepLinesValue = flag;
+            }
+            else if (prop.localName === 'pageBreakBefore') {
+                snap.pageBreakBeforeValue = flag;
+            }
+            else if (prop.localName === 'widowControl') {
+                snap.widowControlValue = flag;
+            }
+            else if (prop.localName === 'bidi') {
+                snap.bidiValue = flag;
+            }
+            else if (prop.localName === 'suppressLineNumbers') {
+                snap.suppressLineNumbersValue = flag;
+            }
+            else if (prop.localName === 'suppressAutoHyphens') {
+                snap.suppressAutoHyphensValue = flag;
+            }
+            else if (prop.localName === 'contextualSpacing') {
+                snap.contextualSpacingValue = flag;
+            }
+            else if (prop.localName === 'adjustRightInd') {
+                snap.adjustRightIndentValue = flag;
+            }
+            else if (prop.localName === 'overflowPunct') {
+                snap.overflowPunctuationValue = flag;
+            }
+            else if (prop.localName === 'autoSpaceDE') {
+                snap.autoSpaceDEValue = flag;
+            }
+            else if (prop.localName === 'autoSpaceDN') {
+                snap.autoSpaceDNValue = flag;
+            }
+            else if (prop.localName === 'snapToGrid') {
+                snap.snapToGridValue = flag;
+            }
+            else if (prop.localName === 'wordWrap') {
+                snap.wordWrapValue = flag;
+            }
+            else if (prop.localName === 'mirrorIndents') {
+                snap.mirrorIndentsValue = flag;
+            }
+            else if (prop.localName === 'kinsoku') {
+                snap.kinsokuValue = flag;
+            }
+            else if (prop.localName === 'topLinePunct') {
+                snap.topLinePunctuationValue = flag;
+            }
+            else {
+                pPrExtra.push(prop);
+            }
+        }
+    }
+    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; }
+    }
+    snap.pPrExtra = pPrExtra;
+    return snap;
+}
+// ---------------------------------------------------------------------------
+// Serialize helpers (wire units)
+// ---------------------------------------------------------------------------
+function pushOnOff(children, localName, value) {
+    if (value === undefined) {
+        return;
+    }
+    children.push(serializeOnOff(localName, value));
+}
+function pushParkedNamed(children, remaining, localName) {
+    var kept = [];
+    for (var i = 0; i < remaining.length; i++) {
+        var el = remaining[i];
+        if (isWml(el, localName)) {
+            children.push(el);
+        }
+        else {
+            kept.push(el);
+        }
+    }
+    return kept;
+}
+/**
+ * Serialize wire-twips indents record → `w:ind`.
+ * D2: authored `left`/`right` plus any RT `start`/`end`/`*Chars` slots.
+ * @private
+ */
+export function serializeIndentsRecord(ind) {
+    var attrs = [];
+    if (ind.left !== undefined) {
+        attrs.push(wmlAttr('left', String(ind.left)));
+    }
+    if (ind.right !== undefined) {
+        attrs.push(wmlAttr('right', String(ind.right)));
+    }
+    if (ind.start !== undefined) {
+        attrs.push(wmlAttr('start', String(ind.start)));
+    }
+    if (ind.end !== undefined) {
+        attrs.push(wmlAttr('end', String(ind.end)));
+    }
+    if (ind.hanging !== undefined) {
+        attrs.push(wmlAttr('hanging', String(ind.hanging)));
+    }
+    if (ind.firstLine !== undefined) {
+        attrs.push(wmlAttr('firstLine', String(ind.firstLine)));
+    }
+    if (ind.leftChars !== undefined) {
+        attrs.push(wmlAttr('leftChars', String(ind.leftChars)));
+    }
+    if (ind.rightChars !== undefined) {
+        attrs.push(wmlAttr('rightChars', String(ind.rightChars)));
+    }
+    if (ind.firstLineChars !== undefined) {
+        attrs.push(wmlAttr('firstLineChars', String(ind.firstLineChars)));
+    }
+    if (ind.hangingChars !== undefined) {
+        attrs.push(wmlAttr('hangingChars', String(ind.hangingChars)));
+    }
+    return wmlElement('ind', { attributes: attrs });
+}
+/**
+ * Serialize wire-unit spacing record → `w:spacing`.
+ * @private
+ */
+export function serializeSpacingRecord(sp) {
+    var attrs = [];
+    if (sp.before !== undefined) {
+        attrs.push(wmlAttr('before', String(sp.before)));
+    }
+    if (sp.after !== undefined) {
+        attrs.push(wmlAttr('after', String(sp.after)));
+    }
+    if (sp.beforeLines !== undefined) {
+        attrs.push(wmlAttr('beforeLines', String(sp.beforeLines)));
+    }
+    if (sp.afterLines !== undefined) {
+        attrs.push(wmlAttr('afterLines', String(sp.afterLines)));
+    }
+    if (sp.line !== undefined) {
+        attrs.push(wmlAttr('line', String(sp.line)));
+        // Schema default is auto; emit explicitly so consumers do not have to
+        // apply the XSD default when @line is present without @lineRule.
+        attrs.push(wmlAttr('lineRule', sp.lineRule !== undefined ? sp.lineRule : 'auto'));
+    }
+    else if (sp.lineRule !== undefined) {
+        attrs.push(wmlAttr('lineRule', sp.lineRule));
+    }
+    if (sp.beforeAutospacing !== undefined) {
+        attrs.push(wmlAttr('beforeAutospacing', sp.beforeAutospacing ? '1' : '0'));
+    }
+    if (sp.afterAutospacing !== undefined) {
+        attrs.push(wmlAttr('afterAutospacing', sp.afterAutospacing ? '1' : '0'));
+    }
+    return wmlElement('spacing', { attributes: attrs });
+}
+function serializeTabs(stops) {
+    var children = stops.map(function (s) {
+        var attrs = [
+            wmlAttr('val', s.alignment),
+            wmlAttr('pos', String(pointToTwips(s.position))),
+        ];
+        if (s.leader !== undefined) {
+            attrs.push(wmlAttr('leader', s.leader));
+        }
+        return wmlElement('tab', { attributes: attrs });
+    });
+    return wmlElement('tabs', { children: children });
+}
+function serializeBorderEdge(localName, 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(localName, { attributes: attrs });
+}
+function serializePBdr(borders) {
+    var children = [];
+    if (borders.top !== undefined) {
+        children.push(serializeBorderEdge('top', borders.top));
+    }
+    if (borders.left !== undefined) {
+        children.push(serializeBorderEdge('left', borders.left));
+    }
+    if (borders.bottom !== undefined) {
+        children.push(serializeBorderEdge('bottom', borders.bottom));
+    }
+    if (borders.right !== undefined) {
+        children.push(serializeBorderEdge('right', borders.right));
+    }
+    if (borders.between !== undefined) {
+        children.push(serializeBorderEdge('between', borders.between));
+    }
+    if (borders.bar !== undefined) {
+        children.push(serializeBorderEdge('bar', borders.bar));
+    }
+    return wmlElement('pBdr', { children: children });
+}
+function serializeShd(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 });
+}
+/**
+ * Materialize format-owned `w:pPr` children in CT_PPrBase / CT_PPr order.
+ * Inject optional paragraph-owned `numPr` / `sectPr` at schema positions.
+ * D5: never emits `w:suppressHyphenation` from typed state.
+ *
+ * @private
+ */
+export function buildPPrChildrenFromSnapshot(snap, inject) {
+    var children = [];
+    var remaining = snap.pPrExtra.slice();
+    pushOnOff(children, 'keepNext', snap.keepNextValue);
+    pushOnOff(children, 'keepLines', snap.keepLinesValue);
+    pushOnOff(children, 'pageBreakBefore', snap.pageBreakBeforeValue);
+    remaining = pushParkedNamed(children, remaining, 'framePr');
+    pushOnOff(children, 'widowControl', snap.widowControlValue);
+    if (inject !== undefined && inject.numPr !== undefined) {
+        children.push(inject.numPr);
+    }
+    pushOnOff(children, 'suppressLineNumbers', snap.suppressLineNumbersValue);
+    if (snap.bordersValue !== undefined) {
+        children.push(serializePBdr(snap.bordersValue));
+    }
+    if (snap.shadingValue !== undefined && shadingHasEntries(snap.shadingValue)) {
+        children.push(serializeShd(snap.shadingValue));
+    }
+    if (snap.tabStopsValue !== undefined && snap.tabStopsValue.length > 0) {
+        children.push(serializeTabs(snap.tabStopsValue));
+    }
+    // D5: only schema `w:suppressAutoHyphens` — never author-emit suppressHyphenation.
+    pushOnOff(children, 'suppressAutoHyphens', snap.suppressAutoHyphensValue);
+    pushOnOff(children, 'kinsoku', snap.kinsokuValue);
+    pushOnOff(children, 'wordWrap', snap.wordWrapValue);
+    pushOnOff(children, 'overflowPunct', snap.overflowPunctuationValue);
+    pushOnOff(children, 'topLinePunct', snap.topLinePunctuationValue);
+    pushOnOff(children, 'autoSpaceDE', snap.autoSpaceDEValue);
+    pushOnOff(children, 'autoSpaceDN', snap.autoSpaceDNValue);
+    pushOnOff(children, 'bidi', snap.bidiValue);
+    pushOnOff(children, 'adjustRightInd', snap.adjustRightIndentValue);
+    pushOnOff(children, 'snapToGrid', snap.snapToGridValue);
+    if (snap.spacingValue !== undefined && !spacingRecordIsEmpty(snap.spacingValue)) {
+        children.push(serializeSpacingRecord(snap.spacingValue));
+    }
+    if (snap.indentsValue !== undefined && !indentsRecordIsEmpty(snap.indentsValue)) {
+        children.push(serializeIndentsRecord(snap.indentsValue));
+    }
+    pushOnOff(children, 'contextualSpacing', snap.contextualSpacingValue);
+    pushOnOff(children, 'mirrorIndents', snap.mirrorIndentsValue);
+    remaining = pushParkedNamed(children, remaining, 'suppressOverlap');
+    if (snap.jcRaw !== undefined) {
+        children.push(wmlElement('jc', { attributes: [wmlAttr('val', snap.jcRaw)] }));
+    }
+    // Prefer typed token; else raw unknown for RT.
+    if (snap.textDirectionValue !== undefined) {
+        children.push(wmlElement('textDirection', {
+            attributes: [wmlAttr('val', snap.textDirectionValue)],
+        }));
+    }
+    else if (snap.textDirectionRaw !== undefined) {
+        children.push(wmlElement('textDirection', {
+            attributes: [wmlAttr('val', snap.textDirectionRaw)],
+        }));
+    }
+    if (snap.baselineAlignmentValue !== undefined) {
+        children.push(wmlElement('textAlignment', {
+            attributes: [wmlAttr('val', snap.baselineAlignmentValue)],
+        }));
+    }
+    else if (snap.baselineAlignmentRaw !== undefined) {
+        children.push(wmlElement('textAlignment', {
+            attributes: [wmlAttr('val', snap.baselineAlignmentRaw)],
+        }));
+    }
+    remaining = pushParkedNamed(children, remaining, 'textboxTightWrap');
+    remaining = pushParkedNamed(children, remaining, 'divId');
+    remaining = pushParkedNamed(children, remaining, 'cnfStyle');
+    if (snap.outlineLevelValue !== undefined) {
+        children.push(wmlElement('outlineLvl', {
+            attributes: [wmlAttr('val', String(snap.outlineLevelValue))],
+        }));
+    }
+    // Mark rPr is paragraph-owned (breakCharacterFormat); inject replaces parking.
+    if (inject !== undefined && inject.rPr !== undefined) {
+        children.push(inject.rPr);
+    }
+    if (inject !== undefined && inject.sectPr !== undefined) {
+        children.push(inject.sectPr);
+    }
+    remaining = pushParkedNamed(children, remaining, 'pPrChange');
+    // Any remaining parked / unknown / foreign (incl. suppressHyphenation if still present) at end.
+    for (var i = 0; i < remaining.length; i++) {
+        children.push(remaining[i]);
+    }
+    return children;
+}
+// ---------------------------------------------------------------------------
+// Styles-surface helpers (points bags + lineSpacing alias) — shared codecs
+// ---------------------------------------------------------------------------
+/**
+ * Wire `w:spacing` → public points {@link ParagraphSpacing} with `lineSpacing` key.
+ * Used by the styles feature; preserves prior payload shape.
+ * @private
+ */
+export function parseParagraphSpacingPoints(el) {
+    if (!isWml(el, 'spacing')) {
+        return undefined;
+    }
+    var record = parseSpacingRecord(el);
+    if (record === undefined) {
+        return undefined;
+    }
+    // Styles surface historically omitted autospacing / *Lines; keep that shape.
+    if (record.before === undefined
+        && record.after === undefined
+        && record.line === undefined
+        && record.lineRule === undefined) {
+        return undefined;
+    }
+    return __assign({}, (record.before !== undefined ? { before: twipsToPoint(record.before) } : {}), (record.after !== undefined ? { after: twipsToPoint(record.after) } : {}), (record.line !== undefined ? { lineSpacing: twipsToPoint(record.line) } : {}), (record.lineRule !== undefined ? { lineRule: record.lineRule } : {}));
+}
+/**
+ * Wire `w:ind` → public points {@link ParagraphIndentation}.
+ * @private
+ */
+export function parseParagraphIndentationPoints(el) {
+    if (!isWml(el, 'ind')) {
+        return undefined;
+    }
+    var record = parseIndentsRecord(el);
+    if (record === undefined) {
+        return undefined;
+    }
+    // Styles surface: physical left/right only (matches prior codec).
+    var left = record.left !== undefined
+        ? twipsToPoint(record.left)
+        : undefined;
+    var right = record.right !== undefined
+        ? twipsToPoint(record.right)
+        : undefined;
+    if (left === undefined && right === undefined
+        && record.firstLine === undefined && record.hanging === undefined) {
+        return undefined;
+    }
+    return __assign({}, (left !== undefined ? { left: left } : {}), (right !== undefined ? { right: right } : {}), (record.firstLine !== undefined ? { firstLine: twipsToPoint(record.firstLine) } : {}), (record.hanging !== undefined ? { hanging: twipsToPoint(record.hanging) } : {}));
+}
+/**
+ * Points {@link ParagraphSpacing} → `w:spacing` (styles `lineSpacing` key).
+ * @private
+ */
+export function serializeParagraphSpacingPoints(spacing) {
+    var record = {};
+    if (spacing.before !== undefined) {
+        record.before = pointToTwips(spacing.before);
+    }
+    if (spacing.after !== undefined) {
+        record.after = pointToTwips(spacing.after);
+    }
+    var line = spacing.lineSpacing !== undefined
+        ? spacing.lineSpacing
+        : spacing.line;
+    if (line !== undefined) {
+        record.line = pointToTwips(line);
+    }
+    if (spacing.lineRule !== undefined) {
+        record.lineRule = spacing.lineRule;
+    }
+    if (spacing.beforeAutospacing !== undefined) {
+        record.beforeAutospacing = spacing.beforeAutospacing;
+    }
+    if (spacing.afterAutospacing !== undefined) {
+        record.afterAutospacing = spacing.afterAutospacing;
+    }
+    return serializeSpacingRecord(record);
+}
+/**
+ * Points {@link ParagraphIndentation} → `w:ind` (D2 left/right spellings).
+ * @private
+ */
+export function serializeParagraphIndentationPoints(indentation) {
+    var record = {};
+    if (indentation.left !== undefined) {
+        record.left = pointToTwips(indentation.left);
+    }
+    if (indentation.right !== undefined) {
+        record.right = pointToTwips(indentation.right);
+    }
+    if (indentation.firstLine !== undefined) {
+        record.firstLine = pointToTwips(indentation.firstLine);
+    }
+    if (indentation.hanging !== undefined) {
+        record.hanging = pointToTwips(indentation.hanging);
+    }
+    return serializeIndentsRecord(record);
+}