@portone/docx-editor 0.2.1 → 0.4.0

package/dist/numbering/markers.js

@@ -3,71 +3,31 @@ import { listFor } from "./listTemplate.js";
 import {
   levelIndentPt
 } from "./parseNumbering.js";
-var ROMAN = [
-  [1e3, "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 toRoman(value) {
-  let rest = value;
-  let out = "";
-  for (const [amount, sign] of ROMAN) {
-    while (rest >= amount) {
-      out += sign;
-      rest -= amount;
-    }
-  }
-  return out;
-}
-function toLetters(value) {
-  const index = (value - 1) % 26;
-  const repeat = Math.floor((value - 1) / 26) + 1;
-  return String.fromCharCode(65 + index).repeat(repeat);
-}
+import { spellNumber } from "./spellers.js";
 var MAX_MARKER_CHARS = 64;
-var MAX_SPELLED_VALUE = {
-  decimal: Number.POSITIVE_INFINITY,
-  bullet: Number.POSITIVE_INFINITY,
-  lowerLetter: 26 * MAX_MARKER_CHARS,
-  upperLetter: 26 * MAX_MARKER_CHARS,
-  lowerRoman: 1e3 * MAX_MARKER_CHARS
-};
-function formatNumber(value, format) {
-  if (value < 1 || value > MAX_SPELLED_VALUE[format]) return `${value}`;
-  switch (format) {
-    case "lowerLetter":
-      return toLetters(value).toLowerCase();
-    case "upperLetter":
-      return toLetters(value);
-    case "lowerRoman":
-      return toRoman(value).toLowerCase();
-    default:
-      return `${value}`;
-  }
-}
-function fillLevels(text, list, counters) {
+function fillLevels(text, list, counters, legal) {
   return text.replaceAll(/%([1-9])/g, (_, digit) => {
     const ilvl = Number(digit) - 1;
     const level = list.levels.get(ilvl);
     if (!level) return "";
-    return formatNumber(counters.get(ilvl) ?? level.start, level.format);
+    const count = counters.get(ilvl) ?? level.start;
+    return spellNumber(
+      count,
+      legal ? "decimal" : level.format,
+      MAX_MARKER_CHARS
+    );
   });
 }
+function restartedBy(level, ilvl) {
+  return level?.restartAfterLevel ?? ilvl - 1;
+}
 function advance(counters, list, ilvl, start) {
   const current = counters.get(ilvl);
   counters.set(ilvl, current === void 0 ? start : current + 1);
   for (const deeper of [...counters.keys(), ...list.levels.keys()]) {
-    if (deeper > ilvl) counters.delete(deeper);
+    if (deeper > ilvl && restartedBy(list.levels.get(deeper), deeper) >= ilvl) {
+      counters.delete(deeper);
+    }
   }
 }
 var MARKER_SEGMENTER = new Intl.Segmenter();
@@ -87,17 +47,24 @@ function computeMarkers(paragraphs, numbering) {
   return paragraphs.map((ref) => {
     if (!ref) return null;
     const list = listFor(numbering, ref.numId);
-    const level = list.levels.get(ref.ilvl);
-    if (!level) return null;
+    const level = list?.levels.get(ref.ilvl);
+    if (!list || !level) return null;
     let counters = countersByList.get(ref.numId);
     if (!counters) {
       counters = /* @__PURE__ */ new Map();
       countersByList.set(ref.numId, counters);
     }
     advance(counters, list, ref.ilvl, level.start);
-    const shape = level.format === "bullet" ? level.text : fillLevels(level.text, list, counters);
-    const text = capped(shape);
-    return text ? { text, indent: levelIndentPt(level.indent) } : null;
+    const shape = level.format === "bullet" ? level.text : fillLevels(level.text, list, counters, level.legal);
+    const drawn = capped(shape);
+    if (!drawn) return null;
+    return {
+      text: level.suffix === "space" ? `${drawn} ` : drawn,
+      indent: levelIndentPt(level.indent),
+      suffix: level.suffix,
+      align: level.align,
+      run: level.run
+    };
   });
 }
 export {

package/dist/numbering/parseNumbering.d.ts

@@ -5,10 +5,11 @@
  * numbering.xml itself goes out as the original bytes on export, so this reading never
  * disturbs the file.
  */
+import type { RunFormat } from "../model/format";
 import type { TabStopDirective } from "../model/tabStops";
-/** The number formats actually used across every fixture */
-declare const NUMBER_FORMATS: readonly ["decimal", "bullet", "lowerLetter", "upperLetter", "lowerRoman"];
-export type NumberFormat = (typeof NUMBER_FORMATS)[number];
+import { type XmlParser } from "../ooxml/xml";
+import { type NumberFormat } from "./spellers";
+export type { NumberFormat } from "./spellers";
 /**
  * The indent a level defines. The unit is twips (1/20 of a point), and a slot that is
  * not recorded is null
@@ -19,6 +20,10 @@ export interface LevelIndent {
     hangingTwips: number | null;
     firstLineTwips: number | null;
 }
+/** What stands between a level's number and the text of the paragraph (`w:suff`, §17.9.28) */
+export type LevelSuffix = "tab" | "space" | "nothing";
+/** Where a level's number sits in the space kept for it (`w:lvlJc`, §17.9.7) */
+export type LevelAlign = "left" | "center" | "right";
 export interface NumberingLevel {
     format: NumberFormat;
     /**
@@ -31,14 +36,58 @@ export interface NumberingLevel {
     indent: LevelIndent | null;
     /** Custom stops contributed by this level's paragraph properties. */
     tabStops?: readonly TabStopDirective[];
+    /**
+     * The deepest level whose advance sends this one back to its start (`w:lvlRestart`, §17.9.10),
+     * as a level number: any level above that one restarts it too. A level of -1 never restarts, and
+     * null is the default, the level right above this one.
+     */
+    restartAfterLevel: number | null;
+    /** Every level in this level's text spelled as a decimal, whatever format it counts in (`w:isLgl`, §17.9.4) */
+    legal: boolean;
+    suffix: LevelSuffix;
+    align: LevelAlign;
+    /**
+     * The formatting of the number itself (`w:rPr`, §17.9.24). It dresses the number alone and
+     * never the text of the paragraph the number stands in front of.
+     * Null where the level writes none, and where the caller handed in no reader for it.
+     */
+    run: RunFormat | null;
 }
+/**
+ * How a level's `w:rPr` is read into display values.
+ * The vocabulary of run properties belongs with the reader that holds styles.xml and the theme
+ * fonts, which this folder cannot reach, so it is handed in.
+ */
+export type ReadLevelRun = (rPr: Element) => RunFormat | null;
 export interface NumberingList {
     /** The shape for each level (ilvl) */
-    levels: Map<number, NumberingLevel>;
+    levels: ReadonlyMap<number, NumberingLevel>;
+}
+/**
+ * A level a list started while editing is registered with.
+ *
+ * It is a level minus the two things the writer of a new definition cannot spell where it stands:
+ * the formatting of the number (`w:rPr`) and the tab stops its paragraphs contribute (`w:tabs`)
+ * are written by `docx/`, which stands above this folder. Leaving them out of what may be
+ * registered is what keeps a registered definition from reaching the file with a part of it
+ * silently dropped.
+ */
+export interface NewListLevel extends NumberingLevel {
+    readonly run: null;
+    readonly tabStops?: undefined;
+}
+/** A list started while editing, whose definition the export writes into numbering.xml as it stands */
+export interface NewList {
+    levels: ReadonlyMap<number, NewListLevel>;
 }
 export interface Numbering {
     /** The list for each numId */
     lists: Map<number, NumberingList>;
+    /**
+     * The lists started while editing, by the number each was given. numbering.xml defines none of
+     * them yet; the export writes the definition registered here.
+     */
+    added: ReadonlyMap<number, NewList>;
 }
 export declare const EMPTY_NUMBERING: Numbering;
 /**
@@ -61,5 +110,34 @@ export declare const NO_LEVEL_INDENT: LevelIndentPt;
  * OOXML rule).
  */
 export declare function levelIndentPt(indent: LevelIndent | null): LevelIndentPt;
-export declare function parseNumbering(xml: string | null): Numbering;
-export {};
+export declare const LEVEL_SUFFIXES: readonly LevelSuffix[];
+/** The justifications a number can take, which are the ones `w:lvlJc` offers a number */
+export declare const LEVEL_ALIGNS: readonly LevelAlign[];
+/**
+ * The list each numbering style names, by the style's id.
+ *
+ * A numbering style is never worn by a paragraph: it is a name on a list, which an abstract
+ * definition reaches through `w:numStyleLink` (§17.9.21). The map is built from styles.xml, which
+ * this folder cannot read for itself.
+ */
+export type NumberingStyleLinks = ReadonlyMap<string, number>;
+/** What a caller may say about reading numbering beyond handing over the XML */
+export interface NumberingOptions {
+    /**
+     * The parser the numbering XML is read through. Left out, the `DOMParser` global is used, and a
+     * runtime carrying none refuses the read with `no-xml-parser`.
+     */
+    xmlParser?: XmlParser;
+    /**
+     * The list each numbering style of the document names. Left out, a definition deferring to a
+     * numbering style is read through the definition that declares it stands behind that style.
+     */
+    links?: NumberingStyleLinks;
+    /** How the formatting a level puts on its number is read. Left out, no level carries any */
+    readRun?: ReadLevelRun;
+}
+/**
+ * The lists this numbering XML defines. `null` is the document that has no numbering part, which
+ * defines none and asks nothing of a parser.
+ */
+export declare function parseNumbering(xml: string | null, options?: NumberingOptions): Numbering;

package/dist/numbering/parseNumbering.js

@@ -1,34 +1,44 @@
 // src/numbering/parseNumbering.ts
+import {
+  ST_DecimalNumber,
+  ST_SignedTwipsMeasure,
+  ST_TwipsMeasure
+} from "../ooxml/simpleTypes.js";
 import { readTabStopDirectives } from "../ooxml/tabStops.js";
-import { childValue, round, wAttr } from "../ooxml/units.js";
-import { childByLocalName, elementChildren, parseXml } from "../ooxml/xml.js";
-var NUMBER_FORMATS = [
-  "decimal",
-  "bullet",
-  "lowerLetter",
-  "upperLetter",
-  "lowerRoman"
-];
-var EMPTY_NUMBERING = { lists: /* @__PURE__ */ new Map() };
-function toInteger(value) {
-  if (value === null) return null;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-function isNumberFormat(value) {
-  return NUMBER_FORMATS.some((format) => format === value);
-}
+import {
+  ALIGN_BY_JC,
+  childValue,
+  isOn,
+  twipsToPt,
+  wAttr
+} from "../ooxml/units.js";
+import {
+  childByLocalName,
+  elementChildren,
+  parseXml,
+  withXmlParser
+} from "../ooxml/xml.js";
+import { isNumberFormat } from "./spellers.js";
+var NO_ADDED_LISTS = /* @__PURE__ */ new Map();
+var EMPTY_NUMBERING = {
+  lists: /* @__PURE__ */ new Map(),
+  added: NO_ADDED_LISTS
+};
 function indentOf(lvl) {
   const pPr = childByLocalName(lvl, "pPr");
   const ind = pPr ? childByLocalName(pPr, "ind") : null;
   if (!ind) return null;
-  const startTwips = toInteger(wAttr(ind, "start") ?? wAttr(ind, "left"));
-  const endTwips = toInteger(wAttr(ind, "end") ?? wAttr(ind, "right"));
+  const startTwips = ST_SignedTwipsMeasure.parse(
+    wAttr(ind, "start") ?? wAttr(ind, "left")
+  );
+  const endTwips = ST_SignedTwipsMeasure.parse(
+    wAttr(ind, "end") ?? wAttr(ind, "right")
+  );
   const indent = {
     startTwips,
     endTwips,
-    hangingTwips: toInteger(wAttr(ind, "hanging")),
-    firstLineTwips: toInteger(wAttr(ind, "firstLine"))
+    hangingTwips: ST_TwipsMeasure.parse(wAttr(ind, "hanging")),
+    firstLineTwips: ST_TwipsMeasure.parse(wAttr(ind, "firstLine"))
   };
   const empty = startTwips === null && endTwips === null && indent.hangingTwips === null && indent.firstLineTwips === null;
   return empty ? null : indent;
@@ -38,9 +48,6 @@ var NO_LEVEL_INDENT = {
   endPt: null,
   textIndentPt: null
 };
-function twipsToPt(twips) {
-  return twips === null ? null : round(twips / 20);
-}
 function levelIndentPt(indent) {
   if (!indent) return NO_LEVEL_INDENT;
   const hangingPt = twipsToPt(indent.hangingTwips);
@@ -50,39 +57,68 @@ function levelIndentPt(indent) {
     textIndentPt: hangingPt !== null ? -hangingPt : twipsToPt(indent.firstLineTwips)
   };
 }
-function readLevel(lvl) {
+var LEVEL_SUFFIXES = [
+  "tab",
+  "space",
+  "nothing"
+];
+var LEVEL_ALIGNS = ["left", "center", "right"];
+function suffixOf(lvl) {
+  const suffix = childValue(lvl, "suff");
+  return LEVEL_SUFFIXES.find((known) => known === suffix) ?? "tab";
+}
+function alignOf(lvl) {
+  const jc = childValue(lvl, "lvlJc");
+  const align = jc === null ? void 0 : ALIGN_BY_JC[jc];
+  return align === void 0 || align === "justify" ? "left" : align;
+}
+function restartAfterLevelOf(lvl) {
+  const restart = ST_DecimalNumber.parse(childValue(lvl, "lvlRestart"));
+  return restart === null ? null : restart - 1;
+}
+function readLevel(lvl, readRun) {
   const format = childValue(lvl, "numFmt");
   const pPr = childByLocalName(lvl, "pPr");
   const tabStops = readTabStopDirectives(pPr);
+  const rPr = childByLocalName(lvl, "rPr");
   return {
     format: isNumberFormat(format) ? format : "decimal",
     text: childValue(lvl, "lvlText") ?? "",
-    start: toInteger(childValue(lvl, "start")) ?? 1,
+    start: ST_DecimalNumber.parse(childValue(lvl, "start")) ?? 1,
     indent: indentOf(lvl),
-    ...tabStops.length === 0 ? {} : { tabStops }
+    ...tabStops.length === 0 ? {} : { tabStops },
+    restartAfterLevel: restartAfterLevelOf(lvl),
+    legal: isOn(lvl, "isLgl"),
+    suffix: suffixOf(lvl),
+    align: alignOf(lvl),
+    run: rPr && readRun ? readRun(rPr) : null
   };
 }
-function readLevels(parent) {
+function readLevels(parent, readRun) {
   const levels = /* @__PURE__ */ new Map();
   for (const child of elementChildren(parent)) {
     if (child.localName !== "lvl") continue;
-    const ilvl = toInteger(wAttr(child, "ilvl"));
-    if (ilvl !== null) levels.set(ilvl, readLevel(child));
+    const ilvl = ST_DecimalNumber.parse(wAttr(child, "ilvl"));
+    if (ilvl !== null) levels.set(ilvl, readLevel(child, readRun));
   }
   return levels;
 }
-function readList(num, abstractLevels) {
-  const abstractNumId = toInteger(childValue(num, "abstractNumId"));
+function readList(num, abstractLevels, readRun) {
+  const abstractNumId = ST_DecimalNumber.parse(
+    childValue(num, "abstractNumId")
+  );
   if (abstractNumId === null) return null;
   const levels = new Map(abstractLevels.get(abstractNumId) ?? []);
   for (const child of elementChildren(num)) {
     if (child.localName !== "lvlOverride") continue;
-    const ilvl = toInteger(wAttr(child, "ilvl"));
+    const ilvl = ST_DecimalNumber.parse(wAttr(child, "ilvl"));
     if (ilvl === null) continue;
     const replacement = childByLocalName(child, "lvl");
-    const base = replacement ? readLevel(replacement) : levels.get(ilvl);
+    const base = replacement ? readLevel(replacement, readRun) : levels.get(ilvl);
     if (!base) continue;
-    const startOverride = toInteger(childValue(child, "startOverride"));
+    const startOverride = ST_DecimalNumber.parse(
+      childValue(child, "startOverride")
+    );
     levels.set(
       ilvl,
       startOverride === null ? base : { ...base, start: startOverride }
@@ -90,26 +126,77 @@ function readList(num, abstractLevels) {
   }
   return { levels };
 }
-function parseNumbering(xml) {
+var NO_STYLE_LINKS = /* @__PURE__ */ new Map();
+function levelsOf(id, definitions, resolved) {
+  const path = /* @__PURE__ */ new Set();
+  let current = id;
+  let levels = /* @__PURE__ */ new Map();
+  while (!path.has(current)) {
+    const known = resolved.get(current);
+    if (known) {
+      levels = known;
+      break;
+    }
+    path.add(current);
+    const el = definitions.byId.get(current);
+    if (!el) break;
+    levels = readLevels(el, definitions.readRun);
+    const styleId = childValue(el, "numStyleLink");
+    if (levels.size > 0 || styleId === null) break;
+    const named = definitions.links.get(styleId);
+    const deferred = (named === void 0 ? void 0 : definitions.ofList.get(named)) ?? definitions.ofStyle.get(styleId);
+    if (deferred === void 0) break;
+    current = deferred;
+  }
+  for (const seen of path) resolved.set(seen, levels);
+  return levels;
+}
+function parseNumbering(xml, options) {
   if (xml === null) return EMPTY_NUMBERING;
+  return withXmlParser(options?.xmlParser, () => readNumbering(xml, options));
+}
+function readNumbering(xml, options) {
   const root = parseXml(xml).documentElement;
-  const abstractLevels = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  const ofStyle = /* @__PURE__ */ new Map();
+  const ofList = /* @__PURE__ */ new Map();
   for (const child of elementChildren(root)) {
-    if (child.localName !== "abstractNum") continue;
-    const id = toInteger(wAttr(child, "abstractNumId"));
-    if (id !== null) abstractLevels.set(id, readLevels(child));
+    if (child.localName === "abstractNum") {
+      const id = ST_DecimalNumber.parse(wAttr(child, "abstractNumId"));
+      if (id === null) continue;
+      byId.set(id, child);
+      const styleId = childValue(child, "styleLink");
+      if (styleId !== null) ofStyle.set(styleId, id);
+    } else if (child.localName === "num") {
+      const numId = ST_DecimalNumber.parse(wAttr(child, "numId"));
+      const id = ST_DecimalNumber.parse(childValue(child, "abstractNumId"));
+      if (numId !== null && id !== null) ofList.set(numId, id);
+    }
+  }
+  const definitions = {
+    byId,
+    ofList,
+    ofStyle,
+    links: options?.links ?? NO_STYLE_LINKS,
+    readRun: options?.readRun
+  };
+  const abstractLevels = /* @__PURE__ */ new Map();
+  for (const id of byId.keys()) {
+    abstractLevels.set(id, levelsOf(id, definitions, abstractLevels));
   }
   const lists = /* @__PURE__ */ new Map();
   for (const child of elementChildren(root)) {
     if (child.localName !== "num") continue;
-    const numId = toInteger(wAttr(child, "numId"));
-    const list = numId === null ? null : readList(child, abstractLevels);
+    const numId = ST_DecimalNumber.parse(wAttr(child, "numId"));
+    const list = numId === null ? null : readList(child, abstractLevels, options?.readRun);
     if (numId !== null && list) lists.set(numId, list);
   }
-  return { lists };
+  return { lists, added: NO_ADDED_LISTS };
 }
 export {
   EMPTY_NUMBERING,
+  LEVEL_ALIGNS,
+  LEVEL_SUFFIXES,
   NO_LEVEL_INDENT,
   levelIndentPt,
   parseNumbering

package/dist/numbering/spellers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * How each number format spells the count of a list item.
+ *
+ * `w:numFmt` names some sixty formats (§17.18.59). The ones here are the ones a marker is drawn
+ * in; a level naming any other counts in decimal instead. A format belongs to `NumberFormat`
+ * because it has a speller here, so a marker can never be counted in a format nothing can write.
+ */
+/** A `w:numFmt` this editor spells out. Every other one is drawn as a decimal */
+export type NumberFormat = "decimal" | "decimalZero" | "bullet" | "lowerLetter" | "upperLetter" | "lowerRoman" | "upperRoman" | "ganada" | "koreanDigital" | "chineseCounting";
+export declare function isNumberFormat(value: string | null): value is NumberFormat;
+/**
+ * The count as this format writes it, and as a decimal where spelling it out would run past the
+ * length a marker is ever drawn at.
+ */
+export declare function spellNumber(count: number, format: NumberFormat, maxChars: number): string;

package/dist/numbering/spellers.js

@@ -0,0 +1,96 @@
+// src/numbering/spellers.ts
+var ROMAN = [
+  [1e3, "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 toRoman(count) {
+  let rest = count;
+  let out = "";
+  for (const [amount, sign] of ROMAN) {
+    while (rest >= amount) {
+      out += sign;
+      rest -= amount;
+    }
+  }
+  return out;
+}
+function repeated(symbols, count) {
+  const index = (count - 1) % symbols.length;
+  const times = Math.floor((count - 1) / symbols.length) + 1;
+  return (symbols[index] ?? "").repeat(times);
+}
+var LATIN = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var GANADA = "\uAC00\uB098\uB2E4\uB77C\uB9C8\uBC14\uC0AC\uC544\uC790\uCC28\uCE74\uD0C0\uD30C\uD558";
+var KOREAN_DIGITS = "\uC601\uC77C\uC774\uC0BC\uC0AC\uC624\uC721\uCE60\uD314\uAD6C";
+function digits(symbols, count) {
+  return Array.from(`${count}`, (digit) => symbols[Number(digit)] ?? "").join(
+    ""
+  );
+}
+var CHINESE_DIGITS = "\u3007\u4E00\u4E8C\u4E09\u56DB\u4E94\u516D\u4E03\u516B\u4E5D\u5341";
+function chineseCounting(count) {
+  if (count <= 10) return CHINESE_DIGITS[count] ?? "";
+  if (count >= 100) return digits(CHINESE_DIGITS, count);
+  const tens = Math.floor(count / 10);
+  const unit = count % 10;
+  return (tens === 1 ? "" : CHINESE_DIGITS[tens] ?? "") + CHINESE_DIGITS[10] + (unit === 0 ? "" : CHINESE_DIGITS[unit] ?? "");
+}
+var POSITIONAL = Number.POSITIVE_INFINITY;
+var NUMBER_SPELLERS = {
+  decimal: { spell: (count) => `${count}`, countsPerChar: POSITIONAL },
+  /** The counts up to nine written with a zero in front (§17.18.59 decimalZero) */
+  decimalZero: {
+    spell: (count) => count < 10 ? `0${count}` : `${count}`,
+    countsPerChar: POSITIONAL
+  },
+  /**
+   * A bullet counts nothing: its `w:lvlText` is the symbol itself. A `%n` slot naming a bullet
+   * level has no symbol to put there, so the count goes in as a decimal, as Word draws it.
+   */
+  bullet: { spell: (count) => `${count}`, countsPerChar: POSITIONAL },
+  lowerLetter: {
+    spell: (count) => repeated(LATIN, count).toLowerCase(),
+    countsPerChar: LATIN.length
+  },
+  upperLetter: {
+    spell: (count) => repeated(LATIN, count),
+    countsPerChar: LATIN.length
+  },
+  lowerRoman: {
+    spell: (count) => toRoman(count).toLowerCase(),
+    countsPerChar: 1e3
+  },
+  upperRoman: { spell: toRoman, countsPerChar: 1e3 },
+  ganada: {
+    spell: (count) => repeated(GANADA, count),
+    countsPerChar: GANADA.length
+  },
+  koreanDigital: {
+    spell: (count) => digits(KOREAN_DIGITS, count),
+    countsPerChar: POSITIONAL
+  },
+  chineseCounting: { spell: chineseCounting, countsPerChar: POSITIONAL }
+};
+function isNumberFormat(value) {
+  return value !== null && Object.hasOwn(NUMBER_SPELLERS, value);
+}
+function spellNumber(count, format, maxChars) {
+  const speller = NUMBER_SPELLERS[format];
+  if (count < 1 || count > speller.countsPerChar * maxChars) return `${count}`;
+  return speller.spell(count);
+}
+export {
+  isNumberFormat,
+  spellNumber
+};

package/dist/numbering/writeNumbering.d.ts

@@ -1,13 +1,14 @@
 /**
- * Splices the definitions of newly started lists into the original numbering.xml.
+ * Splices the definitions the newly started lists were registered with into the original
+ * numbering.xml.
  *
- * Not one character of the original is altered; new elements are merely slotted in at
- * two places.
- * OOXML requires the definitions (`abstractNum`) to come before the numbers (`num`), so
- * the definitions go in front of the first number and the numbers go at the very end.
+ * Not one character of the original is altered; new elements are merely slotted in.
+ * OOXML requires the definitions (`abstractNum`) to come before the numbers (`num`), and
+ * `CHILD_ORDER.numbering` is what places each where it belongs among what the part holds.
  */
+import type { NewList } from "./parseNumbering";
 /**
- * numbering.xml with a standard template definition added for every list number.
+ * numbering.xml with the definition each of these lists was started with added under its number.
  * When there is nothing to add, the original string is returned unchanged.
  */
-export declare function addListDefinitions(xml: string, numIds: readonly number[]): string;
+export declare function addListDefinitions(xml: string, lists: ReadonlyMap<number, NewList>): string;