@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/styles/latent-styles.d.ts

@@ -0,0 +1,68 @@
+import { OpenXmlAttribute, OpenXmlElement } from '../../core/xml/index';
+/**
+ * One `w:lsdException` entry under `w:latentStyles` (`CT_LsdException`).
+ *
+ * @private
+ */
+export declare class LsdException {
+    private readonly nameValue;
+    private readonly lockedValue;
+    private readonly uiPriorityValue;
+    private readonly semiHiddenValue;
+    private readonly unhideWhenUsedValue;
+    private readonly qFormatValue;
+    private readonly extraAttributes;
+    /**
+     * @private
+     */
+    constructor(name: string, locked: boolean | undefined, uiPriority: number | undefined, semiHidden: boolean | undefined, unhideWhenUsed: boolean | undefined, qFormat: boolean | undefined, extraAttributes?: OpenXmlAttribute[]);
+    /** `w:lsdException/@w:name` (required). */
+    readonly name: string;
+    readonly locked: boolean | undefined;
+    readonly uiPriority: number | undefined;
+    readonly semiHidden: boolean | undefined;
+    readonly unhideWhenUsed: boolean | undefined;
+    readonly qFormat: boolean | undefined;
+    /**
+     * @private
+     */
+    serialize(): OpenXmlElement;
+}
+/**
+ * Latent style information (`w:latentStyles` / `CT_LatentStyles`).
+ *
+ * @private
+ */
+export declare class LatentStyles {
+    private readonly defLockedStateValue;
+    private readonly defUIPriorityValue;
+    private readonly defSemiHiddenValue;
+    private readonly defUnhideWhenUsedValue;
+    private readonly defQFormatValue;
+    private readonly countValue;
+    private readonly exceptionsList;
+    private readonly extraAttributes;
+    private readonly extras;
+    /**
+     * @private
+     */
+    constructor(defLockedState: boolean | undefined, defUIPriority: number | undefined, defSemiHidden: boolean | undefined, defUnhideWhenUsed: boolean | undefined, defQFormat: boolean | undefined, count: number | undefined, exceptions: LsdException[], extraAttributes?: OpenXmlAttribute[], extras?: OpenXmlElement[]);
+    readonly defLockedState: boolean | undefined;
+    readonly defUIPriority: number | undefined;
+    readonly defSemiHidden: boolean | undefined;
+    readonly defUnhideWhenUsed: boolean | undefined;
+    readonly defQFormat: boolean | undefined;
+    readonly count: number | undefined;
+    /** Ordered `w:lsdException` entries. */
+    readonly exceptions: ReadonlyArray<LsdException>;
+    /**
+     * @private
+     */
+    serialize(): OpenXmlElement;
+}
+/**
+ * Parse `w:latentStyles` into {@link LatentStyles}.
+ *
+ * @private
+ */
+export declare function parseLatentStyles(element: OpenXmlElement): LatentStyles | undefined;

package/src/features/styles/latent-styles.js

