reamkit 1.0.0 → 1.0.2

package/README.md

@@ -147,9 +147,10 @@ automatically from the document's `docProps/core.xml`), `attachments`
 
 ### Lower-level APIs
 
-- `docxReader` / `xlsxReader`, `layoutStyledDocument`, `svgWriter` — the
-  `@experimental` reader/writer interfaces of the interlayer, for building
-  custom pipelines (and keeping unused formats out of your bundle).
+- `docxReader` / `xlsxReader`, `svgWriter` — the `@experimental` reader/writer
+  interfaces of the interlayer, for building custom pipelines (and keeping
+  unused formats out of your bundle); `layoutStyledDocument` produces the
+  frozen page model (`PageItem` pages in a top-left `Pt` frame) they consume.
 - `renderStyledPdf` drives the layout engine directly; the typed document
   model is on the `reamkit/document-model` subpath.
 

package/dist/esm/core/bidi/index.d.ts

@@ -12,3 +12,5 @@ export declare function analyzeString(text: string, dir?: Direction): StringBidi
 export declare function hasBidiCharacters(text: string): boolean;
 export declare function reverseByCodePoint(text: string): string;
 export declare function reorderTokens(tokenLevels: ReadonlyArray<number>): Array<number>;
+export { segmentLevels } from './segments.js';
+export type { BidiSegment } from './segments.js';

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

@@ -1,5 +1,6 @@
 import "./char-types.js";
 import { computeBidi } from "./algorithm.js";
