@syncfusion/ej2-docx 0.0.0-stage → 35.1.40

package/src/features/numbering/list-style.js

@@ -0,0 +1,1084 @@
+/**
+ * Custom list styles: ListStyle / ListLevel facades over numbering abstracts + styles.
+ *
+ * @public
+ */
+import { DocxError, InvalidArgumentError } from '../../core/errors/docx-error';
+import { WordDocument } from '../document/document';
+import { CharacterFormat, parseCharacterFormat, } from '../document/character-format';
+import { emptyParagraphFormatSnapshot, ParagraphFormat, } from '../document/paragraph-format';
+import { pointToTwips, twipsToPoint } from '../document/length';
+import { elementChildren, isWml, wmlAttr, wmlElement, wValAttribute } from '../document/wml';
+import { createDefaultAbstractNumbering } from './abstract-numbering';
+import { numberingFor } from './index';
+import { characterSnapshotFromRPr, paragraphSnapshotFromPPr, } from '../styles/style-format-bridge';
+import { DocxStyle } from '../styles/style';
+import { styleCollectionFor } from '../styles/index';
+function numberingCatalog(document) {
+    return numberingFor(document);
+}
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+/**
+ * High-level list category for {@link WordDocument.addListStyle}.
+ *
+ * @public
+ */
+export var ListType;
+(function (ListType) {
+    ListType["Bulleted"] = "bulleted";
+    ListType["Numbered"] = "numbered";
+})(ListType || (ListType = {}));
+/**
+ * Number / bullet pattern for a list level (`w:numFmt`).
+ *
+ * @public
+ */
+export var ListPatternType;
+(function (ListPatternType) {
+    ListPatternType["Arabic"] = "arabic";
+    ListPatternType["LeadingZero"] = "leadingZero";
+    ListPatternType["Letter"] = "letter";
+    ListPatternType["LetterLow"] = "letterLow";
+    ListPatternType["Roman"] = "roman";
+    ListPatternType["RomanLow"] = "romanLow";
+    ListPatternType["Ordinal"] = "ordinal";
+    ListPatternType["OrdinalText"] = "ordinalText";
+    ListPatternType["CardinalText"] = "cardinalText";
+    ListPatternType["Bullet"] = "bullet";
+    ListPatternType["NoNumber"] = "noNumber";
+    ListPatternType["FarEast"] = "farEast";
+    ListPatternType["Special"] = "special";
+    ListPatternType["Hebrew1"] = "hebrew1";
+    ListPatternType["Hebrew2"] = "hebrew2";
+    ListPatternType["HindiArabic"] = "hindiArabic";
+    ListPatternType["HindiCardinalText"] = "hindiCardinalText";
+    ListPatternType["HindiLetter1"] = "hindiLetter1";
+    ListPatternType["HindiLetter2"] = "hindiLetter2";
+    ListPatternType["ChineseCounting"] = "chineseCounting";
+    ListPatternType["ChineseCountingThousand"] = "chineseCountingThousand";
+    ListPatternType["ChineseLegalSimplified"] = "chineseLegalSimplified";
+    ListPatternType["JapaneseCounting"] = "japaneseCounting";
+    ListPatternType["JapaneseDigitalTenThousand"] = "japaneseDigitalTenThousand";
+    ListPatternType["JapaneseLegal"] = "japaneseLegal";
+    ListPatternType["KoreanCounting"] = "koreanCounting";
+    ListPatternType["KoreanDigital"] = "koreanDigital";
+    ListPatternType["KoreanDigital2"] = "koreanDigital2";
+    ListPatternType["KoreanLegal"] = "koreanLegal";
+    ListPatternType["Aiueo"] = "aiueo";
+    ListPatternType["AiueoFullWidth"] = "aiueoFullWidth";
+    ListPatternType["Iroha"] = "iroha";
+    ListPatternType["IrohaFullWidth"] = "irohaFullWidth";
+    ListPatternType["Ganada"] = "ganada";
+    ListPatternType["Chosung"] = "chosung";
+    ListPatternType["DecimalEnclosedCircle"] = "decimalEnclosedCircle";
+    ListPatternType["DecimalFullWidth"] = "decimalFullWidth";
+    ListPatternType["DecimalHalfWidth"] = "decimalHalfWidth";
+    ListPatternType["DecimalEnclosedFullstop"] = "decimalEnclosedFullstop";
+    ListPatternType["DecimalEnclosedParen"] = "decimalEnclosedParen";
+    ListPatternType["DecimalEnclosedCircleChinese"] = "decimalEnclosedCircleChinese";
+    ListPatternType["IdeographEnclosedCircle"] = "ideographEnclosedCircle";
+    ListPatternType["IdeographTraditional"] = "ideographTraditional";
+    ListPatternType["IdeographZodiac"] = "ideographZodiac";
+    ListPatternType["IdeographZodiacTraditional"] = "ideographZodiacTraditional";
+    ListPatternType["TaiwaneseCounting"] = "taiwaneseCounting";
+    ListPatternType["TaiwaneseCountingThousand"] = "taiwaneseCountingThousand";
+    ListPatternType["TaiwaneseDigital"] = "taiwaneseDigital";
+    ListPatternType["None"] = "none";
+    ListPatternType["Custom"] = "custom";
+})(ListPatternType || (ListPatternType = {}));
+/**
+ * Character inserted after the list label (`w:suff`).
+ *
+ * @public
+ */
+export var FollowCharacterType;
+(function (FollowCharacterType) {
+    FollowCharacterType["Tab"] = "tab";
+    FollowCharacterType["Space"] = "space";
+    FollowCharacterType["Nothing"] = "nothing";
+})(FollowCharacterType || (FollowCharacterType = {}));
+/**
+ * Horizontal alignment of the list number (`w:lvlJc`).
+ *
+ * @public
+ */
+export var ListNumberAlignment;
+(function (ListNumberAlignment) {
+    ListNumberAlignment["Left"] = "left";
+    ListNumberAlignment["Center"] = "center";
+    ListNumberAlignment["Right"] = "right";
+})(ListNumberAlignment || (ListNumberAlignment = {}));
+// ---------------------------------------------------------------------------
+// Pattern / wire maps
+// ---------------------------------------------------------------------------
+var PATTERN_TO_NUMFMT = {
+    arabic: 'decimal',
+    leadingZero: 'decimalZero',
+    letter: 'upperLetter',
+    letterLow: 'lowerLetter',
+    roman: 'upperRoman',
+    romanLow: 'lowerRoman',
+    ordinal: 'ordinal',
+    ordinalText: 'ordinalText',
+    cardinalText: 'cardinalText',
+    bullet: 'bullet',
+    noNumber: 'none',
+    none: 'none',
+    hebrew1: 'hebrew1',
+    hebrew2: 'hebrew2',
+    hindiArabic: 'hindiNumbers',
+    hindiCardinalText: 'hindiCounting',
+    hindiLetter1: 'hindiVowels',
+    hindiLetter2: 'hindiConsonants',
+    chineseCounting: 'chineseCounting',
+    chineseCountingThousand: 'chineseCountingThousand',
+    chineseLegalSimplified: 'chineseLegalSimplified',
+    japaneseCounting: 'japaneseCounting',
+    japaneseDigitalTenThousand: 'japaneseDigitalTenThousand',
+    japaneseLegal: 'japaneseLegal',
+    koreanCounting: 'koreanCounting',
+    koreanDigital: 'koreanDigital',
+    koreanDigital2: 'koreanDigital2',
+    koreanLegal: 'koreanLegal',
+    aiueo: 'aiueo',
+    aiueoFullWidth: 'aiueoFullWidth',
+    iroha: 'iroha',
+    irohaFullWidth: 'irohaFullWidth',
+    ganada: 'ganada',
+    chosung: 'chosung',
+    decimalEnclosedCircle: 'decimalEnclosedCircle',
+    decimalFullWidth: 'decimalFullWidth',
+    decimalHalfWidth: 'decimalHalfWidth',
+    decimalEnclosedFullstop: 'decimalEnclosedFullstop',
+    decimalEnclosedParen: 'decimalEnclosedParen',
+    decimalEnclosedCircleChinese: 'decimalEnclosedCircleChinese',
+    ideographEnclosedCircle: 'ideographEnclosedCircle',
+    ideographTraditional: 'ideographTraditional',
+    ideographZodiac: 'ideographZodiac',
+    ideographZodiacTraditional: 'ideographZodiacTraditional',
+    taiwaneseCounting: 'taiwaneseCounting',
+    taiwaneseCountingThousand: 'taiwaneseCountingThousand',
+    taiwaneseDigital: 'taiwaneseDigital',
+    farEast: 'ideographTraditional',
+    special: 'bullet',
+    custom: 'decimal',
+};
+var NUMFMT_TO_PATTERN = {
+    decimal: ListPatternType.Arabic,
+    decimalZero: ListPatternType.LeadingZero,
+    upperLetter: ListPatternType.Letter,
+    lowerLetter: ListPatternType.LetterLow,
+    upperRoman: ListPatternType.Roman,
+    lowerRoman: ListPatternType.RomanLow,
+    ordinal: ListPatternType.Ordinal,
+    ordinalText: ListPatternType.OrdinalText,
+    cardinalText: ListPatternType.CardinalText,
+    bullet: ListPatternType.Bullet,
+    none: ListPatternType.None,
+    hebrew1: ListPatternType.Hebrew1,
+    hebrew2: ListPatternType.Hebrew2,
+    hindiNumbers: ListPatternType.HindiArabic,
+    hindiCounting: ListPatternType.HindiCardinalText,
+    hindiVowels: ListPatternType.HindiLetter1,
+    hindiConsonants: ListPatternType.HindiLetter2,
+    chineseCounting: ListPatternType.ChineseCounting,
+    chineseCountingThousand: ListPatternType.ChineseCountingThousand,
+    chineseLegalSimplified: ListPatternType.ChineseLegalSimplified,
+    japaneseCounting: ListPatternType.JapaneseCounting,
+    japaneseDigitalTenThousand: ListPatternType.JapaneseDigitalTenThousand,
+    japaneseLegal: ListPatternType.JapaneseLegal,
+    koreanCounting: ListPatternType.KoreanCounting,
+    koreanDigital: ListPatternType.KoreanDigital,
+    koreanDigital2: ListPatternType.KoreanDigital2,
+    koreanLegal: ListPatternType.KoreanLegal,
+    aiueo: ListPatternType.Aiueo,
+    aiueoFullWidth: ListPatternType.AiueoFullWidth,
+    iroha: ListPatternType.Iroha,
+    irohaFullWidth: ListPatternType.IrohaFullWidth,
+    ganada: ListPatternType.Ganada,
+    chosung: ListPatternType.Chosung,
+    decimalEnclosedCircle: ListPatternType.DecimalEnclosedCircle,
+    decimalFullWidth: ListPatternType.DecimalFullWidth,
+    decimalHalfWidth: ListPatternType.DecimalHalfWidth,
+    decimalEnclosedFullstop: ListPatternType.DecimalEnclosedFullstop,
+    decimalEnclosedParen: ListPatternType.DecimalEnclosedParen,
+    decimalEnclosedCircleChinese: ListPatternType.DecimalEnclosedCircleChinese,
+    ideographEnclosedCircle: ListPatternType.IdeographEnclosedCircle,
+    ideographTraditional: ListPatternType.IdeographTraditional,
+    ideographZodiac: ListPatternType.IdeographZodiac,
+    ideographZodiacTraditional: ListPatternType.IdeographZodiacTraditional,
+    taiwaneseCounting: ListPatternType.TaiwaneseCounting,
+    taiwaneseCountingThousand: ListPatternType.TaiwaneseCountingThousand,
+    taiwaneseDigital: ListPatternType.TaiwaneseDigital,
+};
+function patternToNumFmt(pattern) {
+    var mapped = PATTERN_TO_NUMFMT[pattern];
+    if (mapped !== undefined) {
+        return mapped;
+    }
+    return 'decimal';
+}
+function numFmtToPattern(numFmt) {
+    if (numFmt === undefined || numFmt.length === 0) {
+        return ListPatternType.Arabic;
+    }
+    var mapped = NUMFMT_TO_PATTERN[numFmt];
+    if (mapped !== undefined) {
+        return mapped;
+    }
+    return ListPatternType.Custom;
+}
+function isListType(value) {
+    return value === ListType.Bulleted || value === ListType.Numbered;
+}
+function isListPatternType(value) {
+    for (var key in ListPatternType) {
+        if (!Object.prototype.hasOwnProperty.call(ListPatternType, key)) {
+            continue;
+        }
+        if (ListPatternType[key] === value) {
+            return true;
+        }
+    }
+    return false;
+}
+function isFollowCharacterType(value) {
+    return (value === FollowCharacterType.Tab ||
+        value === FollowCharacterType.Space ||
+        value === FollowCharacterType.Nothing);
+}
+function isListNumberAlignment(value) {
+    return (value === ListNumberAlignment.Left ||
+        value === ListNumberAlignment.Center ||
+        value === ListNumberAlignment.Right);
+}
+function assertFiniteNumber(name, value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new InvalidArgumentError(name + ' must be a finite number');
+    }
+}
+function assertNonNegativePoints(name, value) {
+    assertFiniteNumber(name, value);
+    if (value < 0) {
+        throw new InvalidArgumentError(name + ' must be a non-negative number of points');
+    }
+}
+function twipAttr(el, localName) {
+    if (el === undefined) {
+        return undefined;
+    }
+    for (var i = 0; i < el.attributes.length; i += 1) {
+        var attr = el.attributes[i];
+        if (attr !== undefined && attr.localName === localName) {
+            var n = parseInt(attr.value, 10);
+            if (Number.isFinite(n)) {
+                return n;
+            }
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function setTwipAttr(el, localName, twips) {
+    var attrs = el.attributes.slice();
+    var found = false;
+    for (var i = 0; i < attrs.length; i += 1) {
+        var attr = attrs[i];
+        if (attr !== undefined && attr.localName === localName) {
+            attrs[i] = wmlAttr(localName, String(twips));
+            found = true;
+            break;
+        }
+    }
+    if (!found) {
+        attrs.push(wmlAttr(localName, String(twips)));
+    }
+    return wmlElement(el.localName, {
+        attributes: attrs,
+        children: el.children.slice(),
+    });
+}
+function ensureIndInPPr(pPr) {
+    if (pPr === undefined) {
+        return wmlElement('pPr', {
+            children: [wmlElement('ind', { attributes: [] })],
+        });
+    }
+    var kids = elementChildren(pPr).slice();
+    var hasInd = false;
+    for (var i = 0; i < kids.length; i += 1) {
+        if (isWml(kids[i], 'ind')) {
+            hasInd = true;
+            break;
+        }
+    }
+    if (!hasInd) {
+        kids.push(wmlElement('ind', { attributes: [] }));
+    }
+    return wmlElement('pPr', {
+        attributes: pPr.attributes.slice(),
+        children: kids,
+    });
+}
+function findInd(pPr) {
+    if (pPr === undefined) {
+        return undefined;
+    }
+    var kids = elementChildren(pPr);
+    for (var i = 0; i < kids.length; i += 1) {
+        if (isWml(kids[i], 'ind')) {
+            return kids[i];
+        }
+    }
+    return undefined;
+}
+function replaceInd(pPr, ind) {
+    var kids = elementChildren(pPr).slice();
+    var replaced = false;
+    for (var i = 0; i < kids.length; i += 1) {
+        if (isWml(kids[i], 'ind')) {
+            kids[i] = ind;
+            replaced = true;
+            break;
+        }
+    }
+    if (!replaced) {
+        kids.push(ind);
+    }
+    return wmlElement('pPr', {
+        attributes: pPr.attributes.slice(),
+        children: kids,
+    });
+}
+/**
+ * Split `w:lvlText` around this level's own token (`%(ilvl+1)`).
+ * Nested prior-level tokens (`%1` in level 2's `%1.%2.%3.`) belong in the prefix.
+ * When `levelNumber` is omitted, falls back to the first `%n` (legacy).
+ */
+function splitLevelText(lvlText, levelNumber) {
+    if (lvlText === undefined || lvlText.length === 0) {
+        return { prefix: '', body: '', suffix: '' };
+    }
+    var match = null;
+    if (levelNumber !== undefined && levelNumber >= 0 && levelNumber <= 8) {
+        var token = '%' + String(levelNumber + 1);
+        var idx = lvlText.indexOf(token);
+        if (idx >= 0) {
+            return {
+                prefix: lvlText.substring(0, idx),
+                body: token,
+                suffix: lvlText.substring(idx + token.length),
+            };
+        }
+    }
+    match = /%([1-9])/.exec(lvlText);
+    if (match === null || match.index === undefined) {
+        return { prefix: '', body: lvlText, suffix: '' };
+    }
+    var start = match.index;
+    var end = start + match[0].length;
+    return {
+        prefix: lvlText.substring(0, start),
+        body: lvlText.substring(start, end),
+        suffix: lvlText.substring(end),
+    };
+}
+function rebuildLevelText(prefix, body, suffix) {
+    return prefix + body + suffix;
+}
+/**
+ * DocIO encodes prior-level placeholders in `NumberPrefix`/`NumberSuffix` as
+ * U+0000..U+0008 (level 0..8). OOXML `w:lvlText` uses `%1`..`%9`. Raw NULs are
+ * illegal in XML 1.0 attributes and corrupt the package — convert both ways.
+ */
+function docioLevelPlaceholdersToOoxml(value) {
+    var result = '';
+    for (var i = 0; i < value.length; i++) {
+        var code = value.charCodeAt(i);
+        if (code >= 0 && code <= 8) {
+            result += '%' + String(code + 1);
+        }
+        else {
+            result += value.charAt(i);
+        }
+    }
+    return result;
+}
+function ooxmlLevelPlaceholdersToDocio(value) {
+    var result = '';
+    var i = 0;
+    while (i < value.length) {
+        if (value.charAt(i) === '%' && i + 1 < value.length) {
+            var digit = value.charAt(i + 1);
+            if (digit >= '1' && digit <= '9') {
+                result += String.fromCharCode(digit.charCodeAt(0) - '1'.charCodeAt(0));
+                i += 2;
+                continue;
+            }
+        }
+        result += value.charAt(i);
+        i += 1;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// ListLevel
+// ---------------------------------------------------------------------------
+/**
+ * Live list level facade over a {@link NumberingLevel}.
+ *
+ * @public
+ */
+var ListLevel = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ListLevel(owner, level) {
+        this.owner = owner;
+        this.level = level;
+        this.suppressDirty = false;
+        this.characterFormatValue = new CharacterFormat(this);
+        this.paragraphFormatValue = new ParagraphFormat(this);
+        this.hydrateFormatsFromLevel();
+    }
+    Object.defineProperty(ListLevel.prototype, "listStyle", {
+        /** Owning list style. */
+        get: function () {
+            return this.owner;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "levelNumber", {
+        /** Zero-based level index. */
+        get: function () {
+            return this.level.ilvl;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "patternType", {
+        get: function () {
+            return numFmtToPattern(this.level.numFmt);
+        },
+        set: function (value) {
+            if (typeof value !== 'string' || !isListPatternType(value)) {
+                throw new InvalidArgumentError('patternType must be a ListPatternType value');
+            }
+            this.level.setNumFmt(patternToNumFmt(value));
+            if (value === ListPatternType.Bullet) {
+                var text = this.level.lvlText;
+                if (text === undefined || text.indexOf('%') >= 0) {
+                    this.level.setLvlText('\uf0b7');
+                }
+            }
+            else if (value !== ListPatternType.NoNumber && value !== ListPatternType.None) {
+                var parts = splitLevelText(this.level.lvlText, this.level.ilvl);
+                if (parts.body.length === 0 || parts.body.indexOf('%') < 0) {
+                    var token = '%' + String(this.level.ilvl + 1);
+                    this.level.setLvlText(rebuildLevelText(parts.prefix, token, parts.suffix.length > 0 ? parts.suffix : '.'));
+                }
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "startAt", {
+        get: function () {
+            var s = this.level.start;
+            return s !== undefined ? s : 1;
+        },
+        set: function (value) {
+            if (typeof value !== 'number' || !Number.isFinite(value) || Math.floor(value) !== value || value < 0) {
+                throw new InvalidArgumentError('startAt must be a non-negative integer');
+            }
+            this.level.setStart(value);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "levelText", {
+        get: function () {
+            var t = this.level.lvlText;
+            return t !== undefined ? t : '';
+        },
+        set: function (value) {
+            if (typeof value !== 'string') {
+                throw new InvalidArgumentError('levelText must be a string');
+            }
+            this.level.setLvlText(value);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "numberPrefix", {
+        get: function () {
+            return ooxmlLevelPlaceholdersToDocio(splitLevelText(this.level.lvlText, this.level.ilvl).prefix);
+        },
+        set: function (value) {
+            if (typeof value !== 'string') {
+                throw new InvalidArgumentError('numberPrefix must be a string');
+            }
+            var parts = splitLevelText(this.level.lvlText, this.level.ilvl);
+            var body = parts.body;
+            if (body.length === 0 || body.indexOf('%') < 0) {
+                body = this.level.numFmt === 'bullet' ? '\uf0b7' : '%' + String(this.level.ilvl + 1);
+            }
+            var prefix = docioLevelPlaceholdersToOoxml(value);
+            this.level.setLvlText(rebuildLevelText(prefix, body, parts.suffix));
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "numberSuffix", {
+        get: function () {
+            return ooxmlLevelPlaceholdersToDocio(splitLevelText(this.level.lvlText, this.level.ilvl).suffix);
+        },
+        set: function (value) {
+            if (typeof value !== 'string') {
+                throw new InvalidArgumentError('numberSuffix must be a string');
+            }
+            var parts = splitLevelText(this.level.lvlText, this.level.ilvl);
+            var body = parts.body;
+            if (body.length === 0 || body.indexOf('%') < 0) {
+                body = this.level.numFmt === 'bullet' ? '\uf0b7' : '%' + String(this.level.ilvl + 1);
+            }
+            var suffix = docioLevelPlaceholdersToOoxml(value);
+            this.level.setLvlText(rebuildLevelText(parts.prefix, body, suffix));
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "bulletCharacter", {
+        get: function () {
+            if (this.level.numFmt !== 'bullet') {
+                return '';
+            }
+            var t = this.level.lvlText;
+            return t !== undefined ? t : '';
+        },
+        set: function (value) {
+            if (typeof value !== 'string') {
+                throw new InvalidArgumentError('bulletCharacter must be a string');
+            }
+            this.level.setNumFmt('bullet');
+            this.level.setLvlText(value);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "followCharacter", {
+        get: function () {
+            var suff = this.level.findExtra('suff');
+            var val = suff !== undefined ? wValAttribute(suff) : undefined;
+            if (val === 'space') {
+                return FollowCharacterType.Space;
+            }
+            if (val === 'nothing') {
+                return FollowCharacterType.Nothing;
+            }
+            return FollowCharacterType.Tab;
+        },
+        set: function (value) {
+            if (typeof value !== 'string' || !isFollowCharacterType(value)) {
+                throw new InvalidArgumentError('followCharacter must be a FollowCharacterType value');
+            }
+            var wire = 'tab';
+            if (value === FollowCharacterType.Space) {
+                wire = 'space';
+            }
+            else if (value === FollowCharacterType.Nothing) {
+                wire = 'nothing';
+            }
+            this.level.setExtraElement('suff', wmlElement('suff', { attributes: [wmlAttr('val', wire)] }));
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "numberAlignment", {
+        get: function () {
+            var jc = this.level.lvlJc;
+            if (jc === 'center') {
+                return ListNumberAlignment.Center;
+            }
+            if (jc === 'right') {
+                return ListNumberAlignment.Right;
+            }
+            return ListNumberAlignment.Left;
+        },
+        set: function (value) {
+            if (typeof value !== 'string' || !isListNumberAlignment(value)) {
+                throw new InvalidArgumentError('numberAlignment must be a ListNumberAlignment value');
+            }
+            this.level.setLvlJc(value);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "tabSpaceAfter", {
+        get: function () {
+            var pPr = this.level.findExtra('pPr');
+            if (pPr === undefined) {
+                return 0;
+            }
+            var tabs = elementChildren(pPr);
+            for (var i = 0; i < tabs.length; i += 1) {
+                var child = tabs[i];
+                if (!isWml(child, 'tabs')) {
+                    continue;
+                }
+                var tabKids = elementChildren(child);
+                for (var j = 0; j < tabKids.length; j += 1) {
+                    var tab = tabKids[j];
+                    if (!isWml(tab, 'tab')) {
+                        continue;
+                    }
+                    var pos = twipAttr(tab, 'pos');
+                    if (pos !== undefined) {
+                        return twipsToPoint(pos);
+                    }
+                }
+            }
+            return 0;
+        },
+        set: function (value) {
+            assertNonNegativePoints('tabSpaceAfter', value);
+            var twips = pointToTwips(value);
+            var pPr = this.level.findExtra('pPr');
+            if (pPr === undefined) {
+                pPr = wmlElement('pPr', { children: [] });
+            }
+            var kids = elementChildren(pPr).slice().filter(function (el) { return !isWml(el, 'tabs'); });
+            kids.push(wmlElement('tabs', {
+                children: [
+                    wmlElement('tab', {
+                        attributes: [wmlAttr('val', 'left'), wmlAttr('pos', String(twips))],
+                    }),
+                ],
+            }));
+            this.level.setExtraElement('pPr', wmlElement('pPr', { attributes: pPr.attributes.slice(), children: kids }));
+            this.suppressDirty = true;
+            try {
+                this.paragraphFormatValue.hydrate(paragraphSnapshotFromPPr(this.level.findExtra('pPr')));
+            }
+            finally {
+                this.suppressDirty = false;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "numberPosition", {
+        get: function () {
+            var ind = findInd(this.level.findExtra('pPr'));
+            var left = twipAttr(ind, 'left');
+            var hanging = twipAttr(ind, 'hanging');
+            if (left === undefined) {
+                return 0;
+            }
+            var hang = hanging !== undefined ? hanging : 0;
+            return twipsToPoint(left - hang);
+        },
+        set: function (value) {
+            assertFiniteNumber('numberPosition', value);
+            var numberTwips = pointToTwips(value);
+            var pPr = ensureIndInPPr(this.level.findExtra('pPr'));
+            var ind = findInd(pPr);
+            var hanging = twipAttr(ind, 'hanging');
+            var hang = hanging !== undefined ? hanging : 0;
+            ind = setTwipAttr(ind, 'left', numberTwips + hang);
+            pPr = replaceInd(pPr, ind);
+            this.level.setExtraElement('pPr', pPr);
+            this.suppressDirty = true;
+            try {
+                this.paragraphFormatValue.hydrate(paragraphSnapshotFromPPr(pPr));
+            }
+            finally {
+                this.suppressDirty = false;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "textPosition", {
+        get: function () {
+            var ind = findInd(this.level.findExtra('pPr'));
+            var left = twipAttr(ind, 'left');
+            return left !== undefined ? twipsToPoint(left) : 0;
+        },
+        set: function (value) {
+            assertFiniteNumber('textPosition', value);
+            var leftTwips = pointToTwips(value);
+            var pPr = ensureIndInPPr(this.level.findExtra('pPr'));
+            var ind = findInd(pPr);
+            var numberPosTwips = pointToTwips(this.numberPosition);
+            var hanging = leftTwips - numberPosTwips;
+            if (hanging < 0) {
+                hanging = 0;
+            }
+            ind = setTwipAttr(ind, 'left', leftTwips);
+            ind = setTwipAttr(ind, 'hanging', hanging);
+            pPr = replaceInd(pPr, ind);
+            this.level.setExtraElement('pPr', pPr);
+            this.suppressDirty = true;
+            try {
+                this.paragraphFormatValue.hydrate(paragraphSnapshotFromPPr(pPr));
+            }
+            finally {
+                this.suppressDirty = false;
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "restartLevel", {
+        get: function () {
+            var el = this.level.findExtra('lvlRestart');
+            var val = el !== undefined ? wValAttribute(el) : undefined;
+            if (val === undefined || !/^\d+$/.test(val)) {
+                return this.level.ilvl;
+            }
+            return parseInt(val, 10);
+        },
+        set: function (value) {
+            if (typeof value !== 'number' || !Number.isFinite(value) || Math.floor(value) !== value || value < 0 || value > 8) {
+                throw new InvalidArgumentError('restartLevel must be an integer from 0 through 8');
+            }
+            this.level.setExtraElement('lvlRestart', wmlElement('lvlRestart', { attributes: [wmlAttr('val', String(value))] }));
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "isLegalStyleNumbering", {
+        get: function () {
+            return this.level.isLgl === true;
+        },
+        set: function (value) {
+            if (typeof value !== 'boolean') {
+                throw new InvalidArgumentError('isLegalStyleNumbering must be a boolean');
+            }
+            this.level.setIsLgl(value ? true : undefined);
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "linkedParagraphStyleName", {
+        get: function () {
+            var el = this.level.findExtra('pStyle');
+            var val = el !== undefined ? wValAttribute(el) : undefined;
+            return val !== undefined ? val : '';
+        },
+        set: function (value) {
+            if (typeof value !== 'string') {
+                throw new InvalidArgumentError('linkedParagraphStyleName must be a string');
+            }
+            var trimmed = value.trim();
+            if (trimmed.length === 0) {
+                this.level.setExtraElement('pStyle', undefined);
+            }
+            else {
+                this.level.setExtraElement('pStyle', wmlElement('pStyle', { attributes: [wmlAttr('val', trimmed)] }));
+            }
+            this.markDirty();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "characterFormat", {
+        get: function () {
+            return this.characterFormatValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListLevel.prototype, "paragraphFormat", {
+        get: function () {
+            return this.paragraphFormatValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** @private */
+    ListLevel.prototype.notifyCharacterFormatMutation = function () {
+        if (this.suppressDirty) {
+            return;
+        }
+        var children = this.characterFormatValue.buildRPrChildren
+            ? this.characterFormatValue.buildRPrChildren()
+            : undefined;
+        var rPrChildren = [];
+        if (children !== undefined) {
+            rPrChildren = children;
+        }
+        else {
+            var snap = this.characterFormatValue.snapshot
+                ? this.characterFormatValue.snapshot()
+                : undefined;
+            if (snap !== undefined) {
+                // Fall back: serialize via temporary rPr using existing parse path reverse
+                rPrChildren = buildRPrChildrenSafe(this.characterFormatValue);
+            }
+        }
+        if (rPrChildren.length === 0) {
+            this.level.setExtraElement('rPr', undefined);
+        }
+        else {
+            this.level.setExtraElement('rPr', wmlElement('rPr', { children: rPrChildren }));
+        }
+        this.markDirty();
+    };
+    /** @private */
+    ListLevel.prototype.notifyParagraphFormatMutation = function () {
+        if (this.suppressDirty) {
+            return;
+        }
+        var children = this.paragraphFormatValue.buildPPrChildren();
+        if (children.length === 0) {
+            this.level.setExtraElement('pPr', undefined);
+        }
+        else {
+            this.level.setExtraElement('pPr', wmlElement('pPr', { children: children }));
+        }
+        this.markDirty();
+    };
+    ListLevel.prototype.hydrateFormatsFromLevel = function () {
+        this.suppressDirty = true;
+        try {
+            var rPr = this.level.findExtra('rPr');
+            this.characterFormatValue.hydrate(rPr !== undefined ? characterSnapshotFromRPr(rPr) : parseCharacterFormat(wmlElement('rPr')));
+            var pPr = this.level.findExtra('pPr');
+            this.paragraphFormatValue.hydrate(pPr !== undefined ? paragraphSnapshotFromPPr(pPr) : emptyParagraphFormatSnapshot());
+        }
+        finally {
+            this.suppressDirty = false;
+        }
+    };
+    ListLevel.prototype.markDirty = function () {
+        this.owner.markNumberingDirty();
+    };
+    return ListLevel;
+}());
+export { ListLevel };
+function buildRPrChildrenSafe(cf) {
+    // CharacterFormat exposes buildRPrChildrenFromSnapshot on the class in this codebase.
+    var anyCf = cf;
+    if (typeof anyCf.buildRPrChildren === 'function') {
+        return anyCf.buildRPrChildren();
+    }
+    if (typeof anyCf.snapshot === 'function' && typeof anyCf.constructor.buildRPrChildrenFromSnapshot === 'function') {
+        return anyCf.constructor.buildRPrChildrenFromSnapshot(anyCf.snapshot());
+    }
+    // Try module-level pattern used elsewhere: serialize by re-reading after hydrate path
+    return [];
+}
+// ---------------------------------------------------------------------------
+// ListLevelCollection / ListStyle
+// ---------------------------------------------------------------------------
+/**
+ * Nine-level collection for a {@link ListStyle}.
+ *
+ * @public
+ */
+var ListLevelCollection = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ListLevelCollection(items) {
+        this.items = items;
+    }
+    Object.defineProperty(ListLevelCollection.prototype, "count", {
+        get: function () {
+            return this.items.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    ListLevelCollection.prototype.getItem = function (index) {
+        if (typeof index !== 'number' || !Number.isFinite(index) || Math.floor(index) !== index || index < 0 || index > 8) {
+            throw new InvalidArgumentError('level index must be an integer from 0 through 8');
+        }
+        var item = this.items[index];
+        if (item === undefined) {
+            throw new DocxError('content/invalid-num-id', 'List level ' + String(index) + ' is not defined');
+        }
+        return item;
+    };
+    return ListLevelCollection;
+}());
+export { ListLevelCollection };
+/**
+ * Public custom list style facade.
+ *
+ * @public
+ */
+var ListStyle = /** @class */ (function () {
+    /**
+     * @private
+     */
+    function ListStyle(init) {
+        this.document = init.document;
+        this.styleIdValue = init.styleId;
+        this.displayName = init.displayName;
+        this.listTypeValue = init.listType;
+        this.abstractNumId = init.abstractNumId;
+        this.levelsValue = new ListLevelCollection(init.levels);
+    }
+    Object.defineProperty(ListStyle.prototype, "name", {
+        get: function () {
+            return this.displayName;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListStyle.prototype, "listType", {
+        get: function () {
+            return this.listTypeValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListStyle.prototype, "levels", {
+        get: function () {
+            return this.levelsValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListStyle.prototype, "styleId", {
+        /** @private */
+        get: function () {
+            return this.styleIdValue;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ListStyle.prototype, "abstractId", {
+        /** @private */
+        get: function () {
+            return this.abstractNumId;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** @private */
+    ListStyle.prototype.markNumberingDirty = function () {
+        numberingCatalog(this.document).markDirty();
+    };
+    return ListStyle;
+}());
+export { ListStyle };
+var listStyleByAbstract = new WeakMap();
+/**
+ * Create a custom list style on the document.
+ *
+ * @public
+ */
+export function addListStyle(document, listType, styleName) {
+    if (typeof listType !== 'string' || !isListType(listType)) {
+        throw new InvalidArgumentError('listType must be ListType.Bulleted or ListType.Numbered');
+    }
+    if (typeof styleName !== 'string' || styleName.trim().length === 0) {
+        throw new InvalidArgumentError('styleName must be a non-empty string');
+    }
+    var name = styleName.trim();
+    var styles = styleCollectionFor(document);
+    if (styles.findByName(name) !== undefined || styles.getStyle(name) !== undefined) {
+        throw new DocxError('styles/duplicate-style', 'A style named "' + name + '" already exists');
+    }
+    var styleId = sanitizeStyleIdPublic(name);
+    if (styleId.length === 0) {
+        styleId = 'ListStyle';
+    }
+    if (styles.getStyle(styleId) !== undefined) {
+        throw new DocxError('styles/duplicate-style', 'A style with id "' + styleId + '" already exists');
+    }
+    var numbering = numberingCatalog(document);
+    var abstractNumId = numbering.allocateAbstractNumId();
+    var format = listType === ListType.Bulleted ? 'bullet' : 'decimal';
+    var abstract = createDefaultAbstractNumbering(abstractNumId, format);
+    abstract.setName(name);
+    abstract.setStyleLink(styleId);
+    numbering.registerAbstract(abstract);
+    var shell = new DocxStyle(styleId, 'numbering', undefined, true, [
+        wmlElement('name', { attributes: [wmlAttr('val', name)] }),
+    ]);
+    // Force OpaqueStyle numbering entry via addStyle
+    styles.addStyle(shell);
+    var live = styles.getStyle(styleId);
+    if (live === undefined) {
+        // addStyle may no-op if race; ensure via direct path
+        throw new DocxError('styles/undefined-style', 'Failed to register list style "' + name + '"');
+    }
+    var levelFacades = [];
+    var listStyle = new ListStyle({
+        document: document,
+        styleId: styleId,
+        displayName: name,
+        listType: listType,
+        abstractNumId: abstractNumId,
+        levels: levelFacades,
+    });
+    for (var i = 0; i < abstract.levels.length; i += 1) {
+        var lvl = abstract.levels[i];
+        levelFacades.push(new ListLevel(listStyle, lvl));
+    }
+    // Rebuild collection with filled levels
+    listStyle.levelsValue = new ListLevelCollection(levelFacades);
+    listStyleByAbstract.set(abstract, listStyle);
+    return listStyle;
+}
+function sanitizeStyleIdPublic(name) {
+    var out = '';
+    for (var i = 0; i < name.length; i += 1) {
+        var ch = name.charAt(i);
+        var code = name.charCodeAt(i);
+        var isLetter = (code >= 65 && code <= 90) ||
+            (code >= 97 && code <= 122) ||
+            code > 127;
+        var isDigit = code >= 48 && code <= 57;
+        if (isLetter || isDigit) {
+            out += ch;
+        }
+    }
+    return out;
+}
+/**
+ * Resolve abstract num id for a numbering style (styleLink / name).
+ *
+ * @private
+ */
+export function findAbstractForListStyle(numbering, styleId, displayName) {
+    for (var i = 0; i < numbering.abstractNumberings.length; i += 1) {
+        var abs = numbering.abstractNumberings[i];
+        if (abs.styleLink === styleId || (displayName !== undefined && abs.styleLink === displayName)) {
+            return abs.abstractNumId;
+        }
+        if (abs.name === styleId || (displayName !== undefined && abs.name === displayName)) {
+            return abs.abstractNumId;
+        }
+    }
+    return undefined;
+}
+// Wire WordDocument.addListStyle without importing numbering/index at module top.
+Object.defineProperty(WordDocument.prototype, 'addListStyle', {
+    value: function (listType, styleName) {
+        return addListStyle(this, listType, styleName);
+    },
+    writable: true,
+    configurable: true,
+});