@@ -0,0 +1,305 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+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 { elementChildren, isWml, wmlAttr, wmlElement, WML, } from '../document/wml';
+/**
+ * One `w:lsdException` entry under `w:latentStyles` (`CT_LsdException`).
+ *
+ * @private
+ */
+var LsdException = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function LsdException(name, locked, uiPriority, semiHidden, unhideWhenUsed, qFormat, extraAttributes) {
+        if (extraAttributes === void 0) { extraAttributes = []; }
+        this.nameValue = name;
+        this.lockedValue = locked;
+        this.uiPriorityValue = uiPriority;
+        this.semiHiddenValue = semiHidden;
+        this.unhideWhenUsedValue = unhideWhenUsed;
+        this.qFormatValue = qFormat;
+        this.extraAttributes = extraAttributes;
+    }
+    Object.defineProperty(LsdException.prototype, "name", {
+        /** `w:lsdException/@w:name` (required). */
+        get: function () {
+            return this.nameValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LsdException.prototype, "locked", {
+        get: function () {
+            return this.lockedValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LsdException.prototype, "uiPriority", {
+        get: function () {
+            return this.uiPriorityValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LsdException.prototype, "semiHidden", {
+        get: function () {
+            return this.semiHiddenValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LsdException.prototype, "unhideWhenUsed", {
+        get: function () {
+            return this.unhideWhenUsedValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LsdException.prototype, "qFormat", {
+        get: function () {
+            return this.qFormatValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    LsdException.prototype.serialize = function () {
+        var attributes = __spread([wmlAttr('name', this.nameValue)], this.extraAttributes);
+        if (this.lockedValue !== undefined) {
+            attributes.push(wmlAttr('locked', this.lockedValue ? '1' : '0'));
+        }
+        if (this.uiPriorityValue !== undefined) {
+            attributes.push(wmlAttr('uiPriority', String(this.uiPriorityValue)));
+        }
+        if (this.semiHiddenValue !== undefined) {
+            attributes.push(wmlAttr('semiHidden', this.semiHiddenValue ? '1' : '0'));
+        }
+        if (this.unhideWhenUsedValue !== undefined) {
+            attributes.push(wmlAttr('unhideWhenUsed', this.unhideWhenUsedValue ? '1' : '0'));
+        }
+        if (this.qFormatValue !== undefined) {
+            attributes.push(wmlAttr('qFormat', this.qFormatValue ? '1' : '0'));
+        }
+        return wmlElement('lsdException', { attributes: attributes });
+    };
+    return LsdException;
+}());
+export { LsdException };
+/**
+ * Latent style information (`w:latentStyles` / `CT_LatentStyles`).
+ *
+ * @private
+ */
+var LatentStyles = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function LatentStyles(defLockedState, defUIPriority, defSemiHidden, defUnhideWhenUsed, defQFormat, count, exceptions, extraAttributes, extras) {
+        if (extraAttributes === void 0) { extraAttributes = []; }
+        if (extras === void 0) { extras = []; }
+        this.defLockedStateValue = defLockedState;
+        this.defUIPriorityValue = defUIPriority;
+        this.defSemiHiddenValue = defSemiHidden;
+        this.defUnhideWhenUsedValue = defUnhideWhenUsed;
+        this.defQFormatValue = defQFormat;
+        this.countValue = count;
+        this.exceptionsList = exceptions;
+        this.extraAttributes = extraAttributes;
+        this.extras = extras;
+    }
+    Object.defineProperty(LatentStyles.prototype, "defLockedState", {
+        get: function () {
+            return this.defLockedStateValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LatentStyles.prototype, "defUIPriority", {
+        get: function () {
+            return this.defUIPriorityValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LatentStyles.prototype, "defSemiHidden", {
+        get: function () {
+            return this.defSemiHiddenValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LatentStyles.prototype, "defUnhideWhenUsed", {
+        get: function () {
+            return this.defUnhideWhenUsedValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LatentStyles.prototype, "defQFormat", {
+        get: function () {
+            return this.defQFormatValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LatentStyles.prototype, "count", {
+        get: function () {
+            return this.countValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LatentStyles.prototype, "exceptions", {
+        /** Ordered `w:lsdException` entries. */
+        get: function () {
+            return this.exceptionsList;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    LatentStyles.prototype.serialize = function () {
+        var attributes = __spread(this.extraAttributes);
+        if (this.defLockedStateValue !== undefined) {
+            attributes.push(wmlAttr('defLockedState', this.defLockedStateValue ? '1' : '0'));
+        }
+        if (this.defUIPriorityValue !== undefined) {
+            attributes.push(wmlAttr('defUIPriority', String(this.defUIPriorityValue)));
+        }
+        if (this.defSemiHiddenValue !== undefined) {
+            attributes.push(wmlAttr('defSemiHidden', this.defSemiHiddenValue ? '1' : '0'));
+        }
+        if (this.defUnhideWhenUsedValue !== undefined) {
+            attributes.push(wmlAttr('defUnhideWhenUsed', this.defUnhideWhenUsedValue ? '1' : '0'));
+        }
+        if (this.defQFormatValue !== undefined) {
+            attributes.push(wmlAttr('defQFormat', this.defQFormatValue ? '1' : '0'));
+        }
+        if (this.countValue !== undefined) {
+            attributes.push(wmlAttr('count', String(this.countValue)));
+        }
+        var children = this.exceptionsList.map(function (item) { return item.serialize(); });
+        children.push.apply(children, __spread(this.extras));
+        return wmlElement('latentStyles', { attributes: attributes, children: children });
+    };
+    return LatentStyles;
+}());
+export { LatentStyles };
+function wmlAttribute(el, localName) {
+    var __ts33_0;
+    return ((__ts33_0 = el.attributes.find(function (a) { return a.localName === localName && (a.namespaceUri === WML || a.namespaceUri === ''); })), __ts33_0 == null ? undefined : __ts33_0.value);
+}
+function parseOnOffAttribute(raw) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    var normalized = raw.trim().toLowerCase();
+    if (normalized === '' || normalized === 'true' || normalized === '1' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+        return false;
+    }
+    return undefined;
+}
+function parseDecimalAttribute(raw) {
+    if (raw === undefined || !/^-?\d+$/.test(raw.trim())) {
+        return undefined;
+    }
+    return parseInt(raw.trim(), 10);
+}
+function parseLsdException(element) {
+    if (!isWml(element, 'lsdException')) {
+        return undefined;
+    }
+    var name = wmlAttribute(element, 'name');
+    if (name === undefined || name.length === 0) {
+        return undefined;
+    }
+    var known = new Set([
+        'name',
+        'locked',
+        'uiPriority',
+        'semiHidden',
+        'unhideWhenUsed',
+        'qFormat',
+    ]);
+    var extraAttributes = element.attributes.filter(function (a) { return !(known.has(a.localName) && (a.namespaceUri === WML || a.namespaceUri === '')); });
+    return new LsdException(name, parseOnOffAttribute(wmlAttribute(element, 'locked')), parseDecimalAttribute(wmlAttribute(element, 'uiPriority')), parseOnOffAttribute(wmlAttribute(element, 'semiHidden')), parseOnOffAttribute(wmlAttribute(element, 'unhideWhenUsed')), parseOnOffAttribute(wmlAttribute(element, 'qFormat')), extraAttributes);
+}
+/**
+ * Parse `w:latentStyles` into {@link LatentStyles}.
+ *
+ * @private
+ */
+export function parseLatentStyles(element) {
+    var e_1, _a;
+    if (!isWml(element, 'latentStyles')) {
+        return undefined;
+    }
+    var knownRoot = new Set([
+        'defLockedState',
+        'defUIPriority',
+        'defSemiHidden',
+        'defUnhideWhenUsed',
+        'defQFormat',
+        'count',
+    ]);
+    var extraAttributes = element.attributes.filter(function (a) { return !(knownRoot.has(a.localName) && (a.namespaceUri === WML || a.namespaceUri === '')); });
+    var exceptions = [];
+    var extras = [];
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'lsdException')) {
+                var entry = parseLsdException(child);
+                if (entry !== undefined) {
+                    exceptions.push(entry);
+                }
+                continue;
+            }
+            extras.push(child);
+        }
+    }
+    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 new LatentStyles(parseOnOffAttribute(wmlAttribute(element, 'defLockedState')), parseDecimalAttribute(wmlAttribute(element, 'defUIPriority')), parseOnOffAttribute(wmlAttribute(element, 'defSemiHidden')), parseOnOffAttribute(wmlAttribute(element, 'defUnhideWhenUsed')), parseOnOffAttribute(wmlAttribute(element, 'defQFormat')), parseDecimalAttribute(wmlAttribute(element, 'count')), exceptions, extraAttributes, extras);
+}

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

@@ -0,0 +1,71 @@
+/**
+ * Modeled paragraph properties subset for styles `w:pPr` / `w:pPrDefault`.
+ *
+ * Spacing and indentation lengths are plain point `number`s. Codecs delegate to
+ * {@link parseParagraphSpacingPoints} / {@link parseParagraphIndentationPoints}
+ * and their serialize counterparts on `paragraph-format` (TASK-9020-D shared
+ * ownership with body `w:pPr`).
+ *
+ * Citation: ECMA-376-1 §17.3.1 `w:pPr` children — `w:keepNext` (§17.3.1.14),
+ * `w:keepLines` (§17.3.1.15), `w:pageBreakBefore` (§17.3.1.17),
+ * `w:widowControl` (§17.3.1.29), `w:spacing` (§17.3.1.33), `w:ind`
+ * (§17.3.1.12), `w:contextualSpacing` (§17.3.1.8), `w:outlineLvl`
+ * (§17.3.1.31 `CT_DecimalNumber`, zero-based); Transitional `wml.xsd`
+ * `CT_PPrBase`, `CT_Ind`, `CT_Spacing`; Word fixture
+ * `input-documents/Sample_With_All_word_Element.docx` (`w:pPrDefault/w:pPr/w:spacing`).
+ */
+import { ParagraphIndentation, ParagraphSpacing } from '../document/paragraph-format';
+import { OpenXmlElement } from '../../core/xml/index';
+/**
+ * Modeled paragraph properties extracted from a `w:pPr` element.
+ *
+ * @private
+ */
+export interface ModeledParagraphProperties {
+    readonly spacing: ParagraphSpacing | undefined;
+    readonly indentation: ParagraphIndentation | undefined;
+    readonly keepNext: boolean | undefined;
+    readonly keepLines: boolean | undefined;
+    readonly pageBreakBefore: boolean | undefined;
+    readonly widowControl: boolean | undefined;
+    readonly contextualSpacing: boolean | undefined;
+    /** `w:outlineLvl`, zero-based (0 = Heading 1 … 8 = Heading 9). */
+    readonly outlineLevel: number | undefined;
+}
+export declare const EMPTY_MODELED_PARAGRAPH_PROPERTIES: ModeledParagraphProperties;
+/**
+ * Parse `w:spacing` attributes into {@link ParagraphSpacing}.
+ *
+ * Delegates to {@link parseParagraphSpacingPoints} (shared with body pPr).
+ *
+ * @private
+ */
+export declare function parseParagraphSpacing(el: OpenXmlElement): ParagraphSpacing | undefined;
+/**
+ * Parse modeled paragraph properties from a `w:pPr` element.
+ *
+ * @private
+ */
+export declare function parseModeledParagraphProperties(pPr: OpenXmlElement | undefined): ModeledParagraphProperties;
+/**
+ * Merge two modeled paragraph property layers (`base` ← `override`).
+ * `override` fields win when defined; spacing and indentation merge
+ * attribute-by-attribute.
+ *
+ * @private
+ */
+export declare function mergeModeledParagraphProperties(base: ModeledParagraphProperties, override: ModeledParagraphProperties): ModeledParagraphProperties;
+/**
+ * Serialize modeled paragraph properties into a `w:pPr` element.
+ *
+ * Emits only defined fields, in `CT_PPrBase` sequence order
+ * (keepNext → keepLines → pageBreakBefore → widowControl → spacing → ind →
+ * contextualSpacing → outlineLvl). Returns `undefined` when no modeled
+ * property is set — callers must not write empty payload containers.
+ *
+ * Spacing / ind materialize via {@link serializeParagraphSpacingPoints} /
+ * {@link serializeParagraphIndentationPoints} (shared body codecs).
+ *
+ * @private
+ */
+export declare function serializeModeledParagraphProperties(properties: ModeledParagraphProperties): OpenXmlElement | undefined;

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

@@ -0,0 +1,237 @@
+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 };
+        }
+    };
+};
+/**
+ * Modeled paragraph properties subset for styles `w:pPr` / `w:pPrDefault`.
+ *
+ * Spacing and indentation lengths are plain point `number`s. Codecs delegate to
+ * {@link parseParagraphSpacingPoints} / {@link parseParagraphIndentationPoints}
+ * and their serialize counterparts on `paragraph-format` (TASK-9020-D shared
+ * ownership with body `w:pPr`).
+ *
+ * Citation: ECMA-376-1 §17.3.1 `w:pPr` children — `w:keepNext` (§17.3.1.14),
+ * `w:keepLines` (§17.3.1.15), `w:pageBreakBefore` (§17.3.1.17),
+ * `w:widowControl` (§17.3.1.29), `w:spacing` (§17.3.1.33), `w:ind`
+ * (§17.3.1.12), `w:contextualSpacing` (§17.3.1.8), `w:outlineLvl`
+ * (§17.3.1.31 `CT_DecimalNumber`, zero-based); Transitional `wml.xsd`
+ * `CT_PPrBase`, `CT_Ind`, `CT_Spacing`; Word fixture
+ * `input-documents/Sample_With_All_word_Element.docx` (`w:pPrDefault/w:pPr/w:spacing`).
+ */
+import { parseParagraphIndentationPoints, parseParagraphSpacingPoints, serializeParagraphIndentationPoints, serializeParagraphSpacingPoints, } from '../document/paragraph-format';
+import { parseOnOff, serializeOnOff } from '../document/on-off';
+import { elementChildren, isWml, wmlAttr, wmlElement, WML, } from '../document/wml';
+export var EMPTY_MODELED_PARAGRAPH_PROPERTIES = {
+    spacing: undefined,
+    indentation: undefined,
+    keepNext: undefined,
+    keepLines: undefined,
+    pageBreakBefore: undefined,
+    widowControl: undefined,
+    contextualSpacing: undefined,
+    outlineLevel: undefined,
+};
+function wmlAttrVal(el, localName) {
+    var found = el.attributes.find(function (attribute) { return attribute.localName === localName &&
+        (attribute.namespaceUri === WML || attribute.namespaceUri === ''); });
+    return found == null ? undefined : found.value;
+}
+/**
+ * Parse `w:spacing` attributes into {@link ParagraphSpacing}.
+ *
+ * Delegates to {@link parseParagraphSpacingPoints} (shared with body pPr).
+ *
+ * @private
+ */
+export function parseParagraphSpacing(el) {
+    return parseParagraphSpacingPoints(el);
+}
+/**
+ * Parse modeled paragraph properties from a `w:pPr` element.
+ *
+ * @private
+ */
+export function parseModeledParagraphProperties(pPr) {
+    var e_1, _a;
+    if (pPr === undefined || !isWml(pPr, 'pPr')) {
+        return EMPTY_MODELED_PARAGRAPH_PROPERTIES;
+    }
+    var spacing;
+    var indentation;
+    var keepNext;
+    var keepLines;
+    var pageBreakBefore;
+    var widowControl;
+    var contextualSpacing;
+    var outlineLevel;
+    try {
+        for (var _b = __values(elementChildren(pPr)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (!isWml(child, child.localName)) {
+                continue;
+            }
+            switch (child.localName) {
+                case 'spacing':
+                    spacing = parseParagraphSpacingPoints(child);
+                    continue;
+                case 'ind':
+                    indentation = parseParagraphIndentationPoints(child);
+                    continue;
+                case 'keepNext': {
+                    var flag = parseOnOff(child);
+                    if (flag !== undefined) {
+                        keepNext = flag;
+                    }
+                    continue;
+                }
+                case 'keepLines': {
+                    var flag = parseOnOff(child);
+                    if (flag !== undefined) {
+                        keepLines = flag;
+                    }
+                    continue;
+                }
+                case 'pageBreakBefore': {
+                    var flag = parseOnOff(child);
+                    if (flag !== undefined) {
+                        pageBreakBefore = flag;
+                    }
+                    continue;
+                }
+                case 'widowControl': {
+                    var flag = parseOnOff(child);
+                    if (flag !== undefined) {
+                        widowControl = flag;
+                    }
+                    continue;
+                }
+                case 'contextualSpacing': {
+                    var flag = parseOnOff(child);
+                    if (flag !== undefined) {
+                        contextualSpacing = flag;
+                    }
+                    continue;
+                }
+                case 'outlineLvl': {
+                    var raw = wmlAttrVal(child, 'val');
+                    if (raw !== undefined && /^\d$/.test(raw)) {
+                        var level = parseInt(raw, 10);
+                        if (level >= 0 && level <= 8) {
+                            outlineLevel = level;
+                        }
+                    }
+                    continue;
+                }
+                default:
+                    continue;
+            }
+        }
+    }
+    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 {
+        spacing: spacing,
+        indentation: indentation,
+        keepNext: keepNext,
+        keepLines: keepLines,
+        pageBreakBefore: pageBreakBefore,
+        widowControl: widowControl,
+        contextualSpacing: contextualSpacing,
+        outlineLevel: outlineLevel,
+    };
+}
+function mergeFlag(base, override) {
+    return override !== undefined ? override : base;
+}
+/**
+ * Merge two modeled paragraph property layers (`base` ← `override`).
+ * `override` fields win when defined; spacing and indentation merge
+ * attribute-by-attribute.
+ *
+ * @private
+ */
+export function mergeModeledParagraphProperties(base, override) {
+    var spacing = override.spacing !== undefined || base.spacing !== undefined
+        ? __assign({}, (base.spacing != null ? base.spacing : {}), (override.spacing != null ? override.spacing : {})) : undefined;
+    var indentation = override.indentation !== undefined || base.indentation !== undefined
+        ? __assign({}, (base.indentation != null ? base.indentation : {}), (override.indentation != null ? override.indentation : {})) : undefined;
+    return {
+        spacing: spacing,
+        indentation: indentation,
+        keepNext: mergeFlag(base.keepNext, override.keepNext),
+        keepLines: mergeFlag(base.keepLines, override.keepLines),
+        pageBreakBefore: mergeFlag(base.pageBreakBefore, override.pageBreakBefore),
+        widowControl: mergeFlag(base.widowControl, override.widowControl),
+        contextualSpacing: mergeFlag(base.contextualSpacing, override.contextualSpacing),
+        outlineLevel: override.outlineLevel !== undefined ? override.outlineLevel : base.outlineLevel,
+    };
+}
+// ---------------------------------------------------------------------------
+// Serialization (typed fields → w:pPr children, CT_PPrBase sequence order)
+// ---------------------------------------------------------------------------
+/**
+ * Serialize modeled paragraph properties into a `w:pPr` element.
+ *
+ * Emits only defined fields, in `CT_PPrBase` sequence order
+ * (keepNext → keepLines → pageBreakBefore → widowControl → spacing → ind →
+ * contextualSpacing → outlineLvl). Returns `undefined` when no modeled
+ * property is set — callers must not write empty payload containers.
+ *
+ * Spacing / ind materialize via {@link serializeParagraphSpacingPoints} /
+ * {@link serializeParagraphIndentationPoints} (shared body codecs).
+ *
+ * @private
+ */
+export function serializeModeledParagraphProperties(properties) {
+    var children = [];
+    if (properties.keepNext !== undefined) {
+        children.push(serializeOnOff('keepNext', properties.keepNext));
+    }
+    if (properties.keepLines !== undefined) {
+        children.push(serializeOnOff('keepLines', properties.keepLines));
+    }
+    if (properties.pageBreakBefore !== undefined) {
+        children.push(serializeOnOff('pageBreakBefore', properties.pageBreakBefore));
+    }
+    if (properties.widowControl !== undefined) {
+        children.push(serializeOnOff('widowControl', properties.widowControl));
+    }
+    if (properties.spacing !== undefined) {
+        children.push(serializeParagraphSpacingPoints(properties.spacing));
+    }
+    if (properties.indentation !== undefined) {
+        children.push(serializeParagraphIndentationPoints(properties.indentation));
+    }
+    if (properties.contextualSpacing !== undefined) {
+        children.push(serializeOnOff('contextualSpacing', properties.contextualSpacing));
+    }
+    if (properties.outlineLevel !== undefined) {
+        children.push(wmlElement('outlineLvl', { attributes: [wmlAttr('val', String(properties.outlineLevel))] }));
+    }
+    if (children.length === 0) {
+        return undefined;
+    }
+    return wmlElement('pPr', { children: children });
+}