reamkit 1.22.0 → 1.23.0

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

@@ -1,5 +1,7 @@
 import { PathBuilder } from "../vector.js";
 import { applyTransform, cloneDc, colorRef, newDeviceContext } from "./picture.js";
+import { cropDib, fadedDib, readDib } from "./dib.js";
+import { makeBlitter } from "./blit.js";
 import { fromSymbolFont } from "./symbol-fonts.js";
 //#region src/core/metafile/emf.ts
 /** Whether the bytes open with an EMF header (MS-EMF §2.3.4.2: type 1 + " EMF"). */
@@ -21,11 +23,6 @@ var RECORD_NAMES = new Map([
 	[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"]
 ]);
@@ -74,6 +71,34 @@ function readEmf(bytes) {
 	};
 	let building;
 	const open = () => building ?? [];
+	const blitter = makeBlitter((prim) => prims.push(prim));
+	/**
+	* §2.3.1 — one blit record: the source bitmap into the destination
+	* rectangle, both stated in the record's own fields. The rectangle is mapped
+	* the way every other coordinate here is, so the picture lands in the same
+	* device frame as the paths around it.
+	*/
+	const blit = (o) => {
+		const dib = o.cbBmi > 0 ? readDib(bytes, off + o.bmiAt, {
+			bitsAt: off + o.bitsAt,
+			cbBits: o.cbBits,
+			...o.blend?.perPixel === true ? { alpha: true } : {}
+		}) : void 0;
+		if (!dib) {
+			skipped.add("bitmap");
+			return;
+		}
+		const s = o.src;
+		const part = s && (s.x !== 0 || s.y !== 0 || s.w !== dib.width || s.h !== dib.height) ? cropDib(dib, s.x, o.inBitmap === true && dib.bottomUp === true ? dib.height - s.y - s.h : s.y, s.w, s.h) : dib;
+		const a = px(o.dest.x, o.dest.y);
+		const b = px(o.dest.x + o.dest.w, o.dest.y + o.dest.h);
+		blitter.blit(o.blend && o.blend.alpha < 255 ? fadedDib(part, o.blend.alpha / 255) : part, {
+			x: Math.min(a.x, b.x),
+			y: Math.min(a.y, b.y),
+			width: Math.abs(b.x - a.x),
+			height: Math.abs(b.y - a.y)
+		}, o.rop);
+	};
 	const strokeOf = () => {
 		if (dc.pen.style === "none") return void 0;
 		const w = dc.pen.widthLu <= 1 ? 1 : dc.pen.widthLu * Math.abs(sx());
@@ -388,25 +413,114 @@ function readEmf(bytes) {
 				}
 				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");
+			case 77: {
+				const cbBmiSrc = u(88);
+				const rop = u(40);
+				const x = at(24);
+				const y = at(28);
+				const w = at(32);
+				const h = at(36);
+				if (cbBmiSrc === 0) {
+					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;
 				}
+				blit({
+					bmiAt: u(84),
+					cbBmi: cbBmiSrc,
+					bitsAt: u(92),
+					cbBits: u(96),
+					dest: {
+						x,
+						y,
+						w,
+						h
+					},
+					src: {
+						x: at(44),
+						y: at(48),
+						w: type === 77 ? at(100) : w,
+						h: type === 77 ? at(104) : h
+					},
+					rop
+				});
+				break;
+			}
+			case 80:
+				blit({
+					bmiAt: u(48),
+					cbBmi: u(52),
+					bitsAt: u(56),
+					cbBits: u(60),
+					dest: {
+						x: at(24),
+						y: at(28),
+						w: at(40),
+						h: at(44)
+					},
+					src: {
+						x: at(32),
+						y: at(36),
+						w: at(40),
+						h: at(44)
+					},
+					inBitmap: true,
+					rop: 13369376
+				});
+				break;
+			case 81:
+				blit({
+					bmiAt: u(48),
+					cbBmi: u(52),
+					bitsAt: u(56),
+					cbBits: u(60),
+					dest: {
+						x: at(24),
+						y: at(28),
+						w: at(72),
+						h: at(76)
+					},
+					src: {
+						x: at(32),
+						y: at(36),
+						w: at(40),
+						h: at(44)
+					},
+					inBitmap: true,
+					rop: u(68)
+				});
+				break;
+			case 114:
+				blit({
+					bmiAt: u(84),
+					cbBmi: u(88),
+					bitsAt: u(92),
+					cbBits: u(96),
+					dest: {
+						x: at(24),
+						y: at(28),
+						w: at(32),
+						h: at(36)
+					},
+					src: {
+						x: at(44),
+						y: at(48),
+						w: at(100),
+						h: at(104)
+					},
+					blend: {
+						alpha: u(40) >>> 16 & 255,
+						perPixel: u(40) >>> 24 === 1
+					},
+					rop: 13369376
+				});
 				break;
 			default:
 				{

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

@@ -74,7 +74,18 @@ export interface MetaFont {
     readonly italic?: boolean;
     readonly escapement?: number;
 }
-export type MetaObject = MetaPen | MetaBrush | MetaFont;
+/**
+ * An object the reader does not model — a palette, a region, a pattern brush.
+ * It still OCCUPIES a slot in the metafile's object table: handles are indices
+ * into that table, so a creation the reader passed over silently shifted every
+ * one that followed. 23884's chart selects its coloured pens by handle, and one
+ * unrecorded palette put every selection one slot back — on the black pen the
+ * pens had displaced.
+ */
+export interface MetaOther {
+    readonly kind: 'other';
+}
+export type MetaObject = MetaPen | MetaBrush | MetaFont | MetaOther;
 /** The device context: everything a record draws THROUGH. */
 export interface DeviceContext {
     pen: MetaPen;

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

@@ -1,5 +1,7 @@
 import { PathBuilder } from "../vector.js";
 import { cloneDc, colorRef, newDeviceContext } from "./picture.js";
+import { cropDib, readDib } from "./dib.js";
+import { makeBlitter } from "./blit.js";
 import { fromSymbolFont, symbolGeometryOf, symbolOutline } from "./symbol-fonts.js";
 import { ellipseSegments } from "./emf.js";
 //#region src/core/metafile/wmf.ts
@@ -14,9 +16,6 @@ function isWmf(bytes) {
 	return (type === 1 || type === 2) && headerWords === 9;
 }
 var RECORD_NAMES = new Map([
-	[2368, "bitmap"],
-	[2881, "bitmap"],
-	[3907, "bitmap"],
 	[2338, "pie"],
 	[2096, "chord"],
 	[2071, "arc"],
@@ -61,6 +60,16 @@ function readWmf(bytes) {
 		cx: 0,
 		cy: 0
 	};
+	let origin;
+	const emit = (prim) => {
+		origin ??= {
+			x: win.x,
+			y: win.y
+		};
+		const dx = origin.x - win.x;
+		const dy = origin.y - win.y;
+		prims.push(dx === 0 && dy === 0 ? prim : shiftPrim(prim, dx, dy));
+	};
 	const strokeOf = () => {
 		if (dc.pen.style === "none") return void 0;
 		const w = Math.max(1, dc.pen.widthLu);
@@ -79,7 +88,7 @@ function readWmf(bytes) {
 		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({
+		emit({
 			kind: "path",
 			paths: [path],
 			...fillHex !== void 0 ? { fillColorHex: fillHex } : {},
@@ -87,6 +96,27 @@ function readWmf(bytes) {
 		});
 	};
 	const rectSegments = (l, t, r, b) => new PathBuilder().moveTo(l, t).lineTo(r, t).lineTo(r, b).lineTo(l, b).close().build().segments;
+	const blitter = makeBlitter(emit);
+	/**
+	* §2.3.1 — one blit record: the packed bitmap the record ends with, into the
+	* destination rectangle its fields name. A WMF's coordinates are its own
+	* logical units, which is the frame the primitives are already in.
+	*/
+	const blit = (o) => {
+		const dib = readDib(bytes, off + o.dibAt);
+		if (!dib) {
+			skipped.add("bitmap");
+			return;
+		}
+		const s = o.src;
+		const part = s.x !== 0 || s.y !== 0 || s.w !== dib.width || s.h !== dib.height ? cropDib(dib, s.x, dib.bottomUp === true ? dib.height - s.y - s.h : s.y, s.w, s.h) : dib;
+		blitter.blit(part, {
+			x: Math.min(o.dest.x, o.dest.x + o.dest.w),
+			y: Math.min(o.dest.y, o.dest.y + o.dest.h),
+			width: Math.abs(o.dest.w),
+			height: Math.abs(o.dest.h)
+		}, o.rop);
+	};
 	let off = placeable ? 22 : 0;
 	off += 18;
 	let guard = 0;
@@ -135,6 +165,12 @@ function readWmf(bytes) {
 			case 496:
 				objects[pu(0)] = void 0;
 				break;
+			case 247:
+			case 322:
+			case 505:
+			case 1791:
+				put({ kind: "other" });
+				break;
 			case 762:
 				put({
 					kind: "pen",
@@ -223,6 +259,79 @@ function readWmf(bytes) {
 					dc.brush = brush;
 				}
 				break;
+			case 2368:
+			case 2881:
+			case 3907:
+				{
+					const rop = p32(0);
+					const f = fn === 2368 ? {
+						dib: 22,
+						srcH: 4,
+						srcW: 5,
+						ySrc: 2,
+						xSrc: 3,
+						h: 4,
+						w: 5,
+						y: 6,
+						x: 7
+					} : fn === 2881 ? {
+						dib: 26,
+						srcH: 2,
+						srcW: 3,
+						ySrc: 4,
+						xSrc: 5,
+						h: 6,
+						w: 7,
+						y: 8,
+						x: 9
+					} : {
+						dib: 28,
+						srcH: 3,
+						srcW: 4,
+						ySrc: 5,
+						xSrc: 6,
+						h: 7,
+						w: 8,
+						y: 9,
+						x: 10
+					};
+					if (f.dib + 12 > size * 2) {
+						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
+						};
+						const shift = fn === 2368 ? 1 : 0;
+						const [h, w, y, x] = [
+							p(f.h + shift),
+							p(f.w + shift),
+							p(f.y + shift),
+							p(f.x + shift)
+						];
+						paint(rectSegments(x, y, x + w, y + h), true, false);
+						dc.brush = brush;
+						break;
+					}
+					blit({
+						dibAt: f.dib,
+						dest: {
+							x: p(f.x),
+							y: p(f.y),
+							w: p(f.w),
+							h: p(f.h)
+						},
+						src: {
+							x: p(f.xSrc),
+							y: p(f.ySrc),
+							w: p(f.srcW),
+							h: p(f.srcH)
+						},
+						rop
+					});
+				}
+				break;
 			case 804:
 			case 805:
 				{
@@ -251,7 +360,7 @@ function readWmf(bytes) {
 					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));
+					pushText(emit, dc, text, p(1 + words + 1), p(1 + words));
 				}
 				break;
 			case 2610:
@@ -261,7 +370,7 @@ function readWmf(bytes) {
 					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);
+					pushText(emit, dc, text, x, y);
 				}
 				break;
 			default:
@@ -288,15 +397,15 @@ function readWmf(bytes) {
 		skipped: [...skipped]
 	};
 }
-function pushText(prims, dc, text, x, y) {
+function pushText(emit, dc, text, x, y) {
 	if (text.trim() === "") return;
 	const em = Math.abs(dc.font?.heightLu ?? 12);
 	const drawn = symbolPrims(text, dc, x, y, em);
 	if (drawn) {
-		prims.push(...drawn);
+		for (const prim of drawn) emit(prim);
 		return;
 	}
-	prims.push({
+	emit({
 		kind: "text",
 		text: fromSymbolFont(text, dc.font?.family),
 		x,
@@ -311,6 +420,37 @@ function pushText(prims, dc, text, x, y) {
 		...dc.font?.escapement ? { escapement: dc.font.escapement } : {}
 	});
 }
+function shiftPrim(prim, dx, dy) {
+	if (prim.kind === "text") return {
+		...prim,
+		x: prim.x + dx,
+		y: prim.y + dy
+	};
+	if (prim.kind === "image") return {
+		...prim,
+		x: prim.x + dx,
+		y: prim.y + dy
+	};
+	return {
+		...prim,
+		paths: prim.paths.map((path) => ({
+			...path,
+			segments: path.segments.map((sg) => "x" in sg ? {
+				...sg,
+				x: sg.x + dx,
+				y: sg.y + dy,
+				..."x1" in sg ? {
+					x1: sg.x1 + dx,
+					y1: sg.y1 + dy
+				} : {},
+				..."x2" in sg ? {
+					x2: sg.x2 + dx,
+					y2: sg.y2 + dy
+				} : {}
+			} : sg)
+		}))
+	};
+}
 function penStyle(style) {
 	switch (style & 15) {
 		case 1: return "dash";

package/dist/esm/core/ole/escher-blip.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The picture bytes inside one Escher BLIP record — a raster as it stands, or a
+ * metafile unpacked out of its header.
+ *
+ * @param type     The blip record type (`0xF01A`…`0xF02A`).
+ * @param instance The record's `recInstance`, which says how many UIDs precede
+ *                 the payload.
+ * @param data     The record's body, without the 8-byte header.
+ * @returns The bytes to hand the renderer, or `undefined` when the blip holds
+ *          nothing this can read.
+ */
+export declare function readEscherBlip(type: number, instance: number, data: Uint8Array): Uint8Array | undefined;

package/dist/esm/core/ole/escher-blip.js

@@ -0,0 +1,88 @@
+import { unzlibSync } from "fflate";
+//#region src/core/ole/escher-blip.ts
+var BLIP_EMF = 61466;
+var BLIP_WMF = 61467;
+var BLIP_PICT = 61468;
+var BLIP_JPEG = 61469;
+var BLIP_PNG = 61470;
+var BLIP_DIB = 61471;
+var BLIP_TIFF = 61481;
+var BLIP_JPEG_CMYK = 61482;
+var METAFILE_HEADER_BYTES = 34;
+var COMPRESSION_DEFLATE = 0;
+var TWO_UID_INSTANCES = new Set([
+	981,
+	535,
+	1347,
+	1761,
+	1763,
+	1961,
+	1765,
+	481
+]);
+/** The signatures of the rasters a blip may hold, for the scan fallback. */
+var RASTER_MAGICS = [
+	[
+		137,
+		80,
+		78,
+		71
+	],
+	[
+		255,
+		216,
+		255
+	],
+	[
+		71,
+		73,
+		70,
+		56
+	],
+	[66, 77]
+];
+/**
+* The picture bytes inside one Escher BLIP record — a raster as it stands, or a
+* metafile unpacked out of its header.
+*
+* @param type     The blip record type (`0xF01A`…`0xF02A`).
+* @param instance The record's `recInstance`, which says how many UIDs precede
+*                 the payload.
+* @param data     The record's body, without the 8-byte header.
+* @returns The bytes to hand the renderer, or `undefined` when the blip holds
+*          nothing this can read.
+*/
+function readEscherBlip(type, instance, data) {
+	if (type === BLIP_EMF || type === BLIP_WMF || type === BLIP_PICT) return readMetafileBlip(instance, data);
+	if (type === BLIP_JPEG || type === BLIP_PNG || type === BLIP_DIB || type === BLIP_TIFF || type === BLIP_JPEG_CMYK) return scanRaster(data);
+	return scanRaster(data);
+}
+function readMetafileBlip(instance, data) {
+	const uidBytes = TWO_UID_INSTANCES.has(instance) ? 32 : 16;
+	const head = uidBytes + METAFILE_HEADER_BYTES;
+	if (data.length < head) return void 0;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const uncompressed = view.getUint32(uidBytes, true);
+	const compressed = view.getUint32(uidBytes + 24, true);
+	const compression = data[uidBytes + 32];
+	const payload = data.subarray(head, Math.min(data.length, head + (compressed || Infinity)));
+	if (payload.length === 0) return void 0;
+	if (compression !== COMPRESSION_DEFLATE) return payload;
+	try {
+		const out = unzlibSync(payload, uncompressed > 0 ? { out: new Uint8Array(uncompressed) } : {});
+		return out.length > 0 ? out : void 0;
+	} catch {
+		return;
+	}
+}
+function scanRaster(data) {
+	const limit = Math.min(data.length, 80);
+	for (let off = 0; off < limit; off++) for (const magic of RASTER_MAGICS) if (matches(data, off, magic)) return data.subarray(off);
+}
+function matches(d, off, magic) {
+	if (off + magic.length > d.length) return false;
+	for (let i = 0; i < magic.length; i++) if (d[off + i] !== magic[i]) return false;
+	return true;
+}
+//#endregion
+export { readEscherBlip };

package/dist/esm/{pdf-reader → core}/png-encode.js

@@ -1,5 +1,5 @@
 import { zlibSync } from "fflate";
-//#region src/pdf-reader/png-encode.ts
+//#region src/core/png-encode.ts
 var COLOR_TYPE = {
 	gray: 0,
 	rgb: 2,

package/dist/esm/excel/print-model.js

@@ -101,7 +101,8 @@ var DIGIT_EM = [
 	[/^(arial|helvetica|liberation sans|arimo|arial unicode ms)$/i, 1139 / 2048],
 	[/^(times new roman|liberation serif|tinos)$/i, 1024 / 2048],
 	[/^(tahoma)$/i, 1118 / 2048],
-	[/^(verdana|dejavu sans)$/i, 1303 / 2048]
+	[/^(verdana|dejavu sans)$/i, 1303 / 2048],
+	[/* @__PURE__ */ new RegExp("^(新細明體|細明體|pmingliu|mingliu|標楷體|dfkai-sb|宋体|新宋体|simsun|nsimsun|黑体|simhei|微软雅黑|microsoft yahei|微軟正黑體|microsoft jhenghei|ＭＳ [Ｐ]?明朝|ＭＳ [Ｐ]?ゴシック|ms [p]?mincho|ms [p]?gothic|meiryo|メイリオ|游ゴシック|yu gothic|굴림체?|gulim(che)?|돋움체?|dotum(che)?|바탕체?|batang(che)?|맑은 고딕|malgun gothic)$", "iu"), 1024 / 2048]
 ];
 /**
 * §18.3.1.13 — the Maximum Digit Width, in twips, of the normal style's font.
@@ -1021,6 +1022,7 @@ function runPropsFromXf(xf, styles) {
 	if (font.strike) props.strike = true;
 	if (font.sizePt !== void 0) props.fontSizePt = halfPtToPt(Math.round(font.sizePt * 2));
 	if (font.colorHex) props.colorHex = font.colorHex;
+	if (font.name) props.fontFamily = { ascii: font.name };
 	return props;
 }
 function stackedVerticalContent(text, runProps, href) {

package/dist/esm/excel/styles-parser.js

@@ -1,7 +1,7 @@
 import { INDEXED_COLORS } from "../core/indexed-colors.js";
 import { applyColorMods } from "../core/drawingml/colors.js";
-import { resolveInternalEntities } from "../core/opc/xml-entities.js";
 import { resolveAlternateContent } from "../core/opc/alternate-content.js";
+import { resolveInternalEntities } from "../core/opc/xml-entities.js";
 import { XMLParser } from "fast-xml-parser";
 //#region src/excel/styles-parser.ts
 var decoder = new TextDecoder("utf-8");