@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/numbering/index.js

@@ -0,0 +1,668 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+export * from './abstract-numbering';
+export * from './list-string';
+export * from './list-style';
+export * from './numbering-instance';
+export * from './numbering-level';
+export * from './picture-bullet';
+import { DocxError } from '../../core/errors/docx-error';
+import { registerAlwaysOnBodyFeatureBootstrap } from '../document/body-always-on';
+import { Paragraph } from '../document/paragraph';
+import { elementChildren, isWml, wmlAttr, wmlElement } from '../document/wml';
+import { partName } from '../../core/opc/part-name';
+import { featureId, isFeatureRegistered, registerFeature, registerFeatureMaterializeHandler, registerFeaturePartHandler, visitParagraphsInDocumentOrder, } from '../../core/registry/index';
+import { decodeXmlBytes, parseXml, serializeXml, WML_TRANSITIONAL_NAMESPACE } from '../../core/xml/index';
+import { createDefaultAbstractNumbering, parseAbstractNumbering } from './abstract-numbering';
+import { createNumberingInstance, parseNumberingInstance } from './numbering-instance';
+import { ListFormat } from './list-format';
+import { parseNumberingPictureBullet } from './picture-bullet';
+import { setListFormatFactory } from '../document/paragraph';
+// Bridge ListFormat onto Paragraph without extensionless CJS require (Vitest ESM).
+setListFormatFactory(function (paragraph) { return new ListFormat(paragraph); });
+// Side-effect: WordDocument.addListStyle + load list-style module.
+import './list-style';
+// Side-effect: Paragraph.listString.
+import './list-string';
+var NUMBERING = featureId('numbering');
+/**
+ * @private
+ * Transitional numbering relationship (ECMA-376-4 section 9.2.11). */
+export var NUMBERING_RELATIONSHIP_TYPE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering';
+/**
+ * @private
+ * Strict numbering relationship (ECMA-376-1 section 11.3.11). */
+export var STRICT_NUMBERING_RELATIONSHIP_TYPE = 'http://purl.oclc.org/ooxml/officeDocument/relationships/numbering';
+/**
+ * @private
+ * ECMA-376-1 section 11.3.11 Numbering Definitions content type. */
+export var NUMBERING_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml';
+/**
+ * @private
+ */
+export var NUMBERING_PART_NAME = partName('/word/numbering.xml');
+var utf8 = new TextEncoder();
+/**
+ * In-memory Numbering Definitions part (`word/numbering.xml`).
+ *
+ * Typed DOM for `CT_Numbering`: picture bullets, abstract definitions,
+ * numbering instances, and optional `numIdMacAtCleanup`. Unmodeled root
+ * children are preserved in prefix/suffix order.
+ *
+ * @private
+ */
+var NumberingPart = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function NumberingPart(init) {
+        var e_1, _a, e_2, _b, e_3, _c;
+        this.rootPrefix = __spread((init.rootPrefix != null ? init.rootPrefix : []));
+        this.rootSuffix = __spread((init.rootSuffix != null ? init.rootSuffix : []));
+        this.pictureBulletList = __spread((init.pictureBullets != null ? init.pictureBullets : []));
+        this.abstractNumberingList = __spread((init.abstractNumberings != null ? init.abstractNumberings : []));
+        this.numberingList = __spread((init.numberings != null ? init.numberings : []));
+        this.abstractById = new Map();
+        this.numberingById = new Map();
+        this.pictureById = new Map();
+        try {
+            for (var _d = __values(this.pictureBulletList), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var pic = _e.value;
+                this.pictureById.set(pic.numPicBulletId, pic);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var _f = __values(this.abstractNumberingList), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var abs = _g.value;
+                this.abstractById.set(abs.abstractNumId, abs);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        try {
+            for (var _h = __values(this.numberingList), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var num = _j.value;
+                this.numberingById.set(num.numId, num);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        this.numIdMacAtCleanupValue = init.numIdMacAtCleanup;
+        this.pendingNumIds = new Set();
+        this.pendingDecimalNumIds = new Set();
+        this.dirty = init.dirty;
+    }
+    Object.defineProperty(NumberingPart.prototype, "pictureBullets", {
+        /** Ordered picture bullet definitions (`w:numPicBullet`). */
+        get: function () {
+            return this.pictureBulletList;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NumberingPart.prototype, "abstractNumberings", {
+        /** Ordered abstract numbering definitions (`w:abstractNum`). */
+        get: function () {
+            return this.abstractNumberingList;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NumberingPart.prototype, "numberings", {
+        /** Ordered numbering instances (`w:num`). */
+        get: function () {
+            return this.numberingList;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NumberingPart.prototype, "numIdMacAtCleanup", {
+        /** Optional `w:numIdMacAtCleanup/@w:val`. */
+        get: function () {
+            return this.numIdMacAtCleanupValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** Lookup abstract definition by id. */
+    NumberingPart.prototype.getAbstractNumbering = function (abstractNumId) {
+        return this.abstractById.get(abstractNumId);
+    };
+    /** Lookup numbering instance by id. */
+    NumberingPart.prototype.getNumbering = function (numId) {
+        return this.numberingById.get(numId);
+    };
+    /** Lookup picture bullet by id. */
+    NumberingPart.prototype.getPictureBullet = function (numPicBulletId) {
+        return this.pictureById.get(numPicBulletId);
+    };
+    /** Whether a numbering instance id exists in the catalog (including pending). */
+    NumberingPart.prototype.hasInstance = function (numId) {
+        return this.numberingById.has(numId) || this.pendingNumIds.has(numId);
+    };
+    /**
+     * Ensure a numbering instance exists, creating a nine-level default definition when absent.
+     *
+     * @param format - List format used when creating a new abstract numbering definition.
+     *   `'bullet'` (default) produces the standard bullet pattern; `'decimal'` produces the
+     *   cycling `decimal` / `lowerLetter` / `lowerRoman` pattern. Has no effect if the
+     *   instance already exists.
+     */
+    NumberingPart.prototype.ensureInstance = function (numId, format) {
+        if (format === void 0) { format = 'bullet'; }
+        if (numId < 1) {
+            throw new DocxError('content/invalid-num-id', 'Numbering instance id must be at least 1');
+        }
+        if (this.numberingById.has(numId)) {
+            return;
+        }
+        var abstractNumId = this.nextAbstractNumId();
+        var abstract = createDefaultAbstractNumbering(abstractNumId, format);
+        var instance = createNumberingInstance(numId, abstractNumId);
+        this.abstractNumberingList.push(abstract);
+        this.abstractById.set(abstractNumId, abstract);
+        this.numberingList.push(instance);
+        this.numberingById.set(numId, instance);
+        this.dirty = true;
+    };
+    /**
+     * Allocate a new bullet list instance id with a nine-level bullet definition on materialize.
+     */
+    NumberingPart.prototype.createBulletInstance = function () {
+        var numId = this.nextNumId();
+        this.pendingNumIds.add(numId);
+        return numId;
+    };
+    /**
+     * Allocate a new decimal (numbered) list instance id with a nine-level definition on materialize.
+     *
+     * The cycling pattern (`decimal` / `lowerLetter` / `lowerRoman`) is materialized at
+     * save time when the paragraph's `numbering` property is set.
+     */
+    NumberingPart.prototype.createDecimalInstance = function () {
+        var numId = this.nextNumId();
+        this.pendingDecimalNumIds.add(numId);
+        this.pendingNumIds.add(numId);
+        return numId;
+    };
+    /**
+     * Register an existing abstract numbering definition and mark the part dirty.
+     *
+     * @private
+     */
+    NumberingPart.prototype.registerAbstract = function (abstract) {
+        if (this.abstractById.has(abstract.abstractNumId)) {
+            throw new DocxError('content/invalid-num-id', "Abstract numbering id " + String(abstract.abstractNumId) + " already exists");
+        }
+        this.abstractNumberingList.push(abstract);
+        this.abstractById.set(abstract.abstractNumId, abstract);
+        this.dirty = true;
+    };
+    /**
+     * Allocate the next unused abstract numbering id.
+     *
+     * @private
+     */
+    NumberingPart.prototype.allocateAbstractNumId = function () {
+        return this.nextAbstractNumId();
+    };
+    /**
+     * Create a concrete `w:num` linked to an existing abstract definition.
+     *
+     * @param abstractNumId - Existing abstract id.
+     * @param startOverride - Optional level-0 start override.
+     * @private
+     */
+    NumberingPart.prototype.createInstanceFromAbstract = function (abstractNumId, startOverride) {
+        if (!this.abstractById.has(abstractNumId)) {
+            throw new DocxError('content/invalid-num-id', "Abstract numbering id " + String(abstractNumId) + " is not defined");
+        }
+        var numId = this.nextNumId();
+        var instance = createNumberingInstance(numId, abstractNumId);
+        if (startOverride !== undefined) {
+            instance.setStartOverride(0, startOverride);
+        }
+        this.numberingList.push(instance);
+        this.numberingById.set(numId, instance);
+        this.dirty = true;
+        return numId;
+    };
+    /**
+     * Mark the numbering part dirty after an in-place abstract/level mutation.
+     *
+     * @private
+     */
+    NumberingPart.prototype.markDirty = function () {
+        this.dirty = true;
+    };
+    /**
+     * @private
+     * Track a numbering instance referenced before save.
+     */
+    NumberingPart.prototype.registerPendingInstance = function (numId, format) {
+        if (format === void 0) { format = 'bullet'; }
+        if (this.numberingById.has(numId)) {
+            return;
+        }
+        this.pendingNumIds.add(numId);
+        if (format === 'decimal') {
+            this.pendingDecimalNumIds.add(numId);
+        }
+    };
+    /**
+     * @private
+     * Whether a pending (not yet materialized) numbering id was allocated as decimal.
+     */
+    NumberingPart.prototype.isPendingDecimal = function (numId) {
+        return this.pendingDecimalNumIds.has(numId);
+    };
+    /**
+     * @private
+     */
+    NumberingPart.prototype.materializePending = function (document) {
+        var _this = this;
+        var e_4, _a;
+        var ordered = [];
+        var seen = new Set();
+        visitParagraphsInDocumentOrder(document, function (paragraph) {
+            var numId = paragraph.numId;
+            // Word uses numId 0 to mean "no numbering"; never materialize it.
+            if (numId === undefined || numId < 1 || _this.numberingById.has(numId) || seen.has(numId)) {
+                return;
+            }
+            seen.add(numId);
+            ordered.push(numId);
+        });
+        try {
+            for (var ordered_1 = __values(ordered), ordered_1_1 = ordered_1.next(); !ordered_1_1.done; ordered_1_1 = ordered_1.next()) {
+                var numId = ordered_1_1.value;
+                var format = this.pendingDecimalNumIds.has(numId) ? 'decimal' : 'bullet';
+                this.ensureInstance(numId, format);
+                this.pendingNumIds.delete(numId);
+                this.pendingDecimalNumIds.delete(numId);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (ordered_1_1 && !ordered_1_1.done && (_a = ordered_1.return)) _a.call(ordered_1);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    /**
+     * @private
+     */
+    NumberingPart.prototype.isDirty = function () {
+        return this.dirty;
+    };
+    /**
+     * @private
+     */
+    NumberingPart.prototype.serialize = function () {
+        var e_5, _a, e_6, _b, e_7, _c;
+        var children = __spread(this.rootPrefix);
+        try {
+            for (var _d = __values(this.pictureBulletList), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var pic = _e.value;
+                children.push(pic.toOpenXml());
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        try {
+            for (var _f = __values(this.abstractNumberingList), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var abs = _g.value;
+                children.push(abs.toOpenXml());
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        try {
+            for (var _h = __values(this.numberingList), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var num = _j.value;
+                children.push(num.toOpenXml());
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        if (this.numIdMacAtCleanupValue !== undefined) {
+            children.push(wmlElement('numIdMacAtCleanup', {
+                attributes: [wmlAttr('val', String(this.numIdMacAtCleanupValue))],
+            }));
+        }
+        children.push.apply(children, __spread(this.rootSuffix));
+        var root = wmlElement('numbering', {
+            namespaceDeclarations: [{ prefix: 'w', namespaceUri: WML_TRANSITIONAL_NAMESPACE }],
+            children: children,
+        });
+        return utf8.encode(serializeXml(root));
+    };
+    NumberingPart.prototype.nextNumId = function () {
+        var e_8, _a, e_9, _b;
+        var max = 0;
+        try {
+            for (var _c = __values(this.numberingById.keys()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var id = _d.value;
+                if (id > max) {
+                    max = id;
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        try {
+            for (var _e = __values(this.pendingNumIds), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var id = _f.value;
+                if (id > max) {
+                    max = id;
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        return max + 1;
+    };
+    NumberingPart.prototype.nextAbstractNumId = function () {
+        var e_10, _a;
+        var max = -1;
+        try {
+            for (var _b = __values(this.abstractById.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var id = _c.value;
+                if (id > max) {
+                    max = id;
+                }
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        return max + 1;
+    };
+    return NumberingPart;
+}());
+export { NumberingPart };
+function parseNumberingRoot(root) {
+    var e_11, _a;
+    var __ts33_0;
+    var rootPrefix = [];
+    var rootSuffix = [];
+    var pictureBullets = [];
+    var abstractNumberings = [];
+    var numberings = [];
+    var numIdMacAtCleanup;
+    var afterPrimary = false;
+    try {
+        for (var _b = __values(elementChildren(root)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var child = _c.value;
+            if (isWml(child, 'numPicBullet')) {
+                var pic = parseNumberingPictureBullet(child);
+                if (pic !== undefined) {
+                    pictureBullets.push(pic);
+                    afterPrimary = true;
+                }
+                else if (!afterPrimary && abstractNumberings.length === 0 && numberings.length === 0) {
+                    rootPrefix.push(child);
+                }
+                else {
+                    rootSuffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'abstractNum')) {
+                afterPrimary = true;
+                var entry = parseAbstractNumbering(child);
+                if (entry !== undefined) {
+                    abstractNumberings.push(entry);
+                }
+                else {
+                    rootSuffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'num')) {
+                afterPrimary = true;
+                var entry = parseNumberingInstance(child);
+                if (entry !== undefined) {
+                    numberings.push(entry);
+                }
+                else {
+                    rootSuffix.push(child);
+                }
+                continue;
+            }
+            if (isWml(child, 'numIdMacAtCleanup')) {
+                afterPrimary = true;
+                var raw = ((__ts33_0 = child.attributes.find(function (a) { return a.localName === 'val' && a.namespaceUri === WML_TRANSITIONAL_NAMESPACE; })), __ts33_0 == null ? undefined : __ts33_0.value);
+                if (raw !== undefined && /^-?\d+$/.test(raw) && numIdMacAtCleanup === undefined) {
+                    numIdMacAtCleanup = Number.parseInt(raw, 10);
+                }
+                else {
+                    rootSuffix.push(child);
+                }
+                continue;
+            }
+            if (!afterPrimary && abstractNumberings.length === 0 && numberings.length === 0) {
+                rootPrefix.push(child);
+            }
+            else {
+                rootSuffix.push(child);
+            }
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return {
+        rootPrefix: rootPrefix,
+        rootSuffix: rootSuffix,
+        pictureBullets: pictureBullets,
+        abstractNumberings: abstractNumberings,
+        numberings: numberings,
+        numIdMacAtCleanup: numIdMacAtCleanup,
+    };
+}
+function loadNumberingPart(part) {
+    if (part === undefined) {
+        return new NumberingPart({ dirty: false });
+    }
+    var root = parseXml(decodeXmlBytes(part.data));
+    if (!isWml(root, 'numbering')) {
+        return new NumberingPart({ dirty: false });
+    }
+    var parsed = parseNumberingRoot(root);
+    return new NumberingPart(__assign({ rootPrefix: parsed.rootPrefix, rootSuffix: parsed.rootSuffix, pictureBullets: parsed.pictureBullets, abstractNumberings: parsed.abstractNumberings, numberings: parsed.numberings }, (parsed.numIdMacAtCleanup !== undefined
+        ? { numIdMacAtCleanup: parsed.numIdMacAtCleanup }
+        : {}), { dirty: false }));
+}
+var registered = false;
+/**
+ * @private
+ * Test hook */
+export function resetNumberingFeatureForTests() {
+    registered = false;
+}
+/**
+ * @private
+ * Register the numbering package-part handler. Idempotent. */
+export function registerNumberingFeature() {
+    if (registered) {
+        return;
+    }
+    registered = true;
+    registerFeature({ id: NUMBERING });
+    registerFeaturePartHandler({
+        featureId: NUMBERING,
+        relationshipTypes: [NUMBERING_RELATIONSHIP_TYPE, STRICT_NUMBERING_RELATIONSHIP_TYPE],
+        defaultRelativeTarget: 'numbering.xml',
+        partName: NUMBERING_PART_NAME,
+        contentType: NUMBERING_CONTENT_TYPE,
+        loadPart: function (part, ctx) {
+            void ctx;
+            return loadNumberingPart(part);
+        },
+    });
+    registerFeatureMaterializeHandler({
+        featureId: NUMBERING,
+        materialize: function (document) {
+            var part = document.featurePart(NUMBERING);
+            if (part instanceof NumberingPart) {
+                part.materializePending(document);
+            }
+        },
+    });
+}
+/**
+ * Numbering catalog for a document.
+ *
+ * On the default `@syncfusion/ej2-docx` entry, numbering is always-on: the package-part
+ * handler is registered at module load and re-armed via
+ * {@link registerAlwaysOnBodyFeatureBootstrap} before each
+ * {@link WordDocument.create} / load. On {@link WordDocument.create}, feature package
+ * parts are not pre-attached; this attaches an empty {@link NumberingPart} so
+ * authoring APIs (`createBulletInstance`, paragraph numbering) work without a load.
+ *
+ * @throws DocxError `feature/not-registered` when the numbering module was not
+ * registered (pure core path without the main entry / numbering subpath).
+ * @private
+ */
+export function numberingFor(document) {
+    var existing = document.featurePart(NUMBERING);
+    if (existing instanceof NumberingPart) {
+        return existing;
+    }
+    if (!isFeatureRegistered(NUMBERING) || existing !== undefined) {
+        throw new DocxError('feature/not-registered', 'Numbering part was not loaded; call registerNumberingFeature() before WordDocument.open');
+    }
+    var empty = new NumberingPart({ dirty: false });
+    document.setFeaturePart(NUMBERING, empty);
+    return empty;
+}
+/**
+ * @private Helper to apply numbering to a paragraph via the legacy numbering property.
+* methods instead; the numbering property remains
+ * for backward compatibility but is not the canonical public API.
+ */
+function applyParagraphNumbering(paragraph, value) {
+    if (value === undefined) {
+        paragraph.numId = undefined;
+        paragraph.listLevel = undefined;
+        return;
+    }
+    var numbering = numberingFor(paragraph.owningDocument());
+    var level = value.level != null ? value.level : 0;
+    var listId = value.numId;
+    if (numbering.getNumbering(listId) === undefined) {
+        if (numbering.hasInstance(listId)) {
+            numbering.registerPendingInstance(listId, 'bullet');
+        }
+        else {
+            numbering.ensureInstance(listId, 'bullet');
+        }
+    }
+    else {
+        numbering.registerPendingInstance(listId);
+    }
+    paragraph.numId = listId;
+    paragraph.listLevel = level;
+}
+Object.defineProperty(Paragraph.prototype, 'numbering', {
+    set: function (value) {
+        applyParagraphNumbering(this, value);
+    },
+});
+// Always-on on the main `@syncfusion/ej2-docx` entry: package-part handler for numbering.xml
+// re-arms after test handler resets via WordDocument.create / fromPackage.
+registerAlwaysOnBodyFeatureBootstrap(function () {
+    registerNumberingFeature();
+});
+registerNumberingFeature();