reamkit 1.22.0 → 1.23.0

package/dist/esm/core/fonts/scripts.js

@@ -0,0 +1,177 @@
+//#region src/core/fonts/scripts.ts
+var RANGES = [
+	[
+		1424,
+		1535,
+		"hebrew"
+	],
+	[
+		1536,
+		1791,
+		"arabic"
+	],
+	[
+		1872,
+		1919,
+		"arabic"
+	],
+	[
+		2208,
+		2303,
+		"arabic"
+	],
+	[
+		3584,
+		3711,
+		"thai"
+	],
+	[
+		4352,
+		4607,
+		"kr"
+	],
+	[
+		8592,
+		8703,
+		"symbols"
+	],
+	[
+		8960,
+		9215,
+		"symbols"
+	],
+	[
+		9312,
+		9471,
+		"symbols"
+	],
+	[
+		9472,
+		10175,
+		"symbols"
+	],
+	[
+		11008,
+		11263,
+		"symbols"
+	],
+	[
+		12288,
+		12351,
+		"han"
+	],
+	[
+		12352,
+		12543,
+		"jp"
+	],
+	[
+		12592,
+		12687,
+		"kr"
+	],
+	[
+		13312,
+		19903,
+		"han"
+	],
+	[
+		19968,
+		40959,
+		"han"
+	],
+	[
+		44032,
+		55215,
+		"kr"
+	],
+	[
+		63744,
+		64255,
+		"han"
+	],
+	[
+		64285,
+		64335,
+		"hebrew"
+	],
+	[
+		64336,
+		65023,
+		"arabic"
+	],
+	[
+		65136,
+		65279,
+		"arabic"
+	],
+	[
+		65280,
+		65519,
+		"han"
+	]
+];
+/**
+* The writing system a character needs a face for, or `undefined` when a Latin
+* family covers it.
+*
+* @param cp       The code point.
+* @param hanFace  Which face draws unified Han in this document (see
+*                 {@link scriptsInFlow}); defaults to Simplified.
+*/
+function scriptForCodepoint(cp, hanFace = "sc") {
+	for (const [lo, hi, key] of RANGES) {
+		if (cp < lo) break;
+		if (cp <= hi) return key === "han" ? hanFace : key;
+	}
+}
+/**
+* The writing systems a document holds text in, beside the Latin one.
+*
+* Unified Han is written the same in Japanese, Korean and Chinese and drawn
+* differently in each, and the character does not say which — the document
+* does: Kana beside it means Japanese, Hangul means Korean. So the whole text
+* is read once, and the answer applies to every Han character in it.
+*
+* @param flow The parsed document.
+* @returns The scripts to fetch a face for, and the one Han is drawn with.
+*/
+function scriptsInFlow(flow) {
+	const scripts = /* @__PURE__ */ new Set();
+	const marks = /* @__PURE__ */ new Set();
+	const read = (text) => {
+		for (const ch of text) {
+			const cp = ch.codePointAt(0) ?? 0;
+			if (cp < 1424) continue;
+			const key = scriptForCodepoint(cp, "sc");
+			if (key === void 0) continue;
+			if (key === "sc") {
+				marks.add("han");
+				continue;
+			}
+			scripts.add(key);
+		}
+	};
+	const shapeText = (shape) => {
+		if (shape.text) visit(shape.text.content);
+		for (const child of shape.children ?? []) shapeText(child.shape);
+	};
+	const visit = (elements) => {
+		for (const el of elements) if (el.kind === "paragraph") for (const run of el.paragraph.runs) read(run.text);
+		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
+		else if (el.kind === "shape") shapeText(el.shape);
+	};
+	visit(flow.body);
+	for (const band of flow.headersFooters?.values() ?? []) visit(band);
+	for (const note of flow.footnotes?.values() ?? []) visit(note);
+	for (const note of flow.endnotes?.values() ?? []) visit(note);
+	for (const comment of flow.comments?.values() ?? []) visit(comment.content);
+	const hanFace = scripts.has("jp") ? "jp" : scripts.has("kr") ? "kr" : "sc";
+	if (marks.has("han")) scripts.add(hanFace);
+	return {
+		scripts,
+		hanFace
+	};
+}
+//#endregion
+export { scriptForCodepoint, scriptsInFlow };

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

