@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/numberingParser.js

@@ -1,72 +1,29 @@
+import { DERIVED_PART_ROOT_ATTRIBUTES, attributeRemainder } from "./attributeRemainder.js";
+import { CAPTURE, dispatchChildren, sequencePositions } from "./containerChildren.js";
 import { isNumberingReference } from "./numberingReference.js";
 import { formatOoxmlCounter, padDecimal } from "./ooxmlCounterFormatter.js";
-import { LevelSuffixSchema, narrowEnum } from "./parserEnums.js";
-import { parseRunProperties } from "./runParser.js";
-import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, findChildren, getAttribute, getLocalName, getNamespaceUri, parseBooleanElement, parseNumericAttribute, parseXmlDocument } from "./xmlParser.js";
+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";
 //#region src/docx/numberingParser.ts
-const NUMBER_FORMAT_MAP = {
-	decimal: "decimal",
-	upperRoman: "upperRoman",
-	lowerRoman: "lowerRoman",
-	upperLetter: "upperLetter",
-	lowerLetter: "lowerLetter",
-	ordinal: "ordinal",
-	cardinalText: "cardinalText",
-	ordinalText: "ordinalText",
-	hex: "hex",
-	chicago: "chicago",
-	bullet: "bullet",
-	none: "none",
-	decimalZero: "decimalZero",
-	ganada: "ganada",
-	chosung: "chosung",
-	ideographDigital: "ideographDigital",
-	japaneseCounting: "japaneseCounting",
-	aiueo: "aiueo",
-	iroha: "iroha",
-	decimalFullWidth: "decimalFullWidth",
-	decimalHalfWidth: "decimalHalfWidth",
-	japaneseLegal: "japaneseLegal",
-	japaneseDigitalTenThousand: "japaneseDigitalTenThousand",
-	decimalEnclosedCircle: "decimalEnclosedCircle",
-	decimalFullWidth2: "decimalFullWidth2",
-	aiueoFullWidth: "aiueoFullWidth",
-	irohaFullWidth: "irohaFullWidth",
-	decimalEnclosedFullstop: "decimalEnclosedFullstop",
-	decimalEnclosedParen: "decimalEnclosedParen",
-	decimalEnclosedCircleChinese: "decimalEnclosedCircleChinese",
-	ideographEnclosedCircle: "ideographEnclosedCircle",
-	ideographTraditional: "ideographTraditional",
-	ideographZodiac: "ideographZodiac",
-	ideographZodiacTraditional: "ideographZodiacTraditional",
-	taiwaneseCounting: "taiwaneseCounting",
-	ideographLegalTraditional: "ideographLegalTraditional",
-	taiwaneseCountingThousand: "taiwaneseCountingThousand",
-	taiwaneseDigital: "taiwaneseDigital",
-	chineseCounting: "chineseCounting",
-	chineseLegalSimplified: "chineseLegalSimplified",
-	chineseCountingThousand: "chineseCountingThousand",
-	koreanDigital: "koreanDigital",
-	koreanCounting: "koreanCounting",
-	koreanLegal: "koreanLegal",
-	koreanDigital2: "koreanDigital2",
-	vietnameseCounting: "vietnameseCounting",
-	russianLower: "russianLower",
-	russianUpper: "russianUpper",
-	numberInDash: "numberInDash",
-	hebrew1: "hebrew1",
-	hebrew2: "hebrew2",
-	arabicAlpha: "arabicAlpha",
-	arabicAbjad: "arabicAbjad",
-	hindiVowels: "hindiVowels",
-	hindiConsonants: "hindiConsonants",
-	hindiNumbers: "hindiNumbers",
-	hindiCounting: "hindiCounting",
-	thaiLetters: "thaiLetters",
-	thaiNumbers: "thaiNumbers",
-	thaiCounting: "thaiCounting"
+/** `w:abstractNum` reads its id; everything else it carries is the remainder's. */
+const MODELLED_ABSTRACT_NUM_ATTRIBUTES = /* @__PURE__ */ new Set(["abstractNumId"]);
+/** `w:lvl` reads the level it defines and Word's two template markers. */
+const MODELLED_LVL_ATTRIBUTES = /* @__PURE__ */ new Set([
+	"ilvl",
+	"tplc",
+	"tentative"
+]);
+/** `w:num` reads the id paragraphs reference it by. */
+const MODELLED_NUM_ATTRIBUTES = /* @__PURE__ */ new Set(["numId"]);
+/** `w:lvlOverride` reads the level it overrides. */
+const MODELLED_LVL_OVERRIDE_ATTRIBUTES = /* @__PURE__ */ new Set(["ilvl"]);
+const attributeValue = (element) => getAttribute(element, "w", "val") ?? void 0;
+const integerValue = (element) => {
+	const parsed = parseNumericAttribute(element, "w", "val");
+	return parsed === void 0 || !Number.isFinite(parsed) ? void 0 : parsed;
 };
-const wordprocessingLocalName = (element) => WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "") ? getLocalName(element.name) : null;
 /**
 * Parse numbering.xml into NumberingDefinitions
 *
@@ -81,16 +38,29 @@ function parseNumbering(numberingXml) {
 	if (!numberingXml) return createNumberingMap(definitions);
 	const root = parseXmlDocument(numberingXml);
 	if (!root) return createNumberingMap(definitions);
-	const abstractNumElements = findChildren(root, "w", "abstractNum");
-	for (const abstractNum of abstractNumElements) {
-		const parsed = parseAbstractNumbering(abstractNum);
-		if (parsed) definitions.abstractNums.push(parsed);
-	}
-	const numElements = findChildren(root, "w", "num");
-	for (const num of numElements) {
-		const parsed = parseNumberingInstance(num);
-		if (parsed) definitions.nums.push(parsed);
-	}
+	const preserved = dispatchChildren({
+		element: root,
+		container: "w:numbering",
+		capturePosition: sequencePositions("w:numbering", root),
+		handlers: {
+			abstractNum: (child) => {
+				const parsed = parseAbstractNumbering(child);
+				if (parsed) definitions.abstractNums.push(parsed);
+			},
+			num: (child) => {
+				const parsed = parseNumberingInstance(child);
+				if (parsed) definitions.nums.push(parsed);
+			},
+			numPicBullet: CAPTURE,
+			numIdMacAtCleanup: CAPTURE
+		}
+	});
+	if (preserved !== void 0) definitions.preserved = preserved;
+	const preservedAttributes = attributeRemainder({
+		element: root,
+		modelled: DERIVED_PART_ROOT_ATTRIBUTES
+	});
+	if (preservedAttributes !== void 0) definitions.preservedAttributes = preservedAttributes;
 	return createNumberingMap(definitions);
 }
 /**
@@ -105,55 +75,44 @@ function parseAbstractNumbering(element) {
 		abstractNumId,
 		levels: []
 	};
-	let multiLevelTypeEl;
-	let nameEl;
-	let numStyleLinkEl;
-	let styleLinkEl;
-	const levelElements = [];
-	for (const child of element.elements ?? []) {
-		if (child.type !== "element") continue;
-		switch (wordprocessingLocalName(child)) {
-			case "multiLevelType":
-				multiLevelTypeEl ??= child;
-				break;
-			case "name":
-				nameEl ??= child;
-				break;
-			case "numStyleLink":
-				numStyleLinkEl ??= child;
-				break;
-			case "styleLink":
-				styleLinkEl ??= child;
-				break;
-			case "lvl":
-				levelElements.push(child);
-				break;
-			default: break;
+	const read = (key, value) => {
+		if (value === void 0) return;
+		abstractNum[key] = value;
+	};
+	const preserved = dispatchChildren({
+		element,
+		container: "w:abstractNum",
+		capturePosition: sequencePositions("w:abstractNum", element),
+		handlers: {
+			nsid: (child) => read("nsid", attributeValue(child)),
+			multiLevelType: (child) => read("multiLevelType", narrow(attributeValue(child), MULTI_LEVEL_TYPES)),
+			tmpl: (child) => read("tmpl", attributeValue(child)),
+			name: (child) => read("name", attributeValue(child)),
+			styleLink: (child) => read("styleLink", attributeValue(child)),
+			numStyleLink: (child) => read("numStyleLink", attributeValue(child)),
+			lvl: (child) => {
+				const level = parseListLevel(child);
+				if (level) abstractNum.levels.push(level);
+			}
 		}
-	}
-	if (multiLevelTypeEl) {
-		const mlType = getAttribute(multiLevelTypeEl, "w", "val");
-		if (mlType === "hybridMultilevel" || mlType === "multilevel" || mlType === "singleLevel") abstractNum.multiLevelType = mlType;
-	}
-	if (nameEl) {
-		const nameVal = getAttribute(nameEl, "w", "val");
-		if (nameVal != null) abstractNum.name = nameVal;
-	}
-	if (numStyleLinkEl) {
-		const numStyleLinkVal = getAttribute(numStyleLinkEl, "w", "val");
-		if (numStyleLinkVal != null) abstractNum.numStyleLink = numStyleLinkVal;
-	}
-	if (styleLinkEl) {
-		const styleLinkVal = getAttribute(styleLinkEl, "w", "val");
-		if (styleLinkVal != null) abstractNum.styleLink = styleLinkVal;
-	}
-	for (const lvlEl of levelElements) {
-		const level = parseListLevel(lvlEl);
-		if (level) abstractNum.levels.push(level);
-	}
+	});
+	if (preserved !== void 0) abstractNum.preserved = preserved;
+	const preservedAttributes = attributeRemainder({
+		element,
+		modelled: MODELLED_ABSTRACT_NUM_ATTRIBUTES
+	});
+	if (preservedAttributes !== void 0) abstractNum.preservedAttributes = preservedAttributes;
 	abstractNum.levels.sort((a, b) => a.ilvl - b.ilvl);
 	return abstractNum;
 }
+/** ECMA-376 §17.9.1: a `w:abstractNum` defines levels 0 through 8 and no more. */
+const MAX_LIST_LEVEL = 8;
+const MULTI_LEVEL_TYPES = [
+	"hybridMultilevel",
+	"multilevel",
+	"singleLevel"
+];
+const narrow = (carried, members) => members.find((member) => member === carried);
 /**
 * Parse a single w:num element (numbering instance)
 */
