reamkit 1.23.0 → 1.25.0

package/dist/esm/core/drawingml/text-warp.js

@@ -0,0 +1,355 @@
+//#region src/core/drawingml/text-warp.ts
+/** Distance from the box's centre line, `0` at the middle and `1` at either edge. */
+var fromCentre = (u) => Math.abs(2 * u - 1);
+/** A band of constant height `1 - drop` whose top edge is `top`. */
+var band = (top, drop) => ({
+	top,
+	bottom: top + (1 - drop)
+});
+/**
+* §20.1.10.76 ST_TextShapeType — the warp each preset applies, keyed by its
+* name. `adj` arrives as the `a:avLst` adjustment in hundred-thousandths, or
+* the preset's own default when the file states none.
+*/
+var ENVELOPES = new Map([
+	["textPlain", {
+		defaultAdj: 0,
+		at: () => ({
+			top: 0,
+			bottom: 1
+		})
+	}],
+	["textStop", {
+		defaultAdj: 12500,
+		at: (u, adj) => {
+			const t = adj * Math.max(0, (fromCentre(u) - .375) / .625);
+			return {
+				top: t,
+				bottom: 1 - t
+			};
+		}
+	}],
+	["textTriangle", {
+		defaultAdj: 5e4,
+		at: (u, adj) => ({
+			top: adj * fromCentre(u),
+			bottom: 1
+		})
+	}],
+	["textTriangleInverted", {
+		defaultAdj: 5e4,
+		at: (u, adj) => ({
+			top: 0,
+			bottom: 1 - adj * fromCentre(u)
+		})
+	}],
+	["textChevron", {
+		defaultAdj: 25e3,
+		at: (u, adj) => band(adj * fromCentre(u), adj)
+	}],
+	["textChevronInverted", {
+		defaultAdj: 25e3,
+		at: (u, adj) => band(adj * (1 - fromCentre(u)), adj)
+	}],
+	["textCanUp", {
+		defaultAdj: 14e3,
+		at: (u, adj) => band(adj * fromCentre(u) ** 4, adj)
+	}],
+	["textCanDown", {
+		defaultAdj: 14e3,
+		at: (u, adj) => band(adj * (1 - fromCentre(u) ** 4), adj)
+	}],
+	["textWave1", {
+		defaultAdj: 6250,
+		at: (u, adj) => band(adj * (1 - Math.sin(2 * Math.PI * u)), 2 * adj)
+	}],
+	["textWave2", {
+		defaultAdj: 6250,
+		at: (u, adj) => band(adj * (1 + Math.sin(2 * Math.PI * u)), 2 * adj)
+	}],
+	["textDoubleWave1", {
+		defaultAdj: 6250,
+		at: (u, adj) => band(adj * (1 - Math.sin(4 * Math.PI * u)), 2 * adj)
+	}],
+	["textWave4", {
+		defaultAdj: 6250,
+		at: (u, adj) => band(adj * (1 + Math.sin(4 * Math.PI * u)), 2 * adj)
+	}],
+	["textInflate", {
+		defaultAdj: 13600,
+		at: (u, adj) => {
+			const t = adj * fromCentre(u) ** 2;
+			return {
+				top: t,
+				bottom: 1 - t
+			};
+		}
+	}],
+	["textDeflate", {
+		defaultAdj: 37500,
+		at: (u, adj) => {
+			const t = adj * (1 - fromCentre(u) ** 2.23);
+			return {
+				top: t,
+				bottom: 1 - t
+			};
+		}
+	}],
+	["textInflateTop", {
+		defaultAdj: 31800,
+		at: (u, adj) => ({
+			top: adj * fromCentre(u) ** 2,
+			bottom: 1
+		})
+	}],
+	["textDeflateTop", {
+		defaultAdj: 47e3,
+		at: (u, adj) => ({
+			top: adj * (1 - fromCentre(u) ** 2),
+			bottom: 1
+		})
+	}],
+	["textInflateBottom", {
+		defaultAdj: 31800,
+		at: (u, adj) => ({
+			top: 0,
+			bottom: 1 - adj * fromCentre(u) ** 2
+		})
+	}],
+	["textDeflateBottom", {
+		defaultAdj: 47e3,
+		at: (u, adj) => ({
+			top: 0,
+			bottom: 1 - adj * (1 - fromCentre(u) ** 2)
+		})
+	}],
+	["textDeflateInflate", {
+		defaultAdj: 19800,
+		at: (u, adj) => ({
+			top: 0,
+			bottom: .268 + adj * fromCentre(u) ** 2
+		})
+	}],
+	["textDeflateInflateDeflate", {
+		defaultAdj: 4600,
+		at: (u, adj) => ({
+			top: 0,
+			bottom: .258 + adj * fromCentre(u) ** 2
+		})
+	}],
+	["textFadeRight", {
+		defaultAdj: 33333,
+		at: (u, adj) => ({
+			top: adj * u,
+			bottom: 1 - adj * u
+		})
+	}],
+	["textFadeLeft", {
+		defaultAdj: 33333,
+		at: (u, adj) => ({
+			top: adj * (1 - u),
+			bottom: 1 - adj * (1 - u)
+		})
+	}],
+	["textFadeUp", {
+		defaultAdj: 1e5,
+		at: (u, adj) => ({
+			top: adj * fromCentre(u) ** 2,
+			bottom: 1
+		})
+	}],
+	["textFadeDown", {
+		defaultAdj: 1e5,
+		at: (u, adj) => ({
+			top: 0,
+			bottom: 1 - adj * fromCentre(u) ** 2
+		})
+	}],
+	["textSlantUp", {
+		defaultAdj: 55500,
+		at: (u, adj) => band(adj * (1 - u), adj)
+	}],
+	["textSlantDown", {
+		defaultAdj: 44400,
+		at: (u, adj) => band(adj * u, adj)
+	}],
+	["textCascadeUp", {
+		defaultAdj: 55500,
+		at: (u, adj) => ({
+			top: .138 * (1 - u),
+			bottom: 1 - adj + adj * (1 - u)
+		})
+	}],
+	["textCascadeDown", {
+		defaultAdj: 55500,
+		at: (u, adj) => ({
+			top: .138 * u,
+			bottom: 1 - adj + adj * u
+		})
+	}],
+	["textCurveUp", {
+		defaultAdj: 45600,
+		at: (u, adj) => curve(1 - u, adj)
+	}],
+	["textCurveDown", {
+		defaultAdj: 45600,
+		at: (u, adj) => curve(u, adj)
+	}]
+]);
+/**
+* The ring presets, which do not hang text between two edges at all: they wind
+* it once round an ellipse inscribed in the box. Both start at the box's left
+* edge; `Inside` climbs over the top with each letter's head pointing out of
+* the ring, `Outside` dips under the bottom with each letter's head pointing
+* into it — which is why half of either one reads upside down.
+*
+* The band the letters occupy is a fixed share of the ring whatever the text:
+* eight letters and thirty-two fill exactly the same annulus, so it is the
+* preset and not the string that fixes the inner radius.
+*/
+var RING_INNER = .34;
+var RINGS = new Map([["textRingInside", {
+	clockwise: true,
+	headOut: true
+}], ["textRingOutside", {
+	clockwise: false,
+	headOut: false
+}]]);
+/**
+* The `textCurve*` pair: the baseline is an arc over the box and the band
+* narrows towards the end the text runs to.
+*
+* @param u   Position across the box, already turned the way the preset runs.
+* @param adj How much of the band's height the taper takes by the far end.
+* @returns   The two edges at `u`.
+*/
+function curve(u, adj) {
+	const bottom = 1 - .24 * (2 * u - 1) ** 2;
+	return {
+		top: bottom - (.758 - adj * u ** 1.7),
+		bottom
+	};
+}
+/**
+* Whether a preset bends text at all. `textNoShape` is the "no warp" member of
+* the enumeration and by far its most common value — two thirds of the decks
+* that mention a warp state only this one — and a body carrying it is an
+* ordinary text box, NOT WordArt stretched to its shape.
+*
+* @param preset The `a:prstTxWarp @prst` value.
+* @returns Whether {@link textWarpEdges} can bend text through this preset.
+*/
+function isTextWarp(preset) {
+	return ENVELOPES.has(preset) || RINGS.has(preset);
+}
+/**
+* The matrix that places one glyph of a warped body.
+*
+* Maps the glyph's own text space — x along its advance, y UP from its
+* baseline — into the page's top-left frame, as `[a, b, c, d, e, f]` with
+* `px = a·x + c·y + e` and `py = b·x + d·y + f`. Upright text therefore has a
+* negative `d`: the glyph's y runs against the page's.
+*
+* @param frame     The two frames, from the laid-out line.
+* @param glyphX    The glyph's left edge in the un-warped block.
+* @param advance   How wide the glyph is there.
+* @param baselineY The line's baseline in the un-warped block.
+* @returns The six numbers, or `undefined` where the warp leaves no room to
+*          draw — the pinched end of a fade, or a preset this file cannot bend.
+*/
+function warpGlyphMatrix(frame, glyphX, advance, baselineY) {
+	const u = (glyphX + advance / 2 - frame.srcX) / frame.srcWidth;
+	const v = (baselineY - frame.srcTop) / frame.srcHeight;
+	const ring = RINGS.get(frame.preset);
+	if (ring) return ringMatrix(frame, ring, u, v, glyphX);
+	return envelopeMatrix(frame, u, v, glyphX, advance);
+}
+/** The glyph matrix for a warp that hangs text between a top and a bottom edge. */
+function envelopeMatrix(frame, u, v, glyphX, advance) {
+	const edges = textWarpEdges(frame.preset, u, frame.adjust);
+	if (!edges) return void 0;
+	const height = edges.bottom - edges.top;
+	if (!(height > 0)) return void 0;
+	const sx = frame.boxWidth / frame.srcWidth;
+	const sy = height * frame.boxHeight / frame.srcHeight;
+	const step = .004;
+	const lo = Math.max(0, u - step);
+	const hi = Math.min(1, u + step);
+	const at = (q) => {
+		const e = textWarpEdges(frame.preset, q, frame.adjust);
+		return e ? e.top + v * (e.bottom - e.top) : void 0;
+	};
+	const before = at(lo);
+	const after = at(hi);
+	const slope = before !== void 0 && after !== void 0 && hi > lo ? (after - before) * frame.boxHeight / ((hi - lo) * frame.boxWidth) : 0;
+	const x0 = frame.boxX + (glyphX - frame.srcX) / frame.srcWidth * frame.boxWidth;
+	const mid = edges.top + v * height;
+	const y0 = frame.boxY + mid * frame.boxHeight - slope * advance * sx / 2;
+	return [
+		sx,
+		slope * sx,
+		0,
+		-sy,
+		x0,
+		y0
+	];
+}
+/**
+* The glyph matrix for a ring: one turn round the ellipse inscribed in the box.
+*
+* The band is a CONSTANT inset from that ellipse, not a scaled copy of it. A
+* scaled copy would be the natural reading — a circular annulus squashed to the
+* box's proportions — but it makes the band four times deeper at the ring's
+* sides than at its top on a box four times wider than tall, and the letters
+* there come out as spikes radiating from the centre. Held at a constant depth
+* the ring's outer edge still touches the box all the way round, which is what
+* both references draw and what a box of capitals measures.
+*/
+function ringMatrix(frame, ring, _u, v, glyphX) {
+	const a = frame.boxWidth / 2;
+	const b = frame.boxHeight / 2;
+	if (!(a > 0 && b > 0 && frame.srcWidth > 0 && frame.srcHeight > 0)) return void 0;
+	const uLeft = (glyphX - frame.srcX) / frame.srcWidth;
+	const turn = ring.clockwise ? -1 : 1;
+	const psi = Math.PI + turn * 2 * Math.PI * uLeft;
+	const cos = Math.cos(psi);
+	const sin = Math.sin(psi);
+	const rawX = -turn * a * sin;
+	const rawY = -turn * b * cos;
+	const speed = Math.hypot(rawX, rawY);
+	if (!(speed > 0)) return void 0;
+	const tx = rawX / speed;
+	const ty = rawY / speed;
+	const inX = -turn * -ty;
+	const inY = -turn * tx;
+	const head = ring.headOut ? -1 : 1;
+	const depth = (1 - RING_INNER) * b;
+	const sT = 2 * Math.PI * speed / frame.srcWidth;
+	const sN = depth / frame.srcHeight;
+	const inset = (ring.headOut ? v : 1 - v) * depth;
+	return [
+		sT * tx,
+		sT * ty,
+		sN * head * inX,
+		sN * head * inY,
+		frame.boxX + a + a * cos + inX * inset,
+		frame.boxY + b - b * sin + inY * inset
+	];
+}
+/**
+* The two edges of a warp at one position across its box.
+*
+* @param preset The `a:prstTxWarp @prst` value.
+* @param u      Position across the box, `0` at its left edge and `1` at its right.
+* @param adj    The `a:avLst` `adj` guide in hundred-thousandths, when the file states one.
+* @returns The top and bottom edges, `0`…`1` down the box, or `undefined` for a
+*          preset this file does not bend (an unknown name, or `textNoShape`).
+*/
+function textWarpEdges(preset, u, adj) {
+	const env = ENVELOPES.get(preset);
+	if (!env) return void 0;
+	const a = (adj ?? env.defaultAdj) / 1e5;
+	return env.at(Math.min(1, Math.max(0, u)), a);
+}
+//#endregion
+export { isTextWarp, warpGlyphMatrix };

