reamkit 0.1.0-alpha.0 → 1.0.1

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/ir/adapters.d.ts

@@ -0,0 +1,37 @@
+import { Feature } from './features.js';
+import { FlowDoc } from './flow.js';
+import { LossReport } from './loss.js';
+export interface ReadOptions {
+    /** Reserved for reader-specific knobs (limits live in the readers). */
+    readonly [key: string]: unknown;
+}
+export interface ReadResult<TDoc> {
+    readonly doc: TDoc;
+    readonly losses: LossReport;
+}
+export interface DocumentReader<TDoc = FlowDoc> {
+    /** Format id: 'docx', 'xlsx', 'pdf', … */
+    readonly id: string;
+    /** Which tree this reader produces. */
+    readonly produces: 'flow' | 'page';
+    /** Feature vocabulary this reader understands (capability matrix source). */
+    readonly supports: ReadonlySet<Feature>;
+    /** Cheap format detection (magic bytes / container markers). */
+    sniff: (bytes: Uint8Array) => boolean;
+    read: (bytes: Uint8Array, opts?: ReadOptions) => ReadResult<TDoc>;
+}
+export interface WriteOptions {
+    readonly [key: string]: unknown;
+}
+export interface WriteResult {
+    readonly bytes: Uint8Array;
+    readonly losses: LossReport;
+}
+export interface DocumentWriter<TDoc> {
+    /** Output format id: 'pdf', 'svg', 'html', 'docx', … */
+    readonly id: string;
+    /** Which tree this writer consumes. */
+    readonly consumes: 'flow' | 'page';
+    readonly supports: ReadonlySet<Feature>;
+    write: (doc: TDoc, opts?: WriteOptions) => WriteResult;
+}

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

@@ -0,0 +1,25 @@
+export type Feature = string;
+export declare const FEATURES: {
+    readonly text: "text";
+    readonly tables: "tables";
+    readonly tablesNested: "tables.nested";
+    readonly lists: "lists";
+    readonly sections: "sections";
+    readonly headersFooters: "headersFooters";
+    readonly images: "images";
+    readonly imagesJp2: "images.jp2";
+    readonly shapes: "shapes";
+    readonly charts: "charts";
+    readonly math: "math";
+    readonly rtl: "rtl";
+    readonly trackedChanges: "trackedChanges";
+    readonly hyphenation: "hyphenation";
+    readonly fontsEmbedding: "fonts.embedding";
+    readonly fontsSubstitution: "fonts.substitution";
+    readonly pdfA: "pdf.archival";
+    readonly pdfTagged: "pdf.tagged";
+    readonly pdfSignatures: "pdf.signatures";
+};
+export type KnownFeature = (typeof FEATURES)[keyof typeof FEATURES];
+/** True when `feature` equals `prefix` or sits under it ('tables.nested' ⊂ 'tables'). */
+export declare function featureWithin(feature: Feature, prefix: Feature): boolean;

package/dist/esm/core/ir/features.js

@@ -0,0 +1,24 @@
+//#region src/core/ir/features.ts
+var FEATURES = {
+	text: "text",
+	tables: "tables",
+	tablesNested: "tables.nested",
+	lists: "lists",
+	sections: "sections",
+	headersFooters: "headersFooters",
+	images: "images",
+	imagesJp2: "images.jp2",
+	shapes: "shapes",
+	charts: "charts",
+	math: "math",
+	rtl: "rtl",
+	trackedChanges: "trackedChanges",
+	hyphenation: "hyphenation",
+	fontsEmbedding: "fonts.embedding",
+	fontsSubstitution: "fonts.substitution",
+	pdfA: "pdf.archival",
+	pdfTagged: "pdf.tagged",
+	pdfSignatures: "pdf.signatures"
+};
+//#endregion
+export { FEATURES };

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

