@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/sections/page-setup.js

@@ -0,0 +1,1479 @@
+import { BorderStyle, LineNumberingMode, PageBorderOffsetFrom, PageBordersApplyType, PageOrientation, PageNumberStyle, PrinterPaperTray, SizeF, VerticalAlignment, } from '../document/page-setup';
+import { Color, colorFromWire, colorToHexWire } from '../document/color';
+import { pointToTwips } from '../document/length';
+import { serializeOnOff } from '../document/on-off';
+import { wmlAttr, wmlElement } from '../document/wml';
+import { featureId, isFeatureRegistered } from '../../core/registry/index';
+import { ColumnCollection } from './column-collection';
+import { Margins } from './margins';
+import { PageSize } from './page-size';
+import { breakCodeToWire, SectionBreakCode } from './section-break-code';
+import { ownerDocumentOf } from './section-document-association';
+import { sectionsError, validatePageNumberStyle, validatePageOrientation, validatePositiveInteger, validateSectionBreakCode, validateSectionLength, validateNonNegativeInteger, } from './section-validation';
+// Re-export public contracts consumed alongside the live PageSetup class.
+export { BorderStyle, LineNumberingMode, PageBorderOffsetFrom, PageBordersApplyType, PageOrientation, PageNumberStyle, PrinterPaperTray, SizeF, VerticalAlignment, };
+/** Office WordDocument relationships namespace for `r:id` on `CT_Rel`. */
+var RELATIONSHIPS_OFFICE_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+var SETTINGS_FEATURE_ID = 'settings';
+var BORDER_STYLE_VALUES = new Set([
+    BorderStyle.Nil,
+    BorderStyle.None,
+    BorderStyle.Single,
+    BorderStyle.Thick,
+    BorderStyle.Double,
+    BorderStyle.Dotted,
+    BorderStyle.Dashed,
+    BorderStyle.DotDash,
+    BorderStyle.DotDotDash,
+    BorderStyle.Triple,
+    BorderStyle.ThinThickSmallGap,
+    BorderStyle.ThickThinSmallGap,
+    BorderStyle.ThinThickThinSmallGap,
+    BorderStyle.ThinThickMediumGap,
+    BorderStyle.ThickThinMediumGap,
+    BorderStyle.ThinThickThinMediumGap,
+    BorderStyle.ThinThickLargeGap,
+    BorderStyle.ThickThinLargeGap,
+    BorderStyle.ThinThickThinLargeGap,
+    BorderStyle.Wave,
+    BorderStyle.DoubleWave,
+    BorderStyle.DashSmallGap,
+    BorderStyle.DashDotStroked,
+    BorderStyle.ThreeDEmboss,
+    BorderStyle.ThreeDEngrave,
+    BorderStyle.Outset,
+    BorderStyle.Inset,
+]);
+/**
+ * Live page-border edge — public surface is {@link space} only.
+ *
+ * @public
+ */
+var PageBorder = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function PageBorder() {
+        this.spaceValue = 0;
+        this.styleValue = BorderStyle.None;
+        this.colorWireValue = 'auto';
+        this.widthPointsValue = 0.5;
+    }
+    Object.defineProperty(PageBorder.prototype, "space", {
+        get: function () {
+            return this.spaceValue;
+        },
+        set: function (value) {
+            if (!Number.isInteger(value) || value < 0 || value > 31) {
+                throw sectionsError('borders.space must be an integer in 0…31');
+            }
+            this.spaceValue = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorder.prototype, "style", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.styleValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorder.prototype, "colorWire", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.colorWireValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorder.prototype, "widthPoints", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.widthPointsValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    PageBorder.prototype.applyCommon = function (style, colorWire, widthPoints) {
+        this.styleValue = style;
+        this.colorWireValue = colorWire;
+        this.widthPointsValue = widthPoints;
+    };
+    /**
+     * @private
+     */
+    PageBorder.prototype.loadFromParsed = function (edge) {
+        this.styleValue = borderStyleFromWire(edge.style);
+        this.colorWireValue = edge.color;
+        this.widthPointsValue = edge.widthPoints;
+        this.spaceValue = Math.round(edge.offsetPoints);
+    };
+    /**
+     * @private
+     */
+    PageBorder.prototype.toParsed = function () {
+        if (!isActiveBorderStyle(this.styleValue)) {
+            return undefined;
+        }
+        return {
+            style: this.styleValue,
+            widthPoints: this.widthPointsValue,
+            offsetPoints: this.spaceValue,
+            color: this.colorWireValue,
+        };
+    };
+    /**
+     * @private
+     */
+    PageBorder.prototype.cloneInto = function (target) {
+        target.spaceValue = this.spaceValue;
+        target.styleValue = this.styleValue;
+        target.colorWireValue = this.colorWireValue;
+        target.widthPointsValue = this.widthPointsValue;
+    };
+    return PageBorder;
+}());
+export { PageBorder };
+/**
+ * Live page borders — common style/color/width plus four edges.
+ *
+ * @public
+ */
+var PageBorders = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function PageBorders() {
+        this.borderTypeValue = BorderStyle.None;
+        this.colorPublicValue = Color.Black;
+        this.colorWireOverride = undefined;
+        this.lineWidthValue = 0.5;
+        this.topEdge = new PageBorder();
+        this.bottomEdge = new PageBorder();
+        this.leftEdge = new PageBorder();
+        this.rightEdge = new PageBorder();
+        this.applyToValue = 'allPages';
+        this.measureFromValue = 'text';
+        this.zOrderValue = 'front';
+    }
+    Object.defineProperty(PageBorders.prototype, "borderType", {
+        get: function () {
+            return this.borderTypeValue;
+        },
+        set: function (value) {
+            this.borderTypeValue = validateBorderStyle(value, 'borders.borderType');
+            this.stampCommonToEdges();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorders.prototype, "color", {
+        get: function () {
+            return this.colorPublicValue;
+        },
+        set: function (value) {
+            if (typeof value !== 'number' || Color[value] === undefined) {
+                throw sectionsError('borders.color must be a Color enum value');
+            }
+            this.colorPublicValue = value;
+            this.colorWireOverride = undefined;
+            this.stampCommonToEdges();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorders.prototype, "lineWidth", {
+        get: function () {
+            return this.lineWidthValue;
+        },
+        set: function (value) {
+            this.lineWidthValue = validateBorderWidth(value, 'borders.lineWidth');
+            this.stampCommonToEdges();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorders.prototype, "top", {
+        get: function () {
+            return this.topEdge;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorders.prototype, "bottom", {
+        get: function () {
+            return this.bottomEdge;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorders.prototype, "left", {
+        get: function () {
+            return this.leftEdge;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorders.prototype, "right", {
+        get: function () {
+            return this.rightEdge;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageBorders.prototype, "applyTo", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.applyToValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    PageBorders.prototype.setApplyTo = function (value) {
+        this.applyToValue = value;
+    };
+    Object.defineProperty(PageBorders.prototype, "measureFrom", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.measureFromValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    PageBorders.prototype.setMeasureFrom = function (value) {
+        this.measureFromValue = value;
+    };
+    Object.defineProperty(PageBorders.prototype, "zOrder", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.zOrderValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    PageBorders.prototype.loadFromParsed = function (bag) {
+        this.applyToValue = bag.applyTo;
+        this.measureFromValue = bag.measureFrom;
+        this.zOrderValue = bag.zOrder;
+        if (bag.top !== undefined) {
+            this.topEdge.loadFromParsed(bag.top);
+        }
+        if (bag.left !== undefined) {
+            this.leftEdge.loadFromParsed(bag.left);
+        }
+        if (bag.bottom !== undefined) {
+            this.bottomEdge.loadFromParsed(bag.bottom);
+        }
+        if (bag.right !== undefined) {
+            this.rightEdge.loadFromParsed(bag.right);
+        }
+        var ref = bag.top !== undefined
+            ? bag.top
+            : bag.left !== undefined
+                ? bag.left
+                : bag.bottom !== undefined
+                    ? bag.bottom
+                    : bag.right;
+        if (ref !== undefined) {
+            this.borderTypeValue = borderStyleFromWire(ref.style);
+            var mapped = colorFromWire(ref.color);
+            if (mapped !== undefined) {
+                this.colorPublicValue = mapped;
+                this.colorWireOverride = undefined;
+            }
+            else {
+                this.colorPublicValue = Color.Black;
+                this.colorWireOverride = ref.color;
+            }
+            this.lineWidthValue = ref.widthPoints;
+        }
+    };
+    /**
+     * @private
+     */
+    PageBorders.prototype.toParsed = function () {
+        var top = this.topEdge.toParsed();
+        var left = this.leftEdge.toParsed();
+        var bottom = this.bottomEdge.toParsed();
+        var right = this.rightEdge.toParsed();
+        var hasEdge = top !== undefined ||
+            left !== undefined ||
+            bottom !== undefined ||
+            right !== undefined;
+        var hasContainerOpts = this.applyToValue !== 'allPages' ||
+            this.measureFromValue !== 'text' ||
+            this.zOrderValue !== 'front';
+        if (!hasEdge && !hasContainerOpts) {
+            return undefined;
+        }
+        return {
+            applyTo: this.applyToValue,
+            measureFrom: this.measureFromValue,
+            zOrder: this.zOrderValue,
+            top: top,
+            left: left,
+            bottom: bottom,
+            right: right,
+        };
+    };
+    /**
+     * @private
+     */
+    PageBorders.prototype.copyFrom = function (source) {
+        this.borderTypeValue = source.borderTypeValue;
+        this.colorPublicValue = source.colorPublicValue;
+        this.colorWireOverride = source.colorWireOverride;
+        this.lineWidthValue = source.lineWidthValue;
+        this.applyToValue = source.applyToValue;
+        this.measureFromValue = source.measureFromValue;
+        this.zOrderValue = source.zOrderValue;
+        source.topEdge.cloneInto(this.topEdge);
+        source.bottomEdge.cloneInto(this.bottomEdge);
+        source.leftEdge.cloneInto(this.leftEdge);
+        source.rightEdge.cloneInto(this.rightEdge);
+    };
+    PageBorders.prototype.stampCommonToEdges = function () {
+        var wire = this.resolveColorWire();
+        this.topEdge.applyCommon(this.borderTypeValue, wire, this.lineWidthValue);
+        this.bottomEdge.applyCommon(this.borderTypeValue, wire, this.lineWidthValue);
+        this.leftEdge.applyCommon(this.borderTypeValue, wire, this.lineWidthValue);
+        this.rightEdge.applyCommon(this.borderTypeValue, wire, this.lineWidthValue);
+    };
+    PageBorders.prototype.resolveColorWire = function () {
+        if (this.colorWireOverride !== undefined && this.colorWireOverride.length > 0) {
+            return this.colorWireOverride;
+        }
+        if (this.colorPublicValue === Color.Transparent) {
+            return 'auto';
+        }
+        var hex = colorToHexWire(this.colorPublicValue);
+        return hex.length > 0 ? hex : 'auto';
+    };
+    return PageBorders;
+}());
+export { PageBorders };
+/**
+ * Live section page setup (`CT_SectPr` model) — public surface per architecture §§4–12.
+ *
+ * Implements the core {@link PageSetupContract} public contract and internal
+ * {@link SectionPropertiesModel} for dual-hold serialization.
+ *
+ * @public
+ */
+var PageSetup = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function PageSetup() {
+        this.attributes = [];
+        this.prefix = [];
+        this.suffix = [];
+        this.headerFooterReferencesValue = [];
+        this.breakCodeValue = SectionBreakCode.NewPage;
+        this.pageSizeValue = new SizeF(PageSize.Letter.width, PageSize.Letter.height);
+        this.orientationValue = PageOrientation.Portrait;
+        this.marginsValue = new Margins(72, 72, 72, 72);
+        this.headerDistanceValue = 36;
+        this.footerDistanceValue = 36;
+        this.gutterValue = 0;
+        this.firstPageTrayValue = undefined;
+        this.otherPagesTrayValue = undefined;
+        this.paperSourcePresent = false;
+        this.bordersValue = new PageBorders();
+        this.lineNumberingPresent = false;
+        this.lineNumberingDistanceFromTextValue = 0;
+        this.lineNumberingModeValue = LineNumberingMode.RestartPage;
+        // Public API is one-based; OOXML `w:lnNumType/@w:start` is zero-based.
+        this.lineNumberingStartValueValue = 1;
+        this.lineNumberingStepValue = 1;
+        this.pageStartingNumberValue = 1;
+        this.restartPageNumberingValue = false;
+        this.pageNumberStyleValue = PageNumberStyle.Arabic;
+        this.chapterNumberingValue = undefined;
+        this.pageNumberingPresent = false;
+        this.columnsValue = new ColumnCollection();
+        this.verticalAlignmentValue = VerticalAlignment.Top;
+        this.bidiValue = false;
+        this.differentFirstPageValue = false;
+        var self = this;
+        this.pageSizeValue.setChangeListener(function (width, height) {
+            validateSectionLength(width, 'pageSize.width');
+            validateSectionLength(height, 'pageSize.height');
+            self.orientationValue =
+                height >= width
+                    ? PageOrientation.Portrait
+                    : PageOrientation.Landscape;
+        });
+    }
+    /**
+     * US Letter defaults (architecture § letter factory).
+     *
+     * @private
+     */
+    PageSetup.createDefaultLetter = function () {
+        return new PageSetup();
+    };
+    /**
+     * Atomic load-path construction — does not call public setters in sequence
+     * (avoids orientation last-write-wins side effects during parse).
+     *
+     * @private
+     */
+    PageSetup.createFromParsedValues = function (values) {
+        var setup = new PageSetup();
+        if (values.attributes !== undefined) {
+            setup.attributes = values.attributes.slice();
+        }
+        if (values.prefix !== undefined) {
+            setup.prefix = values.prefix.slice();
+        }
+        if (values.suffix !== undefined) {
+            setup.suffix = values.suffix.slice();
+        }
+        if (values.headerFooterReferences !== undefined) {
+            setup.headerFooterReferencesValue = values.headerFooterReferences.slice();
+        }
+        if (values.breakCode !== undefined) {
+            setup.breakCodeValue = values.breakCode;
+        }
+        validateSectionLength(values.pageWidth, 'pageSize.width');
+        validateSectionLength(values.pageHeight, 'pageSize.height');
+        setup.pageSizeValue.replace(values.pageWidth, values.pageHeight, false);
+        if (values.orientation !== undefined) {
+            setup.orientationValue = validatePageOrientation(values.orientation);
+        }
+        else {
+            setup.orientationValue =
+                values.pageHeight >= values.pageWidth
+                    ? PageOrientation.Portrait
+                    : PageOrientation.Landscape;
+        }
+        setup.marginsValue.replace(values.marginLeft, values.marginTop, values.marginRight, values.marginBottom);
+        if (values.headerDistance !== undefined) {
+            setup.headerDistanceValue = validateSectionLength(values.headerDistance, 'headerDistance');
+        }
+        if (values.footerDistance !== undefined) {
+            setup.footerDistanceValue = validateSectionLength(values.footerDistance, 'footerDistance');
+        }
+        if (values.gutter !== undefined) {
+            setup.gutterValue = validateSectionLength(values.gutter, 'gutter');
+        }
+        if (values.paperSource !== undefined) {
+            var paper = assertPaperSource(values.paperSource);
+            setup.firstPageTrayValue = paper.firstPageTray;
+            setup.otherPagesTrayValue = paper.otherPagesTray;
+            setup.paperSourcePresent =
+                paper.firstPageTray !== undefined || paper.otherPagesTray !== undefined;
+        }
+        if (values.pageBorders !== undefined) {
+            var bag = assertPageBorders(values.pageBorders);
+            setup.bordersValue.loadFromParsed(bag);
+        }
+        if (values.lineNumbering !== undefined) {
+            var ln = assertLineNumbering(values.lineNumbering);
+            setup.lineNumberingPresent = true;
+            setup.lineNumberingStepValue = ln.countBy;
+            setup.lineNumberingModeValue =
+                ln.restart === undefined || ln.restart === 'newPage'
+                    ? LineNumberingMode.RestartPage
+                    : ln.restart === 'newSection'
+                        ? LineNumberingMode.RestartSection
+                        : LineNumberingMode.Continuous;
+            // Parse bag `startAt` is wire (zero-based). Public API is one-based.
+            // Absent `w:start` matches the schema default of 0 → API 1.
+            setup.lineNumberingStartValueValue =
+                ln.startAt !== undefined ? ln.startAt + 1 : 1;
+            setup.lineNumberingDistanceFromTextValue =
+                ln.distanceFromText !== undefined ? ln.distanceFromText : 0;
+        }
+        if (values.pageStartingNumber !== undefined) {
+            setup.pageStartingNumberValue = validatePositiveInteger(values.pageStartingNumber, 'pageStartingNumber');
+        }
+        if (values.restartPageNumbering !== undefined) {
+            setup.restartPageNumberingValue = values.restartPageNumbering === true;
+        }
+        if (values.pageNumberStyle !== undefined) {
+            setup.pageNumberStyleValue = validatePageNumberStyle(values.pageNumberStyle);
+        }
+        if (values.chapterNumbering !== undefined) {
+            setup.chapterNumberingValue = assertChapterNumbering(values.chapterNumbering);
+        }
+        if (values.pageNumberingPresent === true ||
+            values.pageStartingNumber !== undefined ||
+            values.restartPageNumbering === true ||
+            values.pageNumberStyle !== undefined ||
+            values.chapterNumbering !== undefined) {
+            setup.pageNumberingPresent = true;
+        }
+        if (values.columns !== undefined) {
+            var src = values.columns;
+            setup.columnsValue.replaceFromParsed({
+                equalWidth: src.equalWidth,
+                separator: src.separator,
+                spacing: src.spacing,
+                count: src.count,
+                columns: Array.from(src).map(function (c) { return ({ width: c.width, space: c.spacing }); }),
+            });
+        }
+        if (values.verticalAlignment !== undefined) {
+            setup.verticalAlignmentValue = assertVerticalAlignment(values.verticalAlignment);
+        }
+        if (values.bidi !== undefined) {
+            setup.bidiValue = values.bidi === true;
+        }
+        if (values.differentFirstPage !== undefined) {
+            setup.differentFirstPageValue = values.differentFirstPage === true;
+        }
+        return setup;
+    };
+    /**
+     * @private
+     */
+    PageSetup.prototype.cloneDeep = function () {
+        var clone = PageSetup.createFromParsedValues({
+            attributes: this.attributes,
+            prefix: this.prefix,
+            suffix: this.suffix,
+            headerFooterReferences: this.headerFooterReferencesValue,
+            breakCode: this.breakCodeValue,
+            pageWidth: this.pageSizeValue.width,
+            pageHeight: this.pageSizeValue.height,
+            orientation: this.orientationValue,
+            marginLeft: this.marginsValue.left,
+            marginTop: this.marginsValue.top,
+            marginRight: this.marginsValue.right,
+            marginBottom: this.marginsValue.bottom,
+            headerDistance: this.headerDistanceValue,
+            footerDistance: this.footerDistanceValue,
+            gutter: this.gutterValue,
+            paperSource: this.snapshotPaperSource(),
+            pageBorders: this.bordersValue.toParsed(),
+            lineNumbering: this.snapshotLineNumbering(),
+            pageStartingNumber: this.pageStartingNumberValue,
+            restartPageNumbering: this.restartPageNumberingValue,
+            pageNumberStyle: this.pageNumberStyleValue,
+            chapterNumbering: this.chapterNumberingValue,
+            bidi: this.bidiValue,
+            pageNumberingPresent: this.pageNumberingPresent,
+            columns: this.columnsValue.cloneDeep(),
+            verticalAlignment: this.verticalAlignmentValue,
+            differentFirstPage: this.differentFirstPageValue,
+        });
+        // Preserve independent edge state when common props alone would not reconstruct it.
+        clone.bordersValue.copyFrom(this.bordersValue);
+        return clone;
+    };
+    Object.defineProperty(PageSetup.prototype, "orientation", {
+        // —— public surface ——
+        /**
+         * Page orientation. Setter swaps width/height only when needed (architecture §7).
+         */
+        get: function () {
+            return this.orientationValue;
+        },
+        set: function (value) {
+            var next = validatePageOrientation(value);
+            if (next === this.orientationValue) {
+                return;
+            }
+            var w = this.pageSizeValue.width;
+            var h = this.pageSizeValue.height;
+            if (next === PageOrientation.Landscape) {
+                if (w < h) {
+                    this.pageSizeValue.replace(h, w, false);
+                }
+            }
+            else {
+                if (h < w) {
+                    this.pageSizeValue.replace(h, w, false);
+                }
+            }
+            this.orientationValue = next;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "pageSize", {
+        /**
+         * Live page size (stable identity). Setter copies width/height and derives orientation.
+         */
+        get: function () {
+            return this.pageSizeValue;
+        },
+        set: function (value) {
+            if (value == null || typeof value.width !== 'number' || typeof value.height !== 'number') {
+                throw sectionsError('pageSize must provide numeric width and height');
+            }
+            var width = validateSectionLength(value.width, 'pageSize.width');
+            var height = validateSectionLength(value.height, 'pageSize.height');
+            this.pageSizeValue.replace(width, height, true);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "margins", {
+        /**
+         * Live margins instance (stable identity for the life of this PageSetup).
+         */
+        get: function () {
+            return this.marginsValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "headerDistance", {
+        /**
+         * Distance from page top to header (`w:pgMar/@w:header`), points.
+         */
+        get: function () {
+            return this.headerDistanceValue;
+        },
+        set: function (value) {
+            this.headerDistanceValue = validateSectionLength(value, 'headerDistance');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "footerDistance", {
+        /**
+         * Distance from page bottom to footer (`w:pgMar/@w:footer`), points.
+         */
+        get: function () {
+            return this.footerDistanceValue;
+        },
+        set: function (value) {
+            this.footerDistanceValue = validateSectionLength(value, 'footerDistance');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "borders", {
+        /**
+         * Live page borders (stable identity).
+         */
+        get: function () {
+            return this.bordersValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "firstPageTray", {
+        /**
+         * First-page printer tray (`w:paperSrc/@w:first`).
+         */
+        get: function () {
+            return (this.firstPageTrayValue !== undefined
+                ? this.firstPageTrayValue
+                : PrinterPaperTray.DefaultBin);
+        },
+        set: function (value) {
+            this.firstPageTrayValue = validateNonNegativeInteger(value, 'firstPageTray');
+            this.paperSourcePresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "otherPagesTray", {
+        /**
+         * Other-pages printer tray (`w:paperSrc/@w:other`).
+         */
+        get: function () {
+            return (this.otherPagesTrayValue !== undefined
+                ? this.otherPagesTrayValue
+                : PrinterPaperTray.DefaultBin);
+        },
+        set: function (value) {
+            this.otherPagesTrayValue = validateNonNegativeInteger(value, 'otherPagesTray');
+            this.paperSourcePresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "differentFirstPage", {
+        /**
+         * Different first page (`w:titlePg`).
+         */
+        get: function () {
+            return this.differentFirstPageValue;
+        },
+        set: function (value) {
+            this.differentFirstPageValue = value === true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "differentOddAndEvenPages", {
+        /**
+         * Different odd and even pages — document-scoped via settings `w:evenAndOddHeaders`.
+         */
+        get: function () {
+            var __ts33_3;
+            var document = ownerDocumentOf(this);
+            if (document === undefined || !isFeatureRegistered(SETTINGS_FEATURE_ID)) {
+                return false;
+            }
+            try {
+                var settingsPart = document.featurePart(featureId(SETTINGS_FEATURE_ID));
+                if (settingsPart === undefined) {
+                    return false;
+                }
+                var evenAndOdd = ((__ts33_3 = settingsPart.evenAndOddHeaders), __ts33_3 == null ? undefined : __ts33_3());
+                return evenAndOdd === true;
+            }
+            catch (_err) {
+                return false;
+            }
+        },
+        set: function (value) {
+            if (!isFeatureRegistered(SETTINGS_FEATURE_ID)) {
+                throw sectionsError('differentOddAndEvenPages requires the settings feature (import @syncfusion/ej2-docx/settings)');
+            }
+            var document = ownerDocumentOf(this);
+            if (document === undefined) {
+                throw sectionsError('differentOddAndEvenPages requires page setup associated with a document (use section.pageSetup on a document section)');
+            }
+            var settingsPart = document.featurePart(featureId(SETTINGS_FEATURE_ID));
+            if (settingsPart === undefined ||
+                typeof settingsPart.setEvenAndOddHeaders !==
+                    'function') {
+                throw sectionsError('settings part was not loaded; register settings before WordDocument.open or ensure settings is imported');
+            }
+            settingsPart.setEvenAndOddHeaders(value ? true : undefined);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "pageStartingNumber", {
+        /**
+         * Starting page number when restart is enabled (`w:pgNumType/@w:start`).
+         */
+        get: function () {
+            return this.pageStartingNumberValue;
+        },
+        set: function (value) {
+            this.pageStartingNumberValue = validatePositiveInteger(value, 'pageStartingNumber');
+            this.pageNumberingPresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "restartPageNumbering", {
+        /**
+         * When `true`, write `w:start` with {@link pageStartingNumber}; when `false`, omit start.
+         */
+        get: function () {
+            return this.restartPageNumberingValue;
+        },
+        set: function (value) {
+            this.restartPageNumberingValue = value === true;
+            this.pageNumberingPresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "pageNumberStyle", {
+        /**
+         * Page number format (`w:pgNumType/@w:fmt`). Always emitted when numbering state is set.
+         */
+        get: function () {
+            return this.pageNumberStyleValue;
+        },
+        set: function (value) {
+            this.pageNumberStyleValue = validatePageNumberStyle(value);
+            this.pageNumberingPresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "lineNumberingDistanceFromText", {
+        /**
+         * Distance from text to line numbers (`w:lnNumType/@w:distance`), points.
+         */
+        get: function () {
+            return this.lineNumberingDistanceFromTextValue;
+        },
+        set: function (value) {
+            this.lineNumberingDistanceFromTextValue = validateSectionLength(value, 'lineNumberingDistanceFromText');
+            this.lineNumberingPresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "lineNumberingMode", {
+        /**
+         * Line-number restart mode (`w:lnNumType/@w:restart`).
+         */
+        get: function () {
+            return this.lineNumberingModeValue;
+        },
+        set: function (value) {
+            this.lineNumberingModeValue = validateLineNumberingMode(value);
+            this.lineNumberingPresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "lineNumberingStartValue", {
+        /**
+         * Line-number start value (one-based public API).
+         *
+         * Maps to zero-based `w:lnNumType/@w:start` as `wire = api - 1`.
+         * Example: API `1` ↔ `w:start="0"`.
+         */
+        get: function () {
+            return this.lineNumberingStartValueValue;
+        },
+        set: function (value) {
+            this.lineNumberingStartValueValue = validatePositiveInteger(value, 'lineNumberingStartValue');
+            this.lineNumberingPresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "lineNumberingStep", {
+        /**
+         * Line-number count-by step (`w:lnNumType/@w:countBy`).
+         */
+        get: function () {
+            return this.lineNumberingStepValue;
+        },
+        set: function (value) {
+            if (!Number.isInteger(value) || value < 1) {
+                throw sectionsError('lineNumberingStep must be an integer ≥ 1');
+            }
+            this.lineNumberingStepValue = value;
+            this.lineNumberingPresent = true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "breakCode", {
+        // —— internal (Section / feature bridges) ——
+        /**
+         * Section break kind. Public on {@link Section}; kept here for serialize.
+         *
+         * @private
+         */
+        get: function () {
+            return this.breakCodeValue;
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.breakCodeValue = validateSectionBreakCode(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "columns", {
+        /**
+         * Text columns collection (Section exposes the same instance).
+         *
+         * @private
+         */
+        get: function () {
+            return this.columnsValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "headerFooterReferences", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.headerFooterReferencesValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    PageSetup.prototype.headerFooterReferenceId = function (kindOrTarget, refType) {
+        var __ts33_0;
+        var target = resolveHeaderFooterTarget(kindOrTarget, refType);
+        return ((__ts33_0 = this.headerFooterReferencesValue.find(function (ref) { return ref.kind === target.kind && ref.refType === target.refType; })), __ts33_0 == null ? undefined : __ts33_0.relationshipId);
+    };
+    PageSetup.prototype.setHeaderFooterReference = function (kindOrTarget, refTypeOrId, relationshipId) {
+        var target;
+        var id;
+        if (isHeaderFooterTarget(kindOrTarget)) {
+            target = kindOrTarget;
+            id = typeof refTypeOrId === 'string' ? refTypeOrId : undefined;
+        }
+        else {
+            var refType = refTypeOrId === 'default' || refTypeOrId === 'first' || refTypeOrId === 'even'
+                ? refTypeOrId
+                : undefined;
+            target = resolveHeaderFooterTarget(kindOrTarget, refType);
+            id = relationshipId;
+        }
+        var next = this.headerFooterReferencesValue.filter(function (ref) { return !(ref.kind === target.kind && ref.refType === target.refType); });
+        if (id !== undefined) {
+            next.push({ kind: target.kind, refType: target.refType, relationshipId: id });
+        }
+        this.headerFooterReferencesValue = next;
+    };
+    Object.defineProperty(PageSetup.prototype, "gutter", {
+        /**Gutter margin (`w:pgMar/@w:gutter`), points.
+         */
+        get: function () {
+            return this.gutterValue;
+        },
+        set: function (value) {
+            this.gutterValue = validateSectionLength(value, 'gutter');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "verticalAlignment", {
+        /**
+         * Vertical text alignment on the page (`w:vAlign` / `ST_VerticalJc`).
+         */
+        get: function () {
+            return this.verticalAlignmentValue;
+        },
+        set: function (value) {
+            this.verticalAlignmentValue = assertVerticalAlignment(value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "bidi", {
+        /**
+         * Right-to-left section layout (`w:bidi`, ECMA-376-1 §17.6.1).
+         */
+        get: function () {
+            return this.bidiValue;
+        },
+        set: function (value) {
+            this.bidiValue = value === true;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "pageBorderOffsetFrom", {
+        /**
+         * Page border offset origin (`w:pgBorders/@w:offsetFrom`).
+         */
+        get: function () {
+            return this.bordersValue.measureFrom === 'page'
+                ? PageBorderOffsetFrom.PageEdge
+                : PageBorderOffsetFrom.Text;
+        },
+        set: function (value) {
+            if (value === PageBorderOffsetFrom.PageEdge) {
+                this.bordersValue.setMeasureFrom('page');
+                return;
+            }
+            if (value === PageBorderOffsetFrom.Text) {
+                this.bordersValue.setMeasureFrom('text');
+                return;
+            }
+            throw sectionsError('pageBorderOffsetFrom is invalid');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "pageBordersApplyType", {
+        /**
+         * Which pages receive page borders (`w:pgBorders/@w:display`).
+         */
+        get: function () {
+            var apply = this.bordersValue.applyTo;
+            if (apply === 'firstPage') {
+                return PageBordersApplyType.FirstPage;
+            }
+            if (apply === 'notFirstPage') {
+                return PageBordersApplyType.NotFirstPage;
+            }
+            return PageBordersApplyType.AllPages;
+        },
+        set: function (value) {
+            if (value === PageBordersApplyType.FirstPage) {
+                this.bordersValue.setApplyTo('firstPage');
+                return;
+            }
+            if (value === PageBordersApplyType.NotFirstPage) {
+                this.bordersValue.setApplyTo('notFirstPage');
+                return;
+            }
+            if (value === PageBordersApplyType.AllPages) {
+                this.bordersValue.setApplyTo('allPages');
+                return;
+            }
+            throw sectionsError('pageBordersApplyType is invalid');
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PageSetup.prototype, "chapterNumbering", {
+        /**
+         * @private
+         */
+        get: function () {
+            return this.chapterNumberingValue;
+        },
+        /**
+         * @private
+         */
+        set: function (value) {
+            this.chapterNumberingValue =
+                value === undefined ? undefined : assertChapterNumbering(value);
+            if (value !== undefined) {
+                this.pageNumberingPresent = true;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     */
+    PageSetup.prototype.snapshotPaperSource = function () {
+        if (!this.paperSourcePresent) {
+            return undefined;
+        }
+        if (this.firstPageTrayValue === undefined && this.otherPagesTrayValue === undefined) {
+            return undefined;
+        }
+        return {
+            firstPageTray: this.firstPageTrayValue,
+            otherPagesTray: this.otherPagesTrayValue,
+        };
+    };
+    /**
+     * @private
+     */
+    PageSetup.prototype.snapshotLineNumbering = function () {
+        if (!this.lineNumberingPresent) {
+            return undefined;
+        }
+        var restartWire = this.lineNumberingModeValue === LineNumberingMode.RestartPage
+            ? undefined
+            : this.lineNumberingModeValue;
+        // Public API is one-based; parse/serialize bag uses wire zero-based start.
+        // Omit when wire would be 0 (API default 1) — matches common Word omission.
+        var wireStart = this.lineNumberingStartValueValue - 1;
+        return {
+            countBy: this.lineNumberingStepValue,
+            restart: restartWire,
+            startAt: wireStart !== 0 ? wireStart : undefined,
+            distanceFromText: this.lineNumberingDistanceFromTextValue !== 0
+                ? this.lineNumberingDistanceFromTextValue
+                : undefined,
+        };
+    };
+    /**
+     * Serialize `w:sectPr` in EG_SectPrContents order.
+     *
+     * @private
+     */
+    PageSetup.prototype.toOpenXml = function () {
+        var children = [];
+        for (var i = 0; i < this.headerFooterReferencesValue.length; i++) {
+            children.push(serializeHeaderFooterReference(this.headerFooterReferencesValue[i]));
+        }
+        for (var p = 0; p < this.prefix.length; p++) {
+            children.push(this.prefix[p]);
+        }
+        var wire = breakCodeToWire(this.breakCodeValue);
+        if (wire !== 'newPage') {
+            children.push(wmlElement('type', { attributes: [wmlAttr('val', wire)] }));
+        }
+        children.push(serializePageSize(this.pageSizeValue.width, this.pageSizeValue.height, this.orientationValue));
+        children.push(serializePageMargins(this.marginsValue.top, this.marginsValue.right, this.marginsValue.bottom, this.marginsValue.left, this.headerDistanceValue, this.footerDistanceValue, this.gutterValue));
+        var paperBag = this.snapshotPaperSource();
+        if (paperBag !== undefined) {
+            var paperSrcEl = serializePaperSource(paperBag);
+            if (paperSrcEl !== undefined) {
+                children.push(paperSrcEl);
+            }
+        }
+        var bordersBag = this.bordersValue.toParsed();
+        if (bordersBag !== undefined) {
+            var bordersEl = serializePageBorders(bordersBag);
+            if (bordersEl !== undefined) {
+                children.push(bordersEl);
+            }
+        }
+        var lineBag = this.snapshotLineNumbering();
+        if (lineBag !== undefined) {
+            children.push(serializeLineNumbering(lineBag));
+        }
+        if (this.pageNumberingPresent) {
+            children.push(serializePageNumbering(this.pageNumberStyleValue, this.restartPageNumberingValue ? this.pageStartingNumberValue : undefined, this.chapterNumberingValue));
+        }
+        var colsEl = this.columnsValue.toOpenXmlElement();
+        if (colsEl !== undefined) {
+            children.push(colsEl);
+        }
+        if (this.verticalAlignmentValue !== VerticalAlignment.Top) {
+            children.push(wmlElement('vAlign', {
+                attributes: [wmlAttr('val', this.verticalAlignmentValue)],
+            }));
+        }
+        if (this.bidiValue) {
+            children.push(serializeOnOff('bidi', true));
+        }
+        if (this.differentFirstPageValue) {
+            children.push(serializeOnOff('titlePg', true));
+        }
+        for (var s = 0; s < this.suffix.length; s++) {
+            children.push(this.suffix[s]);
+        }
+        var namespaceDeclarations = this.headerFooterReferencesValue.length > 0
+            ? [{ prefix: 'r', namespaceUri: RELATIONSHIPS_OFFICE_NS }]
+            : [];
+        return wmlElement('sectPr', {
+            attributes: this.attributes,
+            namespaceDeclarations: namespaceDeclarations,
+            children: children,
+        });
+    };
+    return PageSetup;
+}());
+export { PageSetup };
+/**
+ * @private
+ * Default letter section factory (replaces `defaultLetterSection`).
+ */
+export function defaultLetterPageSetup() {
+    return PageSetup.createDefaultLetter();
+}
+// —— helpers ——
+function isHeaderFooterTarget(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    var record = value;
+    return ((record.kind === 'header' || record.kind === 'footer') &&
+        (record.refType === 'default' || record.refType === 'first' || record.refType === 'even'));
+}
+function resolveHeaderFooterTarget(kindOrTarget, refType) {
+    if (isHeaderFooterTarget(kindOrTarget)) {
+        return kindOrTarget;
+    }
+    if (refType === undefined) {
+        throw sectionsError('header/footer refType is required');
+    }
+    return { kind: kindOrTarget, refType: refType };
+}
+function serializeHeaderFooterReference(ref) {
+    var localName = ref.kind === 'header' ? 'headerReference' : 'footerReference';
+    return wmlElement(localName, {
+        attributes: [
+            {
+                namespaceUri: RELATIONSHIPS_OFFICE_NS,
+                localName: 'id',
+                prefix: 'r',
+                value: ref.relationshipId,
+            },
+            wmlAttr('type', ref.refType),
+        ],
+    });
+}
+function serializePageSize(width, height, orientation) {
+    var attrs = [
+        wmlAttr('w', String(pointToTwips(width))),
+        wmlAttr('h', String(pointToTwips(height))),
+    ];
+    if (orientation === PageOrientation.Landscape) {
+        attrs.push(wmlAttr('orient', 'landscape'));
+    }
+    return wmlElement('pgSz', { attributes: attrs });
+}
+function serializePageMargins(top, right, bottom, left, header, footer, gutter) {
+    return wmlElement('pgMar', {
+        attributes: [
+            wmlAttr('top', String(pointToTwips(top))),
+            wmlAttr('right', String(pointToTwips(right))),
+            wmlAttr('bottom', String(pointToTwips(bottom))),
+            wmlAttr('left', String(pointToTwips(left))),
+            wmlAttr('header', String(pointToTwips(header))),
+            wmlAttr('footer', String(pointToTwips(footer))),
+            wmlAttr('gutter', String(pointToTwips(gutter))),
+        ],
+    });
+}
+function serializePaperSource(value) {
+    var attrs = [];
+    if (value.firstPageTray !== undefined) {
+        attrs.push(wmlAttr('first', String(value.firstPageTray)));
+    }
+    if (value.otherPagesTray !== undefined) {
+        attrs.push(wmlAttr('other', String(value.otherPagesTray)));
+    }
+    if (attrs.length === 0) {
+        return undefined;
+    }
+    return wmlElement('paperSrc', { attributes: attrs });
+}
+function serializeLineNumbering(value) {
+    var attrs = [wmlAttr('countBy', String(value.countBy))];
+    if (value.restart !== undefined && value.restart !== 'newPage') {
+        attrs.push(wmlAttr('restart', value.restart));
+    }
+    if (value.startAt !== undefined) {
+        attrs.push(wmlAttr('start', String(value.startAt)));
+    }
+    if (value.distanceFromText !== undefined) {
+        attrs.push(wmlAttr('distance', String(pointToTwips(value.distanceFromText))));
+    }
+    return wmlElement('lnNumType', { attributes: attrs });
+}
+function serializePageNumbering(format, startAt, chapter) {
+    var attrs = [wmlAttr('fmt', format)];
+    if (startAt !== undefined) {
+        attrs.push(wmlAttr('start', String(startAt)));
+    }
+    if (chapter !== undefined) {
+        attrs.push(wmlAttr('chapStyle', String(chapter.headingLevel)));
+        if (chapter.separator !== 'hyphen') {
+            attrs.push(wmlAttr('chapSep', chapter.separator));
+        }
+    }
+    return wmlElement('pgNumType', { attributes: attrs });
+}
+function isActiveBorderStyle(style) {
+    return style !== BorderStyle.None && style !== BorderStyle.Nil;
+}
+function isActiveBorderEdge(edge) {
+    if (edge === undefined) {
+        return false;
+    }
+    return edge.style !== 'none' && edge.style !== 'nil';
+}
+function serializePageBorderEdge(localName, edge) {
+    if (!isActiveBorderEdge(edge)) {
+        return undefined;
+    }
+    var sz = Math.round(edge.widthPoints * 8);
+    var attrs = [
+        wmlAttr('val', edge.style),
+        wmlAttr('sz', String(sz)),
+        wmlAttr('space', String(Math.round(edge.offsetPoints))),
+    ];
+    if (edge.color !== 'auto') {
+        attrs.push(wmlAttr('color', edge.color));
+    }
+    return wmlElement(localName, { attributes: attrs });
+}
+function serializePageBorders(value) {
+    var children = [];
+    var top = value.top === undefined ? undefined : serializePageBorderEdge('top', value.top);
+    var left = value.left === undefined ? undefined : serializePageBorderEdge('left', value.left);
+    var bottom = value.bottom === undefined ? undefined : serializePageBorderEdge('bottom', value.bottom);
+    var right = value.right === undefined ? undefined : serializePageBorderEdge('right', value.right);
+    if (top !== undefined) {
+        children.push(top);
+    }
+    if (left !== undefined) {
+        children.push(left);
+    }
+    if (bottom !== undefined) {
+        children.push(bottom);
+    }
+    if (right !== undefined) {
+        children.push(right);
+    }
+    var attrs = [];
+    if (value.zOrder !== 'front') {
+        attrs.push(wmlAttr('zOrder', value.zOrder));
+    }
+    if (value.applyTo !== 'allPages') {
+        attrs.push(wmlAttr('display', value.applyTo));
+    }
+    if (value.measureFrom !== 'text') {
+        attrs.push(wmlAttr('offsetFrom', value.measureFrom));
+    }
+    if (children.length === 0 && attrs.length === 0) {
+        return undefined;
+    }
+    return wmlElement('pgBorders', { attributes: attrs, children: children });
+}
+function assertPaperSource(value) {
+    var firstPageTray = value.firstPageTray === undefined
+        ? undefined
+        : validateNonNegativeInteger(value.firstPageTray, 'firstPageTray');
+    var otherPagesTray = value.otherPagesTray === undefined
+        ? undefined
+        : validateNonNegativeInteger(value.otherPagesTray, 'otherPagesTray');
+    return { firstPageTray: firstPageTray, otherPagesTray: otherPagesTray };
+}
+function assertLineNumbering(value) {
+    if (!Number.isInteger(value.countBy) || value.countBy < 1) {
+        throw sectionsError('lineNumberingStep must be an integer ≥ 1');
+    }
+    var restart = value.restart;
+    if (restart !== undefined) {
+        switch (restart) {
+            case 'newPage':
+            case 'newSection':
+            case 'continuous':
+                break;
+            default: {
+                var _exhaustive = restart;
+                void _exhaustive;
+                throw sectionsError("lineNumbering.restart must be 'newPage', 'newSection', or 'continuous'");
+            }
+        }
+    }
+    // Parse-bag `startAt` is zero-based wire (`w:lnNumType/@w:start`).
+    if (value.startAt !== undefined && (!Number.isInteger(value.startAt) || value.startAt < 0)) {
+        throw sectionsError('lineNumbering wire startAt must be an integer ≥ 0');
+    }
+    var distanceFromText = value.distanceFromText === undefined
+        ? undefined
+        : validateSectionLength(value.distanceFromText, 'lineNumberingDistanceFromText');
+    return {
+        countBy: value.countBy,
+        restart: restart,
+        startAt: value.startAt,
+        distanceFromText: distanceFromText,
+    };
+}
+function assertChapterNumbering(value) {
+    var headingLevel = value.headingLevel;
+    if (!Number.isInteger(headingLevel) || headingLevel < 1 || headingLevel > 9) {
+        throw sectionsError('chapterNumbering.headingLevel must be an integer in 1…9');
+    }
+    var separator = value.separator;
+    switch (separator) {
+        case 'hyphen':
+        case 'period':
+        case 'colon':
+        case 'emDash':
+        case 'enDash':
+            break;
+        default: {
+            var _exhaustive = separator;
+            void _exhaustive;
+            throw sectionsError('chapterNumbering.separator is invalid');
+        }
+    }
+    return { headingLevel: headingLevel, separator: separator };
+}
+function assertVerticalAlignment(value) {
+    switch (value) {
+        case VerticalAlignment.Top:
+        case 'top':
+            return VerticalAlignment.Top;
+        case VerticalAlignment.Center:
+        case 'center':
+            return VerticalAlignment.Center;
+        case VerticalAlignment.Both:
+        case 'both':
+            return VerticalAlignment.Both;
+        case VerticalAlignment.Bottom:
+        case 'bottom':
+            return VerticalAlignment.Bottom;
+        default: {
+            throw sectionsError('verticalAlignment must be a valid VerticalAlignment value');
+        }
+    }
+}
+function assertPageBorderEdge(edge, label) {
+    if (typeof edge.widthPoints !== 'number' ||
+        Number.isNaN(edge.widthPoints) ||
+        edge.widthPoints < 0.25 ||
+        edge.widthPoints > 12) {
+        throw sectionsError(label + ".widthPoints must be in 0.25\u201312");
+    }
+    if (typeof edge.offsetPoints !== 'number' ||
+        Number.isNaN(edge.offsetPoints) ||
+        edge.offsetPoints < 0 ||
+        edge.offsetPoints > 31) {
+        throw sectionsError(label + ".offsetPoints must be in 0\u202631");
+    }
+    if (!BORDER_STYLE_VALUES.has(edge.style)) {
+        throw sectionsError(label + ".style is not a supported border style");
+    }
+    if (typeof edge.color !== 'string' || edge.color.length === 0) {
+        throw sectionsError(label + ".color must be a non-empty string");
+    }
+    return edge;
+}
+function assertPageBorders(value) {
+    var applyTo = value.applyTo;
+    if (applyTo !== 'allPages' && applyTo !== 'firstPage' && applyTo !== 'notFirstPage') {
+        throw sectionsError('pageBorders.applyTo is invalid');
+    }
+    var measureFrom = value.measureFrom;
+    if (measureFrom !== 'text' && measureFrom !== 'page') {
+        throw sectionsError('pageBorders.measureFrom is invalid');
+    }
+    var zOrder = value.zOrder;
+    if (zOrder !== 'front' && zOrder !== 'back') {
+        throw sectionsError('pageBorders.zOrder is invalid');
+    }
+    return {
+        applyTo: applyTo,
+        measureFrom: measureFrom,
+        zOrder: zOrder,
+        top: value.top === undefined ? undefined : assertPageBorderEdge(value.top, 'pageBorders.top'),
+        left: value.left === undefined ? undefined : assertPageBorderEdge(value.left, 'pageBorders.left'),
+        bottom: value.bottom === undefined
+            ? undefined
+            : assertPageBorderEdge(value.bottom, 'pageBorders.bottom'),
+        right: value.right === undefined
+            ? undefined
+            : assertPageBorderEdge(value.right, 'pageBorders.right'),
+    };
+}
+function validateBorderStyle(value, label) {
+    if (!BORDER_STYLE_VALUES.has(value)) {
+        throw sectionsError(label + " must be a valid BorderStyle value");
+    }
+    return value;
+}
+function validateBorderWidth(value, label) {
+    if (typeof value !== 'number' || Number.isNaN(value) || value < 0.25 || value > 12) {
+        throw sectionsError(label + " must be in 0.25\u201312 points");
+    }
+    return value;
+}
+function validateLineNumberingMode(value) {
+    switch (value) {
+        case LineNumberingMode.Continuous:
+        case LineNumberingMode.RestartPage:
+        case LineNumberingMode.RestartSection:
+            return value;
+        default: {
+            var _exhaustive = value;
+            void _exhaustive;
+            throw sectionsError('lineNumberingMode is invalid');
+        }
+    }
+}
+function borderStyleFromWire(style) {
+    if (BORDER_STYLE_VALUES.has(style)) {
+        return style;
+    }
+    return BorderStyle.None;
+}