reamkit 1.29.0 → 1.31.0

package/dist/esm/layout/turned-section.d.ts

@@ -0,0 +1,38 @@
+import { BodyElement } from '../core/document-model/index.js';
+import { PageItem } from './page-doc.js';
+/** The sheet a turned section prints on, and the margins it states for it. */
+export interface Sheet {
+    readonly width: number;
+    readonly height: number;
+    readonly marginLeft: number;
+    readonly marginRight: number;
+    readonly marginTop: number;
+    readonly marginBottom: number;
+}
+/**
+ * One item of a turned section's body, carried from the frame the text reads
+ * in onto the sheet: a point `(x, y)` of the frame (top-left origin, y down)
+ * lands at `(sheetWidth − y, x)` — the frame's top edge is the sheet's right
+ * edge, and its left edge the sheet's top.
+ *
+ * @param item       The item as the frame's layout placed it.
+ * @param sheetWidth The sheet's width, which is the frame's height.
+ * @returns The same item on the sheet, turned a quarter clockwise.
+ */
+export declare function turnOntoSheet(item: PageItem, sheetWidth: number): PageItem;
+/**
+ * A drawing anchored in a turned section, given the place in the text's frame
+ * from which turning the body carries it to where Word stands it: on the sheet,
+ * at the offsets its anchor states, upright.
+ *
+ * The anchor is resolved against the SHEET — its page, its margins and the
+ * bands beside them. What is measured from the text itself (a paragraph, a
+ * line, a column) has no place on the sheet before the text is laid out, and is
+ * measured from the margin instead. Only pictures and shapes are carried; a
+ * chart or a floating table turns with the text.
+ *
+ * @param el    The body element, anchored or not.
+ * @param sheet The sheet the section prints on.
+ * @returns The element, its anchor restated in the frame and its turn backed off.
+ */
+export declare function floatIntoFrame(el: BodyElement, sheet: Sheet): BodyElement;

package/dist/esm/layout/turned-section.js