@@ -162,280 +121,222 @@ function parseNumberingInstance(element) {
 	if (numIdStr === null) return null;
 	const numId = Number.parseInt(numIdStr, 10);
 	if (Number.isNaN(numId)) return null;
-	let abstractNumIdEl;
-	const overrideElements = [];
-	for (const child of element.elements ?? []) {
-		if (child.type !== "element") continue;
-		if (wordprocessingLocalName(child) === "abstractNumId") {
-			abstractNumIdEl ??= child;
-			continue;
+	const levelOverrides = [];
+	let abstractNumId;
+	const preserved = dispatchChildren({
+		element,
+		container: "w:num",
+		capturePosition: sequencePositions("w:num", element),
+		handlers: {
+			abstractNumId: (child) => {
+				if (abstractNumId !== void 0) return;
+				abstractNumId = integerValue(child);
+			},
+			lvlOverride: (child) => {
+				const override = parseLevelOverride(child);
+				if (override) levelOverrides.push(override);
+			}
 		}
-		if (wordprocessingLocalName(child) === "lvlOverride") overrideElements.push(child);
-	}
-	if (!abstractNumIdEl) return null;
-	const abstractNumIdStr = getAttribute(abstractNumIdEl, "w", "val");
-	if (abstractNumIdStr === null) return null;
-	const abstractNumId = Number.parseInt(abstractNumIdStr, 10);
-	if (Number.isNaN(abstractNumId)) return null;
+	});
+	if (abstractNumId === void 0) return null;
 	const instance = {
 		numId,
 		abstractNumId
 	};
-	if (overrideElements.length > 0) {
-		instance.levelOverrides = [];
-		for (const overrideEl of overrideElements) {
-			const ilvlStr = getAttribute(overrideEl, "w", "ilvl");
-			if (ilvlStr === null) continue;
-			const ilvl = Number.parseInt(ilvlStr, 10);
-			if (Number.isNaN(ilvl)) continue;
-			const override = { ilvl };
-			let startOverrideEl;
-			let lvlEl;
-			for (const child of overrideEl.elements ?? []) {
-				if (child.type !== "element") continue;
-				if (wordprocessingLocalName(child) === "startOverride") {
-					startOverrideEl ??= child;
-					continue;
-				}
-				if (wordprocessingLocalName(child) === "lvl") lvlEl ??= child;
-			}
-			if (startOverrideEl) {
-				const startVal = getAttribute(startOverrideEl, "w", "val");
-				if (startVal !== null) {
-					const startNum = Number.parseInt(startVal, 10);
-					if (!Number.isNaN(startNum)) override.startOverride = startNum;
-				}
-			}
-			if (lvlEl) {
-				const parsedLvl = parseListLevel(lvlEl);
-				if (parsedLvl != null) override.lvl = parsedLvl;
+	if (levelOverrides.length > 0) instance.levelOverrides = levelOverrides;
+	if (preserved !== void 0) instance.preserved = preserved;
+	const preservedAttributes = attributeRemainder({
+		element,
+		modelled: MODELLED_NUM_ATTRIBUTES
+	});
+	if (preservedAttributes !== void 0) instance.preservedAttributes = preservedAttributes;
+	return instance;
+}
+/**
+* Parse a single w:lvlOverride element (one level of one numbering instance)
+*/
+function parseLevelOverride(element) {
+	const ilvl = parseNumericAttribute(element, "w", "ilvl");
+	if (ilvl === void 0) return null;
+	const override = { ilvl };
+	const preserved = dispatchChildren({
+		element,
+		container: "w:lvlOverride",
+		capturePosition: sequencePositions("w:lvlOverride", element),
+		handlers: {
+			startOverride: (child) => {
+				const start = integerValue(child);
+				if (start !== void 0 && override.startOverride === void 0) override.startOverride = start;
+			},
+			lvl: (child) => {
+				const level = parseListLevel(child);
+				if (level && override.lvl === void 0) override.lvl = level;
 			}
-			instance.levelOverrides.push(override);
 		}
-	}
-	return instance;
+	});
+	if (preserved !== void 0) override.preserved = preserved;
+	const preservedAttributes = attributeRemainder({
+		element,
+		modelled: MODELLED_LVL_OVERRIDE_ATTRIBUTES
+	});
+	if (preservedAttributes !== void 0) override.preservedAttributes = preservedAttributes;
+	return override;
 }
 /**
 * Parse a single w:lvl element (list level definition)
 */
 function parseListLevel(element) {
-	const ilvlStr = getAttribute(element, "w", "ilvl");
-	if (ilvlStr === null) return null;
-	const ilvl = Number.parseInt(ilvlStr, 10);
-	if (Number.isNaN(ilvl) || ilvl < 0 || ilvl > 8) return null;
+	const ilvl = parseNumericAttribute(element, "w", "ilvl");
+	if (ilvl === void 0) return null;
 	const level = {
 		ilvl,
 		numFmt: "decimal",
 		lvlText: ""
 	};
-	let startEl;
-	let numFmtEl;
-	let alternateEl;
-	let lvlTextEl;
-	let lvlJcEl;
-	let suffEl;
-	let isLglEl;
-	let lvlRestartEl;
-	let legacyEl;
-	let pPrEl;
-	let rPrEl;
-	for (const child of element.elements ?? []) {
-		if (child.type !== "element") continue;
-		const localName = wordprocessingLocalName(child);
-		if (localName === null) {
-			if (getLocalName(child.name) === "AlternateContent") alternateEl ??= child;
-			continue;
-		}
-		switch (localName) {
-			case "start":
-				startEl ??= child;
-				break;
-			case "numFmt":
-				numFmtEl ??= child;
-				break;
-			case "lvlText":
-				lvlTextEl ??= child;
-				break;
-			case "lvlJc":
-				lvlJcEl ??= child;
-				break;
-			case "suff":
-				suffEl ??= child;
-				break;
-			case "isLgl":
-				isLglEl ??= child;
-				break;
-			case "lvlRestart":
-				lvlRestartEl ??= child;
-				break;
-			case "legacy":
-				legacyEl ??= child;
-				break;
-			case "pPr":
-				pPrEl ??= child;
-				break;
-			case "rPr":
-				rPrEl ??= child;
-				break;
-			default: break;
-		}
-	}
-	if (startEl) {
-		const startVal = getAttribute(startEl, "w", "val");
-		if (startVal !== null) {
-			const startNum = Number.parseInt(startVal, 10);
-			if (!Number.isNaN(startNum)) level.start = startNum;
-		}
-	}
-	if (numFmtEl) level.numFmt = resolveNumFmt(numFmtEl) ?? "decimal";
-	else if (alternateEl) {
+	const alternateEl = findChild(element, "mc", "AlternateContent");
+	const read = (key, value) => {
+		if (value === void 0) return;
+		level[key] = value;
+	};
+	const preserved = dispatchChildren({
+		element,
+		container: "w:lvl",
+		capturePosition: sequencePositions("w:lvl", element),
+		handlers: {
+			start: (child) => read("start", integerValue(child)),
+			numFmt: (child) => {
+				const resolved = resolveNumFmt(child);
+				if (resolved === null) return CAPTURE;
+				Object.assign(level, resolved);
+			},
+			lvlRestart: (child) => read("lvlRestart", integerValue(child)),
+			pStyle: (child) => read("pStyle", attributeValue(child)),
+			isLgl: (child) => read("isLgl", parseBooleanElement(child)),
+			suff: (child) => read("suffix", narrowEnum(attributeValue(child), LevelSuffixSchema)),
+			lvlText: (child) => {
+				read("lvlText", attributeValue(child) ?? "");
+				const isNull = parseOnOffAttribute(child, "w", "null");
+				if (isNull !== void 0) level.lvlTextNull = isNull;
+			},
+			lvlPicBulletId: (child) => read("lvlPicBulletId", integerValue(child)),
+			legacy: (child) => read("legacy", legacyOf(child)),
+			lvlJc: (child) => read("lvlJc", narrowEnum(attributeValue(child), ParagraphAlignmentSchema)),
+			pPr: (child) => read("pPr", parseParagraphProperties(child, null) ?? {}),
+			rPr: (child) => read("rPr", parseRunProperties(child, null, RUN_PROPERTY_OWNERS.standalone) ?? {})
+		},
+		undeclared: { AlternateContent: () => void 0 }
+	});
+	if (preserved !== void 0) level.preserved = preserved;
+	const preservedAttributes = attributeRemainder({
+		element,
+		modelled: MODELLED_LVL_ATTRIBUTES
+	});
+	if (preservedAttributes !== void 0) level.preservedAttributes = preservedAttributes;
+	const tplc = getAttribute(element, "w", "tplc");
+	if (tplc !== null) level.tplc = tplc;
+	const tentative = parseOnOffAttribute(element, "w", "tentative");
+	if (tentative !== void 0) level.tentative = tentative;
+	if (alternateEl && findChild(element, "w", "numFmt") === null) {
 		const choiceFmt = resolveNumFmt(findChild(findChild(alternateEl, "mc", "Choice"), "w", "numFmt"));
 		const fallbackFmt = resolveNumFmt(findChild(findChild(alternateEl, "mc", "Fallback"), "w", "numFmt"));
-		level.numFmt = choiceFmt ?? fallbackFmt ?? level.numFmt;
-	}
-	if (lvlTextEl) level.lvlText = getAttribute(lvlTextEl, "w", "val") ?? "";
-	if (lvlJcEl) {
-		const jcVal = getAttribute(lvlJcEl, "w", "val");
-		if (jcVal === "left" || jcVal === "center" || jcVal === "right") level.lvlJc = jcVal;
-	}
-	if (suffEl) {
-		const suffix = narrowEnum(getAttribute(suffEl, "w", "val"), LevelSuffixSchema);
-		if (suffix) level.suffix = suffix;
-	}
-	if (isLglEl) level.isLgl = parseBooleanElement(isLglEl);
-	if (lvlRestartEl) {
-		const restartVal = getAttribute(lvlRestartEl, "w", "val");
-		if (restartVal !== null) {
-			const restartNum = Number.parseInt(restartVal, 10);
-			if (!Number.isNaN(restartNum)) level.lvlRestart = restartNum;
-		}
-	}
-	if (legacyEl) {
-		const legacySpace = parseNumericAttribute(legacyEl, "w", "legacySpace");
-		const legacyIndent = parseNumericAttribute(legacyEl, "w", "legacyIndent");
-		level.legacy = {
-			legacy: parseBooleanElement(legacyEl),
-			...legacySpace !== void 0 ? { legacySpace } : {},
-			...legacyIndent !== void 0 ? { legacyIndent } : {}
-		};
-	}
-	if (pPrEl) level.pPr = parseLevelParagraphProps(pPrEl);
-	if (rPrEl) {
-		const runProperties = parseRunProperties(rPrEl, null);
-		if (runProperties) level.rPr = runProperties;
+		const resolved = choiceFmt && counterFormatOf(choiceFmt) !== "custom" ? choiceFmt : fallbackFmt ?? choiceFmt;
+		if (resolved) Object.assign(level, resolved);
 	}
 	return level;
 }
 /**
-* Resolve a `<w:numFmt>` element to a NumberFormat we can render, or null
-* when the element is absent or its format is one we don't implement (an
-* mc:Fallback can then supply a closer rendering).
+* Resolve a `<w:numFmt>` element, or null when it is absent or carries a token
+* outside `ST_NumberFormat` (an mc:Fallback can then supply the rendering).
+*
+* `custom` stays `custom`, with its `@w:format` beside it. It used to be
+* decoded here into a synthetic `decimalZero{3,4,5}` the enumeration does not
+* declare, which the serializer wrote back as a `w:val` no consumer can read.
+* The pad width belongs to the renderer, not to the model.
 */
 function resolveNumFmt(numFmtEl) {
 	if (!numFmtEl) return null;
-	const fmtVal = getAttribute(numFmtEl, "w", "val");
-	if (!fmtVal) return null;
-	if (fmtVal === "custom") return parseCustomNumberFormat(getAttribute(numFmtEl, "w", "format"));
-	return NUMBER_FORMAT_MAP[fmtVal] ?? null;
+	const numFmt = narrowEnum(getAttribute(numFmtEl, "w", "val"), NumberFormatSchema);
+	if (numFmt === void 0) return null;
+	if (numFmt !== "custom") return { numFmt };
+	const format = getAttribute(numFmtEl, "w", "format");
+	return format === null ? { numFmt } : {
+		numFmt,
+		numFmtFormat: format
+	};
 }
 /**
-* Map a `w:numFmt w:val="custom"` format string (ECMA-376 §17.9.17 — an XSLT
-* `format` token list like "0001, 0002, 0003, ...") to a NumberFormat. Word
-* only emits zero-padded decimal customs this way; the pad width is the digit
-* count of the first token (clamped to 5). Unknown patterns return null so
-* the caller can fall back to an mc:Fallback or plain decimal.
+* `w:legacy`: the flag is the element's own `w:legacy` attribute.
+*
+* `CT_LvlLegacy` has no `w:val`, so reading one turned every explicit
+* `w:legacy="0"` into the `w:legacy="1"` a rebuild wrote back.
 */
-function parseCustomNumberFormat(format) {
-	const firstToken = format?.split(",")[0]?.trim() ?? "";
-	if (/^0+1$/u.test(firstToken)) switch (Math.min(firstToken.length, 5)) {
-		case 2: return "decimalZero";
-		case 3: return "decimalZero3";
-		case 4: return "decimalZero4";
-		case 5: return "decimalZero5";
-	}
-	return null;
+function legacyOf(element) {
+	const legacy = parseOnOffAttribute(element, "w", "legacy");
+	const legacySpace = parseNumericAttribute(element, "w", "legacySpace");
+	const legacyIndent = parseNumericAttribute(element, "w", "legacyIndent");
+	return {
+		...legacy === void 0 ? {} : { legacy },
+		...legacySpace === void 0 ? {} : { legacySpace },
+		...legacyIndent === void 0 ? {} : { legacyIndent }
+	};
 }
 /**
-* Parse paragraph properties for a list level (subset of full pPr)
-* Main concern: indentation and tabs
+* The width a `custom` format's zero-padded first token counts to, or
+* `undefined` for a pattern folio does not render.
+*
+* ECMA-376 §17.9.17: `@w:format` is an XSLT token list like
+* "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.
 */
-function parseLevelParagraphProps(pPr) {
-	const formatting = {};
-	let indEl;
-	let tabsEl;
-	for (const child of pPr.elements ?? []) {
-		if (child.type !== "element") continue;
-		if (wordprocessingLocalName(child) === "ind") {
-			indEl ??= child;
-			continue;
-		}
-		if (wordprocessingLocalName(child) === "tabs") tabsEl ??= child;
-	}
-	if (indEl) {
-		const left = parseNumericAttribute(indEl, "w", "left");
-		const right = parseNumericAttribute(indEl, "w", "right");
-		const start = parseNumericAttribute(indEl, "w", "start");
-		const end = parseNumericAttribute(indEl, "w", "end");
-		const firstLine = parseNumericAttribute(indEl, "w", "firstLine");
-		const hanging = parseNumericAttribute(indEl, "w", "hanging");
-		const resolvedLeft = left ?? start;
-		const resolvedRight = right ?? end;
-		if (resolvedLeft !== void 0) formatting.indentLeft = resolvedLeft;
-		if (resolvedRight !== void 0) formatting.indentRight = resolvedRight;
-		if (hanging !== void 0) {
-			formatting.indentFirstLine = -hanging;
-			formatting.hangingIndent = true;
-		} else if (firstLine !== void 0) formatting.indentFirstLine = firstLine;
-	}
-	if (tabsEl) {
-		formatting.tabs = [];
-		const tabElements = findChildren(tabsEl, "w", "tab");
-		for (const tabEl of tabElements) {
-			const pos = parseNumericAttribute(tabEl, "w", "pos");
-			const val = getAttribute(tabEl, "w", "val");
-			const leader = getAttribute(tabEl, "w", "leader");
-			if (pos !== void 0 && val) {
-				const parsedLeader = parseTabLeader(leader);
-				formatting.tabs.push({
-					position: pos,
-					alignment: parseTabAlignment(val),
-					...parsedLeader !== void 0 ? { leader: parsedLeader } : {}
-				});
-			}
-		}
-	}
-	return formatting;
-}
+const customNumberFormatPadWidth = (format) => {
+	const firstToken = format?.split(",")[0]?.trim() ?? "";
+	if (!/^0+1$/u.test(firstToken)) return;
+	return Math.min(firstToken.length, 5);
+};
 /**
-* Parse tab alignment value
+* The `@w:format` a level's `w:numFmt` writes, which only `custom` carries.
+*
+* `custom` is the reserved member that defers to another attribute, so the
+* comparison lives here, in the module the reserved-value registry names as
+* its owner, rather than in the serializer that needs the answer.
 */
-function parseTabAlignment(val) {
-	switch (val) {
-		case "left": return "left";
-		case "center": return "center";
-		case "right": return "right";
-		case "decimal": return "decimal";
-		case "bar": return "bar";
-		case "clear": return "clear";
-		case "num": return "num";
-		default: return "left";
+const customNumberFormatOf = (level) => level.numFmt === "custom" ? level.numFmtFormat : void 0;
+/** What the marker renderer counts a level in; `custom` decides by pad width. */
+const counterFormatOf = (level) => {
+	if (level.numFmt !== "custom") return level.numFmt;
+	switch (customNumberFormatPadWidth(level.numFmtFormat)) {
+		case 2: return "decimalZero";
+		case 3: return "decimalZero3";
+		case 4: return "decimalZero4";
+		case 5: return "decimalZero5";
+		default: return "custom";
 	}
-}
+};
 /**
-* Parse tab leader value
+* How a `w:lvlJc` lays a marker out, for the three alignments layout has.
+*
+* `start` and `end` are the Strict logical-direction spellings folio
+* canonicalises to `left` and `right` everywhere it rebuilds a part. The
+* justification members describe how a *line* of text is spread and say nothing
+* about a marker, so they resolve to no alignment rather than to a guess; the
+* value itself is still carried on the level and written back.
 */
-function parseTabLeader(val) {
-	if (!val) return;
-	switch (val) {
-		case "none": return "none";
-		case "dot": return "dot";
-		case "hyphen": return "hyphen";
-		case "underscore": return "underscore";
-		case "heavy": return "heavy";
-		case "middleDot": return "middleDot";
-		default: return;
-	}
-}
+const MARKER_ALIGNMENT = {
+	start: "left",
+	left: "left",
+	center: "center",
+	end: "right",
+	right: "right",
+	both: void 0,
+	distribute: void 0,
+	mediumKashida: void 0,
+	highKashida: void 0,
+	lowKashida: void 0,
+	numTab: void 0,
+	thaiDistribute: void 0
+};
+/** {@link MARKER_ALIGNMENT} for a level that may not state a justification. */
+const markerAlignmentForLevel = (lvlJc) => lvlJc === void 0 ? void 0 : MARKER_ALIGNMENT[lvlJc];
 const markerFormattingFromLevel = (formatting) => {
 	if (!formatting) return;
 	const markerFormatting = {
@@ -476,6 +377,7 @@ function createNumberingMap(definitions) {
 	return {
 		definitions,
 		getLevel(numId, ilvl) {
+			if (ilvl < 0 || ilvl > MAX_LIST_LEVEL) return null;
 			const num = numMap.get(numId);
 			if (!num) return null;
 			if (num.levelOverrides) {
@@ -537,7 +439,7 @@ function computeListRendering(numPr, numbering) {
 	const levelStarts = [];
 	for (let i = 0; i <= ilvl; i += 1) {
 		const listLevel = numbering.getLevel(numId, i);
-		levelNumFmts.push(level.isLgl ? "decimal" : listLevel?.numFmt ?? "decimal");
+		levelNumFmts.push(level.isLgl || !listLevel ? "decimal" : counterFormatOf(listLevel));
 		levelStarts.push(listLevel?.start ?? 1);
 	}
 	const instance = numbering.getInstance(numId);
@@ -548,7 +450,7 @@ function computeListRendering(numPr, numbering) {
 		marker: level.lvlText,
 		markerTemplate: level.lvlText,
 		isBullet: level.numFmt === "bullet",
-		numFmt: level.isLgl ? "decimal" : level.numFmt,
+		numFmt: level.isLgl ? "decimal" : counterFormatOf(level),
 		levelNumFmts,
 		levelStarts
 	};
@@ -557,7 +459,8 @@ function computeListRendering(numPr, numbering) {
 	const markerFormatting = markerFormattingFromLevel(level.rPr);
 	if (markerFormatting) rendering.markerFormatting = markerFormatting;
 	if (level.rPr?.allCaps) rendering.markerAllCaps = true;
-	if (level.lvlJc) rendering.markerAlignment = level.lvlJc;
+	const markerAlignment = markerAlignmentForLevel(level.lvlJc);
+	if (markerAlignment !== void 0) rendering.markerAlignment = markerAlignment;
 	if (level.suffix) rendering.markerSuffix = level.suffix;
 	if (instance?.abstractNumId !== void 0) rendering.abstractNumId = instance.abstractNumId;
 	if (overrideForLevel?.startOverride !== void 0) rendering.startOverride = overrideForLevel.startOverride;
@@ -608,4 +511,4 @@ function isBulletLevel(level) {
 /** Whether a numbering level reserves horizontal space for a visible marker. */
 const numberingLevelHasMarkerSlot = (level) => level.numFmt !== "none";
 //#endregion
-export { computeListRendering, createNumberingMap, formatOoxmlCounter as formatNumber, getBulletCharacter, getCachedNumberingMap, isBulletLevel, markerFormattingFromLevel, numberingLevelHasMarkerSlot, padDecimal, parseNumbering, renderListMarker };
+export { computeListRendering, counterFormatOf, createNumberingMap, customNumberFormatOf, customNumberFormatPadWidth, formatOoxmlCounter as formatNumber, getBulletCharacter, getCachedNumberingMap, isBulletLevel, markerAlignmentForLevel, markerFormattingFromLevel, numberingLevelHasMarkerSlot, padDecimal, parseNumbering, renderListMarker };