@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/sections/index.js

@@ -0,0 +1,1096 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 };
+        }
+    };
+};
+export * from './column-collection';
+export * from './column';
+export * from './margins';
+export * from './page-number-style';
+export * from './page-orientation';
+export * from './page-size';
+export * from './section-break-code';
+export * from './section-document-association';
+export * from './section-validation';
+import { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { WordDocument } from '../document/document';
+import { pointToTwips, twipsToPoint } from '../document/length';
+import { parseOnOff } from '../document/on-off';
+import { Paragraph } from '../document/paragraph';
+import { Section } from '../document/section';
+import { registerSectionPropertiesAttached, registerSectionPropertiesParse, resetSectionPropertiesAttachedForTests, resetSectionPropertiesParseForTests, } from '../document/section-partition-flatten';
+import { registerSectionPageSetupClone, registerSectionPageSetupSeed, resetSectionPageSetupCloneForTests, resetSectionPageSetupSeedForTests, } from '../document/sections';
+import { elementChildren, isWml, wValAttribute, WML, } from '../document/wml';
+import { featureId, isFeatureRegistered, registerFeature, } from '../../core/registry/index';
+import { parseTextColumns, } from './column-collection';
+import { PageOrientation } from './page-orientation';
+import { pageNumberStyleFromWire, } from './page-number-style';
+import { defaultLetterPageSetup, PageSetup, } from './page-setup';
+import { PageSize } from './page-size';
+import { wireToBreakCode, } from './section-break-code';
+import { associatePageSetupDocument, ownerDocumentOf, } from './section-document-association';
+import { DEFAULT_COLUMN_SPACE, TWIPS_MAX, } from './section-validation';
+var SECTIONS = featureId('sections');
+var HEADERS_FOOTERS_FEATURE_ID = 'headers-footers';
+/** Office WordDocument relationships namespace for `r:id` on `CT_Rel`. */
+var RELATIONSHIPS_OFFICE_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+/** Letter defaults when `w:pgSz` / `w:pgMar` are absent on load. */
+var LETTER_WIDTH = PageSize.Letter.width;
+var LETTER_HEIGHT = PageSize.Letter.height;
+var DEFAULT_MARGIN = 72;
+var DEFAULT_HEADER_FOOTER_DISTANCE = 36;
+var DEFAULT_GUTTER = 0;
+var PAGE_BORDER_STYLES = new Set([
+    'nil',
+    'none',
+    'single',
+    'thick',
+    'double',
+    'dotted',
+    'dashed',
+    'dotDash',
+    'dotDotDash',
+    'triple',
+    'thinThickSmallGap',
+    'thickThinSmallGap',
+    'thinThickThinSmallGap',
+    'thinThickMediumGap',
+    'thickThinMediumGap',
+    'thinThickThinMediumGap',
+    'thinThickLargeGap',
+    'thickThinLargeGap',
+    'thinThickThinLargeGap',
+    'wave',
+    'doubleWave',
+    'dashSmallGap',
+    'dashDotStroked',
+    'threeDEmboss',
+    'threeDEngrave',
+    'outset',
+    'inset',
+]);
+// —— re-exports (public / private package surface) ——
+export { BorderStyle, defaultLetterPageSetup, LineNumberingMode, PageBorder, PageBorderOffsetFrom, PageBorders, PageBordersApplyType, PageSetup, PrinterPaperTray, VerticalAlignment, } from './page-setup';
+function sectionsError(message) {
+    return new Error("sections: " + message);
+}
+function relIdAttribute(el) {
+    var found = el.attributes.find(function (a) { return a.localName === 'id' && a.namespaceUri === RELATIONSHIPS_OFFICE_NS; });
+    return found == null ? undefined : found.value;
+}
+function relIdAttr(value) {
+    return {
+        namespaceUri: RELATIONSHIPS_OFFICE_NS,
+        localName: 'id',
+        prefix: 'r',
+        value: value,
+    };
+}
+function wmlAttribute(el, localName) {
+    var found = el.attributes.find(function (a) {
+        return a.localName === localName &&
+            (a.namespaceUri === WML || a.namespaceUri === '');
+    });
+    return found == null ? undefined : found.value;
+}
+function parseTwips(raw) {
+    if (raw === undefined || !/^-?\d+$/.test(raw)) {
+        return undefined;
+    }
+    var n = Number.parseInt(raw, 10);
+    if (n < 0 || n > TWIPS_MAX) {
+        return undefined;
+    }
+    return n;
+}
+function parseUnsignedInt(raw) {
+    if (raw === undefined || !/^\d+$/.test(raw)) {
+        return undefined;
+    }
+    return Number.parseInt(raw, 10);
+}
+function parseOnOffAttribute(raw) {
+    if (raw === undefined || raw.length === 0) {
+        return true;
+    }
+    var normalized = raw.trim().toLowerCase();
+    if (normalized === 'true' || normalized === '1' || normalized === 'on') {
+        return true;
+    }
+    if (normalized === 'false' || normalized === '0' || normalized === 'off') {
+        return false;
+    }
+    return undefined;
+}
+function parseHeaderFooterReference(element) {
+    var kind = isWml(element, 'headerReference')
+        ? 'header'
+        : isWml(element, 'footerReference')
+            ? 'footer'
+            : undefined;
+    if (kind === undefined) {
+        return undefined;
+    }
+    var relationshipId = relIdAttribute(element);
+    var typeRaw = wmlAttribute(element, 'type');
+    var refType = typeRaw === 'default' || typeRaw === 'first' || typeRaw === 'even'
+        ? typeRaw
+        : undefined;
+    if (relationshipId === undefined || refType === undefined) {
+        return undefined;
+    }
+    return { kind: kind, refType: refType, relationshipId: relationshipId };
+}
+function parseSectionMarkWire(element) {
+    var val = wValAttribute(element);
+    if (val === 'newPage' ||
+        val === 'continuous' ||
+        val === 'nextColumn' ||
+        val === 'evenPage' ||
+        val === 'oddPage') {
+        return val;
+    }
+    return undefined;
+}
+function parsePageSizeFields(element) {
+    var wRaw = parseTwips(wmlAttribute(element, 'w'));
+    var hRaw = parseTwips(wmlAttribute(element, 'h'));
+    if (wRaw === undefined || hRaw === undefined) {
+        return undefined;
+    }
+    var orientRaw = wmlAttribute(element, 'orient');
+    var orientation;
+    if (orientRaw === 'landscape') {
+        orientation = PageOrientation.Landscape;
+    }
+    else if (orientRaw === 'portrait') {
+        orientation = PageOrientation.Portrait;
+    }
+    return {
+        width: twipsToPoint(wRaw),
+        height: twipsToPoint(hRaw),
+        orientation: orientation,
+    };
+}
+function parsePageMarginFields(element) {
+    var topRaw = parseTwips(wmlAttribute(element, 'top'));
+    var rightRaw = parseTwips(wmlAttribute(element, 'right'));
+    var bottomRaw = parseTwips(wmlAttribute(element, 'bottom'));
+    var leftRaw = parseTwips(wmlAttribute(element, 'left'));
+    var headerRaw = parseTwips(wmlAttribute(element, 'header'));
+    var footerRaw = parseTwips(wmlAttribute(element, 'footer'));
+    var gutterRaw = parseTwips(wmlAttribute(element, 'gutter'));
+    if (topRaw === undefined ||
+        rightRaw === undefined ||
+        bottomRaw === undefined ||
+        leftRaw === undefined ||
+        headerRaw === undefined ||
+        footerRaw === undefined ||
+        gutterRaw === undefined) {
+        return undefined;
+    }
+    return {
+        top: twipsToPoint(topRaw),
+        right: twipsToPoint(rightRaw),
+        bottom: twipsToPoint(bottomRaw),
+        left: twipsToPoint(leftRaw),
+        header: twipsToPoint(headerRaw),
+        footer: twipsToPoint(footerRaw),
+        gutter: twipsToPoint(gutterRaw),
+    };
+}
+function parsePaperSource(element) {
+    var firstRaw = wmlAttribute(element, 'first');
+    var otherRaw = wmlAttribute(element, 'other');
+    var firstPageTray;
+    var otherPagesTray;
+    if (firstRaw !== undefined) {
+        firstPageTray = parseUnsignedInt(firstRaw);
+        if (firstPageTray === undefined) {
+            return undefined;
+        }
+    }
+    if (otherRaw !== undefined) {
+        otherPagesTray = parseUnsignedInt(otherRaw);
+        if (otherPagesTray === undefined) {
+            return undefined;
+        }
+    }
+    if (firstPageTray === undefined && otherPagesTray === undefined) {
+        return undefined;
+    }
+    return { firstPageTray: firstPageTray, otherPagesTray: otherPagesTray };
+}
+function parseLineNumbering(element) {
+    var countByRaw = wmlAttribute(element, 'countBy');
+    if (countByRaw === undefined) {
+        return undefined;
+    }
+    if (!/^\d+$/.test(countByRaw)) {
+        return undefined;
+    }
+    var countBy = Number.parseInt(countByRaw, 10);
+    if (countBy < 1) {
+        return undefined;
+    }
+    var restart;
+    var restartRaw = wmlAttribute(element, 'restart');
+    if (restartRaw !== undefined) {
+        if (restartRaw !== 'newPage' &&
+            restartRaw !== 'newSection' &&
+            restartRaw !== 'continuous') {
+            return undefined;
+        }
+        restart = restartRaw === 'newPage' ? undefined : restartRaw;
+    }
+    var startAt;
+    var startRaw = wmlAttribute(element, 'start');
+    if (startRaw !== undefined) {
+        if (!/^\d+$/.test(startRaw)) {
+            return undefined;
+        }
+        startAt = Number.parseInt(startRaw, 10);
+    }
+    var distanceFromText;
+    var distanceRaw = wmlAttribute(element, 'distance');
+    if (distanceRaw !== undefined) {
+        var parsed = parseTwips(distanceRaw);
+        if (parsed === undefined) {
+            return undefined;
+        }
+        distanceFromText = twipsToPoint(parsed);
+    }
+    return {
+        countBy: countBy,
+        restart: restart,
+        startAt: startAt,
+        distanceFromText: distanceFromText,
+    };
+}
+function parseChapterSeparator(raw) {
+    if (raw === 'hyphen' ||
+        raw === 'period' ||
+        raw === 'colon' ||
+        raw === 'emDash' ||
+        raw === 'enDash') {
+        return raw;
+    }
+    return undefined;
+}
+function parsePageNumberingFields(element) {
+    var fmtRaw = wmlAttribute(element, 'fmt');
+    // Absent fmt → schema default decimal. Unknown fmt → opaque (never coerce).
+    if (fmtRaw !== undefined) {
+        var known = fmtRaw === 'decimal' ||
+            fmtRaw === 'upperRoman' ||
+            fmtRaw === 'lowerRoman' ||
+            fmtRaw === 'upperLetter' ||
+            fmtRaw === 'lowerLetter' ||
+            fmtRaw === 'ordinal' ||
+            fmtRaw === 'cardinalText' ||
+            fmtRaw === 'ordinalText' ||
+            fmtRaw === 'numberInDash' ||
+            fmtRaw === 'chicago';
+        if (!known) {
+            return undefined;
+        }
+    }
+    var pageNumberStyle = pageNumberStyleFromWire(fmtRaw);
+    var pageStartingNumber;
+    var restartPageNumbering;
+    var startRaw = wmlAttribute(element, 'start');
+    if (startRaw !== undefined) {
+        if (!/^\d+$/.test(startRaw)) {
+            return undefined;
+        }
+        var startAt = Number.parseInt(startRaw, 10);
+        if (startAt < 1) {
+            return undefined;
+        }
+        pageStartingNumber = startAt;
+        restartPageNumbering = true;
+    }
+    var chapStyleRaw = wmlAttribute(element, 'chapStyle');
+    var chapSepRaw = wmlAttribute(element, 'chapSep');
+    var chapterNumbering;
+    if (chapStyleRaw !== undefined) {
+        if (!/^\d+$/.test(chapStyleRaw)) {
+            return undefined;
+        }
+        var headingLevel = Number.parseInt(chapStyleRaw, 10);
+        if (headingLevel < 1 || headingLevel > 9) {
+            return undefined;
+        }
+        var separator = 'hyphen';
+        if (chapSepRaw !== undefined) {
+            var parsedSep = parseChapterSeparator(chapSepRaw);
+            if (parsedSep === undefined) {
+                return undefined;
+            }
+            separator = parsedSep;
+        }
+        chapterNumbering = { headingLevel: headingLevel, separator: separator };
+    }
+    else if (chapSepRaw !== undefined) {
+        // chapSep without chapStyle is not meaningful; keep opaque.
+        return undefined;
+    }
+    return {
+        pageStartingNumber: pageStartingNumber,
+        restartPageNumbering: restartPageNumbering,
+        pageNumberStyle: pageNumberStyle,
+        chapterNumbering: chapterNumbering,
+        pageNumberingPresent: true,
+    };
+}
+function isActiveBorderEdge(edge) {
+    return edge !== undefined && edge.style !== 'none' && edge.style !== 'nil';
+}
+function parsePageBorderEdge(element) {
+    var __ts33_4, __ts33_5;
+    var styleRaw = ((__ts33_4 = wValAttribute(element)), __ts33_4 != null
+        ? __ts33_4
+        : wmlAttribute(element, 'val'));
+    if (styleRaw === undefined || !PAGE_BORDER_STYLES.has(styleRaw)) {
+        return undefined;
+    }
+    var style = styleRaw;
+    var szRaw = wmlAttribute(element, 'sz');
+    var widthPoints = 0.5;
+    if (szRaw !== undefined) {
+        if (!/^\d+$/.test(szRaw)) {
+            return undefined;
+        }
+        var eighths = Number.parseInt(szRaw, 10);
+        widthPoints = eighths / 8;
+        if (widthPoints < 0.25 || widthPoints > 12) {
+            return undefined;
+        }
+    }
+    var spaceRaw = wmlAttribute(element, 'space');
+    var offsetPoints = 0;
+    if (spaceRaw !== undefined) {
+        if (!/^\d+$/.test(spaceRaw)) {
+            return undefined;
+        }
+        offsetPoints = Number.parseInt(spaceRaw, 10);
+        if (offsetPoints < 0 || offsetPoints > 31) {
+            return undefined;
+        }
+    }
+    var color = ((__ts33_5 = wmlAttribute(element, 'color')), __ts33_5 != null
+        ? __ts33_5
+        : 'auto');
+    return { style: style, widthPoints: widthPoints, offsetPoints: offsetPoints, color: color };
+}
+function parsePageBorders(element) {
+    var e_1, _a;
+    var displayRaw = wmlAttribute(element, 'display');
+    var applyTo = 'allPages';
+    if (displayRaw !== undefined) {
+        if (displayRaw !== 'allPages' &&
+            displayRaw !== 'firstPage' &&
+            displayRaw !== 'notFirstPage') {
+            return undefined;
+        }
+        applyTo = displayRaw;
+    }
+    var offsetRaw = wmlAttribute(element, 'offsetFrom');
+    var measureFrom = 'text';
+    if (offsetRaw !== undefined) {
+        if (offsetRaw !== 'text' && offsetRaw !== 'page') {
+            return undefined;
+        }
+        measureFrom = offsetRaw;
+    }
+    var zRaw = wmlAttribute(element, 'zOrder');
+    var zOrder = 'front';
+    if (zRaw !== undefined) {
+        if (zRaw !== 'front' && zRaw !== 'back') {
+            return undefined;
+        }
+        zOrder = zRaw;
+    }
+    var top;
+    var left;
+    var bottom;
+    var right;
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'top')) {
+                top = parsePageBorderEdge(child);
+                if (top === undefined) {
+                    return undefined;
+                }
+                continue;
+            }
+            if (isWml(child, 'left')) {
+                left = parsePageBorderEdge(child);
+                if (left === undefined) {
+                    return undefined;
+                }
+                continue;
+            }
+            if (isWml(child, 'bottom')) {
+                bottom = parsePageBorderEdge(child);
+                if (bottom === undefined) {
+                    return undefined;
+                }
+                continue;
+            }
+            if (isWml(child, 'right')) {
+                right = parsePageBorderEdge(child);
+                if (right === undefined) {
+                    return undefined;
+                }
+                continue;
+            }
+            // Unmodeled child (e.g. tl2br) → keep whole element opaque
+            return undefined;
+        }
+    }
+    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 { applyTo: applyTo, measureFrom: measureFrom, zOrder: zOrder, top: top, left: left, bottom: bottom, right: right };
+}
+function parseVerticalAlignment(element) {
+    var val = wValAttribute(element);
+    if (val === 'top' || val === 'center' || val === 'both' || val === 'bottom') {
+        return val;
+    }
+    return undefined;
+}
+/**
+ * Parse `w:sectPr` into a live {@link PageSetup}.
+ *
+ * @private
+ */
+export function parseSectionProperties(element) {
+    var e_2, _a;
+    if (element === undefined || !isWml(element, 'sectPr')) {
+        return undefined;
+    }
+    var prefix = [];
+    var suffix = [];
+    var headerFooterReferences = [];
+    var breakCode;
+    var pageWidth;
+    var pageHeight;
+    var orientation;
+    var marginLeft;
+    var marginTop;
+    var marginRight;
+    var marginBottom;
+    var headerDistance;
+    var footerDistance;
+    var gutter;
+    var paperSource;
+    var pageBorders;
+    var lineNumbering;
+    var pageStartingNumber;
+    var restartPageNumbering;
+    var pageNumberStyle;
+    var chapterNumbering;
+    var pageNumberingPresent;
+    var columns;
+    var verticalAlignment;
+    var bidi;
+    var differentFirstPage = false;
+    var seenModeled = false;
+    try {
+        for (var _b = __values(elementChildren(element)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            var ref = parseHeaderFooterReference(child);
+            if (ref !== undefined) {
+                headerFooterReferences.push(ref);
+                continue;
+            }
+            if (isWml(child, 'type') && breakCode === undefined) {
+                var parsed = parseSectionMarkWire(child);
+                if (parsed !== undefined) {
+                    breakCode = wireToBreakCode(parsed === 'newPage' ? undefined : parsed);
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'pgSz') && pageWidth === undefined) {
+                var parsed = parsePageSizeFields(child);
+                if (parsed !== undefined) {
+                    pageWidth = parsed.width;
+                    pageHeight = parsed.height;
+                    orientation = parsed.orientation;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'pgMar') && marginLeft === undefined) {
+                var parsed = parsePageMarginFields(child);
+                if (parsed !== undefined) {
+                    marginLeft = parsed.left;
+                    marginTop = parsed.top;
+                    marginRight = parsed.right;
+                    marginBottom = parsed.bottom;
+                    headerDistance = parsed.header;
+                    footerDistance = parsed.footer;
+                    gutter = parsed.gutter;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'paperSrc') && paperSource === undefined) {
+                var parsed = parsePaperSource(child);
+                if (parsed !== undefined) {
+                    paperSource = parsed;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'pgBorders') && pageBorders === undefined) {
+                var parsed = parsePageBorders(child);
+                if (parsed !== undefined) {
+                    pageBorders = parsed;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'lnNumType') && lineNumbering === undefined) {
+                var parsed = parseLineNumbering(child);
+                if (parsed !== undefined) {
+                    lineNumbering = parsed;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'pgNumType') && pageNumberingPresent === undefined) {
+                var parsed = parsePageNumberingFields(child);
+                if (parsed !== undefined) {
+                    pageStartingNumber = parsed.pageStartingNumber;
+                    restartPageNumbering = parsed.restartPageNumbering;
+                    pageNumberStyle = parsed.pageNumberStyle;
+                    chapterNumbering = parsed.chapterNumbering;
+                    pageNumberingPresent = true;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'cols') && columns === undefined) {
+                var parsed = parseTextColumns(child);
+                if (parsed !== undefined) {
+                    columns = parsed;
+                    seenModeled = true;
+                    continue;
+                }
+                // default single-column or failed parse of known empty defaults
+                var numRaw = wmlAttribute(child, 'num');
+                var spaceRaw = wmlAttribute(child, 'space');
+                var equalRaw = wmlAttribute(child, 'equalWidth');
+                var sepRaw = wmlAttribute(child, 'sep');
+                var looksDefault = (numRaw === undefined || numRaw === '1') &&
+                    (spaceRaw === undefined ||
+                        spaceRaw === String(pointToTwips(DEFAULT_COLUMN_SPACE))) &&
+                    (equalRaw === undefined || parseOnOffAttribute(equalRaw) === true) &&
+                    (sepRaw === undefined || parseOnOffAttribute(sepRaw) === false) &&
+                    elementChildren(child).length === 0;
+                if (looksDefault) {
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'vAlign') && verticalAlignment === undefined) {
+                var parsed = parseVerticalAlignment(child);
+                if (parsed !== undefined) {
+                    verticalAlignment = parsed === 'top' ? undefined : parsed;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'bidi') && bidi === undefined) {
+                var flag = parseOnOff(child);
+                if (flag === true || flag === false) {
+                    bidi = flag === true;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'titlePg')) {
+                var flag = parseOnOff(child);
+                if (flag === true) {
+                    differentFirstPage = true;
+                    seenModeled = true;
+                    continue;
+                }
+                if (flag === false) {
+                    differentFirstPage = false;
+                    seenModeled = true;
+                    continue;
+                }
+                if (!seenModeled) {
+                    prefix.push(child);
+                }
+                else {
+                    suffix.push(child);
+                }
+                continue;
+            }
+            if (!seenModeled) {
+                prefix.push(child);
+            }
+            else {
+                suffix.push(child);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return PageSetup.createFromParsedValues({
+        attributes: element.attributes,
+        prefix: prefix,
+        suffix: suffix,
+        headerFooterReferences: headerFooterReferences,
+        breakCode: breakCode,
+        pageWidth: pageWidth !== undefined ? pageWidth : LETTER_WIDTH,
+        pageHeight: pageHeight !== undefined ? pageHeight : LETTER_HEIGHT,
+        orientation: orientation,
+        marginLeft: marginLeft !== undefined ? marginLeft : DEFAULT_MARGIN,
+        marginTop: marginTop !== undefined ? marginTop : DEFAULT_MARGIN,
+        marginRight: marginRight !== undefined ? marginRight : DEFAULT_MARGIN,
+        marginBottom: marginBottom !== undefined ? marginBottom : DEFAULT_MARGIN,
+        headerDistance: headerDistance !== undefined
+            ? headerDistance
+            : DEFAULT_HEADER_FOOTER_DISTANCE,
+        footerDistance: footerDistance !== undefined
+            ? footerDistance
+            : DEFAULT_HEADER_FOOTER_DISTANCE,
+        gutter: gutter !== undefined ? gutter : DEFAULT_GUTTER,
+        paperSource: paperSource,
+        pageBorders: pageBorders,
+        lineNumbering: lineNumbering,
+        pageStartingNumber: pageStartingNumber,
+        restartPageNumbering: restartPageNumbering,
+        pageNumberStyle: pageNumberStyle,
+        chapterNumbering: chapterNumbering,
+        pageNumberingPresent: pageNumberingPresent,
+        columns: columns,
+        verticalAlignment: verticalAlignment,
+        bidi: bidi,
+        differentFirstPage: differentFirstPage,
+    });
+}
+/**
+ * Enable line numbering on every line (`w:lnNumType/@w:countBy="1"`).
+ *
+ * Sets {@link PageSetup.lineNumberingStep} to `1` (and marks line numbering present).
+ *
+ * @private
+ */
+export function everyLineNumbers(setup) {
+    setup.lineNumberingStep = 1;
+}
+/**
+ * `true` when the section has no explicit reference for the target slot (inherits).
+ *
+ * @private
+ */
+export function inheritsFromPrevious(section, target) {
+    return section.headerFooterReferenceId(target) === undefined;
+}
+/**
+ * Stop inheriting a header/footer slot by creating an empty part and reference.
+ * Requires the headers-footers feature and a document-associated page setup.
+ *
+ * @private
+ */
+export function unlinkFromPrevious(section, target) {
+    return __awaiter(this, void 0, void 0, function () {
+        var document, hf;
+        return __generator(this, function (_a) {
+            if (!isFeatureRegistered(HEADERS_FOOTERS_FEATURE_ID)) {
+                throw sectionsError('unlinkFromPrevious requires the headers-footers feature (import @syncfusion/ej2-docx/headers-footers)');
+            }
+            document = ownerDocumentOf(section);
+            if (document === undefined) {
+                throw sectionsError('unlinkFromPrevious requires section properties associated with a document');
+            }
+            hf = require('../headers-footers/index');
+            if (target.kind === 'header') {
+                hf.setSectionHeader(document, section, '', target.refType);
+            }
+            else {
+                hf.setSectionFooter(document, section, '', target.refType);
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+var registered = false;
+/** Original `WordDocument.create` before sections feature wraps it. */
+var originalDocumentCreate;
+/**
+ * Seed a live default letter {@link PageSetup} on every new document
+ * while the sections feature is registered.
+ */
+function wrapDocumentCreate() {
+    if (originalDocumentCreate !== undefined) {
+        return;
+    }
+    originalDocumentCreate = WordDocument.create.bind(WordDocument);
+    WordDocument.create = function () {
+        var document = originalDocumentCreate();
+        var props = defaultLetterPageSetup();
+        associatePageSetupDocument(props, document);
+        document.replaceFinalSectionPropertiesModel(props);
+        return document;
+    };
+}
+function unwrapDocumentCreate() {
+    if (originalDocumentCreate === undefined) {
+        return;
+    }
+    WordDocument.create = originalDocumentCreate;
+    originalDocumentCreate = undefined;
+}
+function requirePageSetup(section) {
+    var model = section.pageSetup;
+    if (model instanceof PageSetup) {
+        return model;
+    }
+    var seeded = defaultLetterPageSetup();
+    var document = section.owningDocument();
+    associatePageSetupDocument(seeded, document);
+    section.setPageSetup(seeded);
+    return seeded;
+}
+function installSectionPageSetupAccessors() {
+    var proto = Section.prototype;
+    Object.defineProperty(proto, 'breakCode', {
+        configurable: true,
+        enumerable: true,
+        get: function () {
+            return requirePageSetup(this).breakCode;
+        },
+        set: function (value) {
+            requirePageSetup(this).breakCode = value;
+        },
+    });
+    Object.defineProperty(proto, 'columns', {
+        configurable: true,
+        enumerable: true,
+        get: function () {
+            return requirePageSetup(this).columns;
+        },
+    });
+    Object.defineProperty(proto, 'addColumn', {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: function addColumn(width, spacing) {
+            return requirePageSetup(this).columns.add(width, spacing);
+        },
+    });
+}
+/**
+ * @private
+ * Test hook
+ */
+export function resetSectionsFeatureForTests() {
+    registered = false;
+    unwrapDocumentCreate();
+    resetSectionPageSetupCloneForTests();
+    resetSectionPageSetupSeedForTests();
+    resetSectionPropertiesParseForTests();
+    resetSectionPropertiesAttachedForTests();
+    try {
+        // Allow re-install of the public sectionBreak facade on next register.
+        delete Paragraph.prototype.sectionBreak;
+    }
+    catch (_a) {
+        // Ignore non-configurable leftovers in exotic hosts.
+    }
+}
+/**
+ * Install public `Paragraph.sectionBreak` get/set bridging dual-hold helpers.
+ * Idempotent when the accessor is already present.
+ */
+function installParagraphSectionBreakFacade() {
+    var existing = Object.getOwnPropertyDescriptor(Paragraph.prototype, 'sectionBreak');
+    if (existing !== undefined && (existing.get !== undefined || existing.set !== undefined)) {
+        return;
+    }
+    Object.defineProperty(Paragraph.prototype, 'sectionBreak', {
+        configurable: true,
+        enumerable: true,
+        get: function () {
+            return paragraphSectionBreak(this);
+        },
+        set: function (value) {
+            setParagraphSectionBreak(this, value);
+        },
+    });
+}
+/**
+ * @private
+ * Register the sections feature. Idempotent.
+ */
+export function registerSectionsFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: SECTIONS });
+    wrapDocumentCreate();
+    installSectionPageSetupAccessors();
+    installParagraphSectionBreakFacade();
+    registerSectionPropertiesParse(function (element) { return parseSectionProperties(element); });
+    registerSectionPropertiesAttached(function (model, document) {
+        if (model instanceof PageSetup) {
+            associatePageSetupDocument(model, document);
+        }
+    });
+    registerSectionPageSetupClone(function (source) {
+        if (!(source instanceof PageSetup)) {
+            throw new TypeError('Expected PageSetup');
+        }
+        return source.cloneDeep();
+    });
+    registerSectionPageSetupSeed(function () { return defaultLetterPageSetup(); });
+}
+function isPageSetupModel(value) {
+    return value instanceof PageSetup;
+}
+/**
+ * Ensure body-final section properties are held as a live {@link PageSetup}
+ * object (parse once from preserved OOXML when needed).
+ */
+function ensureFinalSectionModel(document) {
+    var held = document.finalSectionPropertiesModel();
+    if (isPageSetupModel(held)) {
+        associatePageSetupDocument(held, document);
+        return held;
+    }
+    var raw = document.bodySectPr();
+    if (raw === undefined) {
+        return undefined;
+    }
+    var props = parseSectionProperties(raw);
+    if (props === undefined) {
+        return undefined;
+    }
+    associatePageSetupDocument(props, document);
+    document.replaceFinalSectionPropertiesModel(props);
+    return props;
+}
+/**
+ * Ensure paragraph section-break properties are held as a live object when present.
+ */
+function ensureParagraphSectionBreakModel(paragraph) {
+    var held = paragraph.sectionBreakPropertiesModel();
+    if (isPageSetupModel(held)) {
+        associatePageSetupDocument(held, paragraph.owningDocument());
+        return held;
+    }
+    var raw = paragraph.sectionBreakSectPr();
+    if (raw === undefined) {
+        return undefined;
+    }
+    var props = parseSectionProperties(raw);
+    if (props === undefined) {
+        return undefined;
+    }
+    associatePageSetupDocument(props, paragraph.owningDocument());
+    paragraph.replaceSectionBreakPropertiesModel(props);
+    return props;
+}
+/**
+ * Body-final section properties (`w:body/w:sectPr`).
+ *
+ * Returns the same object identity across calls once materialised.
+ *
+ * @private
+ */
+export function finalSection(document) {
+    return ensureFinalSectionModel(document);
+}
+/**
+ * Replace body-final section properties.
+ *
+ * @private
+ */
+export function setFinalSection(document, properties) {
+    associatePageSetupDocument(properties, document);
+    document.replaceFinalSectionPropertiesModel(properties);
+}
+/**
+ * Paragraph section-break properties (`w:pPr/w:sectPr`), when present.
+ *
+ * Returns the same object identity across calls once materialised.
+ *
+ * @private
+ */
+export function paragraphSectionBreak(paragraph) {
+    return ensureParagraphSectionBreakModel(paragraph);
+}
+/**
+ * Set or clear paragraph section-break properties (`w:pPr/w:sectPr`).
+ *
+ * After dual-hold update, repartitions {@link Document.sections} so non-final
+ * pageSetup lives on its own section and flatten emits mid-body + body-final
+ * `w:sectPr` (TASK-8075/8076 authoring path).
+ *
+ * @private
+ */
+export function setParagraphSectionBreak(paragraph, properties) {
+    var document = paragraph.owningDocument();
+    if (properties !== undefined) {
+        associatePageSetupDocument(properties, document);
+        paragraph.replaceSectionBreakPropertiesModel(properties);
+    }
+    else {
+        paragraph.replaceSectionBreakPropertiesModel(undefined);
+        paragraph.replaceSectionBreakSectPr(undefined);
+    }
+    // Rebuild Document.sections so dual-hold authoring matches load partition
+    // (non-final pageSetup on its own section; flatten emits mid-body sectPr).
+    document.repartitionFromBodyBlocks();
+}
+/**
+ * Body-final properties for internal authoring bridges. Seeds a default letter
+ * page setup when none is present so flatten/serialize always has live
+ * {@link PageSetup} while the sections feature is registered.
+ *
+ * @private
+ */
+export function ensureFinalSectionProperties(document) {
+    var existing = ensureFinalSectionModel(document);
+    if (existing !== undefined) {
+        return existing;
+    }
+    var seeded = defaultLetterPageSetup();
+    associatePageSetupDocument(seeded, document);
+    document.replaceFinalSectionPropertiesModel(seeded);
+    return seeded;
+}
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerSectionsFeature();
+});
+registerSectionsFeature();