@@ -0,0 +1,193 @@
+import { pt } from "../core/ir/units.js";
+//#region src/layout/turned-section.ts
+/** A quarter turn in the 1/60000° a DrawingML rotation is stated in (§20.1.7.6). */
+var QUARTER_60K = 90 * 6e4;
+/**
+* One item of a turned section's body, carried from the frame the text reads
+* in onto the sheet: a point `(x, y)` of the frame (top-left origin, y down)
+* lands at `(sheetWidth − y, x)` — the frame's top edge is the sheet's right
+* edge, and its left edge the sheet's top.
+*
+* @param item       The item as the frame's layout placed it.
+* @param sheetWidth The sheet's width, which is the frame's height.
+* @returns The same item on the sheet, turned a quarter clockwise.
+*/
+function turnOntoSheet(item, sheetWidth) {
+	const box = (x, y, w, h) => ({
+		x: pt(sheetWidth - y - h),
+		y: pt(x),
+		width: pt(h),
+		height: pt(w)
+	});
+	switch (item.type) {
+		case "line": {
+			const quarter = withinTurn((item.rotationDeg ?? 0) - 90);
+			const turned = quarter > 180 ? quarter - 360 : quarter;
+			const { rotationDeg: _flat, clip, ...rest } = item;
+			return {
+				...rest,
+				originX: pt(sheetWidth - item.baselineY),
+				baselineY: pt(item.originX),
+				...turned !== 0 ? { rotationDeg: turned } : {},
+				...clip ? { clip: box(clip.x, clip.y, clip.width, clip.height) } : {}
+			};
+		}
+		case "image": {
+			const cx = item.x + item.width / 2;
+			const cy = item.y + item.height / 2;
+			const turned = withinTurn((item.rotationDeg ?? 0) + 90);
+			const { rotationDeg: _flat, clip, ...rest } = item;
+			return {
+				...rest,
+				x: pt(sheetWidth - cy - item.width / 2),
+				y: pt(cx - item.height / 2),
+				...turned !== 0 ? { rotationDeg: turned } : {},
+				...clip ? { clip: {
+					paths: clip.paths,
+					transform: turnMatrix(clip.transform, sheetWidth)
+				} } : {}
+			};
+		}
+		case "shape": {
+			const shadow = item.shape.shadow;
+			return {
+				...item,
+				shape: {
+					...item.shape,
+					transform: turnMatrix(item.shape.transform, sheetWidth),
+					...shadow ? { shadow: {
+						...shadow,
+						dxPt: -shadow.dyPt,
+						dyPt: shadow.dxPt
+					} } : {}
+				}
+			};
+		}
+		case "border": return {
+			...item,
+			...box(item.x, item.y, item.width, item.height),
+			side: TURNED_SIDE[item.side]
+		};
+		case "fill": return {
+			...item,
+			...box(item.x, item.y, item.width, item.height)
+		};
+	}
+}
+/** An angle in degrees brought into one full turn, `[0, 360)`, with the float noise off. */
+function withinTurn(deg) {
+	const t = (deg % 360 + 360) % 360;
+	return Math.abs(t) < 1e-9 || Math.abs(t - 360) < 1e-9 ? 0 : t;
+}
+/** Which edge of a box each edge becomes when the box turns a quarter clockwise. */
+var TURNED_SIDE = {
+	top: "right",
+	right: "bottom",
+	bottom: "left",
+	left: "top"
+};
+/**
+* A local→page matrix `[a b c d e f]` (x' = a·u + c·v + e, y' = b·u + d·v + f,
+* page top-left, y down) followed by the turn onto the sheet.
+*/
+function turnMatrix(m, sheetWidth) {
+	return [
+		-m[1],
+		m[0],
+		-m[3],
+		m[2],
+		sheetWidth - m[5],
+		m[4]
+	];
+}
+/**
+* A drawing anchored in a turned section, given the place in the text's frame
+* from which turning the body carries it to where Word stands it: on the sheet,
+* at the offsets its anchor states, upright.
+*
+* The anchor is resolved against the SHEET — its page, its margins and the
+* bands beside them. What is measured from the text itself (a paragraph, a
+* line, a column) has no place on the sheet before the text is laid out, and is
+* measured from the margin instead. Only pictures and shapes are carried; a
+* chart or a floating table turns with the text.
+*
+* @param el    The body element, anchored or not.
+* @param sheet The sheet the section prints on.
+* @returns The element, its anchor restated in the frame and its turn backed off.
+*/
+function floatIntoFrame(el, sheet) {
+	if (el.kind === "image" && el.image.float !== void 0) {
+		const { image } = el;
+		const float = image.float;
+		const placed = frameAnchor(float, image.width, image.height, sheet);
+		return {
+			...el,
+			image: {
+				...image,
+				float: placed,
+				rotation60k: backedOff(image.rotation60k)
+			}
+		};
+	}
+	if (el.kind === "shape" && el.shape.float !== void 0) {
+		const { shape } = el;
+		const float = shape.float;
+		const placed = frameAnchor(float, shape.width, shape.height, sheet);
+		return {
+			...el,
+			shape: {
+				...shape,
+				float: placed,
+				transform: {
+					...shape.transform,
+					rotation60k: backedOff(shape.transform?.rotation60k)
+				}
+			}
+		};
+	}
+	return el;
+}
+/** A clockwise turn with a quarter taken off, kept in the one full turn. */
+function backedOff(rotation60k) {
+	const full = 360 * 6e4;
+	return (((rotation60k ?? 0) - QUARTER_60K) % full + full) % full;
+}
+/**
+* The anchor a drawing of `w × h` needs in the frame for the body's turn to put
+* it where `float` stands it on the sheet.
+*/
+function frameAnchor(float, w, h, sheet) {
+	const x = sheetX(float.posH, w, sheet);
+	const cx = sheetY(float.posV, h, sheet) + h / 2;
+	const cy = sheet.width - (x + w / 2);
+	const { posH: _h, posV: _v, ...rest } = float;
+	return {
+		...rest,
+		posH: {
+			relativeFrom: "page",
+			offsetPt: pt(cx - w / 2)
+		},
+		posV: {
+			relativeFrom: "page",
+			offsetPt: pt(cy - h / 2)
+		}
+	};
+}
+/** §20.4.3.3 — the box's left edge on the sheet. */
+function sheetX(h, w, sheet) {
+	const textRight = sheet.width - sheet.marginRight;
+	const [base, span] = h?.relativeFrom === "page" ? [0, sheet.width] : h?.relativeFrom === "leftMargin" ? [0, sheet.marginLeft] : h?.relativeFrom === "rightMargin" ? [textRight, sheet.marginRight] : [sheet.marginLeft, textRight - sheet.marginLeft];
+	if (h?.align === "center") return base + (span - w) / 2;
+	if (h?.align === "right") return base + span - w;
+	return base + (h?.offsetPt ?? 0);
+}
+/** §20.4.3.4 — the box's top edge on the sheet. */
+function sheetY(v, h, sheet) {
+	const textBottom = sheet.height - sheet.marginBottom;
+	const [base, span] = v?.relativeFrom === "page" ? [0, sheet.height] : v?.relativeFrom === "topMargin" ? [0, sheet.marginTop] : v?.relativeFrom === "bottomMargin" ? [textBottom, sheet.marginBottom] : [sheet.marginTop, textBottom - sheet.marginTop];
+	if (v?.align === "center") return base + (span - h) / 2;
+	if (v?.align === "bottom") return base + span - h;
+	return base + (v?.offsetPt ?? 0);
+}
+//#endregion
+export { floatIntoFrame, turnOntoSheet };

