@portone/docx-editor 0.2.1 → 0.4.0

package/dist/model/format.js

@@ -1,4 +1,5 @@
 // src/model/format.ts
+import { TAB_LEADERS, TAB_STOP_ALIGNMENTS } from "./tabStops.js";
 var ALIGNS = ["left", "center", "right", "justify"];
 var VERTICAL_ALIGNS = ["superscript", "subscript"];
 var CELL_VERTICAL_ALIGNS = ["top", "center", "bottom"];
@@ -56,6 +57,38 @@ function withWidthNumber(width, value) {
   if (width.type === "pct") return { type: "pct", fiftieths: value };
   return width;
 }
+var RUN_FORMAT_KEYS = [
+  "bold",
+  "italic",
+  "strike",
+  "doubleStrike",
+  "smallCaps",
+  "caps",
+  "underline",
+  "fontSizePt",
+  "characterSpacingPt",
+  "fontFamily",
+  "color",
+  "highlight",
+  "background",
+  "verticalAlign",
+  "lang"
+];
+var TABLE_STYLE_CONDITIONS = [
+  "wholeTable",
+  "band1Vert",
+  "band2Vert",
+  "band1Horz",
+  "band2Horz",
+  "firstRow",
+  "lastRow",
+  "firstCol",
+  "lastCol",
+  "nwCell",
+  "neCell",
+  "swCell",
+  "seCell"
+];
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -89,22 +122,6 @@ function toNumberingRef(value) {
   if (typeof numId !== "number" || typeof ilvl !== "number") return null;
   return { numId, ilvl };
 }
