@syncfusion/ej2-docx 0.0.0-stage → 35.1.39

package/src/features/document/document.js

@@ -0,0 +1,1049 @@
+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 };
+        }
+    };
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+import { DetachedObjectError, InvalidArgumentError, IoError } from '../../core/errors/docx-error';
+import { inspectMarkupCompatibility } from '../../core/mc/index';
+import { createTransitionalWordPackage, loadOpcPackage, officeDocumentPartName, partByName, saveOpcPackage, withReplacedPart } from '../../core/opc/index';
+import { documentBody } from '../../core/preservation/index';
+import { parseXml, serializeXml, WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { materializeFeatureSideEffects } from '../../core/registry/materialize-handlers';
+import { applyFeatureParts, loadFeatureParts, } from '../../core/registry/part-handlers';
+import { applyFeatureMultiParts, loadFeatureMultiParts, } from '../../core/registry/multi-part-handlers';
+import { applyFeaturePackageParts, loadFeaturePackageParts, } from '../../core/registry/package-part-handlers';
+import { detachedBodyBlockParseContext } from '../../core/registry/block-handlers';
+import { isFeaturePackageLevelPart } from './feature-package-level-part';
+import { isFeatureMultiPackagePart } from './feature-multi-package-part';
+import { altChunksInBlocks, bindAltChunkDocument, ensureCoreBlockHandlers } from './alt-chunk';
+import { ensureAlwaysOnBodyFeaturesRegistered } from './body-always-on';
+import { parseBodyBlocks, serializeBodyBlocks } from './body-blocks';
+import { Paragraph } from './paragraph';
+import { Section } from './section';
+import { flattenSectionsToBodyBlocks, materializeSectionProperties, notifySectionPropertiesAttached, partitionBodyIntoSections, } from './section-partition-flatten';
+import { Sections } from './sections';
+import { isWml, wmlElement } from './wml';
+import { decodeBase64, encodeBase64 } from '../../core/compat/base64';
+/**
+ * Core alt-chunk handlers + always-on body/run features (tables / content-controls /
+ * images / drawing when bootstrapped from the main entry).
+ */
+function ensureBodyParseHandlers() {
+    ensureCoreBlockHandlers();
+    ensureAlwaysOnBodyFeaturesRegistered();
+}
+var utf8 = new TextEncoder();
+var utf8Decoder = new TextDecoder('utf-8');
+/**
+ * In-memory WordprocessingML document backed by an OPC package.
+ *
+ * Load via {@link WordDocument.open} / {@link WordDocument.openSync} from bytes or base64,
+ * or {@link WordDocument.openAsync} from a browser `File` / `Blob`. There is no filesystem-path open.
+ * Serialize with {@link WordDocument.save} / {@link WordDocument.saveSync} to bytes, a browser
+ * download file name, or base64. There is no Node.js filesystem write.
+ *
+ * Main-story entry is {@link Document.sections} (each {@link Section.body}).
+ *
+ * @public
+ */
+var WordDocument = /** @class */ (function () {
+    function WordDocument(pkg, rootExtra, background, items, sectPr, featureParts) {
+        var e_1, _a;
+        this.pkg = pkg;
+        this.rootExtra = rootExtra;
+        this.background = background;
+        this.sectPr = sectPr;
+        this.finalSectionModel = undefined;
+        this.featureParts = featureParts;
+        var section = new Section(this, items);
+        this.sectionsInstance = new Sections(this, [section]);
+        // Body constructor only copies the store — attach / bind seeded blocks here.
+        var body = section.body;
+        try {
+            for (var _b = __values(body.listBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var block = _c.value;
+                if (block.type === 'paragraph') {
+                    block.paragraph.attach(body);
+                    continue;
+                }
+                if (block.type === 'feature') {
+                    bindDocumentToFeatureBlock(block.value, this);
+                }
+            }
+        }
+        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; }
+        }
+        bindAltChunkDocument(body.listBlocks(), this);
+        section.syncCollections();
+    }
+    /**
+     * Minimal Transitional package with one empty paragraph (`w:p` in `w:body`).
+     *
+     * Builds the in-memory document and package scaffold directly — does not
+     * serialize then re-parse as the sole create path.
+     */
+    WordDocument.create = function () {
+        ensureBodyParseHandlers();
+        var pkg = createTransitionalWordPackage();
+        var name = officeDocumentPartName(pkg);
+        var paragraph = new Paragraph(undefined);
+        return new WordDocument(pkg, {
+            attributes: [],
+            namespaceDeclarations: [{ prefix: 'w', namespaceUri: WML_TRANSITIONAL_NAMESPACE }],
+        }, undefined, [{ type: 'paragraph', paragraph: paragraph }], undefined, mergeFeatureParts(loadFeatureParts(pkg, name), loadFeatureMultiParts(pkg, name), loadFeaturePackageParts(pkg)));
+    };
+    /**
+     * @private
+     */
+    WordDocument.fromPackage = function (pkg, limits) {
+        var e_2, _a, e_3, _b, e_4, _c;
+        ensureBodyParseHandlers();
+        var name = officeDocumentPartName(pkg);
+        var part = partByName(pkg, name);
+        if (part === undefined) {
+            throw new DetachedObjectError('Main document part is missing');
+        }
+        var root = parseXml(utf8Decoder.decode(part.data), limits);
+        inspectMarkupCompatibility(root);
+        var background;
+        try {
+            for (var _d = __values(root.children), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var child = _e.value;
+                if (child.kind === 'element' && isWml(child, 'background')) {
+                    background = child;
+                    break;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        // Chart, ink, and diagram parts have no typed handlers. Leaving them
+        // unregistered keeps those OPC parts untouched on save.
+        var featureParts = mergeFeatureParts(loadFeatureParts(pkg, name, limits), loadFeatureMultiParts(pkg, name, limits), loadFeaturePackageParts(pkg, limits));
+        var body = documentBody(root);
+        var parseCtx = detachedBodyBlockParseContext();
+        var blocks = [];
+        var sectPr;
+        try {
+            for (var _f = __values(body.children), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var child = _g.value;
+                if (child.kind !== 'element') {
+                    continue;
+                }
+                if (isWml(child, 'sectPr')) {
+                    sectPr = child;
+                    continue;
+                }
+                blocks.push.apply(blocks, __spread(parseBodyBlocks([child], parseCtx)));
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        var document = new WordDocument(pkg, {
+            attributes: root.attributes,
+            namespaceDeclarations: root.namespaceDeclarations.length > 0
+                ? root.namespaceDeclarations
+                : [{ prefix: 'w', namespaceUri: WML_TRANSITIONAL_NAMESPACE }],
+        }, background, [], undefined, featureParts);
+        document.hydratePartitionedSections(blocks, sectPr);
+        try {
+            // Feature post-load hooks (comments main-story elevation TASK-8055 / D14).
+            // Duck-typed so `document.ts` does not value-import `features/comments` (that
+            // cycle left `Paragraph` undefined when comments attached prototype methods).
+            for (var _h = __values(featureParts.values()), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var featurePart = _j.value;
+                var part_1 = featurePart;
+                part_1.afterMainDocumentLoad == null ? undefined : part_1.afterMainDocumentLoad(document);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return document;
+    };
+    /**
+     * @private
+     * Partition body blocks into logical sections and attach them (TASK-8075).
+     * Non-final section properties stay dual-held internally on the closing
+     * paragraph and {@link Section.pageSetup} for flatten/serialize; final
+     * properties dual-hold body-final model / last pageSetup.
+     *
+     * Also used after dual-hold authoring (`setParagraphSectionBreak`) so
+     * `Document.sections` matches paragraph break topology before save.
+     */
+    WordDocument.prototype.hydratePartitionedSections = function (blocks, trailingSectPr) {
+        var e_5, _a;
+        var parts = partitionBodyIntoSections(blocks, trailingSectPr);
+        var sections = [];
+        for (var i = 0; i < parts.length; i += 1) {
+            var part = parts[i];
+            var materialized = materializeSectionProperties(part.properties);
+            var pageSetup = materialized !== undefined &&
+                typeof materialized.toOpenXml === 'function'
+                ? materialized
+                : undefined;
+            var section = new Section(this, part.items, pageSetup);
+            sections.push(section);
+            notifySectionPropertiesAttached(pageSetup, this);
+            // Internal dual-hold: pin the same pageSetup identity on the non-final
+            // closing paragraph so flatten/serialize can read break properties.
+            if (!part.isFinal && pageSetup !== undefined) {
+                var items = part.items;
+                var last = items[items.length - 1];
+                if (last !== undefined && last.type === 'paragraph') {
+                    last.paragraph.replaceSectionBreakPropertiesModel(pageSetup);
+                }
+            }
+        }
+        this.sectionsInstance.replaceAll(sections);
+        this.sectPr = undefined;
+        this.finalSectionModel = undefined;
+        var lastPart = parts[parts.length - 1];
+        var lastSection = sections[sections.length - 1];
+        if (lastPart !== undefined && lastSection !== undefined) {
+            var finalMaterialized = materializeSectionProperties(lastPart.properties);
+            if (finalMaterialized !== undefined &&
+                typeof finalMaterialized.toOpenXml === 'function') {
+                this.finalSectionModel = finalMaterialized;
+                lastSection.setPageSetup(this.finalSectionModel);
+                notifySectionPropertiesAttached(this.finalSectionModel, this);
+                this.sectPr = undefined;
+            }
+            else if (trailingSectPr !== undefined) {
+                // No sections feature model — keep preserved body-final XML only.
+                // trailing may be model | OpenXml; only OpenXml belongs on sectPr.
+                if (trailingSectPr.kind === 'element') {
+                    this.sectPr = trailingSectPr;
+                    lastSection.setPageSetup(undefined);
+                }
+                else {
+                    this.finalSectionModel = trailingSectPr;
+                    lastSection.setPageSetup(this.finalSectionModel);
+                    notifySectionPropertiesAttached(this.finalSectionModel, this);
+                }
+            }
+            else {
+                // No trailing sectPr and no materialized model: seed default
+                // pageSetup when the sections feature is registered.
+                lastSection.setPageSetup(undefined);
+            }
+        }
+        for (var i = 0; i < sections.length; i += 1) {
+            var section = sections[i];
+            var body = section.body;
+            try {
+                for (var _b = __values(body.listBlocks()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var block = _c.value;
+                    if (block.type === 'paragraph') {
+                        block.paragraph.attach(body);
+                        continue;
+                    }
+                    if (block.type === 'feature') {
+                        bindDocumentToFeatureBlock(block.value, this);
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            bindAltChunkDocument(body.listBlocks(), this);
+            section.syncCollections();
+        }
+    };
+    /**
+     * @private
+     * Rebuild {@link Document.sections} from current body blocks + dual-hold
+     * paragraph/body section properties (TASK-8075/8076 authoring path).
+     *
+     * Call after `setParagraphSectionBreak` so non-final pageSetup lives on its
+     * own section and flatten emits paragraph-level + body-final `w:sectPr`.
+     */
+    WordDocument.prototype.repartitionFromBodyBlocks = function () {
+        var trailingModel = this.finalSectionPropertiesModel();
+        var trailing = trailingModel !== undefined ? trailingModel : this.sectPr;
+        this.hydratePartitionedSections(this.listBlocks().slice(), trailing);
+    };
+    WordDocument.open = function (dataOrPath, options) {
+        // Narrow for TS 3.3 overload resolution (string vs binary packages).
+        if (typeof dataOrPath === 'string') {
+            if (options !== undefined && options.format === 'base64') {
+                var base64Options = {
+                    format: 'base64',
+                    limits: options.limits,
+                };
+                return WordDocument.openSync(dataOrPath, base64Options);
+            }
+            return WordDocument.openSync(dataOrPath, options);
+        }
+        return WordDocument.openSync(dataOrPath, options);
+    };
+    WordDocument.openAsync = function (dataOrPath, options) {
+        return openDocumentAsync(dataOrPath, options);
+    };
+    WordDocument.openSync = function (dataOrPath, options) {
+        var bytes = resolveOpenInputToBytes(dataOrPath, options);
+        return WordDocument.fromPackage(loadOpcPackage(bytes, options == null ? undefined : options.limits), options == null ? undefined : options.limits);
+    };
+    WordDocument.load = function (dataOrPath, options) {
+        if (typeof dataOrPath === 'string') {
+            if (options !== undefined && options.format === 'base64') {
+                var base64Options = {
+                    format: 'base64',
+                    limits: options.limits,
+                };
+                return WordDocument.open(dataOrPath, base64Options);
+            }
+            return WordDocument.open(dataOrPath, options);
+        }
+        return WordDocument.open(dataOrPath, options);
+    };
+    WordDocument.loadAsync = function (dataOrPath, options) {
+        return openDocumentAsync(dataOrPath, options);
+    };
+    WordDocument.loadSync = function (dataOrPath, options) {
+        if (typeof dataOrPath === 'string') {
+            if (options !== undefined && options.format === 'base64') {
+                var base64Options = {
+                    format: 'base64',
+                    limits: options.limits,
+                };
+                return WordDocument.openSync(dataOrPath, base64Options);
+            }
+            return WordDocument.openSync(dataOrPath, options);
+        }
+        return WordDocument.openSync(dataOrPath, options);
+    };
+    Object.defineProperty(WordDocument.prototype, "sections", {
+        /**
+         * Ordered document sections. Sole main-story entry (API-RULES / TASK-8074).
+         *
+         * @public
+         */
+        get: function () {
+            return this.sectionsInstance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WordDocument.prototype, "lastSection", {
+        /**
+         * Last section in {@link WordDocument.sections}.
+         *
+         * Equivalent to `sections[sections.count - 1]`. The document always has at
+         * least one section.
+         *
+         * @public
+         */
+        get: function () {
+            var count = this.sectionsInstance.count;
+            var section = this.sectionsInstance[count - 1];
+            if (section === undefined) {
+                throw new DetachedObjectError('Document must have at least one section');
+            }
+            return section;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WordDocument.prototype, "lastParagraph", {
+        /**
+         * Last block-level paragraph of {@link WordDocument.lastSection}.
+         *
+         * Does not walk paragraphs nested in tables or text boxes. Authored
+         * documents always have at least one body paragraph per section.
+         *
+         * @throws DetachedObjectError when the last section has no block-level
+         * paragraph (malformed loaded package).
+         *
+         * @public
+         */
+        get: function () {
+            var paragraphs = this.lastSection.body.listParagraphs();
+            var paragraph = paragraphs[paragraphs.length - 1];
+            if (paragraph === undefined) {
+                throw new DetachedObjectError('Last section has no block-level paragraph (model invariant violated)');
+            }
+            return paragraph;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WordDocument.prototype, "body", {
+        /**
+         * First section body — convenience bridge matching create-path documents
+         * (single section) and public samples that use `doc.body`.
+         *
+         * Prefer {@link WordDocument.sections} for multi-section documents.
+         *
+         * @public
+         */
+        get: function () {
+            return this.firstSectionBody();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Appends a paragraph to {@link WordDocument.body}.
+     *
+     * Style ids route through {@link Paragraph.applyStyle} so built-in catalog
+     * resolution and validation run on assignment.
+     *
+     * @param options - Optional paragraph style id and/or initial text.
+     * @returns The appended {@link Paragraph}.
+     *
+     * @public
+     */
+    WordDocument.prototype.appendParagraph = function (options) {
+        return this.body.appendParagraph(options);
+    };
+    /**
+     * Appends a new section after the current last section.
+     *
+     * Thin delegate over {@link Sections.add}. Clones page setup from the
+     * previous last section when the sections feature has registered a clone
+     * hook; otherwise seeds a default letter page setup when a seed hook is
+     * registered.
+     *
+     * @returns The new {@link Section}.
+     *
+     * @public
+     */
+    WordDocument.prototype.addSection = function () {
+        return this.sectionsInstance.add();
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.assertAttachedParagraph = function (target) {
+        var e_6, _a;
+        try {
+            for (var _b = __values(this.sectionsInstance.asArray()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var section = _c.value;
+                var found = section.body.listBlocks().some(function (b) { return b.type === 'paragraph' && b.paragraph === target; });
+                if (found) {
+                    return;
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        throw new DetachedObjectError('This paragraph is no longer in the document');
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.owningDocument = function () {
+        return this;
+    };
+    Object.defineProperty(WordDocument.prototype, "altChunks", {
+        /**
+         * Modeled `w:altChunk` anchors in the Main Document body.
+         *
+         * @private
+         */
+        get: function () {
+            return altChunksInBlocks(this.listBlocks());
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * @private
+     * First section body (internal feature/load bridges).
+     */
+    WordDocument.prototype.firstSectionBody = function () {
+        var first = this.sectionsInstance[0];
+        if (first === undefined) {
+            throw new DetachedObjectError('Document must have at least one section');
+        }
+        return first.body;
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.listParagraphs = function () {
+        var e_7, _a;
+        var out = [];
+        try {
+            for (var _b = __values(this.sectionsInstance.asArray()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var section = _c.value;
+                var paras = section.body.listParagraphs();
+                for (var i = 0; i < paras.length; i += 1) {
+                    out.push(paras[i]);
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        return out;
+    };
+    /**
+     * @private
+     * Flattened internal store across sections.
+     */
+    WordDocument.prototype.listBlocks = function () {
+        var e_8, _a;
+        var out = [];
+        try {
+            for (var _b = __values(this.sectionsInstance.asArray()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var section = _c.value;
+                var blocks = section.body.listBlocks();
+                for (var i = 0; i < blocks.length; i += 1) {
+                    out.push(blocks[i]);
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        return out;
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.appendBlock = function (block) {
+        this.firstSectionBody().appendRawBlock(block);
+    };
+    /**
+     * Inserts a body item at index (`0…count` inclusive) on the first section body.
+     *
+     * @private
+     */
+    WordDocument.prototype.insertBlockAt = function (index, block) {
+        this.firstSectionBody().insertRawBlockAt(index, block);
+    };
+    /**
+     * Inserts an empty paragraph at a body item index (`0…count` inclusive).
+     *
+     * @private
+     */
+    WordDocument.prototype.insertParagraphAtBlockIndex = function (index) {
+        var paragraph = new Paragraph(undefined);
+        this.insertBlockAt(index, { type: 'paragraph', paragraph: paragraph });
+        return paragraph;
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.insertParagraph = function (index) {
+        return this.firstSectionBody().paragraphs.insert(index);
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.removeParagraph = function (paragraph) {
+        this.firstSectionBody().paragraphs.remove(paragraph);
+    };
+    /**
+     * Removes the body item at `index` (`0…count-1`) on the first section body.
+     *
+     * @private
+     */
+    WordDocument.prototype.removeBlockAt = function (index) {
+        this.firstSectionBody().removeRawBlockAt(index);
+    };
+    /**
+     * Advanced L3 hatch: Main Document `w:document` tree (API-RULES R5.4).
+     * Unstable; prefer semantic properties and `save` / `saveSync`.
+     *
+     * Always flattens section bodies into one physical `w:body` (TASK-8075/8076).
+     *
+     * @private
+     */
+    WordDocument.prototype.toOpenXml = function () {
+        var _this = this;
+        var sectionList = this.sectionsInstance.asArray();
+        var bodyBlocks = flattenSectionsToBodyBlocks(sectionList.map(function (section, index) { return ({
+            listBlocks: function () { return section.body.listBlocks(); },
+            pageSetup: section.internalPageSetupModel(),
+            pageSetupXml: index === sectionList.length - 1 &&
+                section.internalPageSetupModel() === undefined
+                ? _this.sectPr
+                : undefined,
+            replaceItems: function (items) {
+                section.body.replaceItems(items);
+                // Flatten may append an empty terminator paragraph when a
+                // non-final section ends on a table (or other non-p). Attach
+                // so subsequent mutation does not throw DetachedObjectError.
+                for (var bi = 0; bi < items.length; bi += 1) {
+                    var block = items[bi];
+                    if (block.type === 'paragraph') {
+                        block.paragraph.attach(section.body);
+                    }
+                }
+            },
+            isLast: index === sectionList.length - 1,
+        }); }));
+        var bodyChildren = serializeBodyBlocks(bodyBlocks);
+        var sectPr = this.bodySectPr();
+        if (sectPr !== undefined) {
+            bodyChildren.push(sectPr);
+        }
+        var children = [];
+        if (this.background !== undefined) {
+            children.push(this.background);
+        }
+        children.push(wmlElement('body', { children: bodyChildren }));
+        return wmlElement('document', {
+            attributes: this.rootExtra.attributes,
+            namespaceDeclarations: this.rootExtra.namespaceDeclarations,
+            children: children,
+        });
+    };
+    /**
+     * Preserved `w:document/w:background` subtree from load, if any.
+     *
+     * @private
+     */
+    WordDocument.prototype.preservedBackground = function () {
+        return this.background;
+    };
+    /**
+     * @private
+     * Body-final `w:sectPr`, when present.
+     * Serializes a live section-properties model when the sections feature owns it;
+     * otherwise returns preserved OOXML from load / XML write-back.
+     */
+    WordDocument.prototype.bodySectPr = function () {
+        if (this.finalSectionModel !== undefined) {
+            return this.finalSectionModel.toOpenXml();
+        }
+        // Prefer pageSetup on the last section when dual-held (TASK-8074 bridge).
+        var sections = this.sectionsInstance.asArray();
+        var last = sections[sections.length - 1];
+        var lastModel = last == null ? undefined : last.internalPageSetupModel();
+        if (lastModel !== undefined) {
+            return lastModel.toOpenXml();
+        }
+        return this.sectPr;
+    };
+    /**
+     * @private
+     * Replace body-final `w:sectPr` as preserved OOXML.
+     * Clears any live section-properties model (XML becomes source of truth again).
+     */
+    WordDocument.prototype.replaceBodySectPr = function (value) {
+        this.finalSectionModel = undefined;
+        this.sectPr = value;
+        var sections = this.sectionsInstance.asArray();
+        var last = sections[sections.length - 1];
+        if (last !== undefined) {
+            last.setPageSetup(undefined);
+        }
+    };
+    /**
+     * @private
+     * Live body-final section properties model (sections feature), if any.
+     */
+    WordDocument.prototype.finalSectionPropertiesModel = function () {
+        if (this.finalSectionModel !== undefined) {
+            return this.finalSectionModel;
+        }
+        var sections = this.sectionsInstance.asArray();
+        var last = sections[sections.length - 1];
+        return last == null ? undefined : last.internalPageSetupModel();
+    };
+    /**
+     * @private
+     * Attach or clear the live body-final section properties model.
+     * When set, clears preserved `w:sectPr` XML so the model is the sole source of truth.
+     * Also seeds {@link Section.pageSetup} on the last section (TASK-8074 dual-hold).
+     */
+    WordDocument.prototype.replaceFinalSectionPropertiesModel = function (value) {
+        this.finalSectionModel = value;
+        if (value !== undefined) {
+            this.sectPr = undefined;
+        }
+        var sections = this.sectionsInstance.asArray();
+        var last = sections[sections.length - 1];
+        if (last !== undefined) {
+            last.setPageSetup(value);
+        }
+        if (value !== undefined) {
+            notifySectionPropertiesAttached(value, this);
+        }
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.featurePart = function (id) {
+        return this.featureParts.get(id);
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.setFeaturePart = function (id, part) {
+        this.featureParts.set(id, part);
+    };
+    /**
+     * @private
+     */
+    WordDocument.prototype.opcPackage = function () {
+        return this.pkg;
+    };
+    WordDocument.prototype.saveSync = function (options) {
+        var bytes = this.saveSyncBytes();
+        if (options != null && options.format === 'base64') {
+            return encodeBytesToBase64(bytes);
+        }
+        return bytes;
+    };
+    /**
+     * @private
+     * Shared package serialization used by `saveSync` overloads and async `save`.
+     */
+    WordDocument.prototype.saveSyncBytes = function () {
+        var e_9, _a;
+        materializeFeatureSideEffects(this);
+        var name = officeDocumentPartName(this.pkg);
+        var next = this.pkg;
+        var singleParts = new Map();
+        var multiParts = new Map();
+        var packageParts = new Map();
+        try {
+            for (var _b = __values(this.featureParts), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), id = _d[0], part = _d[1];
+                if (isFeatureMultiPackagePart(part)) {
+                    multiParts.set(id, part);
+                }
+                else if (isFeaturePackageLevelPart(part)) {
+                    packageParts.set(id, part);
+                }
+                else {
+                    singleParts.set(id, part);
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        // Multi-part handlers (headers/footers) reserve sectPr relationship ids before
+        // single-part handlers (styles/numbering) allocate new document relationships.
+        next = applyFeatureMultiParts(next, name, multiParts);
+        next = applyFeatureParts(next, name, singleParts);
+        next = applyFeaturePackageParts(next, packageParts);
+        var xml = serializeXml(this.toOpenXml());
+        next = withReplacedPart(next, name, utf8.encode(xml));
+        // Keep the in-memory package aligned with what was written. Feature multi-part
+        // catalogs clear dirty flags after apply; without this, a later saveSync would
+        // start from the pre-apply package and drop embeddings/media/rels (TASK-8056).
+        this.pkg = next;
+        return saveOpcPackage(next);
+    };
+    WordDocument.prototype.save = function (filePathOrOptions) {
+        return __awaiter(this, void 0, void 0, function () {
+            var bytes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        bytes = this.saveSyncBytes();
+                        if (filePathOrOptions === undefined) {
+                            return [2 /*return*/, bytes];
+                        }
+                        if (typeof filePathOrOptions === 'object' && filePathOrOptions.format === 'base64') {
+                            return [2 /*return*/, encodeBytesToBase64(bytes)];
+                        }
+                        return [4 /*yield*/, writeDocumentToPath(filePathOrOptions, bytes)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return WordDocument;
+}());
+export { WordDocument };
+/**
+ * Page `document` used to start a filename download.
+ * Does not probe Node.js `fs` — that module must stay out of the browser bundle.
+ *
+ * @private
+ */
+function browserDocument() {
+    var globalObject = Function('return this')();
+    var host = globalObject.window;
+    if (host == null || host.document == null || typeof host.document.createElementNS !== 'function') {
+        return undefined;
+    }
+    return host.document;
+}
+/**
+ * Download file name from a path-shaped argument (`./out/Output.docx` → `Output.docx`).
+ *
+ * @private
+ */
+function downloadFileName(filePath) {
+    var trimmed = filePath.trim();
+    var parts = trimmed.split(/[/\\]/);
+    var name = parts[parts.length - 1];
+    return name !== undefined && name.length > 0 ? name : trimmed;
+}
+/**
+ * Trigger a browser download of the package bytes.
+ * Same approach as the PDF library filename save (Blob + anchor click).
+ *
+ * @private
+ */
+function downloadDocumentInBrowser(fileName, bytes, doc) {
+    var host = Function('return this')();
+    var blob = new host.Blob([bytes], {
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    });
+    var nav = host.navigator;
+    if (nav != null && typeof nav.msSaveBlob === 'function') {
+        nav.msSaveBlob(blob, fileName);
+        return;
+    }
+    var url = host.URL.createObjectURL(blob);
+    var link = doc.createElementNS('http://www.w3.org/1999/xhtml', 'a');
+    link.download = fileName;
+    link.href = url;
+    var event = doc.createEvent('MouseEvent');
+    event.initEvent('click', true, true);
+    link.dispatchEvent(event);
+    host.setTimeout(function () {
+        host.URL.revokeObjectURL(url);
+    }, 0);
+}
+/**
+ * @private
+ * Browser download of the file name (PDF `save(filename)` pattern).
+ * Never calls Node.js `fs` — Vite externalizes that module and throws
+ * `Cannot access "fs.writeFile"` when the client bundle evaluates it.
+ */
+function writeDocumentToPath(filePath, bytes) {
+    if (typeof filePath !== 'string' || filePath.trim().length === 0) {
+        throw new InvalidArgumentError('save(fileName) requires a non-empty file name string');
+    }
+    var browserDoc = browserDocument();
+    if (browserDoc === undefined) {
+        throw new IoError('save(fileName) downloads in the browser and does not write a filesystem path. Use save() or saveSync() and write the bytes from application code.');
+    }
+    downloadDocumentInBrowser(downloadFileName(filePath), bytes, browserDoc);
+    return Promise.resolve();
+}
+function toUint8Array(data) {
+    if (data instanceof Uint8Array) {
+        return data;
+    }
+    return new Uint8Array(data);
+}
+function openDocumentAsync(dataOrPath, options) {
+    if (isBlobLike(dataOrPath)) {
+        return dataOrPath.arrayBuffer().then(function (buffer) {
+            return WordDocument.openSync(buffer, options);
+        });
+    }
+    try {
+        if (typeof dataOrPath === 'string') {
+            if (options !== undefined && options.format === 'base64') {
+                var base64Options = {
+                    format: 'base64',
+                    limits: options.limits,
+                };
+                return Promise.resolve(WordDocument.openSync(dataOrPath, base64Options));
+            }
+            return Promise.reject(pathOpenRemoved());
+        }
+        return Promise.resolve(WordDocument.openSync(dataOrPath, options));
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+}
+function isBlobLike(value) {
+    if (typeof value !== 'object' || value === null || !('arrayBuffer' in value)) {
+        return false;
+    }
+    return typeof value.arrayBuffer === 'function';
+}
+function stripBase64DataUrlPrefix(value) {
+    var comma = value.indexOf(',');
+    if (comma >= 0 && /^data:/i.test(value) && /;base64/i.test(value.slice(0, comma))) {
+        return value.slice(comma + 1);
+    }
+    return value;
+}
+function decodeBase64ToBytes(base64) {
+    if (typeof base64 !== 'string' || base64.trim().length === 0) {
+        throw new InvalidArgumentError("open(..., { format: 'base64' }) requires a non-empty base64 string");
+    }
+    var payload = stripBase64DataUrlPrefix(base64).replace(/\s+/g, '');
+    try {
+        return decodeBase64(payload);
+    }
+    catch (err) {
+        throw new InvalidArgumentError("Invalid base64 payload for open(..., { format: 'base64' })", { cause: err });
+    }
+}
+function encodeBytesToBase64(bytes) {
+    return encodeBase64(bytes);
+}
+function resolveOpenInputToBytes(dataOrPath, options) {
+    if (typeof dataOrPath !== 'string') {
+        return toUint8Array(dataOrPath);
+    }
+    if (options != null && options.format === 'base64') {
+        return decodeBase64ToBytes(dataOrPath);
+    }
+    throw pathOpenRemoved();
+}
+function pathOpenRemoved() {
+    return new InvalidArgumentError("open/load does not read a filesystem path. Pass Uint8Array, ArrayBuffer, base64 with { format: 'base64' }, or a File/Blob to openAsync/loadAsync.");
+}
+function bindDocumentToFeatureBlock(value, document) {
+    if (typeof value !== 'object' || value === null || !('bindDocument' in value)) {
+        return;
+    }
+    var bindDocument = value.bindDocument;
+    bindDocument.call(value, document);
+}
+function mergeFeatureParts(single, multi, packageLevel) {
+    var e_10, _a, e_11, _b, e_12, _c;
+    var out = new Map();
+    try {
+        for (var single_1 = __values(single), single_1_1 = single_1.next(); !single_1_1.done; single_1_1 = single_1.next()) {
+            var _d = __read(single_1_1.value, 2), id = _d[0], part = _d[1];
+            out.set(id, part);
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (single_1_1 && !single_1_1.done && (_a = single_1.return)) _a.call(single_1);
+        }
+        finally { if (e_10) throw e_10.error; }
+    }
+    try {
+        for (var multi_1 = __values(multi), multi_1_1 = multi_1.next(); !multi_1_1.done; multi_1_1 = multi_1.next()) {
+            var _e = __read(multi_1_1.value, 2), id = _e[0], part = _e[1];
+            out.set(id, part);
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (multi_1_1 && !multi_1_1.done && (_b = multi_1.return)) _b.call(multi_1);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    try {
+        for (var packageLevel_1 = __values(packageLevel), packageLevel_1_1 = packageLevel_1.next(); !packageLevel_1_1.done; packageLevel_1_1 = packageLevel_1.next()) {
+            var _f = __read(packageLevel_1_1.value, 2), id = _f[0], part = _f[1];
+            out.set(id, part);
+        }
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (packageLevel_1_1 && !packageLevel_1_1.done && (_c = packageLevel_1.return)) _c.call(packageLevel_1);
+        }
+        finally { if (e_12) throw e_12.error; }
+    }
+    return out;
+}
+// Re-export Body from body.ts so existing `import { Document, Body } from '.../document'` keeps working.
+export { Body } from './body';