@@ -0,0 +1,24 @@
+import { BodyElement, Chart, DocumentInfo, Numbering, Section, SectionProperties, StyleSheet } from '../document-model/index.js';
+import { FontRegistry } from '../font/index.js';
+import { ResourceStore } from './resources.js';
+export interface FlowDoc {
+    readonly kind: 'flow';
+    readonly body: ReadonlyArray<BodyElement>;
+    /** Multi-section page geometry (docx). Empty for single-geometry sources. */
+    readonly sections: ReadonlyArray<Section>;
+    /** Single-section page geometry (xlsx print setup). */
+    readonly section?: SectionProperties;
+    readonly styles: StyleSheet;
+    readonly numbering?: Numbering;
+    readonly headersFooters?: ReadonlyMap<string, ReadonlyArray<BodyElement>>;
+    /** Parsed charts keyed by relationship id (ChartBlock.chartRelId). */
+    readonly charts?: ReadonlyMap<string, Chart>;
+    /** Content-addressed binary resources (images). */
+    readonly resources: ResourceStore;
+    /** Fonts embedded in the source document itself (docx fontTable), by name. */
+    readonly embeddedFonts?: ReadonlyMap<string, FontRegistry>;
+    /** Document metadata from docProps/core.xml. */
+    readonly info?: DocumentInfo;
+    /** Document natural language hint (BCP-47), e.g. for tagged-PDF /Lang. */
+    readonly language?: string;
+}

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

@@ -0,0 +1,11 @@
+export type { Pt } from './units.js';
+export { pt, twipsToPt, halfPtToPt, eighthPtToPt, emuToPt, pxToPt, inchToPt, mmToPt, } from './units.js';
+export type { ResourceId } from './resources.js';
+export { ResourceStore } from './resources.js';
+export type { Feature, KnownFeature } from './features.js';
+export { FEATURES, featureWithin } from './features.js';
+export type { Loss, LossReport, LossSeverity } from './loss.js';
+export { ConversionLossError, formatLoss } from './loss.js';
+export interface NativeBag {
+    readonly [formatId: string]: unknown;
+}

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

@@ -0,0 +1,22 @@
+import { Feature } from './features.js';
+/**
+ * - `dropped`     — content is absent from the output (e.g. math → markdown).
+ * - `degraded`    — content survives with reduced fidelity (e.g. gradient → flat fill).
+ * - `substituted` — content was replaced by an equivalent (e.g. font substitution).
+ */
+export type LossSeverity = 'dropped' | 'degraded' | 'substituted';
+export interface Loss {
+    readonly severity: LossSeverity;
+    readonly feature: Feature;
+    /** Human-readable specifics: what exactly happened to what. */
+    readonly detail: string;
+    /** Optional location hint (page/paragraph/sheet reference). */
+    readonly where?: string;
+}
+export type LossReport = ReadonlyArray<Loss>;
+export declare function formatLoss(loss: Loss): string;
+/** Thrown by strict-mode conversions on the first recorded loss. */
+export declare class ConversionLossError extends Error {
+    readonly loss: Loss;
+    constructor(loss: Loss);
+}

package/dist/esm/core/ir/loss.js

@@ -0,0 +1,15 @@
+//#region src/core/ir/loss.ts
+function formatLoss(loss) {
+	const where = loss.where ? ` at ${loss.where}` : "";
+	return `[${loss.severity}] ${loss.feature}${where}: ${loss.detail}`;
+}
+/** Thrown by strict-mode conversions on the first recorded loss. */
+var ConversionLossError = class extends Error {
+	constructor(loss) {
+		super(`strict conversion failed — ${formatLoss(loss)}`);
+		this.loss = loss;
+		this.name = "ConversionLossError";
+	}
+};
+//#endregion
+export { ConversionLossError, formatLoss };

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

@@ -0,0 +1,16 @@
+export type ResourceId = string & {
+    readonly __brand: 'resource-id';
+};
+export declare class ResourceStore {
+    private readonly byId;
+    /**
+     * Store bytes and return their content-addressed id. Re-putting identical
+     * bytes returns the existing id (deduplication); a hash collision with
+     * different bytes probes deterministic `~n` suffixes.
+     */
+    put(bytes: Uint8Array): ResourceId;
+    get(id: ResourceId): Uint8Array | undefined;
+    has(id: ResourceId): boolean;
+    ids(): ReadonlyArray<ResourceId>;
+    get size(): number;
+}

package/dist/esm/core/ir/resources.js