-var TAB_ALIGNMENTS = [
-  "start",
-  "center",
-  "end",
-  "decimal",
-  "num",
-  "bar"
-];
-var TAB_LEADERS = [
-  "none",
-  "dot",
-  "hyphen",
-  "underscore",
-  "heavy",
-  "middleDot"
-];
 function toTabStops(value) {
   if (!Array.isArray(value)) return null;
   const stops = [];
@@ -112,7 +129,9 @@ function toTabStops(value) {
     if (!isRecord(entry) || typeof entry.positionPt !== "number" || !Number.isFinite(entry.positionPt)) {
       continue;
     }
-    const align = TAB_ALIGNMENTS.find((candidate) => candidate === entry.align);
+    const align = TAB_STOP_ALIGNMENTS.find(
+      (candidate) => candidate === entry.align
+    );
     if (!align) continue;
     const leader = TAB_LEADERS.find((candidate) => candidate === entry.leader);
     stops.push({
@@ -150,6 +169,7 @@ function toParagraphFormat(value) {
   const tabStops = toTabStops(value.tabStops);
   if (tabStops) format.tabStops = tabStops;
   if (value.pageBreakBefore === true) format.pageBreakBefore = true;
+  if (typeof value.keepNext === "boolean") format.keepNext = value.keepNext;
   copyBorders(value, format);
   const background = matching(FILL, value.background);
   if (background) format.background = background;
@@ -158,13 +178,20 @@ function toParagraphFormat(value) {
 function toRunFormat(value) {
   if (!isRecord(value)) return null;
   const format = {};
-  if (value.bold === true) format.bold = true;
-  if (value.italic === true) format.italic = true;
-  if (value.strike === true) format.strike = true;
-  if (value.smallCaps === true) format.smallCaps = true;
-  if (isUnderlineKind(value.underline)) format.underline = value.underline;
+  if (typeof value.bold === "boolean") format.bold = value.bold;
+  if (typeof value.italic === "boolean") format.italic = value.italic;
+  if (typeof value.strike === "boolean") format.strike = value.strike;
+  if (typeof value.doubleStrike === "boolean")
+    format.doubleStrike = value.doubleStrike;
+  if (typeof value.smallCaps === "boolean") format.smallCaps = value.smallCaps;
+  if (typeof value.caps === "boolean") format.caps = value.caps;
+  if (isUnderlineKind(value.underline) || value.underline === "none") {
+    format.underline = value.underline;
+  }
   if (typeof value.fontSizePt === "number")
     format.fontSizePt = value.fontSizePt;
+  if (typeof value.characterSpacingPt === "number")
+    format.characterSpacingPt = value.characterSpacingPt;
   const fontFamily = matching(FONT_FAMILY, value.fontFamily);
   if (fontFamily) format.fontFamily = fontFamily;
   const color = matching(HEX_COLOR, value.color);
@@ -249,6 +276,53 @@ function toCellMargins(value) {
   ];
   return sides.every((side) => side === null) ? null : margins;
 }
+function toBandSizes(value) {
+  if (!isRecord(value)) return null;
+  const size = (side) => typeof side === "number" && Number.isInteger(side) && side > 0 ? side : null;
+  const bands = { row: size(value.row), col: size(value.col) };
+  return bands.row === null && bands.col === null ? null : bands;
+}
+function toCellStyleBorders(value) {
+  if (!isRecord(value)) {
+    return { top: null, bottom: null, left: null, right: null };
+  }
+  return {
+    top: matching(BORDER_CSS, value.top) ?? null,
+    bottom: matching(BORDER_CSS, value.bottom) ?? null,
+    left: matching(BORDER_CSS, value.left) ?? null,
+    right: matching(BORDER_CSS, value.right) ?? null
+  };
+}
+function toCellStyleFormat(value) {
+  if (!isRecord(value)) return null;
+  return {
+    background: matching(FILL, value.background) ?? null,
+    borders: toCellStyleBorders(value.borders),
+    inside: toInsideBorders(value.inside) ?? {
+      horizontal: null,
+      vertical: null
+    },
+    margins: toCellMargins(value.margins) ?? {
+      topPt: null,
+      rightPt: null,
+      bottomPt: null,
+      leftPt: null
+    },
+    verticalAlign: isCellVerticalAlign(value.verticalAlign) ? value.verticalAlign : null
+  };
+}
+function toTableStyleConditions(value) {
+  if (!isRecord(value)) return null;
+  const conditions = {};
+  let found = false;
+  for (const type of TABLE_STYLE_CONDITIONS) {
+    const format = toCellStyleFormat(value[type]);
+    if (format === null) continue;
+    conditions[type] = format;
+    found = true;
+  }
+  return found ? conditions : null;
+}
 function toRowHeight(value) {
   if (!isRecord(value) || typeof value.pt !== "number") return null;
   if (value.rule === "exact") return { rule: "exact", pt: value.pt };
@@ -287,9 +361,12 @@ function spanCount(value) {
 }
 export {
   NO_FILL,
+  RUN_FORMAT_KEYS,
+  TABLE_STYLE_CONDITIONS,
   isHighlightName,
   isUnderlineKind,
   spanCount,
+  toBandSizes,
   toCellFormat,
   toCellMargins,
   toColWidth,
@@ -299,6 +376,7 @@ export {
   toRowFormat,
   toRunFormat,
   toTableFormat,
+  toTableStyleConditions,
   toTableWidth,
   widthNumber,
   withWidthNumber

package/dist/model/tabStops.d.ts

@@ -6,6 +6,15 @@ export interface TabStop {
     align: TabAlignment | "bar";
     leader?: TabLeader;
 }
+/**
+ * What a stop may be aligned to, and what it may draw the space it covers with.
+ *
+ * These are the members of the two unions above, listed so that a reader checking a value against
+ * them cannot fall out of step with the types. `ooxml/simpleTypes` builds `ST_TabJc` and
+ * `ST_TabTlc` on them, adding the spellings the document writes that the model does not keep.
+ */
+export declare const TAB_STOP_ALIGNMENTS: readonly TabStop["align"][];
+export declare const TAB_LEADERS: readonly TabLeader[];
 /** A tab entry before the paragraph-property hierarchy has been resolved. */
 export type TabStopDirective = TabStop | {
     positionPt: number;

package/dist/model/tabStops.js

@@ -1,4 +1,20 @@
 // src/model/tabStops.ts
+var TAB_STOP_ALIGNMENTS = [
+  "start",
+  "center",
+  "end",
+  "decimal",
+  "num",
+  "bar"
+];
+var TAB_LEADERS = [
+  "none",
+  "dot",
+  "hyphen",
+  "underscore",
+  "heavy",
+  "middleDot"
+];
 function layerTabStopDirectives(base, over) {
   const stops = /* @__PURE__ */ new Map();
   for (const stop of base) {
@@ -17,6 +33,8 @@ function mergeTabStops(base, over) {
   );
 }
 export {
+  TAB_LEADERS,
+  TAB_STOP_ALIGNMENTS,
   layerTabStopDirectives,
   mergeTabStops
 };

package/dist/numbering/listRegistry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The register of list definitions a document node carries.
+ *
+ * A list started while editing is registered with the definition it was started with, and the
+ * register rides on the document node itself: undo takes a registration back with the edit that
+ * made it, and the export writes out what was registered rather than working a definition out for
+ * itself. Only what `abstractNumXml` writes in full may be registered, and the value is read back
+ * through this file so that nothing else can end up in the register.
+ */
+import { type NewList } from "./parseNumbering";
+/** The lists registered on one document, by the number each was given */
+export type NewLists = ReadonlyMap<number, NewList>;
+export declare const NO_NEW_LISTS: NewLists;
+/** The document attr the register travels on */
+export declare const NEW_LISTS_ATTR = "newLists";
+/**
+ * What the document node carries for a register.
+ *
+ * The entries run in the order of the numbers they define so that the same register is always the
+ * same value, whichever order the lists were started in, and an empty register is the null a
+ * document that never started a list carries: a list left is then a list never started.
+ */
+export declare function newListsValue(lists: NewLists): unknown;
+/**
+ * The register a document node carries. Empty for a node carrying none, and for one carrying an
+ * entry that is not a list definition: a definition the writer cannot read back in full is a
+ * definition it must not write half of.
+ */
+export declare function newListsOf(value: unknown): NewLists;
+/**
+ * The register with the definitions of the lists nothing wears any more taken out.
+ *
+ * A number goes back into circulation with its definition, so leaving a list is exactly what
+ * joining it was not: pressing the list button twice gives back the document that was there
+ * before the first press.
+ */
+export declare function listsWorn(lists: NewLists, worn: ReadonlySet<number>): NewLists;

package/dist/numbering/listRegistry.js

@@ -0,0 +1,112 @@
+// src/numbering/listRegistry.ts
+import { ST_SignedTwipsMeasure, ST_TwipsMeasure } from "../ooxml/simpleTypes.js";
+import { MAX_ILVL } from "./listTemplate.js";
+import {
+  LEVEL_ALIGNS,
+  LEVEL_SUFFIXES
+} from "./parseNumbering.js";
+import { isNumberFormat } from "./spellers.js";
+var NO_NEW_LISTS = /* @__PURE__ */ new Map();
+var NEW_LISTS_ATTR = "newLists";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toLevelIndent(value) {
+  if (!isRecord(value)) return null;
+  const { startTwips, endTwips, hangingTwips, firstLineTwips } = value;
+  const signed = (slot) => slot === null || typeof slot === "number" && ST_SignedTwipsMeasure.format(slot) !== null;
+  const unsigned = (slot) => slot === null || typeof slot === "number" && ST_TwipsMeasure.format(slot) !== null;
+  if (!signed(startTwips) || !signed(endTwips) || !unsigned(hangingTwips) || !unsigned(firstLineTwips))
+    return null;
+  return { startTwips, endTwips, hangingTwips, firstLineTwips };
+}
+function levelValue(ilvl, level) {
+  return {
+    ilvl,
+    format: level.format,
+    text: level.text,
+    start: level.start,
+    indent: level.indent,
+    restartAfterLevel: level.restartAfterLevel,
+    legal: level.legal,
+    suffix: level.suffix,
+    align: level.align
+  };
+}
+function toLevel(value) {
+  if (!isRecord(value)) return null;
+  const { ilvl, format, text, start } = value;
+  if (typeof ilvl !== "number" || !Number.isSafeInteger(ilvl) || ilvl < 0 || ilvl > MAX_ILVL)
+    return null;
+  if (typeof format !== "string" || !isNumberFormat(format)) return null;
+  if (typeof text !== "string") return null;
+  if (typeof start !== "number" || !Number.isSafeInteger(start)) return null;
+  const suffix = LEVEL_SUFFIXES.find((known) => known === value.suffix);
+  const align = LEVEL_ALIGNS.find((known) => known === value.align);
+  if (suffix === void 0 || align === void 0) return null;
+  const restartAfterLevel = value.restartAfterLevel;
+  if (restartAfterLevel !== null && (typeof restartAfterLevel !== "number" || !Number.isSafeInteger(restartAfterLevel) || restartAfterLevel < -1 || restartAfterLevel >= MAX_ILVL))
+    return null;
+  if (typeof value.legal !== "boolean") return null;
+  if (value.run !== void 0 && value.run !== null) return null;
+  if (value.tabStops !== void 0) return null;
+  const indent = toLevelIndent(value.indent);
+  if (value.indent !== null && indent === null) return null;
+  return {
+    ilvl,
+    level: {
+      format,
+      text,
+      start,
+      indent,
+      restartAfterLevel,
+      legal: value.legal,
+      suffix,
+      align,
+      run: null
+    }
+  };
+}
+function toList(value) {
+  if (!isRecord(value)) return null;
+  const { numId, levels } = value;
+  if (typeof numId !== "number" || !Number.isSafeInteger(numId) || numId <= 0)
+    return null;
+  if (!Array.isArray(levels)) return null;
+  const read = /* @__PURE__ */ new Map();
+  for (const entry of levels) {
+    const level = toLevel(entry);
+    if (level === null || read.has(level.ilvl)) return null;
+    read.set(level.ilvl, level.level);
+  }
+  return read.size === 0 ? null : { numId, list: { levels: read } };
+}
+function newListsValue(lists) {
+  if (lists.size === 0) return null;
+  return Array.from(lists).sort(([left], [right]) => left - right).map(([numId, list]) => ({
+    numId,
+    levels: Array.from(list.levels).sort(([left], [right]) => left - right).map(([ilvl, level]) => levelValue(ilvl, level))
+  }));
+}
+function newListsOf(value) {
+  if (!Array.isArray(value)) return NO_NEW_LISTS;
+  const lists = /* @__PURE__ */ new Map();
+  for (const entry of value) {
+    const read = toList(entry);
+    if (read === null || lists.has(read.numId)) return NO_NEW_LISTS;
+    lists.set(read.numId, read.list);
+  }
+  return lists;
+}
+function listsWorn(lists, worn) {
+  const dropped = [...lists.keys()].filter((numId) => !worn.has(numId));
+  if (dropped.length === 0) return lists;
+  return new Map([...lists].filter(([numId]) => worn.has(numId)));
+}
+export {
+  NEW_LISTS_ATTR,
+  NO_NEW_LISTS,
+  listsWorn,
+  newListsOf,
+  newListsValue
+};

package/dist/numbering/listTemplate.d.ts

@@ -1,29 +1,38 @@
 /**
- * The standard shape of a newly started list.
+ * A list started while editing: the definition it is started with, the number it takes, and the
+ * `<w:abstractNum>` that definition is written out as.
  *
- * The definition of a new list is not kept in the document model.
- * So its shape has to be derivable from the list number (numId) alone, and that rule
- * lives here. Even numbers are numbered lists, odd numbers are bullet lists.
- *
- * Drawing the markers on screen and writing the definitions into numbering.xml both look
- * at the same template.
+ * Nothing here reads anything into the number. The definition is a value the editor registers
+ * (`./listRegistry`), the same value the markers are drawn from and the one written into
+ * numbering.xml, so a list goes out as what it was started as.
  */
-import type { LevelIndent, Numbering, NumberingList } from "./parseNumbering";
+import type { LevelIndent, NewList, Numbering, NumberingList } from "./parseNumbering";
 export type ListKind = "numbered" | "bullet";
 /** A list has nine levels (the count OOXML defines) */
 export declare const LEVEL_COUNT = 9;
 export declare const MAX_ILVL: number;
 export declare function templateIndent(ilvl: number): LevelIndent;
-export declare function listKindOf(numId: number): ListKind;
+/** The definition a list of this kind is started with */
+export declare function templateList(kind: ListKind): NewList;
+/**
+ * The definition standing behind this number: the one the document wrote down, or the one a list
+ * started while editing was registered with. Undefined for a number nothing defines, which is a
+ * list neither drawn nor written.
+ */
+export declare function listFor(numbering: Numbering, numId: number): NumberingList | undefined;
+/** Reserves safe positive ids, using gaps if incrementing the highest id would lose precision. */
+export declare function numberingIdAllocator(ids: Iterable<number>): () => number;
 /**
- * The list definition for this number.
- * A number the document's numbering.xml does not know is read as the standard template
- * (which is the case for a list that was just started).
+ * A number for a new list, and the numbering that now defines it under that number.
+ *
+ * `used` names the numbers the document already spends, the ones no definition stands behind
+ * included: a number a paragraph already wears would otherwise join that paragraph to the new list.
  */
-export declare function listFor(numbering: Numbering, numId: number): NumberingList;
-/** The next number not yet in use. Picks the even or odd one matching the shape */
-export declare function nextNumId(used: Iterable<number>, kind: ListKind): number;
-/** Writes one template out as a `<w:abstractNum>` definition */
-export declare function abstractNumXml(abstractNumId: number, kind: ListKind): string;
+export declare function allocateList(numbering: Numbering, used: Iterable<number>, list: NewList): {
+    numId: number;
+    numbering: Numbering;
+};
+/** Writes one registered definition out as a `<w:abstractNum>` */
+export declare function abstractNumXml(abstractNumId: number, list: NewList): string;
 /** The `<w:num>` that ties a list number to a definition */
 export declare function numXml(numId: number, abstractNumId: number): string;

package/dist/numbering/listTemplate.js

@@ -1,6 +1,7 @@
 // src/numbering/listTemplate.ts
 import { elementXml } from "../ooxml/element.js";
 import { wName } from "../ooxml/names.js";
+import { orderedElement } from "../ooxml/props.js";
 var LEVEL_COUNT = 9;
 var MAX_ILVL = LEVEL_COUNT - 1;
 var NUMBER_CYCLE = [
@@ -28,7 +29,12 @@ function templateLevel(kind, ilvl) {
     format: numbered ? cycled(NUMBER_CYCLE, ilvl, "decimal") : "bullet",
     text: numbered ? `%${ilvl + 1}.` : cycled(BULLET_CYCLE, ilvl, "\u25CF"),
     start: 1,
-    indent: templateIndent(ilvl)
+    indent: templateIndent(ilvl),
+    restartAfterLevel: null,
+    legal: false,
+    suffix: "tab",
+    align: "left",
+    run: null
   };
 }
 function templateList(kind) {
@@ -38,19 +44,35 @@ function templateList(kind) {
   }
   return { levels };
 }
-var TEMPLATES = {
-  numbered: templateList("numbered"),
-  bullet: templateList("bullet")
-};
-function listKindOf(numId) {
-  return numId % 2 === 0 ? "numbered" : "bullet";
-}
 function listFor(numbering, numId) {
-  return numbering.lists.get(numId) ?? TEMPLATES[listKindOf(numId)];
+  return numbering.lists.get(numId) ?? numbering.added.get(numId);
+}
+function numberingIdAllocator(ids) {
+  const used = new Set(ids);
+  let highest = 0;
+  for (const id of used) if (id > highest) highest = id;
+  let next = Number.isSafeInteger(highest + 1) ? highest + 1 : 1;
+  return () => {
+    while (used.has(next)) next += 1;
+    const id = next;
+    used.add(id);
+    next = Number.isSafeInteger(id + 1) ? id + 1 : 1;
+    return id;
+  };
 }
-function nextNumId(used, kind) {
-  const from = Math.max(0, ...used) + 1;
-  return listKindOf(from) === kind ? from : from + 1;
+function allocateList(numbering, used, list) {
+  const numId = numberingIdAllocator([
+    ...numbering.lists.keys(),
+    ...numbering.added.keys(),
+    ...used
+  ])();
+  return {
+    numId,
+    numbering: {
+      ...numbering,
+      added: new Map([...numbering.added, [numId, list]])
+    }
+  };
 }
 function indXml(indent) {
   const slots = [
@@ -61,25 +83,65 @@ function indXml(indent) {
   ];
   const attrs = slots.filter((slot) => slot[1] !== null).map(([name, twips]) => [wName(name), `${twips}`]);
   if (attrs.length === 0) return "";
-  return elementXml(wName("pPr"), [], [elementXml(wName("ind"), attrs)]);
+  return orderedElement(
+    wName("pPr"),
+    [],
+    [{ name: "ind", xml: elementXml(wName("ind"), attrs) }]
+  );
+}
+function lvlRestartXml(restartAfterLevel) {
+  if (restartAfterLevel === null) return null;
+  return {
+    name: "lvlRestart",
+    xml: elementXml(wName("lvlRestart"), [
+      [wName("val"), `${restartAfterLevel + 1}`]
+    ])
+  };
+}
+function isLglXml(legal) {
+  return legal ? { name: "isLgl", xml: elementXml(wName("isLgl"), []) } : null;
+}
+function suffXml(suffix) {
+  if (suffix === "tab") return null;
+  return {
+    name: "suff",
+    xml: elementXml(wName("suff"), [[wName("val"), suffix]])
+  };
 }
 function levelXml(ilvl, level) {
   const ind = indXml(level.indent);
-  return elementXml(
+  const optional = [
+    lvlRestartXml(level.restartAfterLevel),
+    isLglXml(level.legal),
+    suffXml(level.suffix),
+    ind === "" ? null : { name: "pPr", xml: ind }
+  ];
+  return orderedElement(
     wName("lvl"),
     [[wName("ilvl"), `${ilvl}`]],
     [
-      elementXml(wName("start"), [[wName("val"), `${level.start}`]]),
-      elementXml(wName("numFmt"), [[wName("val"), level.format]]),
-      elementXml(wName("lvlText"), [[wName("val"), level.text]]),
-      elementXml(wName("lvlJc"), [[wName("val"), "left"]]),
-      ind
+      {
+        name: "start",
+        xml: elementXml(wName("start"), [[wName("val"), `${level.start}`]])
+      },
+      {
+        name: "numFmt",
+        xml: elementXml(wName("numFmt"), [[wName("val"), level.format]])
+      },
+      {
+        name: "lvlText",
+        xml: elementXml(wName("lvlText"), [[wName("val"), level.text]])
+      },
+      {
+        name: "lvlJc",
+        xml: elementXml(wName("lvlJc"), [[wName("val"), level.align]])
+      },
+      ...optional.filter((child) => child !== null)
     ]
   );
 }
-function abstractNumXml(abstractNumId, kind) {
-  const levels = TEMPLATES[kind].levels;
-  const body = Array.from(levels.entries()).map(([ilvl, level]) => levelXml(ilvl, level)).join("");
+function abstractNumXml(abstractNumId, list) {
+  const body = Array.from(list.levels.entries()).map(([ilvl, level]) => levelXml(ilvl, level)).join("");
   return elementXml(
     wName("abstractNum"),
     [[wName("abstractNumId"), `${abstractNumId}`]],
@@ -97,9 +159,10 @@ export {
   LEVEL_COUNT,
   MAX_ILVL,
   abstractNumXml,
+  allocateList,
   listFor,
-  listKindOf,
-  nextNumId,
   numXml,
-  templateIndent
+  numberingIdAllocator,
+  templateIndent,
+  templateList
 };

package/dist/numbering/markers.d.ts

@@ -4,21 +4,30 @@
  * A pure computation that never touches the document model: the same paragraphs with the
  * same numbering definitions always yield the same numbers.
  */
-import type { NumberingRef } from "../model/format";
-import { type LevelIndentPt, type Numbering } from "./parseNumbering";
+import type { NumberingRef, RunFormat } from "../model/format";
+import { type LevelAlign, type LevelIndentPt, type LevelSuffix, type Numbering } from "./parseNumbering";
 /** The number to draw in front of one paragraph */
 export interface ListMarker {
+    /**
+     * The number as it is drawn, the space a level asking for one (`w:suff`) included: a separator
+     * made of a character belongs to the marker, while the tab every other level asks for is the
+     * width the number sits in rather than anything to draw
+     */
     text: string;
     /**
      * The indent defined by the level this paragraph belongs to. Used when the paragraph
      * records none of its own
      */
     indent: LevelIndentPt;
+    /** Whether the number sits in a width of its own, which is what a tab suffix asks for */
+    suffix: LevelSuffix;
+    align: LevelAlign;
+    /** The formatting the level puts on the number, which dresses the number and nothing else */
+    run: RunFormat | null;
 }
 /**
- * A slot is null for a paragraph that is not a list item, or whose level shape could not
- * be found.
- * A number the document does not know (a list started fresh while editing) is drawn with
- * the standard template's shape.
+ * A slot is null for a paragraph that is not a list item, or whose level shape could not be found.
+ * A number nothing defines - neither numbering.xml nor a list started while editing - draws no
+ * marker, which is what Word does with a `w:numId` no `w:num` answers.
  */
 export declare function computeMarkers(paragraphs: readonly (NumberingRef | null)[], numbering: Numbering): (ListMarker | null)[];