reamkit 1.16.0 → 1.17.0

package/dist/esm/core/drawingml/shape-render.js

@@ -60,12 +60,125 @@ function gradientToSolid(gradient) {
 function gradientSvgDef(id, g) {
 	const n = (x) => String(Math.round(x * 1e4) / 1e4);
 	const stops = g.stops.map((s) => `<stop offset="${n(s.offset)}" stop-color="#${s.colorHex}"/>`).join("");
-	if (g.kind === "radial") return `<radialGradient id="${id}">${stops}</radialGradient>`;
+	if (g.kind === "radial") {
+		const c = g.center;
+		if (!c) return `<radialGradient id="${id}">${stops}</radialGradient>`;
+		const r = Math.SQRT2 / 2;
+		return `<radialGradient id="${id}" cx="${n(c.x)}" cy="${n(c.y)}" r="${n(r)}">${stops}</radialGradient>`;
+	}
 	const rad = -(g.angle ?? 0) * Math.PI / 180;
 	const dx = Math.cos(rad) / 2;
 	const dy = Math.sin(rad) / 2;
 	return `<linearGradient id="${id}" x1="${n(.5 - dx)}" y1="${n(.5 - dy)}" x2="${n(.5 + dx)}" y2="${n(.5 + dy)}">${stops}</linearGradient>`;
 }
+var LINE_END_STEPS = {
+	sm: 3,
+	med: 4.5,
+	lg: 6
+};
+var MIN_LINE_END_PEN_PT = 1;
+/**
+* §20.1.8.24 / §20.1.8.42 — the arrowheads a line asks for at its ends, as
+* filled paths in the same local frame as the shape's own geometry. The head
+* rides the first point of the first subpath and the tail the last point of
+* the last one, each turned along the segment that reaches it.
+*
+* @param paths        The shape's geometry paths.
+* @param line         The parsed line (its `headEnd`/`tailEnd` are read).
+* @param strokeWidthPt The pen width the decorations are sized against.
+* @returns The decoration paths (empty when the line asks for none).
+*/
+function lineEndPaths(paths, line, strokeWidthPt) {
+	if (!line || !line.headEnd && !line.tailEnd || line.fill === "none") return [];
+	const pts = pathPoints(paths);
+	if (pts.length < 2) return [];
+	const out = [];
+	const pen = Math.max(strokeWidthPt, MIN_LINE_END_PEN_PT);
+	if (line.headEnd) {
+		const p = pts[0];
+		const q = pts[1];
+		const path = endPath(line.headEnd, p, q, pen);
+		if (path) out.push(path);
+	}
+	if (line.tailEnd) {
+		const p = pts[pts.length - 1];
+		const q = pts[pts.length - 2];
+		const path = endPath(line.tailEnd, p, q, pen);
+		if (path) out.push(path);
+	}
+	return out;
+}
+function pathPoints(paths) {
+	const out = [];
+	for (const path of paths) for (const seg of path.segments) {
+		if (seg.op === "close") continue;
+		out.push({
+			x: seg.x,
+			y: seg.y
+		});
+	}
+	return out;
+}
+function endPath(end, tip, from, pen) {
+	const dx = tip.x - from.x;
+	const dy = tip.y - from.y;
+	const len = Math.hypot(dx, dy);
+	if (len < 1e-6) return void 0;
+	const ux = dx / len;
+	const uy = dy / len;
+	const nx = -uy;
+	const ny = ux;
+	const L = LINE_END_STEPS[end.length ?? "med"] * pen;
+	const W = LINE_END_STEPS[end.width ?? "med"] * pen;
+	const at = (along, across) => ({
+		x: tip.x - ux * along + nx * across,
+		y: tip.y - uy * along + ny * across
+	});
+	const segments = [];
+	const move = (p) => {
+		segments.push({
+			op: "move",
+			x: p.x,
+			y: p.y
+		});
+	};
+	const line2 = (p) => {
+		segments.push({
+			op: "line",
+			x: p.x,
+			y: p.y
+		});
+	};
+	if (end.type === "diamond") {
+		move(at(0, 0));
+		line2(at(L / 2, W / 2));
+		line2(at(L, 0));
+		line2(at(L / 2, -W / 2));
+	} else if (end.type === "oval") {
+		const r = W / 2;
+		const c = at(L / 2, 0);
+		for (let i = 0; i < 8; i++) {
+			const a = i / 8 * 2 * Math.PI;
+			const p = {
+				x: c.x + r * Math.cos(a),
+				y: c.y + r * Math.sin(a)
+			};
+			if (i === 0) move(p);
+			else line2(p);
+		}
+	} else if (end.type === "stealth") {
+		move(at(0, 0));
+		line2(at(L, W / 2));
+		line2(at(L * .6, 0));
+		line2(at(L, -W / 2));
+	} else {
+		move(at(0, 0));
+		line2(at(L, W / 2));
+		line2(at(L, -W / 2));
+	}
+	segments.push({ op: "close" });
+	return { segments };
+}
 /**
 * Build a {@link StrokeStyle} from a shape's `a:ln` line, resolving the default
 * width (0.75pt), dash pattern and line cap. Returns `undefined` for no line or
@@ -77,7 +190,7 @@ function gradientSvgDef(id, g) {
 function buildStroke(line) {
 	if (!line || line.fill === "none") return void 0;
 	const widthPt = line.width ?? DEFAULT_LINE_WIDTH_EMU / 12700;
-	const dash = line.dash && line.dash !== "solid" ? dashPattern(line.dash, widthPt) : void 0;
+	const dash = line.customDash?.map((n) => Math.max(.01, n * widthPt)) ?? (line.dash && line.dash !== "solid" ? dashPattern(line.dash, widthPt) : void 0);
 	const cap = line.cap === "flat" ? "butt" : line.cap;
 	return {
 		colorHex: line.colorHex ?? "000000",
@@ -148,4 +261,4 @@ function buildShapeTransform(pageX, pageY, widthPt, heightPt, rotation60k, flipH
 	];
 }
 //#endregion
-export { DEFAULT_INSET_LR_PT, DEFAULT_INSET_TB_PT, buildShapePaths, buildShapeTransform, buildStroke, gradientSvgDef, gradientToSolid };
+export { DEFAULT_INSET_LR_PT, DEFAULT_INSET_TB_PT, buildShapePaths, buildShapeTransform, buildStroke, gradientSvgDef, gradientToSolid, lineEndPaths };

package/dist/esm/core/drawingml/theme-parser.d.ts

@@ -41,6 +41,16 @@ export declare function parseThemeLineWidths(themeXml: Uint8Array): Array<number
  *          declares no `a:fmtScheme`.
  */
 export declare function parseThemeFillStyles(themeXml: Uint8Array): Array<PoNode>;
+/**
+ * Parse a theme's BACKGROUND fill styles (§20.1.4.1.7 `a:bgFillStyleLst`), as
+ * the raw nodes. An `<a:fillRef>` reaches them with an index past 1000 — slot
+ * 1001 is the first — and that is where the page-sized backdrops Word's cover
+ * pages are built from live (fdo78957.docx).
+ *
+ * @param themeXml The raw theme part bytes, UTF-8.
+ * @returns The fill children in list order; empty when the theme declares none.
+ */
+export declare function parseThemeBgFillStyles(themeXml: Uint8Array): Array<PoNode>;
 /**
  * Parse a theme's effect styles (§20.1.4.1.15 `a:effectStyleLst`), as the raw
  * nodes. `<a:effectRef idx="N">` is a 1-based index into this list, exactly as

package/dist/esm/core/drawingml/theme-parser.js

@@ -108,6 +108,24 @@ function parseThemeFillStyles(themeXml) {
 	return list ? [...poChildren(list)] : [];
 }
 /**
+* Parse a theme's BACKGROUND fill styles (§20.1.4.1.7 `a:bgFillStyleLst`), as
+* the raw nodes. An `<a:fillRef>` reaches them with an index past 1000 — slot
+* 1001 is the first — and that is where the page-sized backdrops Word's cover
+* pages are built from live (fdo78957.docx).
+*
+* @param themeXml The raw theme part bytes, UTF-8.
+* @returns The fill children in list order; empty when the theme declares none.
+*/
+function parseThemeBgFillStyles(themeXml) {
+	const list = poFindByPath(parser.parse(decoder.decode(themeXml)), [
+		"a:theme",
+		"a:themeElements",
+		"a:fmtScheme",
+		"a:bgFillStyleLst"
+	]);
+	return list ? [...poChildren(list)] : [];
+}
+/**
 * Parse a theme's effect styles (§20.1.4.1.15 `a:effectStyleLst`), as the raw
 * nodes. `<a:effectRef idx="N">` is a 1-based index into this list, exactly as
 * the fill and line references index theirs.
@@ -136,4 +154,4 @@ function colorOf(slot) {
 	}
 }
 //#endregion
-export { parseTheme, parseThemeEffectStyles, parseThemeFillStyles, parseThemeLineWidths };
+export { parseTheme, parseThemeBgFillStyles, parseThemeEffectStyles, parseThemeFillStyles, parseThemeLineWidths };

package/dist/esm/core/font/measure.d.ts

@@ -12,6 +12,11 @@ export interface FontMeasure {
     readonly textWidthPt: (text: string, fontSize: number) => number;
     /** Encode `text` as a hex string of 4-digit glyph ids (Identity-H addressing). */
     readonly encodeTextAsCidHex: (text: string) => string;
+    /**
+     * The complete PDF text-showing operator for `text` — `<hex> Tj`, or a
+     * `[…] TJ` array when shaping moved a glyph off its own advance.
+     */
+    readonly showText: (text: string) => string;
 }
 /**
  * Build a {@link FontMeasure} over a parsed font.

package/dist/esm/core/font/measure.js

@@ -33,10 +33,30 @@ function createFontMeasure(parsed, kern = true) {
 		for (const gid of shaped.gids) out += gid.toString(16).padStart(4, "0").toUpperCase();
 		return out;
 	};
+	const showText = (text) => {
+		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+		const parts = [];
+		let hex = "";
+		let kerned = false;
+		for (let i = 0; i < shaped.gids.length; i++) {
+			const gid = shaped.gids[i];
+			hex += gid.toString(16).padStart(4, "0").toUpperCase();
+			const delta = (shaped.advances[i] ?? 0) - (parsed.advanceWidths[gid] ?? 0);
+			if (delta === 0) continue;
+			const adj = -delta * 1e3 / parsed.unitsPerEm;
+			parts.push(`<${hex}>`, String(Number(adj.toFixed(2))));
+			hex = "";
+			kerned = true;
+		}
+		if (!kerned) return `<${hex}> Tj`;
+		if (hex !== "") parts.push(`<${hex}>`);
+		return `[${parts.join(" ")}] TJ`;
+	};
 	return {
 		pdfWidthForGid,
 		textWidthPt,
-		encodeTextAsCidHex
+		encodeTextAsCidHex,
+		showText
 	};
 }
 //#endregion

package/dist/esm/core/images.d.ts

@@ -1,5 +1,5 @@
 /** The raster formats this module recognizes and can prepare for embedding. */