+import "./segments.js";
 //#region src/core/bidi/index.ts
 function analyzeString(text, dir = "auto") {
 	const codePoints = [];

package/dist/esm/core/bidi/segments.d.ts

@@ -0,0 +1,6 @@
+export interface BidiSegment {
+    readonly text: string;
+    readonly object?: boolean;
+    readonly rtl?: boolean;
+}
+export declare function segmentLevels(segments: ReadonlyArray<BidiSegment>, baseDir: 'ltr' | 'rtl'): Array<number>;

package/dist/esm/core/bidi/segments.js

@@ -0,0 +1,41 @@
+import { computeBidi } from "./algorithm.js";
+//#region src/core/bidi/segments.ts
+var OBJECT_REPLACEMENT = 65532;
+var RLE = 8235;
+var PDF_FMT = 8236;
+var LRE = 8234;
+function segmentLevels(segments, baseDir) {
+	const bidiCps = [];
+	const realIndexOfBidi = [];
+	let realCount = 0;
+	for (const seg of segments) {
+		const isObject = seg.object === true;
+		const wrap = seg.rtl ? RLE : baseDir === "rtl" && !isObject ? LRE : 0;
+		if (wrap) {
+			bidiCps.push(wrap);
+			realIndexOfBidi.push(-1);
+		}
+		if (isObject) {
+			bidiCps.push(OBJECT_REPLACEMENT);
+			realIndexOfBidi.push(realCount);
+			realCount++;
+		} else for (const ch of seg.text) {
+			bidiCps.push(ch.codePointAt(0));
+			realIndexOfBidi.push(realCount);
+			realCount++;
+		}
+		if (wrap) {
+			bidiCps.push(PDF_FMT);
+			realIndexOfBidi.push(-1);
+		}
+	}
+	const { levels } = computeBidi(bidiCps, baseDir);
+	const realLevels = new Array(realCount).fill(baseDir === "rtl" ? 1 : 0);
+	for (let i = 0; i < bidiCps.length; i++) {
+		const ri = realIndexOfBidi[i];
+		if (ri >= 0) realLevels[ri] = levels[i];
+	}
+	return realLevels;
+}
+//#endregion
+export { segmentLevels };

package/dist/esm/core/converter/facade.js

@@ -1,7 +1,7 @@
 import { FontRegistry } from "../font/font-registry.js";
 import { FEATURES } from "../ir/features.js";
 import { ConversionLossError } from "../ir/loss.js";
-import { layoutStyledDocument } from "../../pdf/styled-page-renderer.js";
+import { layoutStyledDocument } from "../../layout/styled-layout.js";
 import { docxReader } from "../../word/docx-reader.js";
 import { xlsxReader } from "../../excel/xlsx-reader.js";
 import { chainProviders } from "../fonts/provider.js";

package/dist/esm/core/converter/project.js

@@ -1,8 +1,9 @@
+import { EMPTY_STYLE_SHEET } from "../style-cascade/resolver.js";
+import "../style-cascade/index.js";
 //#region src/core/converter/project.ts
 function flowRenderOptions(flow) {
 	return {
-		styles: flow.styles,
-		...flow.numbering ? { numbering: flow.numbering } : {},
+		styles: EMPTY_STYLE_SHEET,
 		...flow.sections.length > 0 ? { sections: flow.sections } : {},
 		...flow.section ? { section: flow.section } : {},
 		...flow.headersFooters ? { headersFooters: flow.headersFooters } : {},

package/dist/esm/core/converter/ream.js

@@ -1,8 +1,9 @@
 import { fetchFontSet } from "../fonts/remote-fonts.js";
 import { FontRegistry } from "../font/font-registry.js";
 import { ConversionLossError } from "../ir/loss.js";
+import { layoutStyledDocument } from "../../layout/styled-layout.js";
 import { signPdf } from "../../pdf/signature.js";
-import { layoutStyledDocument, renderStyledPdf } from "../../pdf/styled-page-renderer.js";
+import { renderStyledPdf } from "../../pdf/styled-page-renderer.js";
 import "../../pdf/index.js";
 import { flowRenderOptions } from "./project.js";
 import { writeSvg } from "../../svg/svg-writer.js";

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

@@ -6,3 +6,5 @@ export type { FontVariant, FontBytesByVariant } from './font-registry.js';
 export { pickVariant } from './font-registry.js';
 export { parseGposKerning, parseGsubLigatures, shapeText } from './opentype-layout.js';
 export type { KerningMap, LigatureMap, ShapedRun } from './opentype-layout.js';
+export { createFontMeasure } from './measure.js';
+export type { FontMeasure } from './measure.js';

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

@@ -0,0 +1,7 @@
+import { ParsedTtf } from './ttf-parser.js';
+export interface FontMeasure {
+    readonly pdfWidthForGid: (gid: number) => number;
+    readonly textWidthPt: (text: string, fontSize: number) => number;
+    readonly encodeTextAsCidHex: (text: string) => string;
+}
+export declare function createFontMeasure(parsed: ParsedTtf): FontMeasure;

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

@@ -0,0 +1,30 @@
+import { shapeText } from "./opentype-layout.js";
+//#region src/core/font/measure.ts
+function createFontMeasure(parsed) {
+	const scale = 1e3 / parsed.unitsPerEm;
+	const widths = new Array(parsed.numGlyphs);
+	for (let i = 0; i < parsed.numGlyphs; i++) widths[i] = Math.round((parsed.advanceWidths[i] ?? 0) * scale);
+	const pdfWidthForGid = (gid) => {
+		if (gid < 0 || gid >= parsed.numGlyphs) return 1e3;
+		return widths[gid];
+	};
+	const textWidthPt = (text, fontSize) => {
+		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms);
+		let totalEm = 0;
+		for (const a of shaped.advances) totalEm += a;
+		return totalEm * fontSize / parsed.unitsPerEm;
+	};
+	const encodeTextAsCidHex = (text) => {
+		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms);
+		let out = "";
+		for (const gid of shaped.gids) out += gid.toString(16).padStart(4, "0").toUpperCase();
+		return out;
+	};
+	return {
+		pdfWidthForGid,
+		textWidthPt,
+		encodeTextAsCidHex
+	};
+}
+//#endregion
+export { createFontMeasure };

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

@@ -0,0 +1,17 @@
+export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000';
+export declare function detectImageFormat(bytes: Uint8Array): ImageFormat | null;
+export interface EmbedImageOptions {
+    readonly flattenAlpha?: boolean;
+}
+export interface PreparedImage {
+    readonly format: ImageFormat;
+    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png';
+    readonly widthPx: number;
+    readonly heightPx: number;
+    readonly colorSpace?: 'DeviceGray' | 'DeviceRGB';
+    readonly bitsPerComponent?: number;
+    readonly filter: 'DCTDecode' | 'FlateDecode' | 'JPXDecode';
+    readonly data: Uint8Array;
+    readonly smaskData?: Uint8Array;
+}
+export declare function prepareImage(bytes: Uint8Array, options?: EmbedImageOptions): PreparedImage;

package/dist/esm/core/images.js

@@ -0,0 +1,308 @@
+import { unzlibSync, zlibSync } from "fflate";
+//#region src/core/images.ts
+function detectImageFormat(bytes) {
+	if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "jpeg";
+	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";
+	return null;
+}
+function prepareImage(bytes, options = {}) {
+	const format = detectImageFormat(bytes);
+	if (format === "jpeg") return prepareJpeg(bytes);
+	if (format === "png") return preparePng(bytes, options);
+	if (format === "jpeg2000") return prepareJpeg2000(bytes);
+	throw new Error("Unsupported image format");
+}
+function prepareJpeg2000(bytes) {
+	const { width, height } = readJpeg2000Info(bytes);
+	return {
+		format: "jpeg2000",
+		mimeType: "image/jp2",
+		widthPx: width,
+		heightPx: height,
+		filter: "JPXDecode",
+		data: bytes
+	};
+}
+function readU32(b, o) {
+	return b[o] * 16777216 + (b[o + 1] << 16) + (b[o + 2] << 8) + b[o + 3];
+}
+var boxType = (b, o) => String.fromCharCode(b[o], b[o + 1], b[o + 2], b[o + 3]);
+function readJpeg2000Info(bytes) {
+	if (bytes[0] === 255 && bytes[1] === 79) return readSiz(bytes, 2);
+	let p = 0;
+	while (p + 8 <= bytes.length) {
+		let len = readU32(bytes, p);
+		const type = boxType(bytes, p + 4);
+		let contentStart = p + 8;
+		if (len === 1) {
+			len = readU32(bytes, p + 12);
+			contentStart = p + 16;
+		}
+		const end = len === 0 ? bytes.length : p + len;
+		if (type === "jp2h") {
+			let q = contentStart;
+			while (q + 8 <= end) {
+				const clen = readU32(bytes, q);
+				if (boxType(bytes, q + 4) === "ihdr") return {
+					height: readU32(bytes, q + 8),
+					width: readU32(bytes, q + 12)
+				};
+				if (clen === 0) break;
+				q += clen;
+			}
+		}
+		if (len === 0) break;
+		p = end;
+	}
+	for (let i = 0; i + 22 < bytes.length; i++) if (bytes[i] === 255 && bytes[i + 1] === 81) return readSiz(bytes, i);
+	throw new Error("JPEG 2000: no ihdr/SIZ found");
+}
+function readSiz(bytes, sizOffset) {
+	const xsiz = readU32(bytes, sizOffset + 6);
+	const ysiz = readU32(bytes, sizOffset + 10);
+	const xo = readU32(bytes, sizOffset + 14);
+	const yo = readU32(bytes, sizOffset + 18);
+	const width = xsiz - xo;
+	const height = ysiz - yo;
+	if (width <= 0 || height <= 0) throw new Error("JPEG 2000: invalid SIZ dimensions");
+	return {
+		width,
+		height
+	};
+}
+function prepareJpeg(bytes) {
+	const info = readJpegInfo(bytes);
+	return {
+		format: "jpeg",
+		mimeType: "image/jpeg",
+		widthPx: info.width,
+		heightPx: info.height,
+		colorSpace: info.numComponents === 1 ? "DeviceGray" : "DeviceRGB",
+		bitsPerComponent: info.precision,
+		filter: "DCTDecode",
+		data: bytes
+	};
+}
+function readJpegInfo(bytes) {
+	if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) throw new Error("Not a JPEG (missing SOI)");
+	let i = 2;
+	while (i + 9 < bytes.length) {
+		if (bytes[i] !== 255) {
+			i++;
+			continue;
+		}
+		let marker = bytes[i + 1];
+		while (marker === 255) {
+			i++;
+			marker = bytes[i + 1];
+		}
+		if (marker === 1 || marker >= 208 && marker <= 217) {
+			i += 2;
+			continue;
+		}
+		if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return {
+			precision: bytes[i + 4],
+			height: bytes[i + 5] << 8 | bytes[i + 6],
+			width: bytes[i + 7] << 8 | bytes[i + 8],
+			numComponents: bytes[i + 9]
+		};
+		const length = bytes[i + 2] << 8 | bytes[i + 3];
+		i += 2 + length;
+	}
+	throw new Error("JPEG SOFn marker not found");
+}
+function preparePng(bytes, options = {}) {
+	let decoded = decodePng(bytes);
+	if (options.flattenAlpha && decoded.smaskRaw) decoded = flattenAlphaOnWhite(decoded);
+	return {
+		format: "png",
+		mimeType: "image/png",
+		widthPx: decoded.width,
+		heightPx: decoded.height,
+		colorSpace: decoded.colorSpace,
+		bitsPerComponent: decoded.bitsPerComponent,
+		filter: "FlateDecode",
+		data: zlibSync(decoded.raw),
+		...decoded.smaskRaw ? { smaskData: zlibSync(decoded.smaskRaw) } : {}
+	};
+}
+function decodePng(bytes) {
+	let width = 0;
+	let height = 0;
+	let bitDepth = 0;
+	let colorType = 0;
+	let interlaceMethod = 0;
+	const idatChunks = [];
+	let pos = 8;
+	while (pos + 12 <= bytes.length) {
+		const len = readU32BE(bytes, pos);
+		const type = chunkType(bytes, pos + 4);
+		const dataOff = pos + 8;
+		if (type === "IHDR") {
+			width = readU32BE(bytes, dataOff);
+			height = readU32BE(bytes, dataOff + 4);
+			bitDepth = bytes[dataOff + 8];
+			colorType = bytes[dataOff + 9];
+			interlaceMethod = bytes[dataOff + 12];
+		} else if (type === "IDAT") idatChunks.push(bytes.subarray(dataOff, dataOff + len));
+		else if (type === "IEND") break;
+		pos = dataOff + len + 4;
+	}
+	if (width === 0 || height === 0) throw new Error("PNG: missing IHDR");
+	if (idatChunks.length === 0) throw new Error("PNG: no IDAT");
+	if (interlaceMethod !== 0) throw new Error("PNG: interlaced not supported");
+	if (bitDepth !== 8) throw new Error(`PNG: bit depth ${bitDepth} not supported`);
+	const inflated = unzlibSync(concatBytes(idatChunks));
+	const channels = pngChannels(colorType);
+	if (channels === 0) throw new Error(`PNG color type ${colorType} not supported`);
+	const bpp = channels;
+	const scanlineBytes = width * bpp;
+	const expected = height * (1 + scanlineBytes);
+	if (inflated.length !== expected) throw new Error(`PNG: inflated size ${inflated.length} != expected ${expected} (interlaced or malformed)`);
+	const raw = new Uint8Array(height * scanlineBytes);
+	let prev = null;
+	for (let y = 0; y < height; y++) {
+		const inOff = y * (1 + scanlineBytes);
+		const filterType = inflated[inOff];
+		const decoded = new Uint8Array(scanlineBytes);
+		for (let x = 0; x < scanlineBytes; x++) {
+			const filt = inflated[inOff + 1 + x];
+			const a = x < bpp ? 0 : decoded[x - bpp];
+			const b = prev ? prev[x] : 0;
+			const c = !prev || x < bpp ? 0 : prev[x - bpp];
+			let v;
+			switch (filterType) {
+				case 0:
+					v = filt;
+					break;
+				case 1:
+					v = filt + a;
+					break;
+				case 2:
+					v = filt + b;
+					break;
+				case 3:
+					v = filt + Math.floor((a + b) / 2);
+					break;
+				case 4:
+					v = filt + paethPredictor(a, b, c);
+					break;
+				default: throw new Error(`PNG: unknown filter type ${filterType}`);
+			}
+			decoded[x] = v & 255;
+		}
+		raw.set(decoded, y * scanlineBytes);
+		prev = decoded;
+	}
+	return splitChannels(width, height, colorType, raw);
+}
+function flattenAlphaOnWhite(decoded) {
+	const alpha = decoded.smaskRaw;
+	if (!alpha) return decoded;
+	const channels = decoded.colorSpace === "DeviceRGB" ? 3 : 1;
+	const pixelCount = decoded.width * decoded.height;
+	const out = new Uint8Array(pixelCount * channels);
+	for (let i = 0; i < pixelCount; i++) {
+		const a = alpha[i] / 255;
+		for (let c = 0; c < channels; c++) {
+			const src = decoded.raw[i * channels + c];
+			out[i * channels + c] = Math.round(src * a + 255 * (1 - a));
+		}
+	}
+	return {
+		width: decoded.width,
+		height: decoded.height,
+		raw: out,
+		colorSpace: decoded.colorSpace,
+		bitsPerComponent: decoded.bitsPerComponent
+	};
+}
+function splitChannels(width, height, colorType, raw) {
+	const pixelCount = width * height;
+	if (colorType === 0) return {
+		width,
+		height,
+		raw,
+		colorSpace: "DeviceGray",
+		bitsPerComponent: 8
+	};
+	if (colorType === 2) return {
+		width,
+		height,
+		raw,
+		colorSpace: "DeviceRGB",
+		bitsPerComponent: 8
+	};
+	if (colorType === 4) {
+		const gray = new Uint8Array(pixelCount);
+		const alpha = new Uint8Array(pixelCount);
+		for (let i = 0; i < pixelCount; i++) {
+			gray[i] = raw[i * 2];
+			alpha[i] = raw[i * 2 + 1];
+		}
+		return {
+			width,
+			height,
+			raw: gray,
+			colorSpace: "DeviceGray",
+			bitsPerComponent: 8,
+			smaskRaw: alpha
+		};
+	}
+	if (colorType === 6) {
+		const rgb = new Uint8Array(pixelCount * 3);
+		const alpha = new Uint8Array(pixelCount);
+		for (let i = 0; i < pixelCount; i++) {
+			rgb[i * 3] = raw[i * 4];
+			rgb[i * 3 + 1] = raw[i * 4 + 1];
+			rgb[i * 3 + 2] = raw[i * 4 + 2];
+			alpha[i] = raw[i * 4 + 3];
+		}
+		return {
+			width,
+			height,
+			raw: rgb,
+			colorSpace: "DeviceRGB",
+			bitsPerComponent: 8,
+			smaskRaw: alpha
+		};
+	}
+	throw new Error(`PNG color type ${colorType} not supported (palette/indexed?)`);
+}
+function pngChannels(colorType) {
+	if (colorType === 0) return 1;
+	if (colorType === 2) return 3;
+	if (colorType === 4) return 2;
+	if (colorType === 6) return 4;
+	return 0;
+}
+function paethPredictor(a, b, c) {
+	const p = a + b - c;
+	const pa = Math.abs(p - a);
+	const pb = Math.abs(p - b);
+	const pc = Math.abs(p - c);
+	if (pa <= pb && pa <= pc) return a;
+	if (pb <= pc) return b;
+	return c;
+}
+function readU32BE(bytes, offset) {
+	return bytes[offset] * 16777216 + (bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]);
+}
+function chunkType(bytes, offset) {
+	return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+}
+function concatBytes(parts) {
+	let total = 0;
+	for (const p of parts) total += p.length;
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const p of parts) {
+		out.set(p, off);
+		off += p.length;
+	}
+	return out;
+}
+//#endregion
+export { detectImageFormat, prepareImage };