package/dist/esm/pdf/styled-page-emitter.js

@@ -676,12 +676,13 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			}
 			lastStroke = strokeHex;
 		}
-		const tz = Math.round((tok.synthetic?.widthScale ?? 1) * 100);
+		const scale = (tok.synthetic?.widthScale ?? 1) * (tok.resolvedRun.widthScale ?? 1);
+		const tz = Math.round(scale * 100);
 		if (tz !== lastTz) {
 			out.push(`${formatNumber(tz)} Tz`);
 			lastTz = tz;
 		}
-		const tc = tok.resolvedRun.letterSpacingPt ?? 0;
+		const tc = (tok.resolvedRun.letterSpacingPt ?? 0) / (tz > 0 ? tz / 100 : 1);
 		if (tc !== lastTc) {
 			out.push(`${formatNumber(tc)} Tc`);
 			lastTc = tc;
@@ -888,7 +889,69 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		lastColor = "";
 		lastTc = 0;
 	};
+	const emitTurned = (cmd) => {
+		if (inBT) {
+			out.push("ET");
+			inBT = false;
+		}
+		const rad = (cmd.rotationDeg ?? 0) * Math.PI / 180;
+		const cos = Math.cos(rad);
+		const sin = Math.sin(rad);
+		const ox = cmd.originX;
+		const oy = H - cmd.baselineY;
+		out.push("q");
+		out.push(`${formatNumber(cos)} ${formatNumber(sin)} ${formatNumber(-sin)} ${formatNumber(cos)} ${formatNumber(ox - ox * cos + oy * sin)} ${formatNumber(oy - ox * sin - oy * cos)} cm`);
+		lastFont = "";
+		lastFauxWidth = 0;
+		lastStroke = void 0;
+		lastTz = 100;
+		lastSize = -1;
+		lastColor = "";
+		lastTc = 0;
+		const from = links.length;
+		const { rotationDeg: _turned, ...flat } = cmd;
+		out.push("BT");
+		inBT = true;
+		emitOneLine(flat);
+		if (inBT) {
+			out.push("ET");
+			inBT = false;
+		}
+		out.push("Q");
+		lastFont = "";
+		lastFauxWidth = 0;
+		lastStroke = void 0;
+		lastTz = 100;
+		lastSize = -1;
+		lastColor = "";
+		lastTc = 0;
+		for (let k = from; k < links.length; k++) {
+			const link = links[k];
+			const [x0, y0, x1, y1] = link.rect;
+			const corners = [
+				[x0, y0],
+				[x1, y0],
+				[x1, y1],
+				[x0, y1]
+			].map(([x, y]) => [ox + (x - ox) * cos - (y - oy) * sin, oy + (x - ox) * sin + (y - oy) * cos]);
+			const xs = corners.map((c) => c[0]);
+			const ys = corners.map((c) => c[1]);
+			links[k] = {
+				...link,
+				rect: [
+					Math.min(...xs),
+					Math.min(...ys),
+					Math.max(...xs),
+					Math.max(...ys)
+				]
+			};
+		}
+	};
 	const emitOneLine = (cmd) => {
+		if (cmd.rotationDeg && cmd.warp === void 0 && !settableInOneMatrix(cmd.line)) {
+			emitTurned(cmd);
+			return;
+		}
 		const line = cmd.line;
 		const originX = cmd.originX;
 		const baselineY = H - cmd.baselineY;
@@ -1397,6 +1460,19 @@ function rotateAboutCm(cx, cy, deg) {
 	const s = Math.sin(rad);
 	return `${formatNumber(c)} ${formatNumber(s)} ${formatNumber(-s)} ${formatNumber(c)} ${formatNumber(cx - cx * c + cy * s)} ${formatNumber(cy - cx * s - cy * c)} cm`;
 }
+/**
+* Whether a line is ONE text matrix and a run of glyphs: nothing in it placed
+* on its own — a tab, a stretched space, a picture, a formula, a right-to-left
+* run, a rise, a faked italic — and nothing drawn beside its glyphs, a run's
+* shading, a highlight or a rule. Only such a line can be turned by its matrix
+* alone; any other is placed token by token in page space.
+*
+* @param line The laid-out line.
+* @returns True when a single `Tm` sets the whole of it.
+*/
+function settableInOneMatrix(line) {
+	return computeJustifyExtra(line) === 0 && line.tokens.every((t) => t.kind === "text" && t.tab !== true && t.bidiLevel % 2 === 0 && t.risePt === void 0 && t.synthetic?.italic !== true && t.highlight !== true && t.resolvedRun.shadingColorHex === void 0 && t.resolvedRun.underline === "none" && !t.resolvedRun.strike);
+}
 function computeJustifyExtra(line) {
 	const alignment = line.resolved.alignment;
 	if (alignment !== "both" && alignment !== "distribute") return 0;

package/dist/esm/pdf-reader/annot-draw.js

@@ -1,4 +1,6 @@
-import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
+import { reorderVisual } from "../core/bidi/algorithm.js";
+import { analyzeString, hasBidiCharacters } from "../core/bidi/index.js";
 //#region src/pdf-reader/annot-draw.ts
 /** The circle constant: how far a Bézier handle reaches to round a quarter. */
 var KAPPA = .5523;
@@ -20,6 +22,7 @@ function drawnAppearance(file, annot) {
 	const subtype = file.get(annot, "Subtype");
 	if (!(subtype instanceof PdfName)) return void 0;
 	if (subtype.value === "Widget") return typedValue(file, annot) ?? checkedBox(file, annot);
+	if (subtype.value === "FreeText") return freeText(file, annot);
 	const markup = markupShape(file, annot, subtype.value);
 	if (markup) return markup;
 	const pen = borderWidth(file, annot);
@@ -162,6 +165,10 @@ var SQUIGGLE_AMP_EM = .07;
 */
 function drawnResources(file, annot) {
 	const subtype = file.get(annot, "Subtype");
+	if (subtype instanceof PdfName && subtype.value === "FreeText") {
+		const text = freeTextContents(file, annot);
+		return text === void 0 ? void 0 : new Map([["Font", new Map([[FREE_TEXT_FONT, spelledFace(text)]])]]);
+	}
 	if (!(subtype instanceof PdfName) || subtype.value !== "Widget") return void 0;
 	const acro = file.get(file.catalog, "AcroForm");
 	if (!(acro instanceof Map)) return void 0;
@@ -211,6 +218,91 @@ function typedValue(file, annot) {
 	ops.push("ET", "Q");
 	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(ops.join("\n")));
 }
+/**
+* §12.5.6.6 — a free-text annotation with no appearance: its contents, a line
+* to each line break, from the top of its `/Rect` in the size and colour its
+* `/DA` asks. Left undrawn the words were simply gone: bug1865341.pdf's one
+* note, "Załącznik", and nothing else on the page.
+*/
+function freeText(file, annot) {
+	const text = freeTextContents(file, annot);
+	const rect = rectangle(file.get(annot, "Rect"));
+	if (text === void 0 || !rect) return void 0;
+	const da = defaultAppearance(file, annot);
+	const box = inset(rect, 2);
+	const size = da.size > 0 ? da.size : 12;
+	const codes = codesOf(text);
+	const ops = [
+		"q",
+		"BT",
+		`/${FREE_TEXT_FONT} ${num(size)} Tf`,
+		`${da.color} rg`
+	];
+	text.split(/\r\n|[\r\n]/u).forEach((line, i) => {
+		const y = box[3] - size * (.8 + i * 1.16);
+		const hex = visualOrder(line).map((ch) => (codes.get(ch) ?? 0).toString(16).padStart(2, "0")).join("");
+		ops.push(`1 0 0 1 ${num(box[0])} ${num(y)} Tm`, `<${hex}> Tj`);
+	});
+	ops.push("ET", "Q");
+	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(ops.join("\n")));
+}
+/** UAX #9 — a line's characters in the order they stand on the page, left to right. */
+function visualOrder(line) {
+	const chars = [...line];
+	if (!hasBidiCharacters(line)) return chars;
+	const { levels } = analyzeString(line);
+	return reorderVisual(levels).map((i) => chars[i] ?? "");
+}
+/** The resource name the face of a drawn free-text annotation goes by. */
+var FREE_TEXT_FONT = "FreeText";
+/** §7.9.2.2 — an annotation's `/Contents`, decoded as the text string it is. */
+function freeTextContents(file, annot) {
+	const found = file.get(annot, "Contents");
+	const raw = found instanceof PdfHexString ? String.fromCharCode(...found.bytes) : typeof found === "string" ? found : void 0;
+	if (raw === void 0) return void 0;
+	const text = textString(raw).replace(/\s+$/u, "");
+	return text.length > 0 ? text : void 0;
+}
+/**
+* §7.9.2.2 — a text string's characters: UTF-16BE behind its byte-order mark,
+* UTF-8 behind its own, and otherwise one byte to a character.
+*/
+function textString(raw) {
+	if (raw.startsWith("þÿ")) {
+		let out = "";
+		for (let i = 2; i + 1 < raw.length; i += 2) out += String.fromCharCode(raw.charCodeAt(i) << 8 | raw.charCodeAt(i + 1));
+		return out;
+	}
+	if (raw.startsWith("")) return new TextDecoder("utf-8").decode(Uint8Array.from([...raw.slice(3)].map((c) => c.charCodeAt(0))));
+	return raw;
+}
+/**
+* A code for each character a text shows, in the order it first shows them —
+* so a simple face can set a text no standard encoding covers.
+*/
+function codesOf(text) {
+	const codes = /* @__PURE__ */ new Map();
+	for (const ch of text.replace(/[\r\n]/gu, "")) if (!codes.has(ch) && codes.size < 255) codes.set(ch, codes.size + 1);
+	return codes;
+}
+/**
+* The Helvetica a drawn free-text annotation is set in, its encoding spelling
+* each code's character out as a glyph name (`uni0142` for ł) — which is how
+* the text reads back as what it is.
+*/
+function spelledFace(text) {
+	const differences = [1];
+	for (const ch of codesOf(text).keys()) {
+		const cp = ch.codePointAt(0) ?? 32;
+		differences.push(new PdfName(`uni${cp.toString(16).toUpperCase().padStart(4, "0")}`));
+	}
+	return new Map([
+		["Type", new PdfName("Font")],
+		["Subtype", new PdfName("Type1")],
+		["BaseFont", new PdfName("Helvetica")],
+		["Encoding", new Map([["Differences", differences]])]
+	]);
+}
 /** §12.7.4.3 — the field is a multi-line text box (bit 13 of `/Ff`). */
 var MULTILINE = 4096;
 /**

package/dist/esm/pdf-reader/annots.d.ts

@@ -8,5 +8,23 @@ export interface Appearance {
     readonly ctm: Matrix;
     /** The appearance's `/Resources`, when it states its own. */
     readonly resources: PdfDict | undefined;
+    /** §8.10.1 — the form's `/BBox`, in its own space, which clips what it paints. */
+    readonly bbox?: readonly [number, number, number, number];
 }
+/**
+ * §8.10.1 — an appearance's content as it paints: clipped to its `/BBox`.
+ *
+ * The box is the form's clip, not a hint. A form-filling tool that wrote its
+ * field backgrounds in PAGE coordinates inside a box forty points wide paints
+ * them nowhere any viewer shows — and painted anyway, with the fill colour it
+ * never set, bug1669099.pdf's form came back with three black slabs over its
+ * letterhead and its terms of payment, each twice as far across the sheet as
+ * the field it belonged to. The clip is installed the way the content would
+ * install one, so every pass that reads the appearance sees the same page.
+ *
+ * @param file       The owning file.
+ * @param appearance The appearance.
+ * @returns Its content, preceded by the clip to its box where it has one.
+ */
+export declare function appearanceContent(file: PdfFile, appearance: Appearance): Uint8Array;
 export declare function collectPageAppearances(file: PdfFile, page: PdfPage): Array<Appearance>;

package/dist/esm/pdf-reader/annots.js

@@ -2,6 +2,32 @@ import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { IDENTITY, multiply } from "./content.js";
 import { drawnAppearance, drawnResources, textMarkupOf } from "./annot-draw.js";
 //#region src/pdf-reader/annots.ts
+/**
+* §8.10.1 — an appearance's content as it paints: clipped to its `/BBox`.
+*
+* The box is the form's clip, not a hint. A form-filling tool that wrote its
+* field backgrounds in PAGE coordinates inside a box forty points wide paints
+* them nowhere any viewer shows — and painted anyway, with the fill colour it
+* never set, bug1669099.pdf's form came back with three black slabs over its
+* letterhead and its terms of payment, each twice as far across the sheet as
+* the field it belonged to. The clip is installed the way the content would
+* install one, so every pass that reads the appearance sees the same page.
+*
+* @param file       The owning file.
+* @param appearance The appearance.
+* @returns Its content, preceded by the clip to its box where it has one.
+*/
+function appearanceContent(file, appearance) {
+	const data = file.streamData(appearance.stream);
+	const box = appearance.bbox;
+	if (!box) return data;
+	const [x0, y0, x1, y1] = box;
+	const clip = new TextEncoder().encode(`${String(x0)} ${String(y0)} ${String(x1 - x0)} ${String(y1 - y0)} re W n\n`);
+	const out = new Uint8Array(clip.length + data.length);
+	out.set(clip, 0);
+	out.set(data, clip.length);
+	return out;
+}
 /** §12.5.3 `/F` — the annotation is not painted at all. */
 var FLAG_HIDDEN = 2;
 var FLAG_NOVIEW = 32;
@@ -35,6 +61,7 @@ function collectPageAppearances(file, page) {
 	const annots = file.get(page.dict, "Annots");
 	if (!Array.isArray(annots)) return [];
 	const out = [];
+	const regenerate = needsAppearances(file);
 	for (const entry of annots) {
 		const annot = file.resolve(entry);
 		if (!(annot instanceof Map)) continue;
@@ -44,6 +71,18 @@ function collectPageAppearances(file, page) {
 		const flags = file.get(annot, "F");
 		if (typeof flags === "number" && (flags & FLAG_HIDDEN || flags & FLAG_NOVIEW)) continue;
 		const stream = normalAppearance(file, annot);
+		const typed = regenerate && isWidget(file, annot) ? drawnAppearance(file, annot) : void 0;
+		if (typed && typedField(file, annot)) {
+			const kept = stream ? withoutVariableText(file, stream) : void 0;
+			const rect = rectangle(file.get(annot, "Rect"));
+			if (kept && rect) out.push(fitted(file, kept, rect));
+			out.push({
+				stream: typed,
+				ctm: IDENTITY,
+				resources: drawnResources(file, annot)
+			});
+			continue;
+		}
 		if (!stream) {
 			const drawn = drawnAppearance(file, annot);
 			if (drawn) out.push({
@@ -55,17 +94,55 @@ function collectPageAppearances(file, page) {
 		}
 		const rect = rectangle(file.get(annot, "Rect"));
 		if (!rect) continue;
-		const matrix = matrixOf(file, stream.dict);
-		const bbox = rectangle(file.get(stream.dict, "BBox"));
-		const resources = file.get(stream.dict, "Resources");
-		out.push({
-			stream,
-			ctm: multiply(matrix, fitToRect(bbox, matrix, rect)),
-			resources: resources instanceof Map ? resources : void 0
-		});
+		out.push(fitted(file, stream, rect));
 	}
 	return out;
 }
+/** An appearance stream placed on its annotation's `/Rect` (§12.5.5). */
+function fitted(file, stream, rect) {
+	const matrix = matrixOf(file, stream.dict);
+	const bbox = rectangle(file.get(stream.dict, "BBox"));
+	const resources = file.get(stream.dict, "Resources");
+	return {
+		stream,
+		ctm: multiply(matrix, fitToRect(bbox, matrix, rect)),
+		resources: resources instanceof Map ? resources : void 0,
+		...bbox ? { bbox } : {}
+	};
+}
+/** §12.7.2 — whether the form asks the viewer to build its fields' appearances. */
+function needsAppearances(file) {
+	const acro = file.get(file.catalog, "AcroForm");
+	return acro instanceof Map && file.get(acro, "NeedAppearances") === true;
+}
+function isWidget(file, annot) {
+	const subtype = file.get(annot, "Subtype");
+	return subtype instanceof PdfName && subtype.value === "Widget";
+}
+/** Whether a widget belongs to a text field — `/FT /Tx`, on it or up its field tree. */
+function typedField(file, annot) {
+	let node = annot;
+	for (let depth = 0; node && depth < 32; depth++) {
+		const type = file.get(node, "FT");
+		if (type instanceof PdfName) return type.value === "Tx";
+		const parent = file.get(node, "Parent");
+		node = parent instanceof Map ? parent : void 0;
+	}
+	return false;
+}
+/**
+* §12.7.3.3 — an appearance with its variable text taken out: the part it
+* marks `/Tx BMC … EMC`, which is what a viewer rebuilds from the value.
+* bug1844583.pdf's stale appearance still reads "Dlrow Olleh" there, over a
+* field whose value is "Hello World".
+*/
+function withoutVariableText(file, stream) {
+	const stripped = new TextDecoder("latin1").decode(file.streamData(stream)).replace(/\/Tx\s+BMC[\s\S]*?EMC/gu, "");
+	const dict = new Map(stream.dict);
+	dict.delete("Filter");
+	dict.delete("DecodeParms");
+	return new PdfStream(dict, Uint8Array.from([...stripped].map((c) => c.charCodeAt(0))));
+}
 /** §12.5.5 `/AP` `/N` — the normal appearance, through `/AS` when it is a set. */
 function normalAppearance(file, annot) {
 	const ap = file.get(annot, "AP");
@@ -149,4 +226,4 @@ function rectangle(v) {
 	];
 }
 //#endregion
-export { collectPageAppearances };
+export { appearanceContent, collectPageAppearances };

package/dist/esm/pdf-reader/cff-outline.d.ts

@@ -32,5 +32,32 @@ export declare function cffNameToGid(program: Uint8Array): Map<string, number> |
  *          CID-keyed or cannot be read.
  */
 export declare function cffCidToGid(program: Uint8Array): Map<number, number> | undefined;
+/**
+ * How far the pen moves after a name-keyed CFF program's `space`, in
+ * thousandths of an em — the width a writer gives the space a page never
+ * showed, which is the one it was typeset with.
+ *
+ * @param program The raw CFF bytes.
+ * @returns The advance, or `undefined` where the program has no `space` or its
+ *          width cannot be read off the charstring.
+ */
+export declare function cffSpaceAdvance(program: Uint8Array): number | undefined;
+/**
+ * The embedding a CFF program's licence allows: CFF has no OS/2 table, and
+ * Adobe writes the OS/2 `fsType` into the Top DICT's `PostScript` string
+ * instead (TN 5176 §9, key 12 21) as `/FSType 8 def`.
+ *
+ * @param program The raw CFF bytes.
+ * @returns The value, or `undefined` where the program states none.
+ */
+export declare function cffFsType(program: Uint8Array): number | undefined;
+/**
+ * The `/FSType n def` a PostScript font program writes where an OpenType one
+ * has its OS/2 field (Adobe TN 5176 §9; a Type 1 font's `FontInfo` alike).
+ *
+ * @param text The PostScript to search.
+ * @returns The value, or `undefined` where the text states none.
+ */
+export declare function postScriptFsType(text: string): number | undefined;
 /** The `CFF ` table of an OpenType wrapper, where the program is one. */
 export declare function openTypeCff(program: Uint8Array): Uint8Array | undefined;