@@ -0,0 +1,50 @@
+//#region src/core/ir/resources.ts
+var FNV_PRIME = 16777619;
+function hashBytes(bytes) {
+	let a = 2166136261;
+	let b = 3421674724;
+	for (const byte of bytes) {
+		a = Math.imul(a ^ byte, FNV_PRIME);
+		b = Math.imul(b ^ byte, FNV_PRIME);
+	}
+	return `${(a >>> 0).toString(16).padStart(8, "0")}${(b >>> 0).toString(16).padStart(8, "0")}`;
+}
+function equalBytes(x, y) {
+	if (x.length !== y.length) return false;
+	for (let i = 0; i < x.length; i++) if (x[i] !== y[i]) return false;
+	return true;
+}
+var ResourceStore = class {
+	byId = /* @__PURE__ */ new Map();
+	/**
+	* Store bytes and return their content-addressed id. Re-putting identical
+	* bytes returns the existing id (deduplication); a hash collision with
+	* different bytes probes deterministic `~n` suffixes.
+	*/
+	put(bytes) {
+		const base = `r-${hashBytes(bytes)}-${bytes.length}`;
+		for (let n = 0;; n++) {
+			const id = n === 0 ? base : `${base}~${n}`;
+			const existing = this.byId.get(id);
+			if (existing === void 0) {
+				this.byId.set(id, bytes);
+				return id;
+			}
+			if (equalBytes(existing, bytes)) return id;
+		}
+	}
+	get(id) {
+		return this.byId.get(id);
+	}
+	has(id) {
+		return this.byId.has(id);
+	}
+	ids() {
+		return [...this.byId.keys()];
+	}
+	get size() {
+		return this.byId.size;
+	}
+};
+//#endregion
+export { ResourceStore };

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

@@ -0,0 +1,16 @@
+export type Pt = number & {
+    readonly __brand: 'pt';
+};
+/** Brand a raw number as points. The number must already BE points. */
+export declare function pt(value: number): Pt;
+export declare function twipsToPt(twips: number): Pt;
+/** Half-points (OOXML font sizes, `w:sz`): 2 half-points = 1 pt. */
+export declare function halfPtToPt(halfPt: number): Pt;
+/** Eighths of a point (OOXML border widths, `w:sz` on borders): 8 = 1 pt. */
+export declare function eighthPtToPt(eighthPt: number): Pt;
+/** English Metric Units (DrawingML): 914400 EMU = 1 inch = 72 pt → 12700 EMU = 1 pt. */
+export declare function emuToPt(emu: number): Pt;
+/** CSS reference pixels: 96 px = 1 inch = 72 pt. */
+export declare function pxToPt(px: number): Pt;
+export declare function inchToPt(inches: number): Pt;
+export declare function mmToPt(mm: number): Pt;

package/dist/esm/core/ir/units.js

@@ -0,0 +1,41 @@
+//#region src/core/ir/units.ts
+/** Brand a raw number as points. The number must already BE points. */
+function pt(value) {
+	return value;
+}
+/**
+* Twentieths of a point (OOXML `dxa` / twips): 20 twips = 1 pt.
+*
+* Deliberately `* (1/20)`, not `/ 20`: the two differ in the last ulp for ~35%
+* of integer inputs, and the layout engine historically multiplied by a
+* `TWIP_TO_PT = 1/20` constant — keeping the exact operator keeps the
+* byte-identical corpus gate meaningful across the IR migration.
+*/
+var TWIP_TO_PT = 1 / 20;
+function twipsToPt(twips) {
+	return twips * TWIP_TO_PT;
+}
+/** Half-points (OOXML font sizes, `w:sz`): 2 half-points = 1 pt. */
+function halfPtToPt(halfPt) {
+	return halfPt / 2;
+}
+/** Eighths of a point (OOXML border widths, `w:sz` on borders): 8 = 1 pt. */
+function eighthPtToPt(eighthPt) {
+	return eighthPt / 8;
+}
+/** English Metric Units (DrawingML): 914400 EMU = 1 inch = 72 pt → 12700 EMU = 1 pt. */
+function emuToPt(emu) {
+	return emu / 12700;
+}
+/** CSS reference pixels: 96 px = 1 inch = 72 pt. */
+function pxToPt(px) {
+	return px * .75;
+}
+function inchToPt(inches) {
+	return inches * 72;
+}
+function mmToPt(mm) {
+	return mm / 25.4 * 72;
+}
+//#endregion
+export { eighthPtToPt, emuToPt, halfPtToPt, inchToPt, mmToPt, pt, pxToPt, twipsToPt };

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

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

package/dist/esm/{line-breaker → 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/{line-breaker → core/line-breaker}/knuth-plass.js

@@ -1,4 +1,4 @@
-//#region src/line-breaker/knuth-plass.ts
+//#region src/core/line-breaker/knuth-plass.ts
 var FORCED_BREAK = -1e4;
 var FORBIDDEN_BREAK = 1e4;
 var LINE_PENALTY = 10;
@@ -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>>;