@docx4j/core-ts 0.1.0 → 0.1.2

package/dist/model/listnumbering/formats.mjs

@@ -0,0 +1,320 @@
+import { log } from '../properties/log.mjs';
+// ---------------------------------------------------------------- the formatters
+/** docx4j `NumberFormatRomanAbstract`: 1 to 3999, nothing outside. */
+const ROMAN = [
+    [1000, 'm'], [900, 'cm'], [500, 'd'], [400, 'cd'], [100, 'c'], [90, 'xc'],
+    [50, 'l'], [40, 'xl'], [10, 'x'], [9, 'ix'], [5, 'v'], [4, 'iv'], [1, 'i'],
+];
+function romanLower(value) {
+    if (value >= 4000 || value < 1)
+        throw new RangeError('Numbers must be in range 1-3999');
+    let n = value;
+    let out = '';
+    for (const [number, letters] of ROMAN) {
+        while (n >= number) {
+            n -= number;
+            out += letters;
+        }
+    }
+    return out;
+}
+/**
+ * docx4j `NumberFormatAlphabet`: the n-th letter up to the alphabet's length, then that letter
+ * repeated - after z comes aa, bb, cc, not ab (ECMA-376 17.18.59, and Word).  The Cyrillic,
+ * Arabic and Thai sets are the ones Word's labels use, which leave out some letters of each
+ * script (Russian has no ё, й, ъ, ы, ь; Thai omits ฃ and ฅ).
+ */
+function alphabet(letters) {
+    const glyphs = Array.from(letters);
+    return (value) => {
+        if (value < 1)
+            throw new RangeError(`No letter for ${value}`);
+        const size = glyphs.length;
+        return glyphs[(value - 1) % size].repeat(Math.floor((value - 1) / size) + 1);
+    };
+}
+/** docx4j `NumberFormatDigits`: a decimal label in another script's digits. */
+function digits(ten) {
+    const glyphs = Array.from(ten);
+    if (glyphs.length !== 10)
+        throw new Error('ten digits expected');
+    return (value) => String(value).replace(/[0-9]/g, (c) => glyphs[c.charCodeAt(0) - 48]);
+}
+/** docx4j `NumberFormatDecimalZero`: 01, 02 ... 09, 10. */
+function decimalZero(value) {
+    return value < 10 ? `0${value}` : String(value);
+}
+/** docx4j `NumberFormatOrdinal`: 1st, 2nd, 3rd, 4th, 11th, 21st, 101st, 111th. */
+function ordinal(value) {
+    return `${value}${ordinalSuffix(value)}`;
+}
+function ordinalSuffix(n) {
+    const abs = Math.abs(n);
+    const lastTwo = abs % 100;
+    if (lastTwo >= 11 && lastTwo <= 13)
+        return 'th';
+    switch (abs % 10) {
+        case 1: return 'st';
+        case 2: return 'nd';
+        case 3: return 'rd';
+        default: return 'th';
+    }
+}
+const ONES = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine',
+    'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen',
+    'Eighteen', 'Nineteen'];
+const TENS = ['', '', 'Twenty', 'Thirty', 'Forty', 'Fifty', 'Sixty', 'Seventy', 'Eighty', 'Ninety'];
+const SCALES = ['', 'Thousand', 'Million', 'Billion'];
+const ORDINAL_ONES = ['Zeroth', 'First', 'Second', 'Third', 'Fourth', 'Fifth', 'Sixth', 'Seventh',
+    'Eighth', 'Ninth', 'Tenth', 'Eleventh', 'Twelfth', 'Thirteenth', 'Fourteenth', 'Fifteenth',
+    'Sixteenth', 'Seventeenth', 'Eighteenth', 'Nineteenth'];
+/** docx4j `NumberFormatCardinalText.words`: the cardinal words, every word capitalised. */
+function cardinalWords(value) {
+    if (value < 20)
+        return ONES[value];
+    let n = value;
+    const groups = [];
+    while (n > 0) {
+        groups.push(n % 1000);
+        n = Math.floor(n / 1000);
+    }
+    let out = '';
+    for (let i = groups.length - 1; i >= 0; i--) {
+        if (groups[i] === 0)
+            continue;
+        if (out.length > 0)
+            out += ' ';
+        out += belowThousand(groups[i]);
+        if (i > 0)
+            out += ` ${SCALES[i]}`;
+    }
+    return out;
+}
+function belowThousand(n) {
+    let out = '';
+    let rest = n;
+    if (rest >= 100) {
+        out += `${ONES[Math.floor(rest / 100)]} Hundred`;
+        rest %= 100;
+        if (rest > 0)
+            out += ' ';
+    }
+    if (rest >= 20) {
+        out += TENS[Math.floor(rest / 10)];
+        if (rest % 10 > 0)
+            out += `-${ONES[rest % 10]}`;
+    }
+    else if (rest > 0) {
+        out += ONES[rest];
+    }
+    return out;
+}
+/** docx4j `NumberFormatCardinalText`: One, Twenty-One, One Hundred One, One Thousand. */
+function cardinalText(value) {
+    if (value < 0)
+        throw new RangeError(`No words for ${value}`);
+    return cardinalWords(value);
+}
+/** docx4j `NumberFormatOrdinalText`: the cardinal words with the last word made ordinal. */
+function ordinalText(value) {
+    if (value < 0)
+        throw new RangeError(`No words for ${value}`);
+    const cardinal = cardinalWords(value);
+    const cut = Math.max(cardinal.lastIndexOf(' '), cardinal.lastIndexOf('-'));
+    const head = cut < 0 ? '' : cardinal.slice(0, cut + 1);
+    return head + ordinalWord(cardinal.slice(cut + 1));
+}
+function ordinalWord(word) {
+    const index = ONES.indexOf(word);
+    if (index >= 0)
+        return ORDINAL_ONES[index];
+    if (word.endsWith('y'))
+        return `${word.slice(0, -1)}ieth`; // Twenty -> Twentieth
+    return `${word}th`; // Hundred, Thousand, Million
+}
+/** docx4j `NumberFormatChicago`: * † ‡ §, then doubled, then tripled. */
+const CHICAGO_SYMBOLS = ['*', '†', '‡', '§'];
+function chicago(value) {
+    if (value < 1)
+        throw new RangeError(`No symbol for ${value}`);
+    const symbol = CHICAGO_SYMBOLS[(value - 1) % CHICAGO_SYMBOLS.length];
+    return symbol.repeat(Math.floor((value - 1) / CHICAGO_SYMBOLS.length) + 1);
+}
+const CIRCLED = ['①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧',
+    '⑨', '⑩', '⑪', '⑫', '⑬', '⑭', '⑮', '⑯', '⑰',
+    '⑱', '⑲', '⑳'];
+/** docx4j `NumberFormatDecimalEnclosedCircle`: ① to ⑳, and nothing above. */
+function decimalEnclosedCircle(value) {
+    if (value <= 0 || value > 20)
+        throw new RangeError('Numbers must be in range 1-20');
+    return CIRCLED[value - 1];
+}
+const HEBREW_UNITS = ['א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט'];
+const HEBREW_TENS = ['י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ'];
+const HEBREW_HUNDREDS = ['ק', 'ר', 'ש', 'ת'];
+/** docx4j `NumberFormatHebrew1`: טו and טז for 15 and 16, ת repeated above 400, no gershayim. */
+function hebrew1(value) {
+    if (value < 1)
+        throw new RangeError(`No Hebrew numeral for ${value}`);
+    let out = '';
+    let n = value;
+    while (n >= 400) {
+        out += 'ת';
+        n -= 400;
+    }
+    if (n >= 100) {
+        out += HEBREW_HUNDREDS[Math.floor(n / 100) - 1];
+        n %= 100;
+    }
+    if (n === 15)
+        return `${out}טו`;
+    if (n === 16)
+        return `${out}טז`;
+    if (n >= 10) {
+        out += HEBREW_TENS[Math.floor(n / 10) - 1];
+        n %= 10;
+    }
+    if (n > 0)
+        out += HEBREW_UNITS[n - 1];
+    return out;
+}
+/** docx4j `NumberFormatChineseAbstract`, with the lower or the legal (upper) characters. */
+function chinese(characters, units, bigUnits) {
+    const fourDigit = (num) => {
+        let out = '';
+        let n = num;
+        let unitPosition = 0;
+        let lastIsZero = false;
+        while (n > 0) {
+            const digit = n % 10;
+            if (digit !== 0) {
+                out = `${characters[digit]}${units[unitPosition]}${out}`;
+                lastIsZero = false;
+            }
+            else if (!lastIsZero) {
+                out = `${characters[0]}${out}`;
+                lastIsZero = true;
+            }
+            n = Math.floor(n / 10);
+            unitPosition++;
+        }
+        // remove the trailing 零
+        if (out.endsWith(characters[0]))
+            out = out.slice(0, -characters[0].length);
+        return out;
+    };
+    return (value) => {
+        if (value === 0)
+            return characters[0];
+        let out = '';
+        let n = value;
+        let bigUnitPosition = 0;
+        let lastIsZero = false;
+        while (n > 0) {
+            const part = n % 10000;
+            if (part !== 0) {
+                out = `${fourDigit(part)}${bigUnitPosition > 0 ? bigUnits[bigUnitPosition] : ''}${out}`;
+                lastIsZero = false;
+            }
+            else if (!lastIsZero && out.length > 0) {
+                out = `${characters[0]}${out}`;
+                lastIsZero = true;
+            }
+            n = Math.floor(n / 10000);
+            bigUnitPosition++;
+        }
+        return out;
+    };
+}
+const chineseLower = chinese(['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'], ['', '十', '百', '千'], ['', '万', '亿']);
+const chineseUpper = chinese(['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'], ['', '拾', '佰', '仟'], ['', '万', '亿']);
+const decimal = (value) => String(value);
+// ---------------------------------------------------------------- the registry
+/** `w:numFmt` -> its formatter. docx4j `NumberFormatter.REGISTRY`. */
+const REGISTRY = new Map([
+    ['decimal', decimal],
+    ['decimalHalfWidth', decimal],
+    ['none', () => ''],
+    // TODO (docx4j's own): revisit; the code elsewhere for bullets overlaps with this numFmt stuff
+    ['bullet', () => '*'],
+    ['upperRoman', (v) => romanLower(v).toUpperCase()],
+    ['lowerRoman', romanLower],
+    ['lowerLetter', alphabet('abcdefghijklmnopqrstuvwxyz')],
+    ['upperLetter', alphabet('ABCDEFGHIJKLMNOPQRSTUVWXYZ')],
+    ['decimalZero', decimalZero],
+    ['ordinal', ordinal],
+    ['cardinalText', cardinalText],
+    ['ordinalText', ordinalText],
+    ['hex', (v) => (v >>> 0).toString(16).toUpperCase()],
+    ['chicago', chicago],
+    ['numberInDash', (v) => `- ${v} -`],
+    ['decimalFullWidth', digits('０１２３４５６７８９')],
+    ['decimalFullWidth2', digits('０１２３４５６７８９')],
+    ['thaiNumbers', digits('๐๑๒๓๔๕๖๗๘๙')],
+    ['hindiNumbers', digits('०१२३४५६७८९')],
+    ['russianLower', alphabet('абвгдежзиклмнопрстуфхцчшщэюя')],
+    ['russianUpper', alphabet('АБВГДЕЖЗИКЛМНОПРСТУФХЦЧШЩЭЮЯ')],
+    ['arabicAlpha', alphabet('أبتثجحخدذرزسشصضطظعغفقكلمنهوي')],
+    ['thaiLetters', alphabet('กขคฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรลวศษสหฬอฮ')],
+    ['hebrew1', hebrew1],
+    // these two are the same in Chinese, no need to be processed separately
+    ['chineseCounting', chineseLower],
+    ['chineseCountingThousand', chineseLower],
+    // this one means use upper Chinese number characters
+    ['chineseLegalSimplified', chineseUpper],
+    // these two are the same, just to adapt to documents in Chinese
+    ['decimalEnclosedCircle', decimalEnclosedCircle],
+    ['decimalEnclosedCircleChinese', decimalEnclosedCircle],
+]);
+/** The formats warned about already: one warning per format, whatever the value or document. */
+const WARNED = new Set();
+/** Adds or replaces the formatter for a `w:numFmt`; `undefined` removes it. docx4j `register`. */
+export function register(numFmt, formatter) {
+    if (formatter === undefined)
+        REGISTRY.delete(numFmt);
+    else
+        REGISTRY.set(numFmt, formatter);
+}
+/** The formatter registered for a `w:numFmt`, or undefined. docx4j `NumberFormatter.get`. */
+export function formatterFor(numFmt) {
+    return numFmt === undefined ? undefined : REGISTRY.get(numFmt);
+}
+/** Every `w:numFmt` this package can format (a test's, and a caller's, inventory). */
+export function registeredFormats() {
+    return [...REGISTRY.keys()];
+}
+/** Forgets which formats have been warned about; a test that asserts on the warning needs it. */
+export function resetWarnings() {
+    WARNED.clear();
+}
+/**
+ * A counter as its label. docx4j `NumberFormatter.getCurrentValueFormatted(numFmt, current, where)`.
+ *
+ * A `w:numFmt` of undefined is decimal; so is a format with no formatter, and a value the
+ * formatter cannot express - with one warning per format naming `where` ("numId 3 ilvl 0") it
+ * first happened.
+ */
+export function formatValue(numFmt, value, where) {
+    if (numFmt === undefined)
+        return String(value);
+    const formatter = REGISTRY.get(numFmt);
+    if (formatter === undefined) {
+        warnOnce(numFmt, `no formatter for numFmt ${numFmt}; decimal labels used`, where);
+        return String(value);
+    }
+    try {
+        return formatter(value);
+    }
+    catch (e) {
+        if (!(e instanceof RangeError))
+            throw e;
+        warnOnce(numFmt, `numFmt ${numFmt} cannot express ${value} (${e.message}); decimal label used`, where);
+        return String(value);
+    }
+}
+function warnOnce(numFmt, message, where) {
+    if (WARNED.has(numFmt))
+        return;
+    WARNED.add(numFmt);
+    log.warn(`${message}${where === undefined ? '' : ` (first at ${where})`}; not reported again for this format`);
+}