-export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000';
+export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000' | 'gif';
 /**
  * Sniff the raster format from a file's leading magic bytes (JPEG SOI, the PNG
  * signature, or a JP2 box / raw JPEG 2000 codestream). Returns the
@@ -24,7 +24,7 @@ export interface EmbedImageOptions {
  */
 export interface PreparedImage {
     readonly format: ImageFormat;
-    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png';
+    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png' | 'image/gif';
     readonly widthPx: number;
     readonly heightPx: number;
     /**

package/dist/esm/core/images.js

@@ -10,6 +10,7 @@ function detectImageFormat(bytes) {
 	if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10) return "png";
 	if (bytes.length >= 12 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 0 && bytes[3] === 12 && bytes[4] === 106 && bytes[5] === 80 && bytes[6] === 32 && bytes[7] === 32 && bytes[8] === 13 && bytes[9] === 10 && bytes[10] === 135 && bytes[11] === 10) return "jpeg2000";
 	if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 79 && bytes[2] === 255 && bytes[3] === 81) return "jpeg2000";
+	if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56 && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97) return "gif";
 	return null;
 }
 /**
@@ -24,6 +25,7 @@ function prepareImage(bytes, options = {}) {
 	if (format === "jpeg") return prepareJpeg(bytes);
 	if (format === "png") return preparePng(bytes, options);
 	if (format === "jpeg2000") return prepareJpeg2000(bytes);
+	if (format === "gif") return prepareGif(bytes, options);
 	throw new Error("Unsupported image format");
 }
 function prepareJpeg2000(bytes) {
@@ -125,6 +127,185 @@ function readJpegInfo(bytes) {
 	}
 	throw new Error("JPEG SOFn marker not found");
 }
+/**
+* Decode a GIF (87a/89a) into a {@link PreparedImage}: the first frame's
+* palette indices expanded to RGB and re-compressed, with a transparent index
+* becoming a soft mask. PDF has no GIF filter, so the pixels have to be handed
+* over as raw ones — dml-picture-in-textframe.docx (and seventeen other corpus
+* documents) draw nothing at all without this.
+*
+* @param bytes   The GIF file.
+* @param options Emit options (PDF/A-1 forbids the soft mask).
+* @returns The prepared image.
+* @throws Error when the file is truncated or holds no image.
+*/
+function prepareGif(bytes, options = {}) {
+	const frame = decodeGif(bytes);
+	const rgb = new Uint8Array(frame.width * frame.height * 3);
+	const alpha = frame.transparentIndex !== void 0 ? new Uint8Array(frame.width * frame.height) : void 0;
+	for (let i = 0; i < frame.indices.length; i++) {
+		const idx = frame.indices[i];
+		const p = idx * 3;
+		rgb[i * 3] = frame.palette[p] ?? 0;
+		rgb[i * 3 + 1] = frame.palette[p + 1] ?? 0;
+		rgb[i * 3 + 2] = frame.palette[p + 2] ?? 0;
+		if (alpha) alpha[i] = idx === frame.transparentIndex ? 0 : 255;
+	}
+	if (alpha && options.flattenAlpha) {
+		for (let i = 0; i < alpha.length; i++) if (alpha[i] === 0) {
+			rgb[i * 3] = 255;
+			rgb[i * 3 + 1] = 255;
+			rgb[i * 3 + 2] = 255;
+		}
+	}
+	return {
+		format: "gif",
+		mimeType: "image/gif",
+		widthPx: frame.width,
+		heightPx: frame.height,
+		colorSpace: "DeviceRGB",
+		bitsPerComponent: 8,
+		filter: "FlateDecode",
+		data: zlibSync(rgb),
+		...alpha && !options.flattenAlpha ? { smaskData: zlibSync(alpha) } : {}
+	};
+}
+function decodeGif(bytes) {
+	const u16 = (i) => (bytes[i] ?? 0) | (bytes[i + 1] ?? 0) << 8;
+	const screenW = u16(6);
+	const screenH = u16(8);
+	const packed = bytes[10] ?? 0;
+	let pos = 13;
+	let globalPalette = new Uint8Array(0);
+	if ((packed & 128) !== 0) {
+		const size = 3 * (1 << (packed & 7) + 1);
+		globalPalette = bytes.subarray(pos, pos + size);
+		pos += size;
+	}
+	let transparentIndex;
+	while (pos < bytes.length) {
+		const block = bytes[pos];
+		if (block === 33) {
+			const label = bytes[pos + 1];
+			pos += 2;
+			if (label === 249 && (bytes[pos + 1] & 1) !== 0) transparentIndex = bytes[pos + 4];
+			while (pos < bytes.length && bytes[pos] !== 0) pos += bytes[pos] + 1;
+			pos++;
+			continue;
+		}
+		if (block !== 44) break;
+		const width = u16(pos + 5) || screenW;
+		const height = u16(pos + 7) || screenH;
+		const flags = bytes[pos + 9];
+		pos += 10;
+		let palette = globalPalette;
+		if ((flags & 128) !== 0) {
+			const size = 3 * (1 << (flags & 7) + 1);
+			palette = bytes.subarray(pos, pos + size);
+			pos += size;
+		}
+		const minCodeSize = bytes[pos];
+		pos++;
+		const chunks = [];
+		while (pos < bytes.length && bytes[pos] !== 0) {
+			const len = bytes[pos];
+			chunks.push(bytes.subarray(pos + 1, pos + 1 + len));
+			pos += len + 1;
+		}
+		const indices = lzwDecode(concatBytes(chunks), minCodeSize, width * height);
+		return {
+			width,
+			height,
+			indices: (flags & 64) !== 0 ? deinterlace(indices, width, height) : indices,
+			palette,
+			...transparentIndex !== void 0 ? { transparentIndex } : {}
+		};
+	}
+	throw new Error("GIF holds no image");
+}
+function lzwDecode(data, minCodeSize, pixelCount) {
+	const clear = 1 << minCodeSize;
+	const end = clear + 1;
+	const out = new Uint8Array(pixelCount);
+	let outPos = 0;
+	let prefix = new Int32Array(4096);
+	let suffix = new Uint8Array(4096);
+	let length = new Int32Array(4096);
+	const reset = () => {
+		prefix = new Int32Array(4096);
+		suffix = new Uint8Array(4096);
+		length = new Int32Array(4096);
+		for (let i = 0; i < clear; i++) {
+			prefix[i] = -1;
+			suffix[i] = i;
+			length[i] = 1;
+		}
+	};
+	reset();
+	let next = end + 1;
+	let codeSize = minCodeSize + 1;
+	let prev = -1;
+	let bitBuf = 0;
+	let bitCount = 0;
+	const stack = new Uint8Array(4096);
+	for (let i = 0; i < data.length || bitCount >= codeSize;) {
+		while (bitCount < codeSize && i < data.length) {
+			bitBuf |= (data[i] & 255) << bitCount;
+			bitCount += 8;
+			i++;
+		}
+		if (bitCount < codeSize) break;
+		const code = bitBuf & (1 << codeSize) - 1;
+		bitBuf >>>= codeSize;
+		bitCount -= codeSize;
+		if (code === clear) {
+			reset();
+			next = end + 1;
+			codeSize = minCodeSize + 1;
+			prev = -1;
+			continue;
+		}
+		if (code === end) break;
+		let cur = code;
+		if (code >= next) {
+			if (prev < 0) break;
+			cur = prev;
+		}
+		let depth = 0;
+		while (cur >= 0 && depth < 4096) {
+			stack[depth] = suffix[cur];
+			depth++;
+			cur = prefix[cur];
+		}
+		if (code >= next) stack[depth++] = stack[depth - 2] ?? 0;
+		for (let d = depth - 1; d >= 0 && outPos < out.length; d--) out[outPos++] = stack[d];
+		if (prev >= 0 && next < 4096) {
+			prefix[next] = prev;
+			suffix[next] = stack[depth - 1];
+			length[next] = (length[prev] ?? 1) + 1;
+			next++;
+			if (next === 1 << codeSize && codeSize < 12) codeSize++;
+		}
+		prev = code < next ? code : prev;
+		if (outPos >= out.length) break;
+	}
+	return out;
+}
+function deinterlace(src, width, height) {
+	const out = new Uint8Array(src.length);
+	const passes = [
+		[0, 8],
+		[4, 8],
+		[2, 4],
+		[1, 2]
+	];
+	let row = 0;
+	for (const [start, step] of passes) for (let y = start; y < height; y += step) {
+		out.set(src.subarray(row * width, (row + 1) * width), y * width);
+		row++;
+	}
+	return out;
+}
 function preparePng(bytes, options = {}) {
 	let decoded = decodePng(bytes);
 	if (options.flattenAlpha && decoded.smaskRaw) decoded = flattenAlphaOnWhite(decoded);

package/dist/esm/core/ir/flow.d.ts

@@ -1,4 +1,4 @@
-import { BodyElement, Chart, Comment, DocumentInfo, Numbering, Section, SectionProperties, StyleSheet } from '../document-model/index.js';
+import { BodyElement, Chart, Comment, DocumentInfo, Numbering, Section, SectionProperties, ShapeFill, StyleSheet } from '../document-model/index.js';
 import { FontRegistry } from '../font/index.js';
 import { ResourceStore } from './resources.js';
 /**
@@ -46,4 +46,26 @@ export interface FlowDoc {
     readonly info?: DocumentInfo;
     /** Document natural language hint (BCP-47), e.g. for tagged-PDF /Lang. */
     readonly language?: string;
+    /**
+     * ECMA-376 §17.15.1.35 `w:doNotExpandShiftReturn` — a justified line that
+     * ends at a soft line break keeps its natural width.
+     */
+    readonly doNotExpandShiftReturn?: boolean;
+    /**
+     * ECMA-376 §17.2.1 `w:background` — the colour every page is painted, when
+     * the document asks for one AND §17.15.1.28 `w:displayBackgroundShape` says
+     * to draw it.
+     */
+    readonly pageBackgroundColorHex?: string;
+    /**
+     * ECMA-376 §17.2.1 — the same background as the FILL it is, when that is more
+     * than a flat colour: the `v:background`'s gradient or picture. The colour
+     * above stays the flat fallback, for writers that paint only colours.
+     */
+    readonly pageBackgroundFill?: ShapeFill;
+    /**
+     * ECMA-376 §17.15.1.38 `w:gutterAtTop` — the binding space `w:pgMar
+     * @w:gutter` reserves belongs to the TOP margin rather than the left.
+     */
+    readonly gutterAtTop?: boolean;
 }

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`;