reamkit 1.33.2 → 1.34.0

package/dist/esm/layout/undrawn.d.ts

@@ -0,0 +1,18 @@
+import { Loss } from '../core/ir/index.js';
+import { LaidOutPage } from './page-doc.js';
+/**
+ * The characters the pages draw with no glyph, each once, in the order they
+ * first appear.
+ *
+ * @param pages The laid-out pages.
+ * @returns The code points, and the 1-based page each first appears on.
+ */
+export declare function undrawnCharacters(pages: ReadonlyArray<LaidOutPage>): Map<number, number>;
+/**
+ * The loss for the characters the pages draw as boxes, or `undefined` when
+ * every character has a glyph.
+ *
+ * @param pages The laid-out pages.
+ * @returns One loss that names the characters, at the page the first is on.
+ */
+export declare function undrawnLoss(pages: ReadonlyArray<LaidOutPage>): Loss | undefined;

package/dist/esm/layout/undrawn.js

@@ -0,0 +1,59 @@
+//#region src/layout/undrawn.ts
+/** How many of the characters a loss names before it only counts the rest. */
+var NAMED = 8;
+/**
+* The characters the pages draw with no glyph, each once, in the order they
+* first appear.
+*
+* @param pages The laid-out pages.
+* @returns The code points, and the 1-based page each first appears on.
+*/
+function undrawnCharacters(pages) {
+	const out = /* @__PURE__ */ new Map();
+	let pageNo = 0;
+	const readLine = (line) => {
+		for (const t of line.tokens) if (t.kind === "text") for (const ch of t.text) {
+			const cp = ch.codePointAt(0);
+			if (isControl(cp) || out.has(cp)) continue;
+			if (t.font.parsed.glyphForCodepoint(cp) === 0) out.set(cp, pageNo);
+		}
+		else if (t.kind === "math") for (const item of t.items) {
+			if (item.kind !== "glyph") continue;
+			for (const ch of item.text) {
+				const cp = ch.codePointAt(0);
+				if (isControl(cp) || out.has(cp)) continue;
+				if (item.font.parsed.glyphForCodepoint(cp) === 0) out.set(cp, pageNo);
+			}
+		}
+		else for (const text of t.metafile?.texts ?? []) readLine(text.line);
+	};
+	for (const page of pages) {
+		pageNo++;
+		for (const item of page.commands) if (item.type === "line") readLine(item.line);
+	}
+	return out;
+}
+/**
+* The loss for the characters the pages draw as boxes, or `undefined` when
+* every character has a glyph.
+*
+* @param pages The laid-out pages.
+* @returns One loss that names the characters, at the page the first is on.
+*/
+function undrawnLoss(pages) {
+	const undrawn = undrawnCharacters(pages);
+	if (undrawn.size === 0) return void 0;
+	const cps = [...undrawn.keys()];
+	return {
+		severity: "dropped",
+		feature: "text",
+		detail: `no available font has a glyph for ${cps.slice(0, NAMED).map((cp) => `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`).join(", ")}${cps.length > NAMED ? ` and ${cps.length - NAMED} more` : ""}; they are drawn as empty boxes and are missing from the text layer`,
+		where: `page ${undrawn.get(cps[0])}`
+	};
+}
+/** C0 and C1 controls: a line break or a tab is never drawn as a glyph. */
+function isControl(cp) {
+	return cp < 32 || cp >= 127 && cp < 160;
+}
+//#endregion
+export { undrawnCharacters, undrawnLoss };

package/dist/esm/pdf/cid-font.d.ts

@@ -10,6 +10,11 @@ export interface EmbedTtfOptions {
      * otherwise, since PDF/A-2/3 only constrain it when present).
      */
     readonly cidSet?: boolean;
