reamkit 1.16.0 → 1.18.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' | 'tiff';
 /**
  * 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' | 'image/tiff';
     readonly widthPx: number;
     readonly heightPx: number;
     /**

package/dist/esm/core/images.js

@@ -1,3 +1,4 @@
+import { decodeTiff, isTiff } from "./tiff.js";
 import { unzlibSync, zlibSync } from "fflate";
 //#region src/core/images.ts
 /**
@@ -10,6 +11,8 @@ 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";
+	if (isTiff(bytes)) return "tiff";
 	return null;
 }
 /**
@@ -24,6 +27,8 @@ 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);
+	if (format === "tiff") return prepareTiff(bytes, options);
 	throw new Error("Unsupported image format");
 }
 function prepareJpeg2000(bytes) {
@@ -125,6 +130,220 @@ 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 prepareTiff(bytes, options = {}) {
+	const img = decodeTiff(bytes);
+	const channels = img.channels === 4 ? 3 : img.channels;
+	const data = img.channels === 4 ? cmykToRgb(img.data) : img.data.slice();
+	const alpha = img.alpha;
+	if (alpha && options.flattenAlpha) for (let i = 0; i < alpha.length; i++) {
+		if (alpha[i] === 255) continue;
+		const a = alpha[i] / 255;
+		for (let c = 0; c < channels; c++) {
+			const at = i * channels + c;
+			data[at] = Math.round(data[at] * a + 255 * (1 - a));
+		}
+	}
+	return {
+		format: "tiff",
+		mimeType: "image/tiff",
+		widthPx: img.width,
+		heightPx: img.height,
+		colorSpace: channels === 3 ? "DeviceRGB" : "DeviceGray",
+		bitsPerComponent: 8,
+		filter: "FlateDecode",
+		data: zlibSync(data),
+		...alpha && !options.flattenAlpha ? { smaskData: zlibSync(alpha.slice()) } : {}
+	};
+}
+function cmykToRgb(cmyk) {
+	const out = new Uint8Array(cmyk.length / 4 * 3);
+	for (let i = 0; i * 4 + 3 < cmyk.length; i++) {
+		const k = 255 - cmyk[i * 4 + 3];
+		out[i * 3] = (255 - cmyk[i * 4]) * k / 255;
+		out[i * 3 + 1] = (255 - cmyk[i * 4 + 1]) * k / 255;
+		out[i * 3 + 2] = (255 - cmyk[i * 4 + 2]) * k / 255;
+	}
+	return out;
+}
+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/lzw.d.ts

@@ -0,0 +1,17 @@
+/** How to run {@link lzwDecodeMsb}: the early-change flag and an output cap. */
+export interface LzwOptions {
+    /**
+     * Widen the code one step BEFORE the table fills (PDF `/EarlyChange`,
+     * TIFF's own convention). 1 by default, matching both specifications' norm.
+     */
+    readonly earlyChange?: number;
+    /** Stop after this many output bytes — the guard against a decompression bomb. */
+    readonly limit: number;
+}
+/**
+ * Decode an MSB-first LZW stream (TIFF 6.0 §13 / ISO 32000-1 §7.4.4.2). The
+ * KwKwK case (a code not yet in the table) repeats the previous string plus its
+ * own first byte. Truncated input ends the stream where it stops rather than
+ * throwing: a partly-decoded strip still prints.
+ */
+export declare function lzwDecodeMsb(data: Uint8Array, options: LzwOptions): Uint8Array;

package/dist/esm/core/lzw.js

@@ -0,0 +1,83 @@
+//#region src/core/lzw.ts
+/**
+* Decode an MSB-first LZW stream (TIFF 6.0 §13 / ISO 32000-1 §7.4.4.2). The
+* KwKwK case (a code not yet in the table) repeats the previous string plus its
+* own first byte. Truncated input ends the stream where it stops rather than
+* throwing: a partly-decoded strip still prints.
+*/
+function lzwDecodeMsb(data, options) {
+	const earlyChange = options.earlyChange ?? 1;
+	let out = new Uint8Array(4096);
+	let outLen = 0;
+	const emit = (e) => {
+		if (outLen + e.length > options.limit) return false;
+		if (outLen + e.length > out.length) {
+			let cap = out.length * 2;
+			while (cap < outLen + e.length) cap *= 2;
+			const grown = new Uint8Array(cap);
+			grown.set(out.subarray(0, outLen));
+			out = grown;
+		}
+		out.set(e, outLen);
+		outLen += e.length;
+		return true;
+	};
+	let bitBuffer = 0;
+	let bitCount = 0;
+	let pos = 0;
+	let codeLength = 9;
+	const readCode = () => {
+		while (bitCount < codeLength) {
+			if (pos >= data.length) return -1;
+			bitBuffer = (bitBuffer << 8 | data[pos++]) >>> 0;
+			bitCount += 8;
+		}
+		bitCount -= codeLength;
+		return bitBuffer >>> bitCount & (1 << codeLength) - 1;
+	};
+	const dict = new Array(4096);
+	let nextCode = 258;
+	let prev = -1;
+	const reset = () => {
+		for (let i = 0; i < 256; i++) dict[i] = Uint8Array.of(i);
+		nextCode = 258;
+		codeLength = 9;
+		prev = -1;
+	};
+	reset();
+	for (;;) {
+		const code = readCode();
+		if (code < 0 || code === 257) break;
+		if (code === 256) {
+			reset();
+			continue;
+		}
+		if (prev < 0) {
+			const first = dict[code];
+			if (!first || !emit(first)) break;
+			prev = code;
+			continue;
+		}
+		const prevEntry = dict[prev];
+		let entry = code < nextCode ? dict[code] : void 0;
+		if (!entry) {
+			entry = new Uint8Array(prevEntry.length + 1);
+			entry.set(prevEntry);
+			entry[prevEntry.length] = prevEntry[0];
+		}
+		if (!emit(entry)) break;
+		if (nextCode < 4096) {
+			const added = new Uint8Array(prevEntry.length + 1);
+			added.set(prevEntry);
+			added[prevEntry.length] = entry[0];
+			dict[nextCode++] = added;
+			if (nextCode + earlyChange === 512) codeLength = 10;
+			else if (nextCode + earlyChange === 1024) codeLength = 11;
+			else if (nextCode + earlyChange === 2048) codeLength = 12;
+		}
+		prev = code;
+	}
+	return out.subarray(0, outLen);
+}
+//#endregion
+export { lzwDecodeMsb };

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

@@ -0,0 +1,16 @@
+import { PathSegment } from '../vector.js';
+import { MetaPicture } from './picture.js';
+/** Whether the bytes open with an EMF header (MS-EMF §2.3.4.2: type 1 + " EMF"). */
+export declare function isEmf(bytes: Uint8Array): boolean;
+/**
+ * Read an EMF into its primitives.
+ *
+ * @throws Error when the bytes are not an EMF or its header is malformed.
+ */
+export declare function readEmf(bytes: Uint8Array): MetaPicture;
+type Mapper = (x: number, y: number) => {
+    x: number;
+    y: number;
+};
+export declare function ellipseSegments(map: Mapper, l: number, t: number, r: number, b: number): Array<PathSegment>;
+export {};