reamkit 1.16.0 → 1.18.0

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

@@ -0,0 +1,635 @@
+import { PathBuilder } from "../vector.js";
+import { applyTransform, cloneDc, colorRef, newDeviceContext } from "./picture.js";
+//#region src/core/metafile/emf.ts
+/** Whether the bytes open with an EMF header (MS-EMF §2.3.4.2: type 1 + " EMF"). */
+function isEmf(bytes) {
+	if (bytes.length < 44) return false;
+	const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	return v.getUint32(0, true) === 1 && v.getUint32(40, true) === 1179469088;
+}
+var RECORD_NAMES = new Map([
+	[48, "palette"],
+	[49, "palette"],
+	[50, "palette"],
+	[51, "palette"],
+	[52, "palette"],
+	[70, "comment"],
+	[71, "region fill"],
+	[72, "region frame"],
+	[73, "region invert"],
+	[74, "region paint"],
+	[78, "masked blit"],
+	[79, "parallelogram blit"],
+	[80, "device bitmap"],
+	[81, "bitmap"],
+	[76, "bitmap"],
+	[77, "bitmap"],
+	[114, "alpha blit"],
+	[116, "transparent blit"],
+	[118, "gradient fill"]
+]);
+/**
+* Read an EMF into its primitives.
+*
+* @throws Error when the bytes are not an EMF or its header is malformed.
+*/
+function readEmf(bytes) {
+	if (!isEmf(bytes)) throw new Error("EMF: not an enhanced metafile");
+	const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const bounds = {
+		left: v.getInt32(8, true),
+		top: v.getInt32(12, true),
+		right: v.getInt32(16, true),
+		bottom: v.getInt32(20, true)
+	};
+	const prims = [];
+	const skipped = /* @__PURE__ */ new Set();
+	const objects = /* @__PURE__ */ new Map();
+	const stack = [];
+	let dc = newDeviceContext();
+	let win = {
+		x: 0,
+		y: 0,
+		cx: 1,
+		cy: 1
+	};
+	let view = {
+		x: 0,
+		y: 0,
+		cx: 1,
+		cy: 1
+	};
+	let haveWin = false;
+	let haveView = false;
+	const sx = () => haveWin && haveView && win.cx !== 0 ? view.cx / win.cx : 1;
+	const sy = () => haveWin && haveView && win.cy !== 0 ? view.cy / win.cy : 1;
+	/** Logical → device, through the world transform and the window mapping. */
+	const px = (x, y) => {
+		const w = applyTransform(dc.transform, x, y);
+		return {
+			x: (w.x - win.x) * sx() + view.x,
+			y: (w.y - win.y) * sy() + view.y
+		};
+	};
+	let building;
+	const open = () => building ?? [];
+	const strokeOf = () => {
+		if (dc.pen.style === "none") return void 0;
+		const w = dc.pen.widthLu <= 1 ? 1 : dc.pen.widthLu * Math.abs(sx());
+		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 } : {}
+		});
+	};
+	/** A closed rectangle, as the geometry records draw one. */
+	const rectSegments = (l, t, r, b) => {
+		const p0 = px(l, t);
+		const p1 = px(r, t);
+		const p2 = px(r, b);
+		const p3 = px(l, b);
+		return new PathBuilder().moveTo(p0.x, p0.y).lineTo(p1.x, p1.y).lineTo(p2.x, p2.y).lineTo(p3.x, p3.y).close().build().segments;
+	};
+	let off = 0;
+	let guard = 0;
+	while (off + 8 <= bytes.length && guard++ < 2e5) {
+		const type = v.getUint32(off, true);
+		const size = v.getUint32(off + 4, true);
+		if (size < 8 || off + size > bytes.length) break;
+		const at = (o) => v.getInt32(off + o, true);
+		const u = (o) => v.getUint32(off + o, true);
+		switch (type) {
+			case 14:
+				off = bytes.length;
+				continue;
+			case 9:
+				win = {
+					...win,
+					cx: at(8),
+					cy: at(12)
+				};
+				haveWin = true;
+				break;
+			case 10:
+				win = {
+					...win,
+					x: at(8),
+					y: at(12)
+				};
+				haveWin = true;
+				break;
+			case 11:
+				view = {
+					...view,
+					cx: at(8),
+					cy: at(12)
+				};
+				haveView = true;
+				break;
+			case 12:
+				view = {
+					...view,
+					x: at(8),
+					y: at(12)
+				};
+				haveView = true;
+				break;
+			case 33:
+				stack.push(cloneDc(dc));
+				break;
+			case 34:
+				{
+					const back = Math.max(1, -at(8));
+					for (let i = 0; i < back && stack.length > 0; i++) dc = stack.pop();
+				}
+				break;
+			case 35:
+				dc.transform = xform(v, off + 8);
+				break;
+			case 36:
+				{
+					const m = xform(v, off + 8);
+					const mode = u(32);
+					dc.transform = mode === 1 ? [
+						1,
+						0,
+						0,
+						1,
+						0,
+						0
+					] : mode === 2 ? multiply(m, dc.transform) : mode === 3 ? multiply(dc.transform, m) : m;
+				}
+				break;
+			case 37:
+				{
+					const ih = u(8);
+					const obj = stockObject(ih) ?? objects.get(ih);
+					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 38:
+				objects.set(u(8), {
+					kind: "pen",
+					colorHex: colorRef(u(24)),
+					widthLu: at(16),
+					style: penStyle(u(12))
+				});
+				break;
+			case 95:
+				objects.set(u(8), {
+					kind: "pen",
+					colorHex: colorRef(u(40)),
+					widthLu: at(32),
+					style: u(36) === 1 ? "none" : penStyle(u(28))
+				});
+				break;
+			case 39:
+				{
+					const style = u(12);
+					objects.set(u(8), {
+						kind: "brush",
+						colorHex: colorRef(u(16)),
+						hollow: style === 1
+					});
+				}
+				break;
+			case 82:
+				objects.set(u(8), readLogFont(v, bytes, off + 12));
+				break;
+			case 40:
+				objects.delete(u(8));
+				break;
+			case 18:
+				dc.bkOpaque = u(8) === 2;
+				break;
+			case 19:
+				dc.fillRule = u(8) === 2 ? "nonzero" : "evenodd";
+				break;
+			case 22:
+				{
+					const f = u(8);
+					dc.alignH = (f & 6) === 6 ? "center" : (f & 2) === 2 ? "right" : "left";
+					dc.alignBaseline = (f & 24) === 24;
+				}
+				break;
+			case 24:
+				dc.textColorHex = colorRef(u(8));
+				break;
+			case 25:
+				dc.bkColorHex = colorRef(u(8));
+				break;
+			case 27:
+				dc.x = at(8);
+				dc.y = at(12);
+				if (building) {
+					const p = px(dc.x, dc.y);
+					building.push({
+						op: "move",
+						x: p.x,
+						y: p.y
+					});
+				}
+				break;
+			case 54:
+				{
+					const from = px(dc.x, dc.y);
+					dc.x = at(8);
+					dc.y = at(12);
+					const to = px(dc.x, dc.y);
+					if (building) {
+						if (building.length === 0) building.push({
+							op: "move",
+							x: from.x,
+							y: from.y
+						});
+						building.push({
+							op: "line",
+							x: to.x,
+							y: to.y
+						});
+					} else paint([{
+						op: "move",
+						x: from.x,
+						y: from.y
+					}, {
+						op: "line",
+						x: to.x,
+						y: to.y
+					}], false, true);
+				}
+				break;
+			case 59:
+				building = [];
+				break;
+			case 61:
+				if (building && building.length > 0) building.push({ op: "close" });
+				break;
+			case 60: break;
+			case 62:
+			case 63:
+			case 64:
+				paint(open(), type !== 64, type !== 62);
+				building = void 0;
+				break;
+			case 68:
+				building = void 0;
+				break;
+			case 43:
+				paint(rectSegments(at(8), at(12), at(16), at(20)), true, true);
+				break;
+			case 42:
+				paint(ellipseSegments(px, at(8), at(12), at(16), at(20)), true, true);
+				break;
+			case 44:
+				paint(rectSegments(at(8), at(12), at(16), at(20)), true, true);
+				break;
+			case 3:
+			case 4:
+			case 2:
+			case 5:
+			case 6:
+			case 86:
+			case 87:
+			case 85:
+			case 88:
+			case 89:
+				{
+					const small = type >= 85;
+					const count = u(24);
+					const pts = readPoints(v, off + 28, count, small);
+					const closed = type === 3 || type === 86;
+					const segs = polySegments(px, pts, {
+						closed,
+						bezier: type === 2 || type === 5 || type === 85 || type === 88,
+						...type === 5 || type === 6 || type === 88 || type === 89 ? { from: {
+							x: dc.x,
+							y: dc.y
+						} } : {}
+					});
+					if (pts.length > 0) {
+						dc.x = pts[pts.length - 1].x;
+						dc.y = pts[pts.length - 1].y;
+					}
+					if (building) building.push(...segs);
+					else paint(segs, closed, true);
+				}
+				break;
+			case 90:
+			case 91:
+			case 7:
+			case 8:
+				{
+					const small = type >= 90;
+					const polys = u(24);
+					const total = u(28);
+					const counts = [];
+					for (let i = 0; i < polys; i++) counts.push(v.getUint32(off + 32 + i * 4, true));
+					const pts = readPoints(v, off + 32 + polys * 4, total, small);
+					const closed = type === 91 || type === 8;
+					const segs = [];
+					let k = 0;
+					for (const c of counts) {
+						segs.push(...polySegments(px, pts.slice(k, k + c), {
+							closed,
+							bezier: false
+						}));
+						k += c;
+					}
+					if (building) building.push(...segs);
+					else paint(segs, closed, true);
+				}
+				break;
+			case 83:
+			case 84:
+				{
+					const refX = at(36);
+					const refY = at(40);
+					const chars = u(44);
+					const offString = u(48);
+					const wide = type === 84;
+					const text = readString(bytes, off + offString, chars, wide);
+					if (text.trim() !== "") {
+						const p = px(refX, refY);
+						const font = dc.font;
+						prims.push({
+							kind: "text",
+							text,
+							x: p.x,
+							y: p.y,
+							alignH: dc.alignH,
+							alignBaseline: dc.alignBaseline,
+							sizeLu: Math.abs(font?.heightLu ?? 12) * Math.abs(sy()),
+							colorHex: dc.textColorHex,
+							...font?.family ? { fontFamily: font.family } : {},
+							...font?.bold ? { bold: true } : {},
+							...font?.italic ? { italic: true } : {},
+							...font?.escapement ? { escapement: font.escapement } : {}
+						});
+					}
+				}
+				break;
+			case 76:
+				{
+					const cbBmiSrc = u(88);
+					const rop = u(40);
+					if (cbBmiSrc === 0) {
+						const x = at(24);
+						const y = at(28);
+						const w = at(32);
+						const h = at(36);
+						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;
+					} else skipped.add("bitmap");
+				}
+				break;
+			default:
+				{
+					const name = RECORD_NAMES.get(type);
+					if (name) skipped.add(name);
+				}
+				break;
+		}
+		off += size;
+	}
+	return {
+		left: bounds.left,
+		top: bounds.top,
+		width: Math.max(1, bounds.right - bounds.left),
+		height: Math.max(1, bounds.bottom - bounds.top),
+		prims,
+		skipped: [...skipped]
+	};
+}
+function xform(v, at) {
+	return [
+		v.getFloat32(at, true),
+		v.getFloat32(at + 4, true),
+		v.getFloat32(at + 8, true),
+		v.getFloat32(at + 12, true),
+		v.getFloat32(at + 16, true),
+		v.getFloat32(at + 20, true)
+	];
+}
+function multiply(a, b) {
+	return [
+		a[0] * b[0] + a[1] * b[2],
+		a[0] * b[1] + a[1] * b[3],
+		a[2] * b[0] + a[3] * b[2],
+		a[2] * b[1] + a[3] * b[3],
+		a[4] * b[0] + a[5] * b[2] + b[4],
+		a[4] * b[1] + a[5] * b[3] + b[5]
+	];
+}
+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 stockObject(ih) {
+	if ((ih & 2147483648) === 0) return void 0;
+	switch (ih & 2147483647) {
+		case 0: return {
+			kind: "brush",
+			colorHex: "FFFFFF",
+			hollow: false
+		};
+		case 1: return {
+			kind: "brush",
+			colorHex: "C0C0C0",
+			hollow: false
+		};
+		case 2: return {
+			kind: "brush",
+			colorHex: "808080",
+			hollow: false
+		};
+		case 3: return {
+			kind: "brush",
+			colorHex: "404040",
+			hollow: false
+		};
+		case 4: return {
+			kind: "brush",
+			colorHex: "000000",
+			hollow: false
+		};
+		case 5: return {
+			kind: "brush",
+			colorHex: "000000",
+			hollow: true
+		};
+		case 6: return {
+			kind: "pen",
+			colorHex: "FFFFFF",
+			widthLu: 1,
+			style: "solid"
+		};
+		case 7: return {
+			kind: "pen",
+			colorHex: "000000",
+			widthLu: 1,
+			style: "solid"
+		};
+		case 8: return {
+			kind: "pen",
+			colorHex: "000000",
+			widthLu: 1,
+			style: "none"
+		};
+		default: return;
+	}
+}
+function readLogFont(v, bytes, at) {
+	const height = v.getInt32(at, true);
+	const escapement = v.getInt32(at + 8, true);
+	const weight = v.getInt32(at + 16, true);
+	const italic = bytes[at + 20] !== 0;
+	const face = readString(bytes, at + 28, 32, true).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 + (wide ? 1 : 0) >= bytes.length) break;
+		const code = wide ? bytes[o] | bytes[o + 1] << 8 : bytes[o];
+		if (code === 0) break;
+		out += String.fromCharCode(code);
+	}
+	return out;
+}
+function readPoints(v, at, count, small) {
+	const out = [];
+	const step = small ? 4 : 8;
+	for (let i = 0; i < count; i++) {
+		const o = at + i * step;
+		if (o + step > v.byteLength) break;
+		out.push(small ? {
+			x: v.getInt16(o, true),
+			y: v.getInt16(o + 2, true)
+		} : {
+			x: v.getInt32(o, true),
+			y: v.getInt32(o + 4, true)
+		});
+	}
+	return out;
+}
+function polySegments(map, pts, o) {
+	const segs = [];
+	if (pts.length === 0) return segs;
+	let i = 0;
+	if (o.from) {
+		const s = map(o.from.x, o.from.y);
+		segs.push({
+			op: "move",
+			x: s.x,
+			y: s.y
+		});
+	} else {
+		const s = map(pts[0].x, pts[0].y);
+		segs.push({
+			op: "move",
+			x: s.x,
+			y: s.y
+		});
+		i = 1;
+	}
+	if (o.bezier) for (; i + 2 < pts.length + 1 && i + 2 <= pts.length; i += 3) {
+		const c1 = map(pts[i].x, pts[i].y);
+		const c2 = map(pts[i + 1].x, pts[i + 1].y);
+		const to = map(pts[i + 2].x, pts[i + 2].y);
+		segs.push({
+			op: "cubic",
+			x1: c1.x,
+			y1: c1.y,
+			x2: c2.x,
+			y2: c2.y,
+			x: to.x,
+			y: to.y
+		});
+	}
+	else for (; i < pts.length; i++) {
+		const p = map(pts[i].x, pts[i].y);
+		segs.push({
+			op: "line",
+			x: p.x,
+			y: p.y
+		});
+	}
+	if (o.closed) segs.push({ op: "close" });
+	return segs;
+}
+var KAPPA = .5522847498307936;
+function ellipseSegments(map, l, t, r, b) {
+	const cx = (l + r) / 2;
+	const cy = (t + b) / 2;
+	const rx = (r - l) / 2;
+	const ry = (b - t) / 2;
+	const k = KAPPA;
+	const p = (x, y) => map(x, y);
+	const s = p(cx + rx, cy);
+	const segs = [{
+		op: "move",
+		x: s.x,
+		y: s.y
+	}];
+	const arc = (c1x, c1y, c2x, c2y, ex, ey) => {
+		const a = p(c1x, c1y);
+		const bb = p(c2x, c2y);
+		const e = p(ex, ey);
+		segs.push({
+			op: "cubic",
+			x1: a.x,
+			y1: a.y,
+			x2: bb.x,
+			y2: bb.y,
+			x: e.x,
+			y: e.y
+		});
+	};
+	arc(cx + rx, cy + ry * k, cx + rx * k, cy + ry, cx, cy + ry);
+	arc(cx - rx * k, cy + ry, cx - rx, cy + ry * k, cx - rx, cy);
+	arc(cx - rx, cy - ry * k, cx - rx * k, cy - ry, cx, cy - ry);
+	arc(cx + rx * k, cy - ry, cx + rx, cy - ry * k, cx + rx, cy);
+	segs.push({ op: "close" });
+	return segs;
+}
+//#endregion
+export { ellipseSegments, isEmf, readEmf };