package/dist/esm/core/line-breaker/index.d.ts

@@ -1,2 +1,2 @@
-export { breakLines } from './knuth-plass.js';
+export { FORCED_BREAK, breakLines } from './knuth-plass.js';
 export type { Item, BoxItem, GlueItem, PenaltyItem, BreakResult, } from './knuth-plass.js';

package/dist/esm/core/line-breaker/knuth-plass.d.ts

@@ -19,6 +19,7 @@ export interface BreakResult {
     readonly breaks: ReadonlyArray<number>;
     readonly ratios: ReadonlyArray<number>;
 }
+export declare const FORCED_BREAK = -10000;
 /**
  * Break a paragraph into lines using the Knuth-Plass total-fit algorithm.
  *

package/dist/esm/core/line-breaker/knuth-plass.js

@@ -91,7 +91,7 @@ function breakLines(items, lineWidths) {
 		const badness = 100 * Math.pow(Math.abs(r), 3);
 		let d;
 		if (penaltyAtBreak >= 0 && penaltyAtBreak < FORBIDDEN_BREAK) d = Math.pow(LINE_PENALTY + badness + penaltyAtBreak, 2);
-		else if (penaltyAtBreak > FORCED_BREAK && penaltyAtBreak < 0) d = Math.pow(LINE_PENALTY + badness, 2) - penaltyAtBreak * penaltyAtBreak;
+		else if (penaltyAtBreak > -1e4 && penaltyAtBreak < 0) d = Math.pow(LINE_PENALTY + badness, 2) - penaltyAtBreak * penaltyAtBreak;
 		else d = Math.pow(LINE_PENALTY + badness, 2);
 		return d;
 	};
@@ -169,4 +169,4 @@ function breakLines(items, lineWidths) {
 	};
 }
 //#endregion
-export { breakLines };
+export { FORCED_BREAK, breakLines };

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

@@ -0,0 +1,3 @@
+import { BodyElement, Numbering } from '../document-model/index.js';
+export declare function applyNumbering(body: ReadonlyArray<BodyElement>, numbering: Numbering | undefined): Array<BodyElement>;
+export declare function applyNumberingToHeadersFooters(hf: ReadonlyMap<string, ReadonlyArray<BodyElement>> | undefined, numbering: Numbering | undefined): ReadonlyMap<string, ReadonlyArray<BodyElement>>;

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

@@ -0,0 +1,62 @@
+import { NumberingState } from "./state.js";
+//#region src/core/numbering/apply.ts
+function applyNumbering(body, numbering) {
+	if (!numbering || numbering.abstractNums.size === 0) return body.map((b) => b);
+	const state = new NumberingState();
+	const transformParagraph = (p) => {
+		const ref = p.properties.numbering;
+		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 ?? {}
+		};
+		return {
+			properties: mergeIndentFromLevel(p.properties, level?.paragraphProperties),
+			runs: [markerRun, ...p.runs]
+		};
+	};
+	const visit = (el) => {
+		if (el.kind === "paragraph") return {
+			kind: "paragraph",
+			paragraph: transformParagraph(el.paragraph)
+		};
+		if (el.kind === "image") return el;
+		if (el.kind === "shape") return el;
+		if (el.kind === "chart") return el;
+		return {
+			kind: "table",
+			table: {
+				...el.table,
+				rows: el.table.rows.map((row) => ({
+					...row,
+					cells: row.cells.map((cell) => ({
+						...cell,
+						content: cell.content.map(visit)
+					}))
+				}))
+			}
+		};
+	};
+	return body.map(visit);
+}
+function mergeIndentFromLevel(paragraphProps, levelProps) {
+	if (!levelProps) return paragraphProps;
+	const out = { ...paragraphProps };
+	if (out.indentLeft === void 0 && levelProps.indentLeft !== void 0) out.indentLeft = levelProps.indentLeft;
+	if (out.indentRight === void 0 && levelProps.indentRight !== void 0) out.indentRight = levelProps.indentRight;
+	if (out.indentFirstLine === void 0 && levelProps.indentFirstLine !== void 0) out.indentFirstLine = levelProps.indentFirstLine;
+	return out;
+}
+function applyNumberingToHeadersFooters(hf, numbering) {
+	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));
+	return out;
+}
+//#endregion
+export { applyNumbering, applyNumberingToHeadersFooters };

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

@@ -1 +1,2 @@
 export { NumberingState, formatLevelMarker } from './state.js';
+export { applyNumbering, applyNumberingToHeadersFooters } from './apply.js';

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

@@ -9,11 +9,12 @@ export declare class OpcPackage {
     private readonly parts;
     private readonly rootRelationships;
     private constructor();
+    private readonly relsCache;
     static open(buffer: Uint8Array, options?: OpcOpenOptions): OpcPackage;
     getPart(path: string): Uint8Array | undefined;
     requirePart(path: string): Uint8Array;
     listParts(): Array<string>;
-    getPartRelationships(partPath: string): Array<Relationship>;
+    getPartRelationships(partPath: string): ReadonlyArray<Relationship>;
     resolveRelatedPart(sourcePartPath: string, relationship: Relationship): {
         readonly path: string;
         readonly data: Uint8Array;

package/dist/esm/core/opc/package.js

@@ -9,6 +9,7 @@ var OpcPackage = class OpcPackage {
 		this.parts = parts;
 		this.rootRelationships = rootRelationships;
 	}
+	relsCache = /* @__PURE__ */ new Map();
 	static open(buffer, options = {}) {
 		const maxArchive = options.maxArchiveBytes ?? 128 * MIB;
 		const maxEntry = options.maxEntryBytes ?? 256 * MIB;
@@ -54,13 +55,16 @@ var OpcPackage = class OpcPackage {
 	}
 	getPartRelationships(partPath) {
 		const normalized = normalizePath(partPath);
+		const cached = this.relsCache.get(normalized);
+		if (cached) return cached;
 		const slash = normalized.lastIndexOf("/");
 		const dir = slash >= 0 ? normalized.substring(0, slash) : "";
 		const base = slash >= 0 ? normalized.substring(slash + 1) : normalized;
 		const relsPath = dir.length > 0 ? `${dir}/_rels/${base}.rels` : `_rels/${base}.rels`;
 		const data = this.parts.get(relsPath);
-		if (!data) return [];
-		return parseRelationships(data);
+		const rels = data ? parseRelationships(data) : [];
+		this.relsCache.set(normalized, rels);
+		return rels;
 	}
 	resolveRelatedPart(sourcePartPath, relationship) {
 		if (relationship.targetMode !== "Internal") return void 0;

package/dist/esm/core/style-cascade/index.d.ts

@@ -1,3 +1,3 @@
-export { EMPTY_STYLE_SHEET, resolveParagraphProperties, resolveRunProperties, } from './resolver.js';
+export { EMPTY_STYLE_SHEET, resolveBodyStyles, resolveHeadersFootersStyles, resolveParagraphProperties, resolveRunProperties, } from './resolver.js';
 export type { ResolvedRunProperties, ResolvedParagraphProperties, } from './types.js';
 export { DEFAULT_RESOLVED_RUN, DEFAULT_RESOLVED_PARAGRAPH } from './types.js';

package/dist/esm/core/style-cascade/resolver.d.ts

@@ -1,5 +1,7 @@
-import { ParagraphProperties, RunProperties, StyleSheet } from '../document-model/index.js';
+import { BodyElement, ParagraphProperties, RunProperties, StyleSheet } from '../document-model/index.js';
 import { ResolvedParagraphProperties, ResolvedRunProperties } from './types.js';
 export declare const EMPTY_STYLE_SHEET: StyleSheet;
 export declare function resolveRunProperties(runDirect: RunProperties, paragraphDirect: ParagraphProperties, sheet: StyleSheet): ResolvedRunProperties;
 export declare function resolveParagraphProperties(paragraphDirect: ParagraphProperties, sheet: StyleSheet): ResolvedParagraphProperties;
+export declare function resolveBodyStyles(body: ReadonlyArray<BodyElement>, sheet: StyleSheet): ReadonlyArray<BodyElement>;
+export declare function resolveHeadersFootersStyles(hf: ReadonlyMap<string, ReadonlyArray<BodyElement>>, sheet: StyleSheet): ReadonlyMap<string, ReadonlyArray<BodyElement>>;