package/dist/model/listnumbering/index.d.mts

@@ -0,0 +1,4 @@
+export { LEVELS, LevelDefinition, AbstractListDefinition, ListDefinition, NumberingDefinitions, type StyleLookup, } from './definitions.mjs';
+export { Counter, NumberingState, NumberingStates, storyKindOf, type PartLike, type StoryKind, } from './state.mjs';
+export { formatValue, formatterFor, register, registeredFormats, resetWarnings, type LabelFormatter, } from './formats.mjs';
+export { Emulator, NumRef, type NumberingResult, type NumberedPackageLike, type NumberingPartLike, } from './Emulator.mjs';

package/dist/model/listnumbering/index.mjs

@@ -0,0 +1,15 @@
+// CR-001 Phase B step 3: list numbering (docx4j `org.docx4j.model.listnumbering`, as CR-014
+// settled it against Word).
+//
+// The split is the one docx4j-python's port uses, so that the two read alike:
+//
+//   definitions.mts  what a list *is*: `LevelDefinition`, `AbstractListDefinition`,
+//                    `ListDefinition`, and `NumberingDefinitions` over one `w:numbering`
+//   state.mts        what it is *up to*: `Counter`, `NumberingState` (one per story of one
+//                    traversal), `NumberingStates`
+//   formats.mts      the `w:numFmt` registry, fail-soft to decimal as Word is
+//   Emulator.mts     the resolution (through `PropertyResolver`) and the counting
+export { LEVELS, LevelDefinition, AbstractListDefinition, ListDefinition, NumberingDefinitions, } from './definitions.mjs';
+export { Counter, NumberingState, NumberingStates, storyKindOf, } from './state.mjs';
+export { formatValue, formatterFor, register, registeredFormats, resetWarnings, } from './formats.mjs';
+export { Emulator, NumRef, } from './Emulator.mjs';

