reamkit 1.17.0 → 1.19.0

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

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

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

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

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

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

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

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

package/dist/esm/core/po-helpers.d.ts

@@ -34,6 +34,15 @@ export declare function poAttrLocal(node: PoNode | undefined, name: string): str
 export declare function poIsLocal(node: PoNode | undefined, name: string): boolean;
 /** {@link poAttr} parsed as a finite number, or undefined when absent/non-numeric. */
 export declare function poIntAttr(node: PoNode | undefined, name: string): number | undefined;
+/**
+ * §22.9.2.15 ST_UniversalMeasure — a number with a UNIT (`"28.35pt"`, `"1cm"`)
+ * as twips. Producers write whole page geometries, tab stops and indents this
+ * way; read as a plain number they are nothing at all.
+ *
+ * @param raw The attribute value.
+ * @returns The measure in twips, or undefined when it names no unit.
+ */
+export declare function universalMeasureTwips(raw: string): number | undefined;
 /** Shorthand for the `val` attribute (`@w:val`/…). */
 export declare function poVal(node: PoNode | undefined): string | undefined;
 /**

package/dist/esm/core/po-helpers.js

@@ -76,6 +76,14 @@ var MEASURE_TWIPS = new Map([
 	["cm", 1440 / 2.54],
 	["mm", 144 / 2.54]
 ]);
+/**
+* §22.9.2.15 ST_UniversalMeasure — a number with a UNIT (`"28.35pt"`, `"1cm"`)
+* as twips. Producers write whole page geometries, tab stops and indents this
+* way; read as a plain number they are nothing at all.
+*
+* @param raw The attribute value.
+* @returns The measure in twips, or undefined when it names no unit.
+*/
 function universalMeasureTwips(raw) {
 	const m = /^\s*(-?[0-9]+(?:\.[0-9]+)?)(pt|pc|pi|in|cm|mm)\s*$/iu.exec(raw);
 	if (!m) return void 0;
@@ -134,4 +142,4 @@ function poFindDescendant(node, tag) {
 	}
 }
 //#endregion
-export { poAttr, poAttrLocal, poChildren, poChildrenWith, poFindByPath, poFindDescendant, poFirstChild, poIntAttr, poIs, poIsLocal, poTag, poText, poToggle, poVal };
+export { poAttr, poAttrLocal, poChildren, poChildrenWith, poFindByPath, poFindDescendant, poFirstChild, poIntAttr, poIs, poIsLocal, poTag, poText, poToggle, poVal, universalMeasureTwips };

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

@@ -0,0 +1,20 @@
+/** One decoded TIFF image: 8-bit chunky samples plus an optional alpha plane. */
+export interface DecodedTiff {
+    readonly width: number;
+    readonly height: number;
+    /** Samples per pixel in {@link data} — 1 (grey), 3 (RGB) or 4 (CMYK). */
+    readonly channels: 1 | 3 | 4;
+    /** Row-major 8-bit samples, `width * height * channels` long. */
+    readonly data: Uint8Array;
+    /** One byte per pixel when the file carries an alpha channel. */
+    readonly alpha?: Uint8Array;
+}
+/** Whether the bytes open with a TIFF header (§2: `II*\0` or `MM\0*`). */
+export declare function isTiff(bytes: Uint8Array): boolean;
+/**
+ * Decode the first image of a baseline TIFF into 8-bit chunky samples.
+ *
+ * @throws Error when the file is malformed or uses a feature outside baseline
+ * TIFF (planar separation, JPEG/fax compression, floating-point samples).
+ */
+export declare function decodeTiff(bytes: Uint8Array): DecodedTiff;