reamkit 1.21.0 → 1.23.0

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

@@ -1,5 +1,8 @@
 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"). */
 function isEmf(bytes) {
@@ -20,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"]
 ]);
@@ -73,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());
@@ -371,7 +397,7 @@ function readEmf(bytes) {
 						const font = dc.font;
 						prims.push({
 							kind: "text",
-							text,
+							text: fromSymbolFont(text, font?.family),
 							x: p.x,
 							y: p.y,
 							alignH: dc.alignH,
@@ -387,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/symbol-fonts.d.ts

@@ -0,0 +1,42 @@
+import { VectorPath } from '../vector.js';
+/**
+ * The geometry a symbol character DRAWS, for the handful that are plain shapes.
+ *
+ * Translating them to Unicode is not enough on its own: the substitute font a
+ * document renders with has no `●` either, and a missing glyph is a box with
+ * its code number in it — which is what 45541_Footer's table filled sixty-eight
+ * cells with. A shape this simple is better drawn than spelled.
+ *
+ * Measured off the fonts themselves: both fill the em square, one unit wide,
+ * from 0.2 em below the baseline to 0.8 em above it.
+ */
+export type SymbolGeometry = 'circle' | 'square' | 'diamond';
+/**
+ * The shapes a symbol string draws, one per character, or `undefined` when any
+ * character is not one of them — a string that mixes a pictogram with a circle
+ * stays text, which is the safer half of the trade.
+ *
+ * @param text   The string as stored.
+ * @param family The typeface it is drawn with.
+ */
+export declare function symbolGeometryOf(text: string, family: string | undefined): Array<SymbolGeometry> | undefined;
+/**
+ * The outline of one symbol in a box, as the path segments a picture draws.
+ *
+ * @param shape  Which symbol.
+ * @param left   The box's left edge, in the metafile's logical units.
+ * @param top    Its top edge (y grows DOWN, as a metafile has it).
+ * @param size   The em, which is both the width and the height of the box.
+ * @returns The closed outline.
+ */
+export declare function symbolOutline(shape: SymbolGeometry, left: number, top: number, size: number): VectorPath;
+/** Whether a typeface's characters are symbols rather than letters. */
+export declare function isSymbolFont(family: string | undefined): boolean;
+/**
+ * Translate a string drawn in a symbol font to the Unicode that means the same.
+ *
+ * @param text   The string as the metafile stored it.
+ * @param family The typeface it was drawn with.
+ * @returns The translated string; characters with no counterpart are kept.
+ */
+export declare function fromSymbolFont(text: string, family: string | undefined): string;

package/dist/esm/core/metafile/symbol-fonts.js

@@ -0,0 +1,154 @@
+import { PathBuilder } from "../vector.js";
+//#region src/core/metafile/symbol-fonts.ts
+/** Half a circle's control-point distance for a cubic quarter-arc. */
+var KAPPA = .5522847498307936;
+/**
+* The shapes a symbol string draws, one per character, or `undefined` when any
+* character is not one of them — a string that mixes a pictogram with a circle
+* stays text, which is the safer half of the trade.
+*
+* @param text   The string as stored.
+* @param family The typeface it is drawn with.
+*/
+function symbolGeometryOf(text, family) {
+	const table = family === void 0 ? void 0 : GEOMETRY_TABLES.get(normalize(family));
+	if (!table || text.length === 0) return void 0;
+	const out = [];
+	for (const ch of text) {
+		const code = ch.codePointAt(0) ?? 0;
+		const key = code >= 61440 && code <= 61695 ? code - 61440 : code;
+		const shape = table.get(key);
+		if (shape === void 0) return void 0;
+		out.push(shape);
+	}
+	return out;
+}
+/**
+* The outline of one symbol in a box, as the path segments a picture draws.
+*
+* @param shape  Which symbol.
+* @param left   The box's left edge, in the metafile's logical units.
+* @param top    Its top edge (y grows DOWN, as a metafile has it).
+* @param size   The em, which is both the width and the height of the box.
+* @returns The closed outline.
+*/
+function symbolOutline(shape, left, top, size) {
+	const b = new PathBuilder();
+	const r = size / 2;
+	const [cx, cy] = [left + r, top + r];
+	if (shape === "circle") {
+		const k = r * KAPPA;
+		return b.moveTo(cx, top).cubicTo(cx + k, top, left + size, cy - k, left + size, cy).cubicTo(left + size, cy + k, cx + k, top + size, cx, top + size).cubicTo(cx - k, top + size, left, cy + k, left, cy).cubicTo(left, cy - k, cx - k, top, cx, top).close().build();
+	}
+	if (shape === "diamond") return b.moveTo(cx, top).lineTo(left + size, cy).lineTo(cx, top + size).lineTo(left, cy).close().build();
+	return b.moveTo(left, top).lineTo(left + size, top).lineTo(left + size, top + size).lineTo(left, top + size).close().build();
+}
+/**
+* Translate a string drawn in a symbol font to the Unicode that means the same.
+*
+* @param text   The string as the metafile stored it.
+* @param family The typeface it was drawn with.
+* @returns The translated string; characters with no counterpart are kept.
+*/
+function fromSymbolFont(text, family) {
+	const table = family === void 0 ? void 0 : SYMBOL_TABLES.get(normalize(family));
+	if (!table) return text;
+	let out = "";
+	for (const ch of text) {
+		const code = ch.codePointAt(0) ?? 0;
+		const key = code >= 61440 && code <= 61695 ? code - 61440 : code;
+		out += table.get(key) ?? ch;
+	}
+	return out;
+}
+function normalize(family) {
+	return family.trim().toLowerCase();
+}
+var WINGDINGS = new Map([
+	[108, "●"],
+	[109, "❍"],
+	[110, "■"],
+	[111, "□"],
+	[112, "❑"],
+	[113, "❒"],
+	[114, "▪"],
+	[115, "▪"],
+	[116, "▫"],
+	[117, "◆"],
+	[118, "❖"],
+	[119, "◇"],
+	[120, "✗"],
+	[159, "•"],
+	[167, "▪"],
+	[252, "✔"],
+	[253, "✘"],
+	[254, "☑"],
+	[255, "☒"]
+]);
+var WEBDINGS = new Map([
+	[103, "■"],
+	[108, "■"],
+	[110, "●"],
+	[111, "○"],
+	[112, "□"],
+	[114, "◆"],
+	[115, "▲"],
+	[116, "▼"],
+	[161, "●"]
+]);
+var SYMBOL = new Map([
+	[97, "α"],
+	[98, "β"],
+	[99, "χ"],
+	[100, "δ"],
+	[101, "ε"],
+	[102, "φ"],
+	[103, "γ"],
+	[104, "η"],
+	[108, "λ"],
+	[109, "μ"],
+	[112, "π"],
+	[114, "ρ"],
+	[115, "σ"],
+	[116, "τ"],
+	[119, "ω"],
+	[183, "•"],
+	[215, "×"],
+	[177, "±"],
+	[163, "≤"],
+	[179, "≥"],
+	[185, "≠"],
+	[187, "≈"]
+]);
+var WINGDINGS_GEOMETRY = new Map([
+	[108, "circle"],
+	[110, "square"],
+	[111, "square"],
+	[114, "square"],
+	[115, "square"],
+	[117, "diamond"],
+	[119, "diamond"]
+]);
+var GEOMETRY_TABLES = new Map([
+	["wingdings", WINGDINGS_GEOMETRY],
+	["wingdings 2", WINGDINGS_GEOMETRY],
+	["wingdings 3", WINGDINGS_GEOMETRY],
+	["webdings", new Map([
+		[103, "square"],
+		[108, "square"],
+		[110, "circle"]
+	])],
+	["monotype sorts", WINGDINGS_GEOMETRY],
+	["zapfdingbats", WINGDINGS_GEOMETRY]
+]);
+var SYMBOL_TABLES = new Map([
+	["wingdings", WINGDINGS],
+	["wingdings 2", WINGDINGS],
+	["wingdings 3", WINGDINGS],
+	["webdings", WEBDINGS],
+	["symbol", SYMBOL],
+	["monotype sorts", WINGDINGS],
+	["zapfdingbats", WINGDINGS]
+]);
+//#endregion
+export { fromSymbolFont, symbolGeometryOf, symbolOutline };

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

@@ -1,5 +1,8 @@
 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
 var PLACEABLE_KEY = 2596720087;
@@ -13,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"],
@@ -60,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);
@@ -78,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 } : {},
@@ -86,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;
@@ -134,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",
@@ -222,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:
 				{
@@ -250,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:
@@ -260,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:
@@ -287,16 +397,22 @@ function readWmf(bytes) {
 		skipped: [...skipped]
 	};
 }
-function pushText(prims, dc, text, x, y) {
+function pushText(emit, dc, text, x, y) {
 	if (text.trim() === "") return;
-	prims.push({
+	const em = Math.abs(dc.font?.heightLu ?? 12);
+	const drawn = symbolPrims(text, dc, x, y, em);
+	if (drawn) {
+		for (const prim of drawn) emit(prim);
+		return;
+	}
+	emit({
 		kind: "text",
-		text,
+		text: fromSymbolFont(text, dc.font?.family),
 		x,
 		y,
 		alignH: dc.alignH,
 		alignBaseline: dc.alignBaseline,
-		sizeLu: Math.abs(dc.font?.heightLu ?? 12),
+		sizeLu: em,
 		colorHex: dc.textColorHex,
 		...dc.font?.family ? { fontFamily: dc.font.family } : {},
 		...dc.font?.bold ? { bold: true } : {},
@@ -304,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";
@@ -367,5 +514,31 @@ function polySegments(pts, closed) {
 	if (closed) segs.push({ op: "close" });
 	return segs;
 }
+/**
+* The symbols a text record draws, as filled outlines, or `undefined` when the
+* string is not one the shapes cover.
+*
+* Both fonts advance one em per symbol and fill that em, sitting from 0.2 em
+* below the baseline to 0.8 em above it — measured off Webdings itself.
+*
+* @param text The string as stored.
+* @param dc   The device context (font, colour, alignment).
+* @param x    The reference point's x, in logical units.
+* @param y    Its y — the text's top unless the context says baseline.
+* @param em   The font's height in logical units.
+* @returns One filled path per character, or `undefined`.
+*/
+function symbolPrims(text, dc, x, y, em) {
+	const shapes = symbolGeometryOf(text, dc.font?.family);
+	if (!shapes) return void 0;
+	const width = em * shapes.length;
+	const left = dc.alignH === "center" ? x - width / 2 : dc.alignH === "right" ? x - width : x;
+	const top = dc.alignBaseline ? y - em * .8 : y;
+	return shapes.map((shape, i) => ({
+		kind: "path",
+		paths: [symbolOutline(shape, left + i * em, top, em)],
+		fillColorHex: dc.textColorHex
+	}));
+}
 //#endregion
 export { isWmf, readWmf };

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;