package/dist/esm/core/drawingml/theme-parser.js

@@ -168,7 +168,13 @@ function parseThemeFillStyles(themeXml) {
 		"a:fmtScheme",
 		"a:fillStyleLst"
 	]);
-	return list ? [...poChildren(list)] : [];
+	return list ? fillsOf(list) : [];
+}
+function fillsOf(list) {
+	return poChildren(list).filter((c) => {
+		const tag = poTag(c);
+		return tag !== void 0 && tag !== "#text";
+	});
 }
 /**
 * Parse a theme's BACKGROUND fill styles (§20.1.4.1.7 `a:bgFillStyleLst`), as
@@ -186,7 +192,7 @@ function parseThemeBgFillStyles(themeXml) {
 		"a:fmtScheme",
 		"a:bgFillStyleLst"
 	]);
-	return list ? [...poChildren(list)] : [];
+	return list ? fillsOf(list) : [];
 }
 /**
 * Parse a theme's effect styles (§20.1.4.1.15 `a:effectStyleLst`), as the raw
@@ -204,7 +210,7 @@ function parseThemeEffectStyles(themeXml) {
 		"a:fmtScheme",
 		"a:effectStyleLst"
 	]);
-	return list ? [...poChildren(list)] : [];
+	return list ? fillsOf(list) : [];
 }
 var EMU_PER_POINT = 12700;
 function colorOf(slot) {

package/dist/esm/core/font/measure.d.ts

@@ -10,6 +10,18 @@ export interface FontMeasure {
     readonly pdfWidthForGid: (gid: number) => number;
     /** Shaped width of `text` at `fontSize`, in points. */
     readonly textWidthPt: (text: string, fontSize: number) => number;
