reamkit 1.16.0 → 1.18.0

package/dist/esm/core/metafile/picture.d.ts

@@ -0,0 +1,106 @@
+import { StrokeStyle, VectorPath } from '../vector.js';
+/** A path drawn by the metafile: filled, stroked, or both. */
+export interface PicturePath {
+    readonly kind: 'path';
+    readonly paths: ReadonlyArray<VectorPath>;
+    /** 6-hex, no leading `#`. Absent when the path is not filled. */
+    readonly fillColorHex?: string;
+    readonly stroke?: StrokeStyle;
+}
+/** A run of text the metafile puts at a point, in its own logical units. */
+export interface PictureText {
+    readonly kind: 'text';
+    readonly text: string;
+    /** The reference point, in logical units (y DOWN, as the metafile has it). */
+    readonly x: number;
+    readonly y: number;
+    /** Which corner of the text the point names (MS-WMF §2.1.2.4 TextAlignment). */
+    readonly alignH: 'left' | 'center' | 'right';
+    /** Whether `y` is the text's TOP (the default) or its baseline. */
+    readonly alignBaseline: boolean;
+    /** Em size in logical units — the height the font was created with. */
+    readonly sizeLu: number;
+    readonly colorHex: string;
+    readonly fontFamily?: string;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    /** Tenths of a degree, counter-clockwise — the font's own escapement. */
+    readonly escapement?: number;
+}
+/** A bitmap the metafile blits into a rectangle of its own logical frame. */
+export interface PictureImage {
+    readonly kind: 'image';
+    /** The destination rectangle in logical units (y down). */
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    /** The bitmap as a standalone file (PNG), ready for the resource store. */
+    readonly png: Uint8Array;
+}
+export type PicturePrim = PicturePath | PictureText | PictureImage;
+/**
+ * One metafile, read: its primitives and the logical box they are drawn in.
+ * Coordinates are the metafile's own, with y running DOWN; the caller maps the
+ * box onto the picture's frame.
+ */
+export interface MetaPicture {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+    readonly prims: ReadonlyArray<PicturePrim>;
+    /** Records the reader knew of but did not draw, for a loss note. */
+    readonly skipped: ReadonlyArray<string>;
+}
+/** A pen, a brush and a font, as the device context holds them. */
+export interface MetaPen {
+    readonly kind: 'pen';
+    readonly colorHex: string;
+    readonly widthLu: number;
+    readonly style: 'solid' | 'dash' | 'dot' | 'dashdot' | 'dashdotdot' | 'none';
+}
+export interface MetaBrush {
+    readonly kind: 'brush';
+    readonly colorHex: string;
+    /** `null` for BS_HOLLOW/BS_NULL — a brush that paints nothing. */
+    readonly hollow: boolean;
+}
+export interface MetaFont {
+    readonly kind: 'font';
+    readonly heightLu: number;
+    readonly family?: string;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly escapement?: number;
+}
+export type MetaObject = MetaPen | MetaBrush | MetaFont;
+/** The device context: everything a record draws THROUGH. */
+export interface DeviceContext {
+    pen: MetaPen;
+    brush: MetaBrush;
+    font?: MetaFont;
+    textColorHex: string;
+    bkColorHex: string;
+    /** MS-WMF §2.1.1.9 — TRANSPARENT leaves the background of text unpainted. */
+    bkOpaque: boolean;
+    alignH: 'left' | 'center' | 'right';
+    alignBaseline: boolean;
+    fillRule: 'nonzero' | 'evenodd';
+    x: number;
+    y: number;
+    /** The world→page transform, as `[a, b, c, d, e, f]`. */
+    transform: readonly [number, number, number, number, number, number];
+}
+export declare const DEFAULT_PEN: MetaPen;
+export declare const DEFAULT_BRUSH: MetaBrush;
+/** A device context in its documented initial state (MS-WMF §3.1.5). */
+export declare function newDeviceContext(): DeviceContext;
+export declare function cloneDc(dc: DeviceContext): DeviceContext;
+/** A COLORREF (`0x00bbggrr`) as the 6-hex this codebase's colours use. */
+export declare function colorRef(v: number): string;
+/** Apply the world transform to a point. */
+export declare function applyTransform(t: DeviceContext['transform'], x: number, y: number): {
+    x: number;
+    y: number;
+};

package/dist/esm/core/metafile/picture.js

