@stll/folio-core 0.61.0 → 0.63.0

package/dist/docx/modelValidation.js

@@ -1,4 +1,5 @@
 import { validateDocumentModel } from "@stll/docx-core";
+import { isCanonicallyEmptyParagraphFormatting } from "@stll/docx-core/model";
 //#region src/docx/modelValidation.ts
 var DocxModelValidationError = class extends Error {
 	issues;
@@ -8,7 +9,149 @@ var DocxModelValidationError = class extends Error {
 		this.issues = issues;
 	}
 };
-const validateFolioDocumentModel = (document) => validateDocumentModel(document);
+const validateFolioDocumentModel = (document) => {
+	const issues = [];
+	try {
+		issues.push(...validateDocumentModel(document).issues);
+	} catch {
+		issues.push({
+			path: "package.document",
+			message: "Document structure is malformed.",
+			severity: "error"
+		});
+	}
+	const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+	const addMalformedIssue = (path, expected) => {
+		issues.push({
+			path,
+			message: `Expected ${expected}.`,
+			severity: "error"
+		});
+	};
+	const input = document;
+	if (!isRecord(input)) {
+		addMalformedIssue("document", "an object");
+		return {
+			valid: false,
+			issues
+		};
+	}
+	const documentPackage = input["package"];
+	if (!isRecord(documentPackage)) {
+		addMalformedIssue("package", "an object");
+		return {
+			valid: false,
+			issues
+		};
+	}
+	const documentBody = documentPackage["document"];
+	if (!isRecord(documentBody)) {
+		addMalformedIssue("package.document", "an object");
+		return {
+			valid: false,
+			issues
+		};
+	}
+	if (Array.isArray(documentBody["comments"]) && documentBody["comments"].length === 0) issues.push({
+		path: "package.document.comments",
+		message: "Empty comment lists must be absent.",
+		severity: "error"
+	});
+	const validateBlocks = (blocks, path) => {
+		if (!Array.isArray(blocks)) {
+			addMalformedIssue(path, "an array");
+			return;
+		}
+		for (const [index, block] of blocks.entries()) {
+			const blockPath = `${path}[${String(index)}]`;
+			if (!isRecord(block)) {
+				addMalformedIssue(blockPath, "an object");
+				continue;
+			}
+			if (block["type"] === "paragraph") {
+				if (block["formatting"] !== void 0 && !isRecord(block["formatting"])) addMalformedIssue(`${blockPath}.formatting`, "an object");
+				else if (block["formatting"] !== void 0 && isRecord(block["formatting"]) && isCanonicallyEmptyParagraphFormatting(block["formatting"])) issues.push({
+					path: `${blockPath}.formatting`,
+					message: "Empty paragraph formatting must be absent.",
+					severity: "error"
+				});
+				continue;
+			}
+			if (block["type"] === "table") {
+				if (!Array.isArray(block["rows"])) {
+					addMalformedIssue(`${blockPath}.rows`, "an array");
+					continue;
+				}
+				for (const [rowIndex, row] of block["rows"].entries()) {
+					const rowPath = `${blockPath}.rows[${String(rowIndex)}]`;
+					if (!isRecord(row)) {
+						addMalformedIssue(rowPath, "an object");
+						continue;
+					}
+					if (!Array.isArray(row["cells"])) {
+						addMalformedIssue(`${rowPath}.cells`, "an array");
+						continue;
+					}
+					for (const [cellIndex, cell] of row["cells"].entries()) {
+						const cellPath = `${rowPath}.cells[${String(cellIndex)}]`;
+						if (!isRecord(cell)) {
+							addMalformedIssue(cellPath, "an object");
+							continue;
+						}
+						validateBlocks(cell["content"], `${cellPath}.content`);
+					}
+				}
+			} else if (block["type"] === "blockSdt" || block["type"] === "blockCustomXml") validateBlocks(block["content"], `${blockPath}.content`);
+		}
+	};
+	validateBlocks(documentBody["content"], "package.document.content");
+	const validateStoryMap = (stories, path) => {
+		if (stories === void 0) return;
+		if (!(stories instanceof Map)) {
+			addMalformedIssue(path, "a map");
+			return;
+		}
+		for (const [id, story] of stories) {
+			const storyPath = `${path}[${JSON.stringify(id)}]`;
+			if (!isRecord(story)) {
+				addMalformedIssue(storyPath, "an object");
+				continue;
+			}
+			validateBlocks(story["content"], `${storyPath}.content`);
+		}
+	};
+	const validateNoteStories = (notes, path) => {
+		if (notes === void 0) return;
+		if (!Array.isArray(notes)) {
+			addMalformedIssue(path, "an array");
+			return;
+		}
+		for (const [index, note] of notes.entries()) {
+			const notePath = `${path}[${String(index)}]`;
+			if (!isRecord(note)) {
+				addMalformedIssue(notePath, "an object");
+				continue;
+			}
+			validateBlocks(note["content"], `${notePath}.content`);
+		}
+	};
+	validateStoryMap(documentPackage["headers"], "package.headers");
+	validateStoryMap(documentPackage["footers"], "package.footers");
+	validateNoteStories(documentPackage["footnotes"], "package.footnotes");
+	validateNoteStories(documentPackage["endnotes"], "package.endnotes");
+	if (Array.isArray(documentBody["comments"])) for (const [index, comment] of documentBody["comments"].entries()) {
+		const commentPath = `package.document.comments[${String(index)}]`;
+		if (!isRecord(comment)) {
+			addMalformedIssue(commentPath, "an object");
+			continue;
+		}
+		validateBlocks(comment["content"], `${commentPath}.content`);
+	}
+	return {
+		valid: issues.every(({ severity }) => severity !== "error"),
+		issues
+	};
+};
 const assertValidFolioDocumentModel = (document, context) => {
 	const validation = validateFolioDocumentModel(document);
 	if (validation.valid) return;

package/dist/docx/newImage.d.ts

@@ -6,6 +6,5 @@ import { DrawingContent, RunContent } from "../types/content.js";
  * Raw OOXML drawings can carry previews for browser rendering. Only an explicit
  * synthetic relationship opts a detached raw picture into media registration.
  */
-declare const isNewDataUrlDrawing: (content: RunContent) => content is DrawingContent;
-//#endregion
-export { isNewDataUrlDrawing };
+export declare const isNewDataUrlDrawing: (content: RunContent) => content is DrawingContent;
+//#endregion

package/dist/docx/nonVisualDrawingProps.d.ts

@@ -11,7 +11,7 @@ import { XmlElement } from "./xmlParser.js";
  * tell the two apart. `@descr` and `@title` are optional and written only when
  * authored, so `""` in either is a string someone wrote.
  */
-declare const parseNonVisualDrawingNames: (element: XmlElement | null | undefined) => document_d_exports.NonVisualDrawingNames;
+export declare const parseNonVisualDrawingNames: (element: XmlElement | null | undefined) => document_d_exports.NonVisualDrawingNames;
 /**
  * The `name`, `descr` and `title` attributes of a `CT_NonVisualDrawingProps`
  * element, leading space included.
@@ -21,6 +21,6 @@ declare const parseNonVisualDrawingNames: (element: XmlElement | null | undefine
  * "Shape 3" would overwrite the author's own name for every drawing whose
  * name did not survive the model, and read back as authored content.
  */
-declare const serializeNonVisualDrawingNames: (names: document_d_exports.NonVisualDrawingNames) => string;
+export declare const serializeNonVisualDrawingNames: (names: document_d_exports.NonVisualDrawingNames) => string;
 type NonVisualDrawingNames = document_d_exports.NonVisualDrawingNames;
-export { type NonVisualDrawingNames, parseNonVisualDrawingNames, serializeNonVisualDrawingNames };
+export type { NonVisualDrawingNames };

package/dist/docx/normalizeBaseDirection.d.ts

@@ -6,6 +6,5 @@ import { document_d_exports } from "../types/document.js";
  * A paragraph whose direction is set directly OR via its style / doc defaults
  * is left untouched.
  */
-declare const normalizeBaseDirection: (doc: document_d_exports.Document) => document_d_exports.Document;
-//#endregion
-export { normalizeBaseDirection };
+export declare const normalizeBaseDirection: (doc: document_d_exports.Document) => document_d_exports.Document;
+//#endregion

package/dist/docx/normalizeBaseDirection.js

@@ -59,14 +59,18 @@ const normalizeCellBlock = (block, styles) => {
 		};
 		case "preservedBlock":
 		case "bookmarkStart":
-		case "bookmarkEnd": return block;
+		case "bookmarkEnd":
+		case "moveFromRangeStart":
+		case "moveFromRangeEnd":
+		case "moveToRangeStart":
+		case "moveToRangeEnd": return block;
 		default: return block;
 	}
 };
 const normalizeBlocks = (blocks, styles) => blocks.map((block) => {
 	if (block.type === "paragraph") return normalizeParagraph(block, styles);
 	if (block.type === "table") return normalizeTable(block, styles);
-	if (block.type === "preservedBlock" || block.type === "bookmarkStart" || block.type === "bookmarkEnd") return block;
+	if (block.type === "preservedBlock" || block.type === "bookmarkStart" || block.type === "bookmarkEnd" || block.type === "moveFromRangeStart" || block.type === "moveFromRangeEnd" || block.type === "moveToRangeStart" || block.type === "moveToRangeEnd") return block;
 	return {
 		...block,
 		content: normalizeBlocks(block.content, styles)

package/dist/docx/noteIds.d.ts

@@ -4,6 +4,5 @@
  * unique per document, so the allocator lives for one call: the result
  * depends only on the document, never on what other documents minted.
  */
-declare const mintEndnoteId: (existingIds: Iterable<number>) => number;
-//#endregion
-export { mintEndnoteId };
+export declare const mintEndnoteId: (existingIds: Iterable<number>) => number;
+//#endregion

package/dist/docx/notePropertiesParser.d.ts

@@ -5,11 +5,10 @@ import { XmlElement } from "./xmlParser.js";
  * Parse footnote properties from w:footnotePr element
  * (Can appear in w:sectPr or w:settings)
  */
-declare function parseFootnoteProperties(element: XmlElement | null): document_d_exports.FootnoteProperties;
+export declare function parseFootnoteProperties(element: XmlElement | null): document_d_exports.FootnoteProperties;
 /**
  * Parse endnote properties from w:endnotePr element
  * (Can appear in w:sectPr or w:settings)
  */
-declare function parseEndnoteProperties(element: XmlElement | null): document_d_exports.EndnoteProperties;
-//#endregion
-export { parseEndnoteProperties, parseFootnoteProperties };
+export declare function parseEndnoteProperties(element: XmlElement | null): document_d_exports.EndnoteProperties;
+//#endregion

package/dist/docx/noteReferenceMark.d.ts

@@ -2,16 +2,16 @@ import { document_d_exports } from "../types/document.js";
 //#region src/docx/noteReferenceMark.d.ts
 type NoteKind = "footnote" | "endnote";
 /** The run carrying a note's in-note reference mark, in the note reference style. */
-declare const noteReferenceMarkRun: (kind: NoteKind) => document_d_exports.Run;
+export declare const noteReferenceMarkRun: (kind: NoteKind) => document_d_exports.Run;
 /** Whether a note already owns its typed marker, including inside tracked content. */
-declare const hasNoteReferenceMark: (kind: NoteKind, content: readonly document_d_exports.BlockContent[]) => boolean;
+export declare const hasNoteReferenceMark: (kind: NoteKind, content: readonly document_d_exports.BlockContent[]) => boolean;
 /**
  * A note's content with its reference mark run at the start of its first
  * paragraph, added when the note has none.
  */
-declare const withNoteReferenceMark: (kind: NoteKind, content: readonly document_d_exports.BlockContent[]) => document_d_exports.BlockContent[];
+export declare const withNoteReferenceMark: (kind: NoteKind, content: readonly document_d_exports.BlockContent[]) => document_d_exports.BlockContent[];
 /** A new note, as an editor adds one: its content led by its own reference mark. */
-declare function createNote(kind: "footnote", id: number, content: readonly document_d_exports.BlockContent[]): document_d_exports.Footnote;
-declare function createNote(kind: "endnote", id: number, content: readonly document_d_exports.BlockContent[]): document_d_exports.Endnote;
+export declare function createNote(kind: "footnote", id: number, content: readonly document_d_exports.BlockContent[]): document_d_exports.Footnote;
+export declare function createNote(kind: "endnote", id: number, content: readonly document_d_exports.BlockContent[]): document_d_exports.Endnote;
 //#endregion
-export { createNote, hasNoteReferenceMark, noteReferenceMarkRun, withNoteReferenceMark };
+export {};

package/dist/docx/noteReferenceStyles.d.ts

@@ -1,18 +1,18 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/noteReferenceStyles.d.ts
 /** The id `commentSerializer` and `paragraphSerializer` write. */
-declare const COMMENT_REFERENCE_STYLE_ID = "CommentReference";
+export declare const COMMENT_REFERENCE_STYLE_ID = "CommentReference";
 /** The ids `noteSerializer` writes for the two note kinds. */
-declare const FOOTNOTE_REFERENCE_STYLE_ID = "FootnoteReference";
-declare const ENDNOTE_REFERENCE_STYLE_ID = "EndnoteReference";
+export declare const FOOTNOTE_REFERENCE_STYLE_ID = "FootnoteReference";
+export declare const ENDNOTE_REFERENCE_STYLE_ID = "EndnoteReference";
 /** Which reference marks a package actually contains. */
-type NoteReferenceNeeds = {
+export type NoteReferenceNeeds = {
   comments: boolean;
   footnotes: boolean;
   endnotes: boolean;
 };
 /** What a package's content requires, read off the model rather than guessed. */
-declare const noteReferenceNeeds: (pkg: {
+export declare const noteReferenceNeeds: (pkg: {
   comments?: unknown[] | undefined;
   footnotes?: unknown[] | undefined;
   endnotes?: unknown[] | undefined;
@@ -24,6 +24,5 @@ declare const noteReferenceNeeds: (pkg: {
  * caller owns the document, and a document that already defines the style
  * (under any id folio recognises) keeps its own.
  */
-declare const missingNoteReferenceStyles: (styles: document_d_exports.StyleDefinitions | undefined, needs: NoteReferenceNeeds) => document_d_exports.Style[];
-//#endregion
-export { COMMENT_REFERENCE_STYLE_ID, ENDNOTE_REFERENCE_STYLE_ID, FOOTNOTE_REFERENCE_STYLE_ID, NoteReferenceNeeds, missingNoteReferenceStyles, noteReferenceNeeds };
+export declare const missingNoteReferenceStyles: (styles: document_d_exports.StyleDefinitions | undefined, needs: NoteReferenceNeeds) => document_d_exports.Style[];
+//#endregion

package/dist/docx/noteReferenceStyles.js

@@ -1,18 +1,5 @@
 import { BUILT_IN_STYLE_NAME } from "./builtInStyles.js";
 //#region src/docx/noteReferenceStyles.ts
-/**
-* The character styles folio's serializers write into every document that
-* carries a comment or a note, and the definitions that keep those references
-* from dangling.
-*
-* `commentSerializer`, `paragraphSerializer` and `noteSerializer` each emit
-* `<w:rStyle w:val="…"/>` for the reference mark, because that is what Word
-* writes and what makes the mark superscript. Nothing guaranteed the document
-* *defined* those styles: a package folio assembled from the generic style set
-* referenced `FootnoteReference` while declaring only seven paragraph styles,
-* so the mark rendered as body text. One owner here, so a serializer and the
-* style table cannot disagree about the id.
-*/
 /** The id `commentSerializer` and `paragraphSerializer` write. */
 const COMMENT_REFERENCE_STYLE_ID = "CommentReference";
 /** The ids `noteSerializer` writes for the two note kinds. */

package/dist/docx/numberingIds.d.ts

@@ -5,10 +5,10 @@ type MintNumberingIdOptions = {
   existingIds: Iterable<number>;
 };
 /** Independent offline packages can allocate deterministically without retaining realm state. */
-declare const createNumberingIdAllocator: (kind: NumberingKind, existingIds: Iterable<number>) => {
+export declare const createNumberingIdAllocator: (kind: NumberingKind, existingIds: Iterable<number>) => {
   reserve: (ids: Iterable<number>) => void;
   next: () => number;
 };
-declare const mintNumberingId: ({ kind, existingIds }: MintNumberingIdOptions) => number;
+export declare const mintNumberingId: ({ kind, existingIds }: MintNumberingIdOptions) => number;
 //#endregion
-export { createNumberingIdAllocator, mintNumberingId };
+export {};

package/dist/docx/numberingParser.d.ts

@@ -1,10 +1,11 @@
 import { document_d_exports } from "../types/document.js";
 import { formatOoxmlCounter, padDecimal } from "./ooxmlCounterFormatter.js";
+import { numberingLevelHasMarkerSlot } from "@stll/docx-core/model";
 //#region src/docx/numberingParser.d.ts
 /**
  * Map of rId to numbering definitions
  */
-type NumberingMap = {
+export type NumberingMap = {
   definitions: document_d_exports.NumberingDefinitions;
   /** Get level info for a numId and ilvl */
   getLevel: (numId: number, ilvl: number) => document_d_exports.ListLevel | null;
@@ -23,7 +24,7 @@ type NumberingMap = {
  * @param numberingXml - Raw XML string from word/numbering.xml (or null if not present)
  * @returns NumberingMap with definitions and helper functions
  */
-declare function parseNumbering(numberingXml: string | null): NumberingMap;
+export declare function parseNumbering(numberingXml: string | null): NumberingMap;
 /** A `w:numFmt` as the model holds it: its token and authored format metadata. */
 type ResolvedNumFmt = Pick<document_d_exports.ListLevel, "numFmt" | "numFmtFormat">;
 /**
@@ -34,17 +35,17 @@ type ResolvedNumFmt = Pick<document_d_exports.ListLevel, "numFmt" | "numFmtForma
  * "0001, 0002, 0003, ...". Word only emits zero-padded decimal customs this
  * way; the width is the digit count of the first token, clamped to five.
  */
-declare const customNumberFormatPadWidth: (format: string | undefined) => number | undefined;
+export declare const customNumberFormatPadWidth: (format: string | undefined) => number | undefined;
 /** What the marker renderer counts a level in; `custom` decides by pad width. */
-declare const counterFormatOf: (level: ResolvedNumFmt) => document_d_exports.CounterFormat;
+export declare const counterFormatOf: (level: ResolvedNumFmt) => document_d_exports.CounterFormat;
 /** {@link MARKER_ALIGNMENT} for a level that may not state a justification. */
-declare const markerAlignmentForLevel: (lvlJc: document_d_exports.ParagraphAlignment | undefined) => document_d_exports.ListRendering["markerAlignment"];
-declare const markerFormattingFromLevel: (formatting: document_d_exports.TextFormatting | undefined) => document_d_exports.ListMarkerFormatting | undefined;
-declare function getCachedNumberingMap(definitions: document_d_exports.NumberingDefinitions): NumberingMap;
+export declare const markerAlignmentForLevel: (lvlJc: document_d_exports.ParagraphAlignment | undefined) => document_d_exports.ListRendering["markerAlignment"];
+export declare const markerFormattingFromLevel: (formatting: document_d_exports.TextFormatting | undefined) => document_d_exports.ListMarkerFormatting | undefined;
+export declare function getCachedNumberingMap(definitions: document_d_exports.NumberingDefinitions): NumberingMap;
 /**
  * Create a NumberingMap with helper functions
  */
-declare function createNumberingMap(definitions: document_d_exports.NumberingDefinitions): NumberingMap;
+export declare function createNumberingMap(definitions: document_d_exports.NumberingDefinitions): NumberingMap;
 /**
  * Resolve a paragraph's `numPr` against the numbering definitions into the
  * base `ListRendering` the layout pipeline needs (marker template, per-level
@@ -57,7 +58,7 @@ declare function createNumberingMap(definitions: document_d_exports.NumberingDef
  * the second-slot offset from the paragraph's content; those fields are absent
  * here because the picker has no paragraph content to inspect.
  */
-declare function computeListRendering(numPr: {
+export declare function computeListRendering(numPr: {
   numId?: number;
   ilvl?: number;
 }, numbering: NumberingMap): document_d_exports.ListRendering | null;
@@ -69,21 +70,19 @@ declare function computeListRendering(numPr: {
  * @param formats - Array of number formats for each level
  * @returns Rendered marker text
  */
-declare function renderListMarker(lvlText: string, counters: number[], formats: document_d_exports.CounterFormat[]): string;
+export declare function renderListMarker(lvlText: string, counters: number[], formats: document_d_exports.CounterFormat[]): string;
 /**
  * Get the bullet character for a bullet list level
  *
  * @param level - The list level definition
  * @returns The bullet character to display
  */
-declare function getBulletCharacter(level: document_d_exports.ListLevel): string;
+export declare function getBulletCharacter(level: document_d_exports.ListLevel): string;
 /**
  * Check if a list level is a bullet (not numbered)
  */
-declare function isBulletLevel(level: document_d_exports.ListLevel): boolean;
+export declare function isBulletLevel(level: document_d_exports.ListLevel): boolean;
 /** Whether a numbering definition uses a bullet marker rather than a numeric or hidden one. */
-declare const numberingLevelUsesBulletMarker: (level: Pick<document_d_exports.ListLevel, "numFmt"> | null | undefined) => boolean;
-/** Whether a numbering level reserves horizontal space for a visible marker. */
-declare const numberingLevelHasMarkerSlot: (level: Pick<document_d_exports.ListLevel, "numFmt">) => boolean;
+export declare const numberingLevelUsesBulletMarker: (level: Pick<document_d_exports.ListLevel, "numFmt"> | null | undefined) => boolean;
 //#endregion
-export { NumberingMap, computeListRendering, counterFormatOf, createNumberingMap, customNumberFormatPadWidth, formatOoxmlCounter as formatNumber, getBulletCharacter, getCachedNumberingMap, isBulletLevel, markerAlignmentForLevel, markerFormattingFromLevel, numberingLevelHasMarkerSlot, numberingLevelUsesBulletMarker, padDecimal, parseNumbering, renderListMarker };
+export { formatOoxmlCounter as formatNumber, numberingLevelHasMarkerSlot, padDecimal };

package/dist/docx/numberingParser.js

@@ -6,7 +6,7 @@ import { parseParagraphProperties } from "./paragraphProperties.js";
 import { LevelSuffixSchema, NumberFormatSchema, ParagraphAlignmentSchema, narrowEnum } from "./parserEnums.js";
 import { RUN_PROPERTY_OWNERS, parseRunProperties } from "./runParser.js";
 import { findChild, getAttribute, parseBooleanElement, parseNumericAttribute, parseOnOffAttribute, parseXmlDocument } from "./xmlParser.js";
-import { isNumberingLevel } from "@stll/docx-core/model";
+import { numberingLevelHasMarkerSlot, resolveNumberingLevel } from "@stll/docx-core/model";
 //#region src/docx/numberingParser.ts
 /**
 * Numbering/List Parser for DOCX
@@ -404,32 +404,8 @@ function createNumberingMap(definitions) {
 	return {
 		definitions,
 		getLevel(numId, ilvl) {
-			if (!isNumberingLevel(ilvl)) return null;
-			const num = numMap.get(numId);
-			if (!num) return null;
-			if (num.levelOverrides) {
-				const override = num.levelOverrides.find((o) => o.ilvl === ilvl);
-				if (override) {
-					if (override.lvl) return override.lvl;
-					const abstractNum = abstractMap.get(num.abstractNumId);
-					if (abstractNum) {
-						const baseLevel = abstractNum.levels.find((l) => l.ilvl === ilvl);
-						if (baseLevel && override.startOverride !== void 0) return {
-							...baseLevel,
-							start: override.startOverride
-						};
-					}
-				}
-			}
-			let abstractNum = abstractMap.get(num.abstractNumId);
-			if (!abstractNum) return null;
-			if (abstractNum.numStyleLink && abstractNum.levels.length === 0) {
-				for (const candidate of abstractMap.values()) if (candidate.styleLink === abstractNum.numStyleLink && candidate.levels.length > 0) {
-					abstractNum = candidate;
-					break;
-				}
-			}
-			return abstractNum.levels.find((l) => l.ilvl === ilvl) ?? null;
+			const resolution = resolveNumberingLevel(definitions, numId, ilvl);
+			return resolution.kind === "level" ? resolution.level : null;
 		},
 		getAbstractNumId(numId) {
 			return numMap.get(numId)?.abstractNumId ?? null;
@@ -508,7 +484,9 @@ function renderListMarker(lvlText, counters, formats) {
 		const placeholder = `%${i}`;
 		if (result.includes(placeholder)) {
 			const counterIndex = i - 1;
-			const formatted = formatOoxmlCounter(counters[counterIndex] ?? 1, formats[counterIndex] ?? "decimal");
+			const counter = counters[counterIndex] ?? 1;
+			const format = formats[counterIndex] ?? "decimal";
+			const formatted = formatOoxmlCounter(counter, format);
 			result = result.replaceAll(placeholder, formatted);
 		}
 	}
@@ -538,7 +516,5 @@ function isBulletLevel(level) {
 }
 /** Whether a numbering definition uses a bullet marker rather than a numeric or hidden one. */
 const numberingLevelUsesBulletMarker = (level) => level?.numFmt === "bullet";
-/** Whether a numbering level reserves horizontal space for a visible marker. */
-const numberingLevelHasMarkerSlot = (level) => level.numFmt !== "none";
 //#endregion
 export { computeListRendering, counterFormatOf, createNumberingMap, customNumberFormatPadWidth, formatOoxmlCounter as formatNumber, getBulletCharacter, getCachedNumberingMap, isBulletLevel, markerAlignmentForLevel, markerFormattingFromLevel, numberingLevelHasMarkerSlot, numberingLevelUsesBulletMarker, padDecimal, parseNumbering, renderListMarker };

package/dist/docx/numberingReference.d.ts

@@ -9,6 +9,6 @@ import { NO_NUMBERING_NUM_ID, NO_PARAGRAPH_NUMBERING, ParagraphNumberingOverride
  * reviewer changed, not a statement about this paragraph's numbering, and it
  * travels as captured markup.
  */
-declare const readParagraphNumbering: (numPr: XmlElement | null | undefined) => ParagraphNumberingOverride$1 | undefined;
+export declare const readParagraphNumbering: (numPr: XmlElement | null | undefined) => ParagraphNumberingOverride$1 | undefined;
 //#endregion
-export { NO_NUMBERING_NUM_ID, NO_PARAGRAPH_NUMBERING, type ParagraphNumberingOverride, type ParagraphNumberingReference, type ParagraphNumberingSlots, type ResolvedParagraphNumbering, isNumberingReference, mergeParagraphNumbering, paragraphNumberingFromSlots, paragraphNumberingLevel, paragraphNumberingReference, paragraphNumberingReferenceId, paragraphNumberingSlots, readParagraphNumbering, resolveParagraphNumbering, sameEffectiveParagraphNumbering, sameStatedParagraphNumbering };
+export { NO_NUMBERING_NUM_ID, NO_PARAGRAPH_NUMBERING, type ParagraphNumberingOverride, type ParagraphNumberingReference, type ParagraphNumberingSlots, type ResolvedParagraphNumbering, isNumberingReference, mergeParagraphNumbering, paragraphNumberingFromSlots, paragraphNumberingLevel, paragraphNumberingReference, paragraphNumberingReferenceId, paragraphNumberingSlots, resolveParagraphNumbering, sameEffectiveParagraphNumbering, sameStatedParagraphNumbering };

package/dist/docx/numberingReferenceNormalization.d.ts

@@ -2,8 +2,8 @@ import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
 //#region src/docx/numberingReferenceNormalization.d.ts
 /** The codes this normalisation is reported under, owned here, not at the caller. */
-declare const UNNUMBERED_PARAGRAPH_WARNING: "unnumbered-paragraph";
-declare const UNNUMBERED_STYLE_WARNING: "unnumbered-style";
+export declare const UNNUMBERED_PARAGRAPH_WARNING: "unnumbered-paragraph";
+export declare const UNNUMBERED_STYLE_WARNING: "unnumbered-style";
 type NormalizeNumberingReferencesInput = {
   documentBody: document_d_exports.DocumentBody;
   numbering: NumberingMap;
@@ -15,7 +15,7 @@ type NormalizeNumberingReferencesInput = {
 type NormalizeNumberingReferencesResult = {
   unnumberedDanglingReferences: number;
 };
-declare const normalizeNumberingReferences: ({ documentBody, numbering, headers, footers, footnotes, endnotes }: NormalizeNumberingReferencesInput) => NormalizeNumberingReferencesResult;
+export declare const normalizeNumberingReferences: ({ documentBody, numbering, headers, footers, footnotes, endnotes }: NormalizeNumberingReferencesInput) => NormalizeNumberingReferencesResult;
 type NormalizeStyleNumberingReferencesInput = {
   styles: readonly document_d_exports.Style[];
   numbering: NumberingMap | undefined;
@@ -24,6 +24,6 @@ type NormalizeStyleNumberingReferencesResult = {
   /** Style ids whose dangling reference became the "no numbering" sentinel. */
   unnumberedStyleIds: string[];
 };
-declare const normalizeStyleNumberingReferences: ({ styles, numbering }: NormalizeStyleNumberingReferencesInput) => NormalizeStyleNumberingReferencesResult;
+export declare const normalizeStyleNumberingReferences: ({ styles, numbering }: NormalizeStyleNumberingReferencesInput) => NormalizeStyleNumberingReferencesResult;
 //#endregion
-export { UNNUMBERED_PARAGRAPH_WARNING, UNNUMBERED_STYLE_WARNING, normalizeNumberingReferences, normalizeStyleNumberingReferences };
+export {};

package/dist/docx/numberingReferenceNormalization.js

@@ -1,6 +1,6 @@
 import { NO_PARAGRAPH_NUMBERING as NO_PARAGRAPH_NUMBERING$1, paragraphNumberingReferenceId } from "./numberingReference.js";
 import { visitDocxParagraphs } from "./paragraphTraversal.js";
-import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
+import { PARSE_WARNING_CODES, numberingInstanceResolves } from "@stll/docx-core/model";
 //#region src/docx/numberingReferenceNormalization.ts
 /**
 * Parse-boundary tolerance for `w:numPr` numbering references.
@@ -18,15 +18,12 @@ import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
 * shows no number would come back numbered.
 */
 /**
-* Whether a `w:numId` still reaches a level definition: a `w:num` that names a
-* `w:abstractNum` the numbering part defines. Both hops can dangle, and a
-* `w:num` with no `w:abstractNum` numbers nothing just as a missing one does.
+* Whether a `w:numId` still reaches a level definition, as the numbering owner
+* decides it: a `w:num` naming a `w:abstractNum` the part defines, or one whose
+* full level override defines a level itself. A `w:num` with neither numbers
+* nothing just as a missing one does.
 */
-const resolvesNumbering = (numId, numbering) => {
-	if (!numbering) return false;
-	const abstractNumId = numbering.getAbstractNumId(numId);
-	return abstractNumId !== null && numbering.getAbstract(abstractNumId) !== null;
-};
+const resolvesNumbering = (numId, numbering) => numbering !== void 0 && numberingInstanceResolves(numbering.definitions, numId);
 /** The codes this normalisation is reported under, owned here, not at the caller. */
 const UNNUMBERED_PARAGRAPH_WARNING = PARSE_WARNING_CODES.unnumberedParagraph;
 const UNNUMBERED_STYLE_WARNING = PARSE_WARNING_CODES.unnumberedStyle;

package/dist/docx/numericIdAllocator.d.ts

@@ -4,9 +4,9 @@ type NumericIdAllocatorOptions = {
   firstId: 0 | 1;
 };
 /** Each OOXML id space owns one instance, retaining loaded and minted ids through rollover. */
-declare const createNumericIdAllocator: ({ space, firstId }: NumericIdAllocatorOptions) => {
+export declare const createNumericIdAllocator: ({ space, firstId }: NumericIdAllocatorOptions) => {
   reserve: (ids: Iterable<number>) => void;
   next: () => number;
 };
 //#endregion
-export { createNumericIdAllocator };
+export {};

package/dist/docx/numericIdNormalization.d.ts

@@ -9,8 +9,8 @@ type NumericIdNormalizationOptions = {
  * Reserve the complete package first, then remap each old value once per space.
  * Source splices preserve unrelated XML bytes; a valid package takes the fast path.
  */
-declare const normalizeImportedNumericIds: (parts: ReadonlyMap<string, string>, options?: NumericIdNormalizationOptions) => ReadonlyMap<string, string>;
+export declare const normalizeImportedNumericIds: (parts: ReadonlyMap<string, string>, options?: NumericIdNormalizationOptions) => ReadonlyMap<string, string>;
 /** Parser boundary: all captures and selective-save bytes see the same identities. */
-declare const normalizeRawDocxNumericIds: (raw: RawDocxContent) => Promise<XmlElement | undefined>;
+export declare const normalizeRawDocxNumericIds: (raw: RawDocxContent) => Promise<XmlElement | undefined>;
 //#endregion
-export { normalizeImportedNumericIds, normalizeRawDocxNumericIds };
+export {};

package/dist/docx/numericIdNormalization.js

@@ -21,7 +21,6 @@ const identitySpace = ({ elementName, attributeName, domain }) => {
 		case "abstractNumId": return "numbering-abstract";
 		case "numPicBulletId":
 		case "lvlPicBulletId": return "numbering-picture";
-		default: break;
 	}
 	switch (element) {
 		case "footnote":

package/dist/docx/ooxmlCounterFormatter.d.ts

@@ -1,8 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/ooxmlCounterFormatter.d.ts
 /** Zero-pad a counter to `width` digits (the `decimalZero` family). */
-declare const padDecimal: (value: number, width: number) => string;
+export declare const padDecimal: (value: number, width: number) => string;
 /** Format one OOXML numbering counter using Microsoft Word display semantics. */
-declare const formatOoxmlCounter: (value: number, format: document_d_exports.CounterFormat | undefined) => string;
-//#endregion
-export { formatOoxmlCounter, padDecimal };
+export declare const formatOoxmlCounter: (value: number, format: document_d_exports.CounterFormat | undefined) => string;
+//#endregion

package/dist/docx/opaqueCarrier.d.ts

@@ -1,7 +1,6 @@
 //#region src/docx/opaqueCarrier.d.ts
-declare const OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC = "[Unsupported block-level tracked-change content]";
-declare const opaqueRevisionCarrierName: (xml: string) => string | undefined;
-declare const countOpaqueRevisionWrappers: (xml: string) => number;
-declare const isOpaqueNestedRowMarkup: (xml: string) => boolean;
-//#endregion
-export { OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC, countOpaqueRevisionWrappers, isOpaqueNestedRowMarkup, opaqueRevisionCarrierName };
+export declare const OPAQUE_REVISION_CARRIER_READER_DIAGNOSTIC = "[Unsupported block-level tracked-change content]";
+export declare const opaqueRevisionCarrierName: (xml: string) => string | undefined;
+export declare const countOpaqueRevisionWrappers: (xml: string) => number;
+export declare const isOpaqueNestedRowMarkup: (xml: string) => boolean;
+//#endregion