@@ -0,0 +1,33 @@
+import { DibImage } from './dib.js';
+import { PictureImage } from './picture.js';
+/** How a blit's ROP wants the source drawn. */
+export type BlitMode = 
+/** SRCCOPY and its neighbours: the source replaces what is under it. */
+'opaque'
+/** SRCAND: a mask, held until the picture it belongs to arrives. */
+ | 'mask'
+/** SRCPAINT: ORed in, so the source's BLACK leaves the ground showing. */
+ | 'or'
+/** A ROP that ignores the source, or one whose result is not a picture. */
+ | 'skip';
+/** The destination rectangle a blit paints, in the metafile's own units. */
+export interface BlitRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * What a ternary raster operation asks a reader to draw.
+ *
+ * @param rop The ROP code, as the record states it.
+ */
+export declare function blitMode(rop: number): BlitMode;
+/**
+ * A sink for a metafile's blits that puts the AND/OR pair back together.
+ *
+ * @param emit Where a finished picture goes — the reader's primitive list.
+ */
+export declare function makeBlitter(emit: (prim: PictureImage) => void): {
+    blit: (img: DibImage, dest: BlitRect, rop: number) => void;
+};

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

@@ -0,0 +1,67 @@
+import { dibToPng, maskedDib } from "./dib.js";
+//#region src/core/metafile/blit.ts
+/**
+* What a ternary raster operation asks a reader to draw.
+*
+* @param rop The ROP code, as the record states it.
+*/
+function blitMode(rop) {
+	switch (rop >>> 0) {
+		case 13369376:
+		case 14812998: return "opaque";
+		case 8913094: return "mask";
+		case 15597702: return "or";
+		case 6684742:
+		case 15728673:
+		case 66:
+		case 16711778: return "skip";
+		default: return (rop >>> 2 & 3342336) !== (rop & 3342336) ? "opaque" : "skip";
+	}
+}
+/**
+* A sink for a metafile's blits that puts the AND/OR pair back together.
+*
+* @param emit Where a finished picture goes — the reader's primitive list.
+*/
+function makeBlitter(emit) {
+	let pending;
+	const place = (img, dest) => {
+		emit({
+			kind: "image",
+			...dest,
+			png: dibToPng(img)
+		});
+	};
+	return { blit: (img, dest, rop) => {
+		const mode = blitMode(rop);
+		if (mode === "skip") return;
+		if (mode === "mask") {
+			pending = {
+				img,
+				dest
+			};
+			return;
+		}
+		const mask = pending;
+		pending = void 0;
+		if (mode === "or") {
+			place(mask && sameRect(mask.dest, dest) ? maskedDib(img, mask.img) : keyBlack(img), dest);
+			return;
+		}
+		place(img, dest);
+	} };
+}
+function sameRect(a, b) {
+	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function keyBlack(img) {
+	const rgba = new Uint8Array(img.rgba);
+	for (let i = 0; i < rgba.length; i += 4) if (rgba[i] === 0 && rgba[i + 1] === 0 && rgba[i + 2] === 0) rgba[i + 3] = 0;
+	return {
+		width: img.width,
+		height: img.height,
+		rgba
+	};
+}
+//#endregion
+export { makeBlitter };

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

@@ -0,0 +1,61 @@
+/** A decoded bitmap: straight (un-premultiplied) RGBA, TOP row first. */
+export interface DibImage {
+    readonly width: number;
+    readonly height: number;
+    readonly rgba: Uint8Array;
+    /**
+     * Whether the source stored its rows bottom-first — which is the usual way,
+     * and which a caller needs to know to read a source rectangle: a blit states
+     * one in the BITMAP's own coordinates, whose origin is its first row.
+     */
+    readonly bottomUp?: boolean;
+}
+/** What a caller knows about the bitmap that its own header does not say. */
+export interface DibOptions {
+    /**
+     * Where the pixels start. EMF states this; a WMF stores the two parts back to
+     * back, so leaving it out means "after the palette".
+     */
+    readonly bitsAt?: number;
+    /** How many pixel bytes there are, when the record states it. */
+    readonly cbBits?: number;
+    /**
+     * Whether a 32-bit bitmap's fourth byte is ALPHA. It is reserved in an
+     * ordinary blit — GDI ignores it and so must this, or a picture whose
+     * producer left it zero comes out invisible — and it is the alpha channel
+     * in an EMR_ALPHABLEND that says so.
+     */
+    readonly alpha?: boolean;
+}
+/**
+ * Decode a packed DIB into RGBA.
+ *
+ * @param bytes The metafile.
+ * @param bmiAt Where the bitmap's header starts.
+ * @param o     What the record says about the bitmap; see {@link DibOptions}.
+ * @returns The bitmap, or `undefined` when the header is malformed or its
+ *          compression is one this decoder does not do.
+ */
+export declare function readDib(bytes: Uint8Array, bmiAt: number, o?: DibOptions): DibImage | undefined;
+/**
+ * The colour bitmap seen through a monochrome one — the two-blit idiom every
+ * clipart of this age is drawn with: an AND of the mask, which knocks the
+ * picture's ground to white, and then an OR of the picture, which is black
+ * exactly where the ground was. Kept apart they draw a black box; put together
+ * they are one bitmap with an alpha channel.
+ *
+ * @param color The bitmap the second blit paints.
+ * @param mask  The first blit's mask: WHITE where the picture is to show
+ *              through, black where it is opaque.
+ */
+export declare function maskedDib(color: DibImage, mask: DibImage): DibImage;
+/**
+ * The bitmap as a PNG file, ready for the resource store. An opaque one is
+ * written without an alpha channel — a quarter less to deflate, and the
+ * writers that flatten transparency then have nothing to do.
+ */
+export declare function dibToPng(img: DibImage): Uint8Array;
+/** The bitmap at a constant transparency — what a blend function's `SrcConstantAlpha` asks for. */
+export declare function fadedDib(img: DibImage, alpha: number): DibImage;
+/** The part of the bitmap a blit's source rectangle names, or all of it. */
+export declare function cropDib(img: DibImage, x: number, y: number, w: number, h: number): DibImage;

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

@@ -0,0 +1,205 @@
+import { encodePng } from "../png-encode.js";
+//#region src/core/metafile/dib.ts
+var MAX_PIXELS = 3e7;
+/**
+* Decode a packed DIB into RGBA.
+*
+* @param bytes The metafile.
+* @param bmiAt Where the bitmap's header starts.
+* @param o     What the record says about the bitmap; see {@link DibOptions}.
+* @returns The bitmap, or `undefined` when the header is malformed or its
+*          compression is one this decoder does not do.
+*/
+function readDib(bytes, bmiAt, o = {}) {
+	const { bitsAt, cbBits } = o;
+	if (bmiAt < 0 || bmiAt + 12 > bytes.length) return void 0;
+	const v = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const headerSize = v.getUint32(bmiAt, true);
+	const core = headerSize === 12;
+	if (!core && (headerSize < 40 || bmiAt + 40 > bytes.length)) return void 0;
+	const width = core ? v.getInt16(bmiAt + 4, true) : v.getInt32(bmiAt + 4, true);
+	const rawHeight = core ? v.getInt16(bmiAt + 6, true) : v.getInt32(bmiAt + 8, true);
+	const bpp = core ? v.getUint16(bmiAt + 10, true) : v.getUint16(bmiAt + 14, true);
+	const compression = core ? 0 : v.getUint32(bmiAt + 16, true);
+	const topDown = rawHeight < 0;
+	const height = Math.abs(rawHeight);
+	if (width <= 0 || height <= 0 || width * height > MAX_PIXELS) return void 0;
+	if (compression !== 0 && compression !== 3) return void 0;
+	if (bpp !== 1 && bpp !== 4 && bpp !== 8 && bpp !== 16 && bpp !== 24 && bpp !== 32) return;
+	const paletteAt = bmiAt + headerSize;
+	const entry = core ? 3 : 4;
+	const declared = core || headerSize < 40 ? 0 : v.getUint32(bmiAt + 32, true);
+	const paletteCount = bpp <= 8 ? declared > 0 ? Math.min(declared, 1 << bpp) : 1 << bpp : 0;
+	const masksAt = compression === 3 ? paletteAt : void 0;
+	const paletteBytes = compression === 3 ? 12 : paletteCount * entry;
+	const start = bitsAt ?? paletteAt + paletteBytes;
+	const stride = (width * bpp + 7 >> 3) + 3 & -4;
+	const need = stride * height;
+	if (start < 0 || start + Math.min(need, cbBits ?? need) > bytes.length) return void 0;
+	const palette = readPalette(v, paletteAt, paletteCount, entry);
+	const channels = masksAt !== void 0 ? [
+		maskChannel(v.getUint32(masksAt, true)),
+		maskChannel(v.getUint32(masksAt + 4, true)),
+		maskChannel(v.getUint32(masksAt + 8, true))
+	] : void 0;
+	const rgba = new Uint8Array(width * height * 4);
+	for (let y = 0; y < height; y++) {
+		const row = start + (topDown ? y : height - 1 - y) * stride;
+		let dst = y * width * 4;
+		for (let x = 0; x < width; x++) {
+			let r = 0;
+			let g = 0;
+			let b = 0;
+			let a = 255;
+			if (bpp <= 8) {
+				const bitsPer = bpp;
+				const bit = x * bitsPer;
+				const rgb = palette[(bytes[row + (bit >> 3)] ?? 0) >> 8 - bitsPer - (bit & 7) & (1 << bitsPer) - 1] ?? 0;
+				r = rgb >>> 16 & 255;
+				g = rgb >>> 8 & 255;
+				b = rgb & 255;
+			} else if (bpp === 16) {
+				const word = (bytes[row + x * 2] ?? 0) | (bytes[row + x * 2 + 1] ?? 0) << 8;
+				if (channels) [r, g, b] = [
+					channels[0](word),
+					channels[1](word),
+					channels[2](word)
+				];
+				else {
+					r = expand5(word >> 10 & 31);
+					g = expand5(word >> 5 & 31);
+					b = expand5(word & 31);
+				}
+			} else {
+				const at = row + x * (bpp >> 3);
+				b = bytes[at] ?? 0;
+				g = bytes[at + 1] ?? 0;
+				r = bytes[at + 2] ?? 0;
+				if (bpp === 32) {
+					const word = (b | g << 8 | r << 16 | (bytes[at + 3] ?? 0) << 24) >>> 0 >>> 0;
+					if (channels) [r, g, b] = [
+						channels[0](word),
+						channels[1](word),
+						channels[2](word)
+					];
+					if (o.alpha === true) {
+						a = bytes[at + 3] ?? 0;
+						if (a > 0 && a < 255) {
+							r = Math.min(255, Math.round(r * 255 / a));
+							g = Math.min(255, Math.round(g * 255 / a));
+							b = Math.min(255, Math.round(b * 255 / a));
+						}
+					}
+				}
+			}
+			rgba[dst] = r;
+			rgba[dst + 1] = g;
+			rgba[dst + 2] = b;
+			rgba[dst + 3] = a;
+			dst += 4;
+		}
+	}
+	return {
+		width,
+		height,
+		rgba,
+		...topDown ? {} : { bottomUp: true }
+	};
+}
+/**
+* The colour bitmap seen through a monochrome one — the two-blit idiom every
+* clipart of this age is drawn with: an AND of the mask, which knocks the
+* picture's ground to white, and then an OR of the picture, which is black
+* exactly where the ground was. Kept apart they draw a black box; put together
+* they are one bitmap with an alpha channel.
+*
+* @param color The bitmap the second blit paints.
+* @param mask  The first blit's mask: WHITE where the picture is to show
+*              through, black where it is opaque.
+*/
+function maskedDib(color, mask) {
+	const rgba = new Uint8Array(color.rgba);
+	for (let y = 0; y < color.height; y++) {
+		const my = Math.min(mask.height - 1, Math.floor(y * mask.height / color.height));
+		for (let x = 0; x < color.width; x++) {
+			const mx = Math.min(mask.width - 1, Math.floor(x * mask.width / color.width));
+			const m = my * mask.width * 4 + mx * 4;
+			if ((mask.rgba[m] + mask.rgba[m + 1] + mask.rgba[m + 2]) / 3 >= 128) rgba[(y * color.width + x) * 4 + 3] = 0;
+		}
+	}
+	return {
+		width: color.width,
+		height: color.height,
+		rgba
+	};
+}
+/**
+* The bitmap as a PNG file, ready for the resource store. An opaque one is
+* written without an alpha channel — a quarter less to deflate, and the
+* writers that flatten transparency then have nothing to do.
+*/
+function dibToPng(img) {
+	let opaque = true;
+	for (let i = 3; i < img.rgba.length; i += 4) if (img.rgba[i] !== 255) {
+		opaque = false;
+		break;
+	}
+	if (!opaque) return encodePng(img.width, img.height, "rgba", img.rgba);
+	const rgb = new Uint8Array(img.width * img.height * 3);
+	for (let i = 0, j = 0; i < img.rgba.length; i += 4, j += 3) {
+		rgb[j] = img.rgba[i];
+		rgb[j + 1] = img.rgba[i + 1];
+		rgb[j + 2] = img.rgba[i + 2];
+	}
+	return encodePng(img.width, img.height, "rgb", rgb);
+}
+/** The bitmap at a constant transparency — what a blend function's `SrcConstantAlpha` asks for. */
+function fadedDib(img, alpha) {
+	const rgba = new Uint8Array(img.rgba);
+	for (let i = 3; i < rgba.length; i += 4) rgba[i] = Math.round(rgba[i] * alpha);
+	return {
+		width: img.width,
+		height: img.height,
+		rgba
+	};
+}
+/** The part of the bitmap a blit's source rectangle names, or all of it. */
+function cropDib(img, x, y, w, h) {
+	const left = Math.max(0, Math.min(img.width - 1, x));
+	const top = Math.max(0, Math.min(img.height - 1, y));
+	const width = Math.max(1, Math.min(img.width - left, w));
+	const height = Math.max(1, Math.min(img.height - top, h));
+	if (left === 0 && top === 0 && width === img.width && height === img.height) return img;
+	const rgba = new Uint8Array(width * height * 4);
+	for (let row = 0; row < height; row++) {
+		const src = ((top + row) * img.width + left) * 4;
+		rgba.set(img.rgba.subarray(src, src + width * 4), row * width * 4);
+	}
+	return {
+		width,
+		height,
+		rgba
+	};
+}
+function readPalette(v, at, count, entry) {
+	const out = new Uint32Array(Math.max(count, 2));
+	out[1] = 16777215;
+	for (let i = 0; i < count; i++) {
+		const o = at + i * entry;
+		if (o + 3 > v.byteLength) break;
+		out[i] = v.getUint8(o + 2) << 16 | v.getUint8(o + 1) << 8 | v.getUint8(o);
+	}
+	return out;
+}
+function maskChannel(mask) {
+	if (mask === 0) return () => 0;
+	let shift = 0;
+	while ((mask >>> shift & 1) === 0) shift++;
+	const span = (mask >>> shift) + 1;
+	return (word) => Math.round(((word & mask) >>> shift) * 255 / (span - 1));
+}
+function expand5(v) {
+	return v << 3 | v >> 2;
+}
+//#endregion
+export { cropDib, dibToPng, fadedDib, maskedDib, readDib };