@@ -0,0 +1,55 @@
+//#region src/core/metafile/picture.ts
+var DEFAULT_PEN = {
+	kind: "pen",
+	colorHex: "000000",
+	widthLu: 1,
+	style: "solid"
+};
+var DEFAULT_BRUSH = {
+	kind: "brush",
+	colorHex: "FFFFFF",
+	hollow: false
+};
+/** A device context in its documented initial state (MS-WMF §3.1.5). */
+function newDeviceContext() {
+	return {
+		pen: DEFAULT_PEN,
+		brush: DEFAULT_BRUSH,
+		textColorHex: "000000",
+		bkColorHex: "FFFFFF",
+		bkOpaque: true,
+		alignH: "left",
+		alignBaseline: false,
+		fillRule: "evenodd",
+		x: 0,
+		y: 0,
+		transform: [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		]
+	};
+}
+function cloneDc(dc) {
+	return { ...dc };
+}
+/** A COLORREF (`0x00bbggrr`) as the 6-hex this codebase's colours use. */
+function colorRef(v) {
+	return [
+		v & 255,
+		v >>> 8 & 255,
+		v >>> 16 & 255
+	].map((c) => c.toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+/** Apply the world transform to a point. */
+function applyTransform(t, x, y) {
+	return {
+		x: t[0] * x + t[2] * y + t[4],
+		y: t[1] * x + t[3] * y + t[5]
+	};
+}
+//#endregion
+export { applyTransform, cloneDc, colorRef, newDeviceContext };

package/dist/esm/core/metafile/wmf.d.ts

@@ -0,0 +1,9 @@
+import { MetaPicture } from './picture.js';
+/** Whether the bytes open with a WMF header — placeable or bare (§2.3.2.2). */
+export declare function isWmf(bytes: Uint8Array): boolean;
+/**
+ * Read a WMF into its primitives.
+ *
+ * @throws Error when the bytes are not a WMF.
+ */
+export declare function readWmf(bytes: Uint8Array): MetaPicture;

package/dist/esm/core/metafile/wmf.js

@@ -0,0 +1,371 @@
+import { PathBuilder } from "../vector.js";
+import { cloneDc, colorRef, newDeviceContext } from "./picture.js";
+import { ellipseSegments } from "./emf.js";
+//#region src/core/metafile/wmf.ts
+var PLACEABLE_KEY = 2596720087;
+/** Whether the bytes open with a WMF header — placeable or bare (§2.3.2.2). */
+function isWmf(bytes) {
+	if (bytes.length < 18) return false;
+	const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (v.getUint32(0, true) === PLACEABLE_KEY) return true;
+	const type = v.getUint16(0, true);
+	const headerWords = v.getUint16(2, true);
+	return (type === 1 || type === 2) && headerWords === 9;
+}
+var RECORD_NAMES = new Map([
+	[2368, "bitmap"],
+	[2881, "bitmap"],
+	[3907, "bitmap"],
+	[2338, "pie"],
+	[2096, "chord"],
+	[2071, "arc"],
+	[1049, "flood fill"],
+	[1352, "flood fill"],
+	[247, "palette"],
+	[1574, "escape"],
+	[765, "region"],
+	[552, "region fill"],
+	[1065, "region frame"],
+	[298, "region invert"],
+	[299, "region paint"]
+]);
+/**
+* Read a WMF into its primitives.
+*
+* @throws Error when the bytes are not a WMF.
+*/
+function readWmf(bytes) {
+	if (!isWmf(bytes)) throw new Error("WMF: not a Windows metafile");
+	const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const placeable = v.getUint32(0, true) === PLACEABLE_KEY;
+	const frame = placeable ? {
+		left: v.getInt16(6, true),
+		top: v.getInt16(8, true),
+		right: v.getInt16(10, true),
+		bottom: v.getInt16(12, true)
+	} : void 0;
+	const prims = [];
+	const skipped = /* @__PURE__ */ new Set();
+	const objects = [];
+	const put = (obj) => {
+		const free = objects.indexOf(void 0);
+		if (free >= 0) objects[free] = obj;
+		else objects.push(obj);
+	};
+	const stack = [];
+	let dc = newDeviceContext();
+	let win = {
+		x: 0,
+		y: 0,
+		cx: 0,
+		cy: 0
+	};
+	const strokeOf = () => {
+		if (dc.pen.style === "none") return void 0;
+		const w = Math.max(1, dc.pen.widthLu);
+		return {
+			colorHex: dc.pen.colorHex,
+			widthPt: w,
+			...dc.pen.style === "solid" ? {} : { dash: dc.pen.style === "dot" ? [w, 2 * w] : [4 * w, 3 * w] }
+		};
+	};
+	const paint = (segments, fill, stroke) => {
+		if (segments.length === 0) return;
+		const path = {
+			segments,
+			fillRule: dc.fillRule
+		};
+		const st = stroke ? strokeOf() : void 0;
+		const fillHex = fill && !dc.brush.hollow ? dc.brush.colorHex : void 0;
+		if (fillHex === void 0 && !st) return;
+		prims.push({
+			kind: "path",
+			paths: [path],
+			...fillHex !== void 0 ? { fillColorHex: fillHex } : {},
+			...st ? { stroke: st } : {}
+		});
+	};
+	const rectSegments = (l, t, r, b) => new PathBuilder().moveTo(l, t).lineTo(r, t).lineTo(r, b).lineTo(l, b).close().build().segments;
+	let off = placeable ? 22 : 0;
+	off += 18;
+	let guard = 0;
+	while (off + 6 <= bytes.length && guard++ < 5e5) {
+		const size = v.getUint32(off, true);
+		const fn = v.getUint16(off + 4, true);
+		if (size < 3 || off + size * 2 > bytes.length) break;
+		const p = (i) => v.getInt16(off + 6 + i * 2, true);
+		const pu = (i) => v.getUint16(off + 6 + i * 2, true);
+		const p32 = (i) => v.getUint32(off + 6 + i * 2, true);
+		switch (fn) {
+			case 0:
+				off = bytes.length;
+				continue;
+			case 523:
+				win = {
+					...win,
+					x: p(1),
+					y: p(0)
+				};
+				break;
+			case 524:
+				win = {
+					...win,
+					cx: p(1),
+					cy: p(0)
+				};
+				break;
+			case 30:
+				stack.push(cloneDc(dc));
+				break;
+			case 295:
+				{
+					const back = Math.max(1, -p(0));
+					for (let i = 0; i < back && stack.length > 0; i++) dc = stack.pop();
+				}
+				break;
+			case 301:
+				{
+					const obj = objects[pu(0)];
+					if (obj?.kind === "pen") dc.pen = obj;
+					else if (obj?.kind === "brush") dc.brush = obj;
+					else if (obj?.kind === "font") dc.font = obj;
+				}
+				break;
+			case 496:
+				objects[pu(0)] = void 0;
+				break;
+			case 762:
+				put({
+					kind: "pen",
+					style: penStyle(pu(0)),
+					widthLu: p(1),
+					colorHex: colorRef(p32(3))
+				});
+				break;
+			case 764:
+				put({
+					kind: "brush",
+					colorHex: colorRef(p32(1)),
+					hollow: pu(0) === 1
+				});
+				break;
+			case 763:
+				put(readLogFont(v, bytes, off + 6));
+				break;
+			case 258:
+				dc.bkOpaque = pu(0) === 2;
+				break;
+			case 262:
+				dc.fillRule = pu(0) === 2 ? "nonzero" : "evenodd";
+				break;
+			case 302:
+				{
+					const f = pu(0);
+					dc.alignH = (f & 6) === 6 ? "center" : (f & 2) === 2 ? "right" : "left";
+					dc.alignBaseline = (f & 24) === 24;
+				}
+				break;
+			case 521:
+				dc.textColorHex = colorRef(p32(0));
+				break;
+			case 513:
+				dc.bkColorHex = colorRef(p32(0));
+				break;
+			case 532:
+				dc.x = p(1);
+				dc.y = p(0);
+				break;
+			case 531:
+				{
+					const x = p(1);
+					const y = p(0);
+					paint([{
+						op: "move",
+						x: dc.x,
+						y: dc.y
+					}, {
+						op: "line",
+						x,
+						y
+					}], false, true);
+					dc.x = x;
+					dc.y = y;
+				}
+				break;
+			case 1051:
+				paint(rectSegments(p(3), p(2), p(1), p(0)), true, true);
+				break;
+			case 1048:
+				paint(ellipseSegments((x, y) => ({
+					x,
+					y
+				}), p(3), p(2), p(1), p(0)), true, true);
+				break;
+			case 1564:
+				paint(rectSegments(p(5), p(4), p(3), p(2)), true, true);
+				break;
+			case 1565:
+				{
+					const rop = p32(0);
+					const h = p(2);
+					const w = p(3);
+					const y = p(4);
+					const x = p(5);
+					const hex = rop === 66 ? "000000" : rop === 16711778 ? "FFFFFF" : void 0;
+					const brush = dc.brush;
+					if (hex !== void 0) dc.brush = {
+						kind: "brush",
+						colorHex: hex,
+						hollow: false
+					};
+					paint(rectSegments(x, y, x + w, y + h), true, false);
+					dc.brush = brush;
+				}
+				break;
+			case 804:
+			case 805:
+				{
+					const count = pu(0);
+					const pts = readPoints(v, off + 8, count);
+					const closed = fn === 804;
+					paint(polySegments(pts, closed), closed, true);
+				}
+				break;
+			case 1336:
+				{
+					const polys = pu(0);
+					const counts = [];
+					for (let i = 0; i < polys; i++) counts.push(v.getUint16(off + 8 + i * 2, true));
+					let at = off + 8 + polys * 2;
+					const segs = [];
+					for (const c of counts) {
+						segs.push(...polySegments(readPoints(v, at, c), true));
+						at += c * 4;
+					}
+					paint(segs, true, true);
+				}
+				break;
+			case 1313:
+				{
+					const count = pu(0);
+					const text = readString(bytes, off + 8, count, false);
+					const words = count + 1 >> 1;
+					pushText(prims, dc, text, p(1 + words + 1), p(1 + words));
+				}
+				break;
+			case 2610:
+				{
+					const y = p(0);
+					const x = p(1);
+					const count = pu(2);
+					const hasRect = (pu(3) & 6) !== 0;
+					const text = readString(bytes, off + 6 + (4 + (hasRect ? 4 : 0)) * 2, count, false);
+					pushText(prims, dc, text, x, y);
+				}
+				break;
+			default:
+				{
+					const name = RECORD_NAMES.get(fn);
+					if (name) skipped.add(name);
+				}
+				break;
+		}
+		off += size * 2;
+	}
+	const box = frame ?? {
+		left: win.x,
+		top: win.y,
+		right: win.x + (win.cx || 1e3),
+		bottom: win.y + (win.cy || 1e3)
+	};
+	return {
+		left: box.left,
+		top: box.top,
+		width: Math.max(1, Math.abs(box.right - box.left)),
+		height: Math.max(1, Math.abs(box.bottom - box.top)),
+		prims,
+		skipped: [...skipped]
+	};
+}
+function pushText(prims, dc, text, x, y) {
+	if (text.trim() === "") return;
+	prims.push({
+		kind: "text",
+		text,
+		x,
+		y,
+		alignH: dc.alignH,
+		alignBaseline: dc.alignBaseline,
+		sizeLu: Math.abs(dc.font?.heightLu ?? 12),
+		colorHex: dc.textColorHex,
+		...dc.font?.family ? { fontFamily: dc.font.family } : {},
+		...dc.font?.bold ? { bold: true } : {},
+		...dc.font?.italic ? { italic: true } : {},
+		...dc.font?.escapement ? { escapement: dc.font.escapement } : {}
+	});
+}
+function penStyle(style) {
+	switch (style & 15) {
+		case 1: return "dash";
+		case 2: return "dot";
+		case 3: return "dashdot";
+		case 4: return "dashdotdot";
+		case 5: return "none";
+		default: return "solid";
+	}
+}
+function readLogFont(v, bytes, at) {
+	const height = v.getInt16(at, true);
+	const escapement = v.getInt16(at + 4, true);
+	const weight = v.getInt16(at + 8, true);
+	const italic = bytes[at + 10] !== 0;
+	const face = readString(bytes, at + 18, 32, false).replace(/\0.*$/u, "");
+	return {
+		kind: "font",
+		heightLu: height,
+		...face ? { family: face } : {},
+		...weight >= 600 ? { bold: true } : {},
+		...italic ? { italic: true } : {},
+		...escapement ? { escapement } : {}
+	};
+}
+function readString(bytes, at, count, wide) {
+	let out = "";
+	for (let i = 0; i < count; i++) {
+		const o = at + (wide ? i * 2 : i);
+		if (o >= bytes.length) break;
+		const code = wide ? bytes[o] | (bytes[o + 1] ?? 0) << 8 : bytes[o];
+		if (code === 0) break;
+		out += String.fromCharCode(code);
+	}
+	return out;
+}
+function readPoints(v, at, count) {
+	const out = [];
+	for (let i = 0; i < count; i++) {
+		const o = at + i * 4;
+		if (o + 4 > v.byteLength) break;
+		out.push({
+			x: v.getInt16(o, true),
+			y: v.getInt16(o + 2, true)
+		});
+	}
+	return out;
+}
+function polySegments(pts, closed) {
+	if (pts.length === 0) return [];
+	const segs = [{
+		op: "move",
+		x: pts[0].x,
+		y: pts[0].y
+	}];
+	for (let i = 1; i < pts.length; i++) segs.push({
+		op: "line",
+		x: pts[i].x,
+		y: pts[i].y
+	});
+	if (closed) segs.push({ op: "close" });
+	return segs;
+}
+//#endregion
+export { isWmf, readWmf };

package/dist/esm/core/numbering/apply.d.ts

@@ -1,4 +1,4 @@
-import { BodyElement, Numbering } from '../document-model/index.js';
+import { BodyElement, Numbering, StyleSheet } from '../document-model/index.js';
 /**
  * Apply list numbering to a body as a FlowDoc transform (§17.9): walk the
  * elements (recursing into table cells), advancing list counters and prepending
@@ -8,9 +8,11 @@ import { BodyElement, Numbering } from '../document-model/index.js';
  *
  * @param body      The body elements to transform.
  * @param numbering The parsed numbering definitions, or `undefined`.
+ * @param styles    The style sheet, for a paragraph whose numbering comes from
+ *                  its STYLE (§17.9.24) rather than its own `w:numPr`.
  * @returns A new body with markers materialized.
  */
-export declare function applyNumbering(body: ReadonlyArray<BodyElement>, numbering: Numbering | undefined): Array<BodyElement>;
+export declare function applyNumbering(body: ReadonlyArray<BodyElement>, numbering: Numbering | undefined, styles?: StyleSheet): Array<BodyElement>;
 /**
  * Apply {@link applyNumbering} to each header/footer band independently (each
  * gets its own counter state), keyed as in the input map.
@@ -19,4 +21,4 @@ export declare function applyNumbering(body: ReadonlyArray<BodyElement>, numberi
  * @param numbering The parsed numbering definitions, or `undefined`.
  * @returns A new map with numbering applied (empty when `hf` is empty/absent).
  */
-export declare function applyNumberingToHeadersFooters(hf: ReadonlyMap<string, ReadonlyArray<BodyElement>> | undefined, numbering: Numbering | undefined): ReadonlyMap<string, ReadonlyArray<BodyElement>>;
+export declare function applyNumberingToHeadersFooters(hf: ReadonlyMap<string, ReadonlyArray<BodyElement>> | undefined, numbering: Numbering | undefined, styles?: StyleSheet): ReadonlyMap<string, ReadonlyArray<BodyElement>>;

package/dist/esm/core/numbering/apply.js

@@ -1,5 +1,13 @@
-import { NumberingState } from "./state.js";
+import { pt } from "../ir/units.js";
+import { NumberingState, effectiveAbstract } from "./state.js";
+import { resolveParagraphProperties } from "../style-cascade/resolver.js";
+import "../style-cascade/index.js";
 //#region src/core/numbering/apply.ts
+/** The height a picture bullet takes when neither the level nor the paragraph
+* mark states a font size — Word's own default text size. */
+var DEFAULT_BULLET_HEIGHT_PT = 11;
+/** SOFT HYPHEN, which a `w:lvlText` may spell a dash bullet with (§17.9.11). */
+var SOFT_HYPHEN = "­";
 /**
 * Apply list numbering to a body as a FlowDoc transform (§17.9): walk the
 * elements (recursing into table cells), advancing list counters and prepending
@@ -9,28 +17,51 @@ import { NumberingState } from "./state.js";
 *
 * @param body      The body elements to transform.
 * @param numbering The parsed numbering definitions, or `undefined`.
+* @param styles    The style sheet, for a paragraph whose numbering comes from
+*                  its STYLE (§17.9.24) rather than its own `w:numPr`.
 * @returns A new body with markers materialized.
 */
-function applyNumbering(body, numbering) {
+function applyNumbering(body, numbering, styles) {
 	if (!numbering || numbering.abstractNums.size === 0) return body.map((b) => b);
 	const state = new NumberingState();
+	const numberingOf = (p) => p.properties.numbering ?? (styles ? resolveParagraphProperties(p.properties, styles).numbering : void 0);
 	const transformParagraph = (p) => {
-		const ref = p.properties.numbering;
+		if (p.properties.sectionBreak === true && p.runs.every((r) => r.text === "")) return p;
+		const ref = numberingOf(p);
 		if (!ref) return p;
 		const marker = state.resolveMarker(numbering, ref);
 		if (marker === null) return p;
 		const instance = numbering.numInstances.get(ref.numId);
-		const level = (instance ? numbering.abstractNums.get(instance.abstractNumId) : void 0)?.levels.get(ref.ilvl);
-		const markerRun = {
-			text: `${marker}\t`,
-			properties: level?.runProperties ?? {},
+		const level = (instance ? effectiveAbstract(numbering, instance) : void 0)?.levels.get(ref.ilvl);
+		const pic = level?.picBullet;
+		const bulletCapPt = level?.runProperties.fontSizePt ?? p.properties.runProperties?.fontSizePt ?? DEFAULT_BULLET_HEIGHT_PT;
+		const bulletScale = pic ? Math.min(1, bulletCapPt / Math.max(1, pic.heightPt)) : 1;
+		const markerRuns = pic ? [{
+			text: "",
+			properties: {},
+			listMarker: true,
+			inlineImage: {
+				resource: pic.resource,
+				width: pt(pic.widthPt * bulletScale),
+				height: pt(pic.heightPt * bulletScale)
+			}
+		}, {
+			text: "	",
+			properties: {},
 			listMarker: true
-		};
+		}] : [{
+			text: `${marker.replaceAll(SOFT_HYPHEN, "-")}\t`,
+			properties: {
+				...p.properties.runProperties,
+				...level?.runProperties
+			},
+			listMarker: true
+		}];
 		const newProps = mergeIndentFromLevel(p.properties, level?.paragraphProperties);
 		return {
 			...p,
 			properties: newProps,
-			runs: [markerRun, ...p.runs]
+			runs: [...markerRuns, ...p.runs]
 		};
 	};
 	const visit = (el) => {
@@ -73,11 +104,11 @@ function mergeIndentFromLevel(paragraphProps, levelProps) {
 * @param numbering The parsed numbering definitions, or `undefined`.
 * @returns A new map with numbering applied (empty when `hf` is empty/absent).
 */
-function applyNumberingToHeadersFooters(hf, numbering) {
+function applyNumberingToHeadersFooters(hf, numbering, styles) {
 	if (!hf || hf.size === 0) return /* @__PURE__ */ new Map();
 	if (!numbering || numbering.abstractNums.size === 0) return hf;
 	const out = /* @__PURE__ */ new Map();
-	for (const [key, value] of hf) out.set(key, applyNumbering(value, numbering));
+	for (const [key, value] of hf) out.set(key, applyNumbering(value, numbering, styles));
 	return out;
 }
 //#endregion

package/dist/esm/core/numbering/index.js

@@ -0,0 +1,2 @@
+import "./state.js";
+import "./apply.js";

package/dist/esm/core/numbering/state.d.ts

@@ -1,4 +1,15 @@
-import { AbstractNumbering, Numbering, NumberingLevel, NumberingReference } from '../document-model/index.js';
+import { AbstractNumbering, Numbering, NumberingInstance, NumberingLevel, NumberingReference } from '../document-model/index.js';
+/**
+ * §17.9.27 — the levels an INSTANCE actually numbers by: its abstract
+ * definition's, with any `w:lvlOverride/w:lvl` shadowing them. Cached per
+ * instance, since every list paragraph asks for it.
+ *
+ * @param numbering The parsed numbering definitions.
+ * @param instance  The `w:num` the paragraph refers to.
+ * @returns The effective abstract numbering, or `undefined` when the instance
+ *          names one that is not there.
+ */
+export declare function effectiveAbstract(numbering: Numbering, instance: NumberingInstance): AbstractNumbering | undefined;
 /**
  * Mutable list-counter state for one numbering scope (e.g. a body or a single
  * header/footer band). Tracks a counter per list per level and advances them as
@@ -6,6 +17,7 @@ import { AbstractNumbering, Numbering, NumberingLevel, NumberingReference } from
  */
 export declare class NumberingState {
     private readonly counters;
+    private readonly restarted;
     /**
      * Advance the counter for `ref` (resetting deeper levels) and format its
      * marker text. The first hit at a level seeds it from the level's `start`;