+    /**
+     * The text of glyphs no character maps to — a conjunct, a reph, a vowel
+     * sign's contextual form — so that /ToUnicode names them too.
+     */
+    readonly glyphText?: ReadonlyMap<number, string>;
 }
 /** The result of {@link embedTtfFont}: the Type 0 font reference plus measurement/encoding helpers. */
 export interface EmbeddedFont {

package/dist/esm/pdf/cid-font.js

@@ -1,6 +1,7 @@
 import { glyphClosure, subsetTtf } from "../core/font/ttf-subset.js";
 import { lettersForLigature } from "../core/font/ligatures.js";
 import { createFontMeasure } from "../core/font/measure.js";
+import "../core/font/index.js";
 import { deflatedStream, dict, name, ref } from "./objects.js";
 //#region src/pdf/cid-font.ts
 var encoder = new TextEncoder();
@@ -57,7 +58,7 @@ function embedTtfFont(doc, parsed, options = {}) {
 		W: widthRuns.flatMap(([first, ws]) => [first, ws]),
 		CIDToGIDMap: name("Identity")
 	}));
-	const toUnicodeRef = doc.add(deflatedStream({}, buildToUnicodeCMap(parsed, subsetGids)));
+	const toUnicodeRef = doc.add(deflatedStream({}, buildToUnicodeCMap(parsed, subsetGids, options.glyphText)));
 	const type0Ref = doc.add(dict({
 		Type: name("Font"),
 		Subtype: name("Type0"),
@@ -126,7 +127,7 @@ function codeRank(cp) {
 	if (cp >= 64256 && cp <= 65023 || cp >= 65136 && cp <= 65279) return 1;
 	return 0;
 }
-function buildToUnicodeCMap(parsed, subsetGids) {
+function buildToUnicodeCMap(parsed, subsetGids, glyphText) {
 	const inSubset = subsetGids ? new Set(subsetGids) : void 0;
 	const gidToCps = /* @__PURE__ */ new Map();
 	const order = [];
@@ -169,6 +170,11 @@ function buildToUnicodeCMap(parsed, subsetGids) {
 			changed = true;
 		}
 	}
+	for (const [gid, text] of glyphText ?? []) {
+		if (gidToCps.has(gid)) continue;
+		gidToCps.set(gid, [...text].map((c) => c.codePointAt(0)));
+		order.push(gid);
+	}
 	const pairs = order.filter((g) => inSubset === void 0 || inSubset.has(g)).map((g) => [g, gidToCps.get(g)]).sort((a, b) => a[0] - b[0]);
 	const utf16beHex = (cps) => {
 		let hex = "";

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

@@ -7,7 +7,7 @@ import "../layout/styled-layout.js";
 import { BORDER_DASHES, FAUX_ITALIC_SHEAR, computeJustifyExtra, lineVisualOrder, settableInOneMatrix, washVeil } from "../layout/line-paint.js";
 import { emitClipPath, emitVectorShape, shadowBlurLayers } from "./vector-graphics.js";
 import { buildGradientAlphaMask, buildGradientPattern, shapeBbox } from "./shading.js";
-import { warpGlyphMatrix } from "../core/drawingml/text-warp.js";
+import { warpGlyphMatrix, warpGlyphRun } from "../core/drawingml/text-warp.js";
 import { sanitizeHref } from "../core/links.js";
 import { embedAssociatedFile } from "./embedded-file.js";
 import { buildSrgbIccProfile } from "./icc-profile.js";
@@ -523,7 +523,8 @@ function embedFontResources(doc, laid, pdfaProfile) {
 		if (res.gids.size === 0) continue;
 		out.set(variant, embedTtfFont(doc, res.parsed, {
 			usedGids: res.gids,
-			cidSet
+			cidSet,
+			...res.glyphText ? { glyphText: res.glyphText } : {}
 		}));
 	}
 	return out;
@@ -677,7 +678,52 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 	let lastColor = "";
 	let lastFauxWidth = 0;
 	let lastStroke;
+	let strokeFollowsFill = false;
 	let lastTz = 100;
+	/** A run's letter spacing, in the text space `Tz` scales (§9.4.4). */
+	const spacingOf = (tok) => {
+		const tz = Math.round((tok.synthetic?.widthScale ?? 1) * (tok.resolvedRun.widthScale ?? 1) * 100);
+		return (tok.resolvedRun.letterSpacingPt ?? 0) / (tz > 0 ? tz / 100 : 1);
+	};
+	/**
+	* The `rg` that makes `hex` the fill colour, when it is not already, and
+	* the `RG` with it while a faked bold strokes the glyphs in their own colour.
+	*/
+	const fillTo = (hex) => {
+		const ops = [];
+		const [r, g, b] = hexToRgb01(hex);
+		const rgb = `${formatNumber(r)} ${formatNumber(g)} ${formatNumber(b)}`;
+		if (hex !== lastColor) {
+			ops.push(`${rgb} rg`);
+			lastColor = hex;
+		}
+		if (strokeFollowsFill && hex !== lastStroke) {
+			ops.push(`${rgb} RG`);
+			lastStroke = hex;
+		}
+		return ops.length > 0 ? ops.join(" ") : void 0;
+	};
+	/**
+	* The show operators for a token's text, with what the Indic shaper needs
+	* passed on. A syllable a run boundary cut is drawn in its runs' colours: the
+	* fill colour switches between its glyphs, each glyph in the colour of the
+	* first character it stands for, and the text state is left in the last.
+	*
+	* @param colours Per code point of `text`, its colour (the token's own,
+	*                reversed with the text where it is).
+	*/
+	const showTextOf = (tok, text, colours = tok.charColorsHex) => {
+		const measure = tok.font.measure;
+		if (!measure.clustered(text)) return measure.showText(text);
+		const sources = colours ? measure.glyphSources(text) : void 0;
+		if (!colours || !sources) return measure.showText(text, tok.fontSizePt, spacingOf(tok));
+		const before = /* @__PURE__ */ new Map();
+		sources.forEach((s, i) => {
+			const op = fillTo(colours[s] ?? tok.resolvedRun.colorHex);
+			if (op !== void 0) before.set(i, op);
+		});
+		return measure.showText(text, tok.fontSizePt, spacingOf(tok), before);
+	};
 	const switchFontIfNeeded = (tok) => {
 		const fontKey = tok.font.resourceName;
 		if (fontKey !== lastFont || tok.fontSizePt !== lastSize) {
@@ -691,13 +737,11 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			out.push(fauxWidth > 0 ? `2 Tr ${formatNumber(fauxWidth)} w` : "0 Tr");
 			lastFauxWidth = fauxWidth;
 		}
-		const strokeHex = outline?.colorHex;
-		if (strokeHex !== lastStroke) {
-			if (strokeHex !== void 0) {
-				const [sr, sg, sb] = hexToRgb01(strokeHex);
-				out.push(`${formatNumber(sr)} ${formatNumber(sg)} ${formatNumber(sb)} RG`);
-			}
-			lastStroke = strokeHex;
+		strokeFollowsFill = outline === void 0 && fauxWidth > 0;
+		if (outline !== void 0 && outline.colorHex !== lastStroke) {
+			const [sr, sg, sb] = hexToRgb01(outline.colorHex);
+			out.push(`${formatNumber(sr)} ${formatNumber(sg)} ${formatNumber(sb)} RG`);
+			lastStroke = outline.colorHex;
 		}
 		const scale = (tok.synthetic?.widthScale ?? 1) * (tok.resolvedRun.widthScale ?? 1);
 		const tz = Math.round(scale * 100);
@@ -705,16 +749,13 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			out.push(`${formatNumber(tz)} Tz`);
 			lastTz = tz;
 		}
-		const tc = (tok.resolvedRun.letterSpacingPt ?? 0) / (tz > 0 ? tz / 100 : 1);
+		const tc = tok.font.measure.clustered(tok.text) ? 0 : spacingOf(tok);
 		if (tc !== lastTc) {
 			out.push(`${formatNumber(tc)} Tc`);
 			lastTc = tc;
 		}
-		if (tok.resolvedRun.colorHex !== lastColor) {
-			const [r, g, b] = hexToRgb01(tok.resolvedRun.colorHex);
-			out.push(`${formatNumber(r)} ${formatNumber(g)} ${formatNumber(b)} rg`);
-			lastColor = tok.resolvedRun.colorHex;
-		}
+		const fill = fillTo(tok.resolvedRun.colorHex);
+		if (fill !== void 0) out.push(fill);
 	};
 	const emitImageToken = (tok, x, baselineY) => {
 		const meta = tok.metafile;
@@ -1024,12 +1065,32 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		const hasImageToken = line.tokens.some((t) => t.kind === "image");
 		const hasMathToken = line.tokens.some((t) => t.kind === "math");
 		const hasRtl = line.tokens.some((t) => t.bidiLevel % 2 === 1);
-		const hasTab = line.tokens.some((t) => t.kind === "text" && t.tab === true);
+		const hasTab = line.tokens.some((t) => t.kind === "text" && (t.tab === true || t.listMarkerSpace === true));
 		/** A text token carrying underline or strikethrough. */
 		const isDecorated = (tok) => tok.kind === "text" && (tok.resolvedRun.underline !== "none" || tok.resolvedRun.strike);
 		const showToken = (tok) => {
-			const text = tok.bidiLevel % 2 === 1 ? reverseByCodePoint(tok.text) : tok.text;
-			return tok.font.measure.showText(text);
+			if (tok.bidiLevel % 2 === 0) return showTextOf(tok, tok.text);
+			return showTextOf(tok, reverseByCodePoint(tok.text), tok.charColorsHex?.slice().reverse());
+		};
+		const actualText = (tokens) => {
+			const open = tokens.map(() => "");
+			const close = tokens.map(() => false);
+			const shaped = (t) => t?.kind === "text" && !t.isSpace && t.tab !== true && t.font.measure.clustered(t.text);
+			for (let i = 0; i < tokens.length; i++) {
+				if (!shaped(tokens[i])) continue;
+				let j = i;
+				let text = "";
+				for (let t = tokens[j]; shaped(t); t = tokens[++j]) text += t.text;
+				let hex = "";
+				for (const b of unicodeString(text).bytes) hex += b.toString(16).padStart(2, "0");
+				open[i] = `/Span <</ActualText <${hex.toUpperCase()}>>> BDC`;
+				close[j - 1] = true;
+				i = j - 1;
+			}
+			return {
+				open,
+				close
+			};
 		};
 		if (line.tokens.some((t) => t.kind === "text" && t.resolvedRun.shadingColorHex)) {
 			if (inBT) {
@@ -1129,13 +1190,31 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 				out.push("BT");
 				inBT = true;
 			}
+			const placeGlyph = (m) => `${formatNumber(m[0])} ${formatNumber(-m[1])} ${formatNumber(m[2])} ${formatNumber(-m[3])} ${formatNumber(m[4])} ${formatNumber(H - m[5])} Tm`;
+			const at = actualText(line.tokens);
 			let cursor = originX;
-			for (const tok of line.tokens) {
+			for (let ti = 0; ti < line.tokens.length; ti++) {
+				const tok = line.tokens[ti];
 				if (tok.kind !== "text" || tok.isSpace) {
 					cursor += tok.widthPt;
 					continue;
 				}
 				switchFontIfNeeded(tok);
+				if (tok.font.measure.clustered(tok.text)) {
+					if (at.open[ti]) out.push(at.open[ti] ?? "");
+					const glyphs = warpGlyphRun(warp, tok.font.measure.glyphRun(tok.text), cursor, tok.widthPt, tok.fontSizePt / tok.font.parsed.unitsPerEm, cmd.baselineY);
+					const colours = tok.charColorsHex;
+					const sources = colours ? tok.font.measure.glyphSources(tok.text) : void 0;
+					for (const g of glyphs) {
+						const fill = sources ? fillTo(colours?.[sources[g.index]] ?? tok.resolvedRun.colorHex) : void 0;
+						if (fill !== void 0) out.push(fill);
+						out.push(placeGlyph(g.matrix));
+						out.push(`<${g.gid.toString(16).padStart(4, "0").toUpperCase()}> Tj`);
+					}
+					if (at.close[ti]) out.push("EMC");
+					cursor += tok.widthPt;
+					continue;
+				}
 				const chars = [...tok.text];
 				const raw = chars.map((c) => tok.font.measure.textWidthPt(c, tok.fontSizePt));
 				const total = raw.reduce((a, b) => a + b, 0);
@@ -1145,7 +1224,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 					const m = warpGlyphMatrix(warp, cursor, adv, cmd.baselineY);
 					cursor += adv;
 					if (!m) continue;
-					out.push(`${formatNumber(m[0])} ${formatNumber(-m[1])} ${formatNumber(m[2])} ${formatNumber(-m[3])} ${formatNumber(m[4])} ${formatNumber(H - m[5])} Tm`);
+					out.push(placeGlyph(m));
 					out.push(tok.font.measure.showText(chars[i]));
 				}
 			}
@@ -1160,16 +1239,20 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			const cos = formatNumber(Math.cos(rad));
 			const sin = formatNumber(Math.sin(rad));
 			out.push(`${cos} ${sin} ${formatNumber(-Math.sin(rad))} ${cos} ${formatNumber(originX)} ${formatNumber(baselineY)} Tm`);
-			for (const tok of line.tokens) {
-				if (tok.kind !== "text") continue;
+			const at = actualText(line.tokens);
+			line.tokens.forEach((tok, i) => {
+				if (tok.kind !== "text") return;
 				switchFontIfNeeded(tok);
-				out.push(tok.font.measure.showText(tok.text));
-			}
+				if (at.open[i]) out.push(at.open[i] ?? "");
+				out.push(showTextOf(tok, tok.text));
+				if (at.close[i]) out.push("EMC");
+			});
 		} else if (extraPerSpace !== 0 || hasImageToken || hasMathToken || hasRtl || hasRise || hasFauxItalic || hasTab) {
 			const order = hasRtl ? lineVisualOrder(line) : line.tokens.map((_, i) => i);
+			const at = actualText(order.map((i) => line.tokens[i]));
 			let x = originX;
-			for (const ti of order) {
-				const tok = line.tokens[ti];
+			for (let oi = 0; oi < order.length; oi++) {
+				const tok = line.tokens[order[oi]];
 				if (tok.kind === "image") {
 					flushLink();
 					emitImageToken(tok, x, baselineY);
@@ -1189,7 +1272,9 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 				switchFontIfNeeded(tok);
 				const slant = tok.synthetic?.italic === true ? FAUX_ITALIC_SHEAR : 0;
 				out.push(`1 0 ${formatNumber(slant)} 1 ${formatNumber(x)} ${formatNumber(baselineY + (tok.risePt ?? 0))} Tm`);
+				if (at.open[oi]) out.push(at.open[oi] ?? "");
 				out.push(showToken(tok));
+				if (at.close[oi]) out.push("EMC");
 				const tokenX0 = x;
 				x += tok.widthPt;
 				if (tok.isSpace) x += extraPerSpace;
@@ -1202,11 +1287,15 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 				inBT = true;
 			}
 			out.push(`1 0 0 1 ${formatNumber(originX)} ${formatNumber(baselineY)} Tm`);
+			const at = actualText(line.tokens);
 			let x = originX;
-			for (const tok of line.tokens) {
+			for (let i = 0; i < line.tokens.length; i++) {
+				const tok = line.tokens[i];
 				if (tok.kind !== "text") continue;
 				switchFontIfNeeded(tok);
-				out.push(tok.font.measure.showText(tok.text));
+				if (at.open[i]) out.push(at.open[i] ?? "");
+				out.push(showTextOf(tok, tok.text));
+				if (at.close[i]) out.push("EMC");
 				trackLink(tok.href, tok.anchor, tok.text, x, x + tok.widthPt);
 				x += tok.widthPt;
 			}

package/dist/esm/pdf/text-page-renderer.js

@@ -1,3 +1,4 @@
+import "../core/font/index.js";
 import "./objects.js";
 import "./cid-font.js";
 import "./writer.js";

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

@@ -423,7 +423,7 @@ export type Matrix = readonly [number, number, number, number, number, number];
 export declare const IDENTITY: Matrix;
 /** Compose two {@link Matrix matrices}: `a` applied first, then `b`. */
 export declare function multiply(a: Matrix, b: Matrix): Matrix;
-export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, PageGradient>, alphas?: ReadonlyMap<string, GsPaint>, spaces?: ReadonlyMap<string, ColorSpaceInfo>, hiddenOc?: ReadonlySet<string>): InterpretResult;
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, PageGradient>, alphas?: ReadonlyMap<string, GsPaint>, spaces?: ReadonlyMap<string, ColorSpaceInfo>, hiddenOc?: ReadonlySet<string>, actualTexts?: ReadonlyMap<string, string>): InterpretResult;
 /**
  * Whether a string is wholly right-to-left: at least one letter of an RTL
  * script and nothing of any other, spaces and joiners aside.

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

@@ -2,6 +2,7 @@ import { PDF_NULL, PdfHexString, PdfName } from "../pdf/objects.js";
 import { bidiClass } from "../core/bidi/char-types.js";
 import { reorderVisual } from "../core/bidi/algorithm.js";
 import { analyzeString, hasBidiCharacters } from "../core/bidi/index.js";
+import { pdfTextString } from "./encodings.js";
 import { Lexer } from "./lexer.js";
 import { cmykHex, dashLengths, grayHex, rgbHex, spaceColor } from "./shading.js";
 //#region src/pdf-reader/content.ts
@@ -184,7 +185,7 @@ function midGradient(gradient) {
 function colorOfOperands(operands, space) {
 	return spaceColor(operands.filter((o) => typeof o === "number"), space);
 }
-function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__PURE__ */ new Map(), alphas = /* @__PURE__ */ new Map(), spaces = /* @__PURE__ */ new Map(), hiddenOc = /* @__PURE__ */ new Set()) {
+function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__PURE__ */ new Map(), alphas = /* @__PURE__ */ new Map(), spaces = /* @__PURE__ */ new Map(), hiddenOc = /* @__PURE__ */ new Set(), actualTexts = /* @__PURE__ */ new Map()) {
 	const runs = [];
 	const images = [];
 	const vectors = [];
@@ -206,6 +207,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 	const ocStack = [];
 	let hiddenDepth = 0;
 	const visible = () => hiddenDepth === 0;
+	let replacing;
 	const toPage = (x, y) => [x * state.ctm[0] + y * state.ctm[2] + state.ctm[4], x * state.ctm[1] + y * state.ctm[3] + state.ctm[5]];
 	const moveTo = (x, y) => {
 		const [px, py] = toPage(x, y);
@@ -379,17 +381,20 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			if (!set) codesShown.set(state.font, set = /* @__PURE__ */ new Set());
 			for (const code of codes) set.add(code);
 		}
-		return state.font.decode(codes);
+		return {
+			text: state.font.decode(codes),
+			glyphs: codes.length
+		};
 	};
 	const emitAt = (origin, shown, end) => {
-		const text = logicalOrder(shown);
-		if (text.length === 0) return;
+		const text = replacing ? "" : logicalOrder(shown.text);
+		if (replacing ? shown.glyphs === 0 : text.length === 0) return;
 		const scaleY = Math.hypot(origin[2], origin[3]) || 1;
 		const scaleX = (Math.hypot(origin[0], origin[1]) || 1) * state.hScale;
 		const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
 		const angle = Math.atan2(origin[1], origin[0]) * 180 / Math.PI;
 		if (!visible()) return;
-		runs.push({
+		const run = {
 			text,
 			x: origin[4],
 			y: origin[5],
@@ -413,19 +418,36 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			...state.font.italic ? { italic: true } : {},
 			colorHex: state.fillGradient ? midGradient(state.fillGradient) : state.fillColor,
 			...mcid !== void 0 ? { mcid } : {}
+		};
+		if (replacing) {
+			replacing.first ??= run;
+			replacing.endX = end[4];
+			replacing.endY = end[5];
+		} else runs.push(run);
+	};
+	const closeReplacement = () => {
+		const open = replacing;
+		replacing = void 0;
+		if (!open?.first || open.text.length === 0) return;
+		outlines.splice(open.outlinesFrom);
+		runs.push({
+			...open.first,
+			text: open.text.replace(/[\t\n\v\f\r]/gu, " "),
+			endX: open.endX ?? open.first.endX,
+			endY: open.endY ?? open.first.endY
 		});
 	};
 	const showString = (operand) => {
 		const origin = multiply(tm, state.ctm);
-		const text = consume(operand);
-		emitAt(origin, text, multiply(tm, state.ctm));
+		const shown = consume(operand);
+		emitAt(origin, shown, multiply(tm, state.ctm));
 	};
 	const showArray = (arr) => {
 		for (const el of arr) if (typeof el === "number") tm = multiply(translation(-el / 1e3 * state.fontSize * state.hScale, 0), tm);
 		else if (typeof el === "string" || el instanceof PdfHexString) {
 			const origin = multiply(tm, state.ctm);
-			const text = consume(el);
-			emitAt(origin, text, multiply(tm, state.ctm));
+			const shown = consume(el);
+			emitAt(origin, shown, multiply(tm, state.ctm));
 		}
 	};
 	const exec = (op) => {
@@ -507,20 +529,32 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			case "BDC": {
 				const tag = operands[operands.length - 2];
 				const props = operands[operands.length - 1];
-				const mcidVal = !(tag instanceof PdfName && tag.value === "Artifact") && props instanceof Map ? props.get("MCID") : void 0;
-				mcStack.push(typeof mcidVal === "number" ? mcidVal : void 0);
+				const isArtifact = tag instanceof PdfName && tag.value === "Artifact";
+				const mcidVal = !isArtifact && props instanceof Map ? props.get("MCID") : void 0;
+				mcStack.push(typeof mcidVal === "number" ? mcidVal : isArtifact ? void 0 : mcStack[mcStack.length - 1]);
+				const own = props instanceof Map ? props.get("ActualText") : void 0;
+				const actual = typeof own === "string" || own instanceof PdfHexString ? pdfTextString(toBytes(own)) : props instanceof PdfName ? actualTexts.get(props.value) : void 0;
+				if (actual !== void 0 && replacing === void 0) replacing = {
+					text: actual,
+					depth: mcStack.length - 1,
+					outlinesFrom: outlines.length
+				};
 				const isOc = tag instanceof PdfName && tag.value === "OC" && props instanceof PdfName && hiddenOc.has(props.value);
 				ocStack.push(isOc);
 				if (isOc) hiddenDepth++;
 				break;
 			}
-			case "BMC":
-				mcStack.push(void 0);
+			case "BMC": {
+				const tag = operands[operands.length - 1];
+				const isArtifact = tag instanceof PdfName && tag.value === "Artifact";
+				mcStack.push(isArtifact ? void 0 : mcStack[mcStack.length - 1]);
 				ocStack.push(false);
 				break;
+			}
 			case "EMC":
 				mcStack.pop();
 				if (ocStack.pop() === true) hiddenDepth--;
+				if (replacing && mcStack.length <= replacing.depth) closeReplacement();
 				break;
 			case "Do": {
 				const nm = operands[0];
@@ -747,6 +781,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			default: operands = [];
 		}
 	}
+	closeReplacement();
 	return {
 		texts: runs,
 		images,

package/dist/esm/pdf-reader/embedded-fonts.js

@@ -1,5 +1,6 @@
 import { parseTtf } from "../core/font/ttf-parser.js";
 import { FontRegistry } from "../core/font/font-registry.js";
+import "../core/font/index.js";
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { FEATURES } from "../core/ir/features.js";
 //#region src/pdf-reader/embedded-fonts.ts

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

@@ -31,3 +31,12 @@ export declare function macGlyphName(index: number): string | undefined;
  * @param baseFont The name as the font dictionary states it.
  */
 export declare function isStandardLatinFace(baseFont: string): boolean;
+/**
+ * §7.9.2.2 — the characters of a text string: UTF-16BE behind its byte-order
+ * mark, UTF-8 behind its own (PDF 2.0), and otherwise PDFDocEncoding, one byte
+ * to a character.
+ *
+ * @param bytes The string's bytes, as written literal or in hex.
+ * @returns The text it stands for.
+ */
+export declare function pdfTextString(bytes: Uint8Array): string;

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

@@ -128,5 +128,70 @@ function macGlyphName(index) {
 function isStandardLatinFace(baseFont) {
 	return STANDARD_LATIN_FACES.has(baseFont.trim().replace(/^[A-Za-z]{6}\+/u, "").toLowerCase());
 }
+var PDF_DOC = new Map([
+	...[
+		728,
+		711,
+		710,
+		729,
+		733,
+		731,
+		730,
+		732
+	].map((cp, i) => [24 + i, cp]),
+	...[
+		8226,
+		8224,
+		8225,
+		8230,
+		8212,
+		8211,
+		402,
+		8260,
+		8249,
+		8250,
+		8722,
+		8240,
+		8222,
+		8220,
+		8221,
+		8216,
+		8217,
+		8218,
+		8482,
+		64257,
+		64258,
+		321,
+		338,
+		352,
+		376,
+		381,
+		305,
+		322,
+		339,
+		353,
+		382
+	].map((cp, i) => [128 + i, cp]),
+	[160, 8364]
+]);
+/**
+* §7.9.2.2 — the characters of a text string: UTF-16BE behind its byte-order
+* mark, UTF-8 behind its own (PDF 2.0), and otherwise PDFDocEncoding, one byte
+* to a character.
+*
+* @param bytes The string's bytes, as written literal or in hex.
+* @returns The text it stands for.
+*/
+function pdfTextString(bytes) {
+	if (bytes[0] === 254 && bytes[1] === 255) {
+		let out = "";
+		for (let i = 2; i + 1 < bytes.length; i += 2) out += String.fromCharCode(bytes[i] << 8 | bytes[i + 1]);
+		return out;
+	}
+	if (bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) return new TextDecoder("utf-8").decode(bytes.subarray(3));
+	let out = "";
+	for (const b of bytes) out += String.fromCodePoint(PDF_DOC.get(b) ?? b);
+	return out;
+}
 //#endregion
-export { baseEncodingTable, isStandardLatinFace, macGlyphName, standardEncodingTable, winAnsiLatinName };
+export { baseEncodingTable, isStandardLatinFace, macGlyphName, pdfTextString, standardEncodingTable, winAnsiLatinName };

package/dist/esm/pdf-reader/face-outlines.js

@@ -1,4 +1,5 @@
 import { editableEmbedding } from "../core/font/ttf-build.js";
+import "../core/font/index.js";
 import { isRightToLeft } from "./content.js";
 import { ASCENDER, NATURAL_LINE_EM } from "./flow-build.js";
 //#region src/pdf-reader/face-outlines.ts

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

@@ -16,6 +16,16 @@ import { PdfFile, PdfPage } from './document.js';
  * @returns The page's runs, each carrying an `href` when it sits under a link.
  */
 export declare function extractPageText(file: PdfFile, page: PdfPage, painted?: ShownCodes): Array<TextRun>;
+/**
+ * §14.9.4 — the replacement text of each property list the page's
+ * `/Properties` names: the content says `/Span /P1 BDC` and the `/ActualText`
+ * is in the resources, not in the stream.
+ *
+ * @param file      The owning file.
+ * @param resources The resource dictionary in force.
+ * @returns Name → the text, for the lists that hold one.
+ */
+export declare function actualTextsOf(file: PdfFile, resources: PdfDict | undefined): Map<string, string>;
 /**
  * The `/Font` resources of one dictionary, built into interpreter fonts. Shared
  * with the path and picture walks, which need them for one thing only: a Type 3