+    /**
+     * How far this text's INK actually reaches from its baseline, in points:
+     * `above` up to its highest glyph edge, `below` down to its lowest. Not the
+     * font's line box — "HHH" reaches a cap height and no further, and only a
+     * string carrying a descender reaches under the baseline at all. WordArt
+     * stretches the ink it draws to fill its shape (§20.1.9.10), so it is the
+     * ink and not the line box that has to be measured.
+     */
+    readonly textInkPt: (text: string, fontSize: number) => {
+        above: number;
+        below: number;
+    };
     /** Encode `text` as a hex string of 4-digit glyph ids (Identity-H addressing). */
     readonly encodeTextAsCidHex: (text: string) => string;
     /**

package/dist/esm/core/font/measure.js

@@ -52,9 +52,45 @@ function createFontMeasure(parsed, kern = true) {
 		if (hex !== "") parts.push(`<${hex}>`);
 		return `[${parts.join(" ")}] TJ`;
 	};
+	const glyf = parsed.tables.get("glyf");
+	const glyphInk = (gid) => {
+		if (!glyf || gid < 0 || gid >= parsed.numGlyphs) return void 0;
+		const start = parsed.glyphOffsets[gid] ?? 0;
+		if ((parsed.glyphOffsets[gid + 1] ?? 0) - start < 10) return void 0;
+		const at = glyf.offset + start;
+		const i16 = (o) => {
+			const v = (parsed.raw[at + o] ?? 0) << 8 | (parsed.raw[at + o + 1] ?? 0);
+			return v >= 32768 ? v - 65536 : v;
+		};
+		return {
+			yMin: i16(4),
+			yMax: i16(8)
+		};
+	};
+	const textInkPt = (text, fontSize) => {
+		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+		let yMax = -Infinity;
+		let yMin = Infinity;
+		for (const gid of shaped.gids) {
+			const ink = glyphInk(gid);
+			if (!ink) continue;
+			if (ink.yMax > yMax) yMax = ink.yMax;
+			if (ink.yMin < yMin) yMin = ink.yMin;
+		}
+		if (!Number.isFinite(yMax) || !Number.isFinite(yMin)) {
+			yMax = parsed.capHeight || parsed.ascender;
+			yMin = 0;
+		}
+		const k = fontSize / parsed.unitsPerEm;
+		return {
+			above: yMax * k,
+			below: -yMin * k
+		};
+	};
 	return {
 		pdfWidthForGid,
 		textWidthPt,
+		textInkPt,
 		encodeTextAsCidHex,
 		showText
 	};

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