package/dist/model/listnumbering/state.d.mts

@@ -0,0 +1,97 @@
+/** One level's count in one {@link NumberingState}. docx4j `ListLevel.Counter`. */
+export declare class Counter {
+    /** The current count. */
+    value: number;
+    /** The level has been counted in this state; its start value is spent. */
+    encounteredAlready: boolean;
+    /**
+     * A shallower level reset it: it holds its start value, and the next use of the level takes
+     * that value rather than incrementing (CR-014 probe P8, measured - a level-2 item straight
+     * after a level-0 one reads "2.1.1", where a counter left at start-1 read "2.0.1").
+     */
+    resetPending: boolean;
+    constructor(value?: number);
+    /** One more item at this level. */
+    increment(): void;
+    /** An independent copy; what {@link NumberingState.copy} is made of. */
+    copy(): Counter;
+    toString(): string;
+}
+/**
+ * The counters of one story of one traversal. docx4j `NumberingState`.
+ *
+ * Not shared: one state belongs to one walk of one story.
+ */
+export declare class NumberingState {
+    private readonly byLevel;
+    private readonly overridesApplied;
+    /**
+     * The counter of a level of an abstract list, created at `initial` (the level's start value
+     * less one) on first use.
+     */
+    counter(abstractNumId: string, ilvl: string, initial: number | undefined): Counter;
+    /**
+     * Every counter this story stands at, keyed `"<abstractNumId>/<ilvl>"`. docx4j
+     * `NumberingState.counters()`, one of the parity accessors it made public in 17.1.1 so that a
+     * port can be held to the *counters* and not only to the labels. The live map, as docx4j's
+     * unmodifiable view is of the live one: do not hold it across a later `getNumber`.
+     */
+    get counters(): ReadonlyMap<string, Counter>;
+    /**
+     * The `w:num` start overrides spent, keyed `"<numId>/<ilvl>"`. docx4j
+     * `NumberingState.startOverridesApplied()`. A `w:num`'s first use at a level is recorded here
+     * whether or not it carries a `w:startOverride`, which is docx4j's own behaviour (the flag is
+     * set wherever the counter takes a start value), and what its goldens show.
+     */
+    get startOverridesApplied(): ReadonlySet<string>;
+    /** Whether this `w:num`'s `w:startOverride` has been spent at a level. */
+    startOverrideApplied(numId: string, ilvl: string): boolean;
+    /** Remember that it has. */
+    markStartOverrideApplied(numId: string, ilvl: string): void;
+    /** Every list starts again, as at the head of a story. */
+    reset(): void;
+    /** Nothing has been numbered in this state yet. */
+    get isEmpty(): boolean;
+    /** An independent copy: what `Emulator.peek` numbers against. */
+    copy(): NumberingState;
+    toString(): string;
+}
+/** As much of a `Part` as {@link NumberingStates.forPart} reads. */
+export interface PartLike {
+    readonly contentType: string;
+}
+/** Which story a part's paragraphs number in. */
+export type StoryKind = 'main' | 'headersFooters' | 'own';
+/**
+ * The story a part belongs to, by content type (never by class, so that this module imports no
+ * part): every header and footer is one story, the footnotes, endnotes and comments parts each
+ * their own, everything else the main story.
+ */
+export declare function storyKindOf(part: PartLike | undefined): StoryKind;
+/**
+ * The numbering states of one traversal, one per story. docx4j `NumberingStates`.
+ *
+ * Word numbers each story from its own counters (CR-014 probe P7, measured 2026-09-12): the body
+ * is one story; a section's header and footer share one (header 1 2 3, footer 4 5 6); the
+ * footnotes part is one (the second footnote continues the first's count); the endnotes part
+ * another; each text box and each comment counts on its own; and the body's count runs past all
+ * of them untouched.
+ *
+ * Only one section was probed, so headers and footers of every section are folded into one story
+ * here until a document says otherwise.
+ */
+export declare class NumberingStates {
+    private readonly mainState;
+    private headersFooters;
+    private readonly byPart;
+    /** The main document's story. */
+    main(): NumberingState;
+    /**
+     * The story the given part's paragraphs number in: the main document (also for undefined, and
+     * for any part not listed in {@link storyKindOf}), the one shared by headers and footers, or
+     * the footnotes, endnotes or comments part's own.
+     */
+    forPart(part: PartLike | undefined): NumberingState;
+    /** A fresh story: a text box's, or a comment's when comments are numbered one by one. */
+    newStory(): NumberingState;
+}

