reamkit 1.22.0 → 1.24.0

package/dist/esm/core/fonts/remote-fonts.js

@@ -6,6 +6,48 @@ var VARIANT_SUFFIX = {
 	italic: "400Regular_Italic",
 	boldItalic: "700Bold_Italic"
 };
+var SCRIPTS = {
+	jp: {
+		pkg: "noto-sans-jp",
+		file: "NotoSansJP"
+	},
+	kr: {
+		pkg: "noto-sans-kr",
+		file: "NotoSansKR"
+	},
+	sc: {
+		pkg: "noto-sans-sc",
+		file: "NotoSansSC"
+	},
+	arabic: {
+		pkg: "noto-sans-arabic",
+		file: "NotoSansArabic"
+	},
+	hebrew: {
+		pkg: "noto-sans-hebrew",
+		file: "NotoSansHebrew"
+	},
+	thai: {
+		pkg: "noto-sans-thai",
+		file: "NotoSansThai"
+	},
+	symbols: {
+		pkg: "noto-sans-symbols-2",
+		file: "NotoSansSymbols2"
+	}
+};
+/**
+* Fetch the ONE face a writing system is drawn with.
+*
+* @param script The writing system.
+* @param fetchImpl Injectable `fetch` (defaults to the global one).
+* @returns The regular face, or `undefined` when the download fails.
+*/
+async function fetchScriptFont(script, fetchImpl = globalThis.fetch.bind(globalThis)) {
+	const family = SCRIPTS[script];
+	const bytes = await fetchTtf(`${CDN_BASE}/${family.pkg}/400Regular/${family.file}_400Regular.ttf`, fetchImpl, false);
+	return bytes ? { regular: bytes } : void 0;
+}
 var FAMILIES = {
 	arimo: {
 		pkg: "arimo",
@@ -31,6 +73,7 @@ var FAMILIES = {
 };
 var EXACT = {
 	calibri: "carlito",
+	"calibri light": "carlito",
 	cambria: "caladea",
 	arial: "arimo",
 	helvetica: "arimo",
@@ -59,22 +102,85 @@ var MONO = new Set([
 	"dejavu sans mono",
 	"monospace"
 ]);
+var WEIGHT_WORDS = new Map([
+	["black", "bold"],
+	["heavy", "bold"],
+	["bold", "bold"],
+	["semibold", "bold"],
+	["demibold", "bold"],
+	["demi", "bold"],
+	["italic", "italic"],
+	["oblique", "italic"],
+	["light", "none"],
+	["thin", "none"],
+	["medium", "none"],
+	["regular", "none"],
+	["book", "none"],
+	["narrow", "narrow"],
+	["condensed", "narrow"],
+	["cond", "narrow"],
+	["expanded", "none"],
+	["extra", "none"],
+	["ultra", "none"],
+	["pro", "none"]
+]);
+/** Arial Narrow's advance widths, as a fraction of Arial's. */
+var NARROW_SCALE = .82;
 /**
 * Map a document-referenced font family to a curated open substitute: an exact
 * metric twin when one is known (e.g. Calibri → Carlito), otherwise a
 * serif/mono/sans style fallback.
 *
+* The name may also carry the FACE — `Times New Roman Bold` is the Times
+* family, and read whole it matches no twin at all and fell through to the
+* generic sans, which is how a Times heading came out in a grotesque.
+*
+* @param name The referenced family name (case-insensitive); empty ⇒ Arimo.
+* @returns The chosen family and what the name said about the face.
+*/
+function resolveFamilyStyle(name) {
+	if (!name) return { key: "arimo" };
+	const words = name.trim().toLowerCase().split(/[\s\-_,]+/u).filter((w) => w !== "");
+	let bold = false;
+	let italic = false;
+	let narrow = false;
+	while (words.length > 1) {
+		const word = WEIGHT_WORDS.get(words[words.length - 1]);
+		if (word === void 0) break;
+		if (word === "bold") bold = true;
+		if (word === "italic") italic = true;
+		if (word === "narrow") narrow = true;
+		words.pop();
+	}
+	const tries = [
+		words.join(" "),
+		words[words.length - 1],
+		words[0]
+	];
+	let key = "arimo";
+	for (const n of tries) {
+		const found = EXACT[n] ?? (MONO.has(n) ? "cousine" : SERIF.has(n) ? "tinos" : void 0);
+		if (found) {
+			key = found;
+			break;
+		}
+	}
+	return {
+		key,
+		...bold ? { bold } : {},
+		...italic ? { italic } : {},
+		...narrow ? { widthScale: NARROW_SCALE } : {}
+	};
+}
+/**
+* The curated substitute for a family name — {@link resolveFamilyStyle} without
+* the face it also carries.
+*
 * @param name The referenced family name (case-insensitive); empty ⇒ Arimo.
 * @returns The chosen {@link FamilyKey}.
 */
 function resolveFamilyKey(name) {
-	if (!name) return "arimo";
-	const n = name.trim().toLowerCase();
-	const exact = EXACT[n];
-	if (exact) return exact;
-	if (MONO.has(n)) return "cousine";
-	if (SERIF.has(n)) return "tinos";
-	return "arimo";
+	return resolveFamilyStyle(name).key;
 }
 function fontUrl(family, variant) {
 	const suffix = VARIANT_SUFFIX[variant];
@@ -128,4 +234,4 @@ async function fetchFontSet(options = {}) {
 	};
 }
 //#endregion
-export { fetchFontSet, resolveFamilyKey };
+export { fetchFontSet, fetchScriptFont, resolveFamilyKey, resolveFamilyStyle };

package/dist/esm/core/fonts/scripts.d.ts

@@ -0,0 +1,26 @@
+import { FlowDoc } from '../ir/flow.js';
+import { ScriptKey } from './remote-fonts.js';
+/**
+ * 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.
+ */
+export declare function scriptForCodepoint(cp: number, hanFace?: ScriptKey): ScriptKey | undefined;
+/**
+ * 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.
+ */
+export declare function scriptsInFlow(flow: FlowDoc): {
+    scripts: Set<ScriptKey>;
+    hanFace: ScriptKey;
+};

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/images.d.ts

@@ -1,11 +1,31 @@
 /** The raster formats this module recognizes and can prepare for embedding. */
-export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000' | 'gif' | 'tiff';
+export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000' | 'gif' | 'tiff' | 'bmp';
 /**
  * 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
  * {@link ImageFormat}, or `null` when none matches.
  */
 export declare function detectImageFormat(bytes: Uint8Array): ImageFormat | null;
+/**
+ * The same picture with one colour knocked out of it, as a PNG.
+ *
+ * A picture may name a colour it is drawn WITHOUT — MS-ODRAW's
+ * `pictureTransparent`, DrawingML's `a:clrChange` to nothing — which is how
+ * clip art of the pre-alpha age says "this rectangle of ground is not part of
+ * the drawing". It is a property of the USE, not of the file, so it is baked
+ * here into bytes of its own: two shapes may knock different colours out of the
+ * same blip, and a resource store that hashes content then keeps them apart by
+ * itself.
+ *
+ * 23884's satellite sits on a red field and its globe on a white one; drawn as
+ * stored, they are a red block and a white square on a blue slide.
+ *
+ * @param bytes The picture, in any format {@link prepareImage} reads.
+ * @param hex   The colour to knock out, 6-hex and no leading `#`.
+ * @returns A PNG with that colour transparent, or `undefined` when the picture
+ *   cannot be decoded to samples this can work on.
+ */
+export declare function knockOutColor(bytes: Uint8Array, hex: string): Uint8Array | undefined;
 /** Options controlling how {@link prepareImage} emits an image. */
 export interface EmbedImageOptions {
     /**
@@ -24,7 +44,7 @@ export interface EmbedImageOptions {
  */
 export interface PreparedImage {
     readonly format: ImageFormat;
-    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png' | 'image/gif' | 'image/tiff';
+    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png' | 'image/gif' | 'image/tiff' | 'image/bmp';
     readonly widthPx: number;
     readonly heightPx: number;
     /**
@@ -38,6 +58,14 @@ export interface PreparedImage {
     readonly data: Uint8Array;
     /** PNG alpha channel, already FlateDecode-compressed (DeviceGray, 8 bpc). */
     readonly smaskData?: Uint8Array;
+    /**
+     * The resolution the picture states for itself, in pixels per inch, when it
+     * states one (JFIF's `Xdensity`/`Ydensity`, PNG's `pHYs`). It is what makes a
+     * picture's NATURAL size: 800 pixels at 300 dpi is 192 points wide, not the
+     * 600 the 96-dpi default would give. Absent ⇒ the reader's own default.
+     */
+    readonly dpiX?: number;
+    readonly dpiY?: number;
 }
 /**
  * Decode and validate one image into a {@link PreparedImage} ready to embed.

package/dist/esm/core/images.js

@@ -1,3 +1,5 @@
+import { decodeBmp, isBmp } from "./bmp.js";
+import { encodePng } from "./png-encode.js";
 import { decodeTiff, isTiff } from "./tiff.js";
 import { unzlibSync, zlibSync } from "fflate";
 //#region src/core/images.ts
@@ -13,9 +15,61 @@ function detectImageFormat(bytes) {
 	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";
+	if (isBmp(bytes)) return "bmp";
 	return null;
 }
 /**
+* The same picture with one colour knocked out of it, as a PNG.
+*
+* A picture may name a colour it is drawn WITHOUT — MS-ODRAW's
+* `pictureTransparent`, DrawingML's `a:clrChange` to nothing — which is how
+* clip art of the pre-alpha age says "this rectangle of ground is not part of
+* the drawing". It is a property of the USE, not of the file, so it is baked
+* here into bytes of its own: two shapes may knock different colours out of the
+* same blip, and a resource store that hashes content then keeps them apart by
+* itself.
+*
+* 23884's satellite sits on a red field and its globe on a white one; drawn as
+* stored, they are a red block and a white square on a blue slide.
+*
+* @param bytes The picture, in any format {@link prepareImage} reads.
+* @param hex   The colour to knock out, 6-hex and no leading `#`.
+* @returns A PNG with that colour transparent, or `undefined` when the picture
+*   cannot be decoded to samples this can work on.
+*/
+function knockOutColor(bytes, hex) {
+	let prepared;
+	try {
+		prepared = prepareImage(bytes);
+	} catch {
+		return;
+	}
+	if (prepared.filter !== "FlateDecode" || prepared.bitsPerComponent !== 8) return void 0;
+	const key = [
+		0,
+		2,
+		4
+	].map((i) => Number.parseInt(hex.slice(i, i + 2), 16));
+	if (key.some((c) => !Number.isFinite(c))) return void 0;
+	const gray = prepared.colorSpace === "DeviceGray";
+	const src = unzlibSync(prepared.data);
+	const existing = prepared.smaskData ? unzlibSync(prepared.smaskData) : void 0;
+	const { widthPx: w, heightPx: h } = prepared;
+	const channels = gray ? 1 : 3;
+	if (src.length < w * h * channels) return void 0;
+	const out = new Uint8Array(w * h * 4);
+	for (let i = 0; i < w * h; i++) {
+		const r = gray ? src[i] : src[i * 3];
+		const g = gray ? src[i] : src[i * 3 + 1];
+		const b = gray ? src[i] : src[i * 3 + 2];
+		out[i * 4] = r;
+		out[i * 4 + 1] = g;
+		out[i * 4 + 2] = b;
+		out[i * 4 + 3] = r === key[0] && g === key[1] && b === key[2] ? 0 : existing?.[i] ?? 255;
+	}
+	return encodePng(w, h, "rgba", out);
+}
+/**
 * Decode and validate one image into a {@link PreparedImage} ready to embed.
 * JPEG and JPEG 2000 pass through verbatim (readers decode them); PNG is
 * inflated, de-filtered and re-compressed, splitting any alpha into a soft mask.
@@ -29,6 +83,7 @@ function prepareImage(bytes, options = {}) {
 	if (format === "jpeg2000") return prepareJpeg2000(bytes);
 	if (format === "gif") return prepareGif(bytes, options);
 	if (format === "tiff") return prepareTiff(bytes, options);
+	if (format === "bmp") return prepareBmp(bytes, options);
 	throw new Error("Unsupported image format");
 }
 function prepareJpeg2000(bytes) {
@@ -91,6 +146,7 @@ function readSiz(bytes, sizOffset) {
 }
 function prepareJpeg(bytes) {
 	const info = readJpegInfo(bytes);
+	const density = readJfifDensity(bytes);
 	return {
 		format: "jpeg",
 		mimeType: "image/jpeg",
@@ -99,7 +155,24 @@ function prepareJpeg(bytes) {
 		colorSpace: info.numComponents === 1 ? "DeviceGray" : "DeviceRGB",
 		bitsPerComponent: info.precision,
 		filter: "DCTDecode",
-		data: bytes
+		data: bytes,
+		...density ?? {}
+	};
+}
+function readJfifDensity(bytes) {
+	if (bytes.length < 20 || bytes[2] !== 255 || bytes[3] !== 224) return void 0;
+	if (!(bytes[6] === 74 && bytes[7] === 70 && bytes[8] === 73 && bytes[9] === 70)) return void 0;
+	const units = bytes[13];
+	const x = bytes[14] << 8 | bytes[15];
+	const y = bytes[16] << 8 | bytes[17];
+	if (x <= 0 || y <= 0) return void 0;
+	if (units === 1) return {
+		dpiX: x,
+		dpiY: y
+	};
+	if (units === 2) return {
+		dpiX: x * 2.54,
+		dpiY: y * 2.54
 	};
 }
 function readJpegInfo(bytes) {
@@ -198,6 +271,34 @@ function prepareTiff(bytes, options = {}) {
 		...alpha && !options.flattenAlpha ? { smaskData: zlibSync(alpha.slice()) } : {}
 	};
 }
+function prepareBmp(bytes, options = {}) {
+	const img = decodeBmp(bytes);
+	const 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 < 3; c++) {
+			const at = i * 3 + c;
+			data[at] = Math.round(data[at] * a + 255 * (1 - a));
+		}
+	}
+	return {
+		format: "bmp",
+		mimeType: "image/bmp",
+		widthPx: img.width,
+		heightPx: img.height,
+		colorSpace: "DeviceRGB",
+		bitsPerComponent: 8,
+		filter: "FlateDecode",
+		data: zlibSync(data),
+		...alpha && !options.flattenAlpha ? { smaskData: zlibSync(alpha.slice()) } : {},
+		...img.dpiX !== void 0 && img.dpiY !== void 0 ? {
+			dpiX: img.dpiX,
+			dpiY: img.dpiY
+		} : {}
+	};
+}
 function cmykToRgb(cmyk) {
 	const out = new Uint8Array(cmyk.length / 4 * 3);
 	for (let i = 0; i * 4 + 3 < cmyk.length; i++) {
@@ -356,7 +457,11 @@ function preparePng(bytes, options = {}) {
 		bitsPerComponent: decoded.bitsPerComponent,
 		filter: "FlateDecode",
 		data: zlibSync(decoded.raw),
-		...decoded.smaskRaw ? { smaskData: zlibSync(decoded.smaskRaw) } : {}
+		...decoded.smaskRaw ? { smaskData: zlibSync(decoded.smaskRaw) } : {},
+		...decoded.dpiX !== void 0 && decoded.dpiY !== void 0 ? {
+			dpiX: decoded.dpiX,
+			dpiY: decoded.dpiY
+		} : {}
 	};
 }
 function decodePng(bytes) {
@@ -367,6 +472,7 @@ function decodePng(bytes) {
 	let interlaceMethod = 0;
 	let palette;
 	let paletteAlpha;
+	let density = {};
 	const idatChunks = [];
 	let pos = 8;
 	while (pos + 12 <= bytes.length) {
@@ -381,7 +487,14 @@ function decodePng(bytes) {
 			interlaceMethod = bytes[dataOff + 12];
 		} else if (type === "PLTE") palette = bytes.subarray(dataOff, dataOff + len);
 		else if (type === "tRNS") paletteAlpha = bytes.subarray(dataOff, dataOff + len);
-		else if (type === "IDAT") idatChunks.push(bytes.subarray(dataOff, dataOff + len));
+		else if (type === "pHYs") {
+			const perX = readU32BE(bytes, dataOff);
+			const perY = readU32BE(bytes, dataOff + 4);
+			if (bytes[dataOff + 8] === 1 && perX > 0 && perY > 0) density = {
+				dpiX: perX * .0254,
+				dpiY: perY * .0254
+			};
+		} else if (type === "IDAT") idatChunks.push(bytes.subarray(dataOff, dataOff + len));
 		else if (type === "IEND") break;
 		pos = dataOff + len + 4;
 	}
@@ -397,7 +510,10 @@ function decodePng(bytes) {
 	const channels = pngChannels(colorType);
 	if (channels === 0) throw new Error(`PNG color type ${colorType} not supported`);
 	const raw = decodeSamples(unzlibSync(concatBytes(idatChunks)), width, height, channels, bitDepth, interlaceMethod === 1, colorType !== 3);
-	return splitChannels(width, height, colorType, raw, palette, paletteAlpha);
+	return {
+		...splitChannels(width, height, colorType, raw, palette, paletteAlpha),
+		...density
+	};
 }
 /**
 * §7.2 / §9 — the image's samples, one byte each, in `width × height ×
@@ -665,4 +781,4 @@ function concatBytes(parts) {
 	return out;
 }
 //#endregion
-export { detectImageFormat, prepareImage };
+export { detectImageFormat, knockOutColor, prepareImage };

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;
+};