package/dist/model/listnumbering/state.mjs

@@ -0,0 +1,179 @@
+// The counters (docx4j `NumberingState` and `NumberingStates`, CR-014 phase 4).
+//
+// Definitions hold no counters: a traversal owns its states, one per **story**, and passes the
+// right one to the `Emulator`.  So two walks of one package do not interleave, a footer's list
+// starts at its own start whenever the footer is read, and `Emulator.peek` can ask what a
+// paragraph's number would be without taking it.
+//
+// Counters are keyed by the **referencing** `w:abstractNum` and the level, which is the sharing
+// rule Word applies: every `w:num` over one abstract definition continues a single sequence
+// (CR-014 probe P1, measured), and a `w:numStyleLink` abstract definition is a list of its own
+// (P2).  A `w:num` with a `w:startOverride` for a level resets that shared counter the first
+// time that `w:num` is met at that level, in this story.
+import { ContentTypes } from '../../opc/ContentTypes.mjs';
+/** One level's count in one {@link NumberingState}. docx4j `ListLevel.Counter`. */
+export class Counter {
+    constructor(value = 0) {
+        /** The level has been counted in this state; its start value is spent. */
+        this.encounteredAlready = false;
+        /**
+         * A shallower level reset it: it holds its start value, and the next use of the level takes
+         * that value rather than incrementing (CR-014 probe P8, measured - a level-2 item straight
+         * after a level-0 one reads "2.1.1", where a counter left at start-1 read "2.0.1").
+         */
+        this.resetPending = false;
+        this.value = value;
+    }
+    /** One more item at this level. */
+    increment() {
+        this.value += 1;
+    }
+    /** An independent copy; what {@link NumberingState.copy} is made of. */
+    copy() {
+        const other = new Counter(this.value);
+        other.encounteredAlready = this.encounteredAlready;
+        other.resetPending = this.resetPending;
+        return other;
+    }
+    toString() {
+        return `${this.value}${this.encounteredAlready ? '' : ' (unused)'}${this.resetPending ? ' (reset)' : ''}`;
+    }
+}
+/**
+ * The counters of one story of one traversal. docx4j `NumberingState`.
+ *
+ * Not shared: one state belongs to one walk of one story.
+ */
+export class NumberingState {
+    constructor() {
+        this.byLevel = new Map();
+        this.overridesApplied = new Set();
+    }
+    /**
+     * The counter of a level of an abstract list, created at `initial` (the level's start value
+     * less one) on first use.
+     */
+    counter(abstractNumId, ilvl, initial) {
+        const key = `${abstractNumId}/${ilvl}`;
+        let found = this.byLevel.get(key);
+        if (found === undefined) {
+            found = new Counter(initial !== null && initial !== void 0 ? initial : 0);
+            this.byLevel.set(key, found);
+        }
+        return found;
+    }
+    /**
+     * Every counter this story stands at, keyed `"<abstractNumId>/<ilvl>"`. docx4j
+     * `NumberingState.counters()`, one of the parity accessors it made public in 17.1.1 so that a
+     * port can be held to the *counters* and not only to the labels. The live map, as docx4j's
+     * unmodifiable view is of the live one: do not hold it across a later `getNumber`.
+     */
+    get counters() {
+        return this.byLevel;
+    }
+    /**
+     * The `w:num` start overrides spent, keyed `"<numId>/<ilvl>"`. docx4j
+     * `NumberingState.startOverridesApplied()`. A `w:num`'s first use at a level is recorded here
+     * whether or not it carries a `w:startOverride`, which is docx4j's own behaviour (the flag is
+     * set wherever the counter takes a start value), and what its goldens show.
+     */
+    get startOverridesApplied() {
+        return this.overridesApplied;
+    }
+    /** Whether this `w:num`'s `w:startOverride` has been spent at a level. */
+    startOverrideApplied(numId, ilvl) {
+        return this.overridesApplied.has(`${numId}/${ilvl}`);
+    }
+    /** Remember that it has. */
+    markStartOverrideApplied(numId, ilvl) {
+        this.overridesApplied.add(`${numId}/${ilvl}`);
+    }
+    /** Every list starts again, as at the head of a story. */
+    reset() {
+        this.byLevel.clear();
+        this.overridesApplied.clear();
+    }
+    /** Nothing has been numbered in this state yet. */
+    get isEmpty() {
+        return this.byLevel.size === 0 && this.overridesApplied.size === 0;
+    }
+    /** An independent copy: what `Emulator.peek` numbers against. */
+    copy() {
+        const other = new NumberingState();
+        for (const [key, counter] of this.byLevel)
+            other.byLevel.set(key, counter.copy());
+        for (const key of this.overridesApplied)
+            other.overridesApplied.add(key);
+        return other;
+    }
+    toString() {
+        return `NumberingState(${[...this.byLevel].map(([k, c]) => `${k}=${c}`).join(', ')})`;
+    }
+}
+/**
+ * The story a part belongs to, by content type (never by class, so that this module imports no
+ * part): every header and footer is one story, the footnotes, endnotes and comments parts each
+ * their own, everything else the main story.
+ */
+export function storyKindOf(part) {
+    switch (part === null || part === void 0 ? void 0 : part.contentType) {
+        case ContentTypes.WORDPROCESSINGML_HEADER:
+        case ContentTypes.WORDPROCESSINGML_FOOTER:
+            return 'headersFooters';
+        case ContentTypes.WORDPROCESSINGML_FOOTNOTES:
+        case ContentTypes.WORDPROCESSINGML_ENDNOTES:
+        case ContentTypes.WORDPROCESSINGML_COMMENTS:
+            return 'own';
+        default:
+            return 'main';
+    }
+}
+/**
+ * The numbering states of one traversal, one per story. docx4j `NumberingStates`.
+ *
+ * Word numbers each story from its own counters (CR-014 probe P7, measured 2026-09-12): the body
+ * is one story; a section's header and footer share one (header 1 2 3, footer 4 5 6); the
+ * footnotes part is one (the second footnote continues the first's count); the endnotes part
+ * another; each text box and each comment counts on its own; and the body's count runs past all
+ * of them untouched.
+ *
+ * Only one section was probed, so headers and footers of every section are folded into one story
+ * here until a document says otherwise.
+ */
+export class NumberingStates {
+    constructor() {
+        this.mainState = new NumberingState();
+        this.byPart = new Map();
+    }
+    /** The main document's story. */
+    main() {
+        return this.mainState;
+    }
+    /**
+     * The story the given part's paragraphs number in: the main document (also for undefined, and
+     * for any part not listed in {@link storyKindOf}), the one shared by headers and footers, or
+     * the footnotes, endnotes or comments part's own.
+     */
+    forPart(part) {
+        var _a;
+        switch (storyKindOf(part)) {
+            case 'headersFooters':
+                (_a = this.headersFooters) !== null && _a !== void 0 ? _a : (this.headersFooters = new NumberingState());
+                return this.headersFooters;
+            case 'own': {
+                let found = this.byPart.get(part);
+                if (found === undefined) {
+                    found = new NumberingState();
+                    this.byPart.set(part, found);
+                }
+                return found;
+            }
+            default:
+                return this.mainState;
+        }
+    }
+    /** A fresh story: a text box's, or a comment's when comments are numbered one by one. */
+    newStory() {
+        return new NumberingState();
+    }
+}