reamkit 1.29.0 → 1.31.0

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

@@ -2,13 +2,15 @@ import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
 import { FEATURES } from "../core/ir/features.js";
 import { collectEmbeddedFonts } from "./embedded-fonts.js";
+import { collectFaceFamilies } from "./font.js";
+import { displayOf, placeRuns, placeVectors, textFrameOf, wordsTurnOf } from "./display.js";
+import { ASCENDER, CARRIER_LINE_PT, buildFlowDoc, dedupeLosses, floatOntoSheet, imageBlock, paragraphBlock, paragraphFromRuns, sectionFromPdfPages, sectionOnSheet, shapeBlock, spaceAfter, withMeasuredMargins } from "./flow-build.js";
+import { faceOutlinesOf, kernedFaces, pageSpacing } from "./face-outlines.js";
 import { extractPageText } from "./text.js";
 import { collectPageVectors } from "./vector.js";
-import { displayOf, placeRuns, placeVectors } from "./display.js";
-import { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, sectionFromPdfPages, shapeBlock, withMeasuredMargins } from "./flow-build.js";
 import { collectPageImages } from "./images.js";
 import { markDrawnRules } from "./text-rules.js";
-import { endedParagraph } from "./layout.js";
+import { FOOTER_PART, HEADER_PART, endedParagraph, footerBand, numberedFrom, numberingOf, pageTextEdges, runningFoot, stepsBetweenWords } from "./layout.js";
 import { readStructTree } from "./struct-tree.js";
 //#region src/pdf-reader/tagged.ts
 var ASSUMED_CONTENT_WIDTH_PT = 468;
@@ -30,8 +32,15 @@ function reconstructTaggedPdf(file) {
 	const root = readStructTree(file);
 	if (!root) return void 0;
 	const pages = file.pages();
-	const shown = pages.map((page) => displayOf(page));
-	const placedRuns = pages.map((page, i) => placeRuns(extractPageText(file, page), shown[i]));
+	const sheets = pages.map((page) => displayOf(page));
+	const painted = /* @__PURE__ */ new Map();
+	const extracted = pages.map((page) => extractPageText(file, page, painted));
+	const spacing = pageSpacing(extracted);
+	const onSheets = extracted.map((runs, i) => placeRuns(runs, sheets[i]));
+	const worded = onSheets.filter((runs) => runs.some((r) => r.text.trim() !== ""));
+	const turned = worded.length > 0 && worded.every((runs) => wordsTurnOf(runs) === 270);
+	const shown = turned ? sheets.map((sheet) => textFrameOf(sheet)) : sheets;
+	const placedRuns = turned ? extracted.map((runs, i) => placeRuns(runs, shown[i])) : onSheets;
 	const vectorLosses = [];
 	const pageVectors = pages.map((page, i) => {
 		const lifted = collectPageVectors(file, page, collectPageImages(file, page).images.map((img) => ({
@@ -78,10 +87,14 @@ function reconstructTaggedPdf(file) {
 	const textOf = (node) => squash(node.mcids.map(({ page, mcid }) => runsOfMcid(page, mcid).map((r) => r.text).join("")).join(" "));
 	const spansOf = (node) => {
 		const spans = [];
-		node.mcids.forEach(({ page, mcid }, i) => {
-			if (i > 0) spans.push({ text: " " });
-			for (const run of runsOfMcid(page, mcid)) spans.push(spanOf(run));
-		});
+		let last;
+		for (const { page, mcid } of node.mcids) {
+			const runs = runsOfMcid(page, mcid);
+			const first = runs[0];
+			if (last !== void 0 && first !== void 0 && spacedApart(last, first)) spans.push(spaceAfter(spans[spans.length - 1]));
+			for (const run of runs) spans.push(spanOf(run));
+			last = runs[runs.length - 1] ?? last;
+		}
 		return spans;
 	};
 	/** One run as the span that carries everything the page showed it with. */
@@ -101,6 +114,23 @@ function reconstructTaggedPdf(file) {
 	});
 	const collectText = (node) => squash([textOf(node), ...node.children.map(collectText)].join(" "));
 	const setting = /* @__PURE__ */ new Map();
+	const pageOf = /* @__PURE__ */ new Map();
+	/** The highest baseline a page's own paragraphs stand on, page space (y up). */
+	const highestOf = (own) => {
+		const tops = own.flatMap((el) => {
+			const set = setting.get(el);
+			return set ? [set.top] : [];
+		});
+		return tops.length > 0 ? Math.max(...tops) : void 0;
+	};
+	/** The lowest baseline a page's own paragraphs reach, page space (y up). */
+	const lowestOf = (own) => {
+		const bottoms = own.flatMap((el) => {
+			const set = setting.get(el);
+			return set ? [set.bottom] : [];
+		});
+		return bottoms.length > 0 ? Math.min(...bottoms) : void 0;
+	};
 	/** The topmost and bottommost baseline under a node, and its largest face. */
 	function baselinesOf(node) {
 		let top;
@@ -156,8 +186,10 @@ function reconstructTaggedPdf(file) {
 			groups[groups.length - 1].push(line);
 			prev = line;
 		}
+		const ends = (spans) => /\s$/u.test(spans.at(-1)?.text ?? "");
+		const opens = (spans) => /^\s/u.test(spans[0]?.text ?? "");
 		return groups.map((g) => ({
-			spans: g.flatMap((l, i) => i > 0 ? [{ text: " " }, ...l.spans] : [...l.spans]),
+			spans: g.flatMap((l, i) => i > 0 && !ends(g[i - 1].spans) && !opens(l.spans) ? [spaceAfter(g[i - 1].spans.at(-1)), ...l.spans] : [...l.spans]),
 			set: {
 				top: g[0].y,
 				bottom: g[g.length - 1].y,
@@ -198,33 +230,48 @@ function reconstructTaggedPdf(file) {
 		}).filter((l) => l.spans.some((sp) => sp.text.trim().length > 0));
 	}
 	function emit(node, out) {
+		const on = (el) => {
+			const page = firstPageOf(node);
+			if (page !== void 0) pageOf.set(el, page);
+			return el;
+		};
 		if (node.type === "Table") {
 			const table = buildTable(node);
-			if (table) out.push(table);
+			if (table) out.push(on(table));
 			return;
 		}
 		if (node.type === "Figure") {
 			for (const img of imagesForNode(node)) {
 				emitted.add(img);
-				out.push(imageBlock(img, resources, node.alt));
+				out.push(on(imageBlock(img, resources, node.alt)));
 			}
 			return;
 		}
 		if (node.type === "LI") {
 			const text = collectText(node);
-			if (text.length > 0) out.push(paragraphBlock(text, void 0));
+			if (text.length > 0) out.push(on(paragraphBlock(text, void 0)));
 			return;
 		}
 		if (node.children.length === 0) {
 			if (textOf(node).length > 0) for (const part of settingsOf(node)) {
 				const el = paragraphFromRuns(part.spans, headingLevel(node.type));
 				setting.set(el, part.set);
-				out.push(el);
+				out.push(on(el));
 			}
 			return;
 		}
 		for (const child of node.children) emit(child, out);
 	}
+	/** The first page any marked content under a node stands on. */
+	function firstPageOf(node) {
+		let first;
+		const visit = (n) => {
+			for (const { page } of n.mcids) if (first === void 0 || page < first) first = page;
+			for (const child of n.children) visit(child);
+		};
+		visit(node);
+		return first;
+	}
 	function buildTable(tableNode) {
 		const raw = [];
 		const collectRows = (n) => {
@@ -288,9 +335,14 @@ function reconstructTaggedPdf(file) {
 			cells
 		};
 	}
-	const body = [];
-	emit(root, body);
-	spaceParagraphs(body, setting, shown[0]?.height ?? 0);
+	const named = [];
+	emit(root, named);
+	const byPage = pages.map(() => []);
+	let current = 0;
+	for (const el of named) {
+		current = Math.max(current, pageOf.get(el) ?? current);
+		byPage[current].push(el);
+	}
 	let zOrder = -1e6;
 	imageLosses.push(...vectorLosses);
 	pages.forEach((_page, index) => {
@@ -299,31 +351,104 @@ function reconstructTaggedPdf(file) {
 			top: shown[index].height
 		};
 		const taken = ruled[index]?.consumed;
+		const drawn = [];
 		for (const v of pageVectors[index] ?? []) {
 			if (taken?.has(v) === true) continue;
-			body.push(shapeBlock(v, frame, zOrder++, true));
+			const shape = shapeBlock(v, frame, zOrder++, true);
+			drawn.push(turned ? floatOntoSheet(shape, shown[index].height) : shape);
 		}
+		byPage[index].unshift(...drawn);
 	});
-	const orphans = [];
 	pageImages.forEach((p, page) => {
-		for (const img of p.images) if (!emitted.has(img)) orphans.push({
-			page,
-			img
-		});
+		const left = p.images.filter((img) => !emitted.has(img)).sort((a, b) => b.y - a.y);
+		byPage[page].push(...left.map((img) => imageBlock(img, resources)));
+	});
+	if (byPage.every((own) => own.length === 0)) return void 0;
+	const loose = placedRuns.map((runs, i) => shown[i].sheet ? [] : runs.filter((r) => !claimed.has(r)));
+	const foot = runningFoot(loose, shown, "foot");
+	const head = runningFoot(loose, shown, "head");
+	const numberedBand = foot?.numbered === true ? foot : head?.numbered === true ? head : void 0;
+	const numbering = numberingOf(numberedBand);
+	const lifted = (r, i) => foot?.lift[i]?.has(r) === true || head?.lift[i]?.has(r) === true;
+	const measured = withMeasuredMargins(sectionFromPdfPages(pages, shown[0]), shown, placedRuns.map((runs, i) => runs.filter((r) => !lifted(r, i))), pageImages.map((p) => p.images), foot?.band);
+	const body = [];
+	const top = measured?.margins?.top ?? 0;
+	const bottom = measured?.margins?.bottom ?? 0;
+	const ends = byPage.map((own) => lowestOf(own));
+	const tops = byPage.map((own) => highestOf(own));
+	const sectionsFrom = (numbering?.runs ?? []).map((run) => run.from).filter((from) => from > 0);
+	const endsAt = [];
+	let sectionFrom = 0;
+	byPage.forEach((own, index) => {
+		if (sectionsFrom.includes(index)) {
+			endsAt.push({
+				at: body.length,
+				from: sectionFrom
+			});
+			sectionFrom = index;
+		}
+		const height = shown[index]?.height ?? 0;
+		spaceParagraphs(own, setting, height);
+		const ended = ends[index - 1];
+		const opens = index > 0 && (own.length === 0 || ended === void 0 || ended - bottom > (height - top - bottom) * SHORT_PAGE_SHARE);
+		const lead = own.findIndex((el) => !floats(el));
+		const set = lead >= 0 ? setting.get(own[lead]) : void 0;
+		const fresh = index === 0 || opens || sectionsFrom.includes(index);
+		const highest = tops[index];
+		const first = set !== void 0 && highest !== void 0 && set.top >= highest - set.size;
+		if (fresh && first && measured?.margins) {
+			const gap = height - top - (set.top + set.size * ASCENDER);
+			if (gap > 1) own[lead] = spacedBefore(own[lead], gap);
+		}
+		if (opens && !sectionsFrom.includes(index)) body.push(pageBreak(true));
+		else if (index === 0 && own.length === 0 && pages.length > 1) body.push(pageBreak(false));
+		body.push(...own);
 	});
-	orphans.sort((a, b) => a.page - b.page || b.img.y - a.img.y);
-	for (const { img } of orphans) body.push(imageBlock(img, resources));
-	if (body.length === 0) return void 0;
 	if (placedRuns.some((page) => page.some((r) => r.text.includes("�")))) imageLosses.push({
 		severity: "dropped",
 		feature: FEATURES.text,
 		detail: "some glyphs map to no character — the font states no /ToUnicode and its program says nothing either, so that text is unrecoverable"
 	});
-	const onPage = placedRuns.flat().reduce((n, r) => n + r.text.length, 0);
+	const onPage = placedRuns.flatMap((runs, i) => runs.filter((r) => !lifted(r, i))).reduce((n, r) => n + r.text.length, 0);
 	const reached = [...claimed].reduce((n, r) => n + r.text.length, 0);
 	if (onPage > 0 && reached * 2 < onPage) return void 0;
+	endsAt.push({
+		at: body.length,
+		from: sectionFrom
+	});
+	const stepped0 = stepsBetweenWords(placedRuns[0] ?? []);
+	const edges0 = pageTextEdges(placedRuns[0] ?? []);
+	const numeralOf = (of) => {
+		if (of === void 0 || of !== numberedBand || numbering === void 0) return void 0;
+		const first = of.lift.findIndex((set) => set.size > 0);
+		return first >= 0 ? numbering.numbers[first]?.text : void 0;
+	};
+	const footBand = foot ? footerBand(foot.band, stepped0, edges0, foot.numbered, numeralOf(foot)) : [];
+	const headBand = head ? footerBand(head.band, stepped0, edges0, head.numbered, numeralOf(head)) : [];
+	const sectionAt = (from) => {
+		const base = sectionOnSheet(measured, shown[0]);
+		return base ? {
+			...base,
+			...numberedFrom(numbering, from),
+			...footBand.length > 0 ? { footers: [{
+				type: "default",
+				relationshipId: FOOTER_PART
+			}] } : {},
+			...headBand.length > 0 ? { headers: [{
+				type: "default",
+				relationshipId: HEADER_PART
+			}] } : {}
+		} : base;
+	};
+	const sections = endsAt.length > 1 ? endsAt.flatMap((end) => {
+		const properties = sectionAt(end.from);
+		return properties ? [{
+			properties,
+			endIndex: end.at
+		}] : [];
+	}) : [];
 	return {
-		doc: buildFlowDoc(body, resources, withMeasuredMargins(sectionFromPdfPages(pages), shown, placedRuns, pageImages.map((p) => p.images)), collectEmbeddedFonts(file, pages, imageLosses)),
+		doc: buildFlowDoc(body, resources, sectionAt(0), collectEmbeddedFonts(file, pages, imageLosses), sections, footBand.length > 0 || headBand.length > 0 ? new Map([...footBand.length > 0 ? [[FOOTER_PART, footBand]] : [], ...headBand.length > 0 ? [[HEADER_PART, headBand]] : []]) : void 0, collectFaceFamilies(file, pages), faceOutlinesOf(painted, spacing), kernedFaces(spacing)),
 		losses: imageLosses
 	};
 }
@@ -414,9 +539,63 @@ function equalGrid(raw) {
 		grid: Array.from({ length: numCols }, () => w)
 	};
 }
+/**
+* Whether the page shows a space between one run and the next: the second
+* starts another line, or stands clear of the first by more than a kern —
+* and neither already carries the space.
+*/
+function spacedApart(prev, next) {
+	if (/\s$/u.test(prev.text) || /^\s/u.test(next.text)) return false;
+	const size = Math.max(prev.fontSizePt, next.fontSizePt, 1);
+	if (Math.abs(prev.y - next.y) > size * .5) return true;
+	return next.x - prev.endX > size * MCID_SPACE_EM;
+}
+/** A gap between two stretches of marked content this wide, in ems, is a word space. */
+var MCID_SPACE_EM = .15;
 function squash(text) {
 	return text.replace(/\s+/g, " ").trim();
 }
+/**
+* How much of a page's text area the page may leave empty below its last line
+* and still be FULL: a page that ends higher than this ended on purpose.
+*/
+var SHORT_PAGE_SHARE = .25;
+/** Whether an element FLOATS — a drawing anchored to its page, which takes no room. */
+function floats(el) {
+	return el.kind === "image" && el.image.float !== void 0 || el.kind === "shape" && el.shape.float !== void 0;
+}
+/** A paragraph given the space the page left above it; anything else as it is. */
+function spacedBefore(el, before) {
+	if (el.kind !== "paragraph") return el;
+	const properties = {
+		...el.paragraph.properties,
+		spacingBefore: pt(before)
+	};
+	return {
+		...el,
+		paragraph: {
+			...el.paragraph,
+			properties
+		}
+	};
+}
+/**
+* An empty paragraph that takes no room: the carrier of a page break, or of
+* nothing at all on a blank first sheet the next page's break has to follow.
+*/
+function pageBreak(breaks) {
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: {
+				...breaks ? { pageBreakBefore: true } : {},
+				spacingLine: CARRIER_LINE_PT,
+				spacingLineRule: "exact"
+			},
+			runs: []
+		}
+	};
+}
 function headingLevel(type) {
 	const m = /^H([1-6])$/.exec(type);
 	return m ? Number(m[1]) - 1 : void 0;

package/dist/esm/pdf-reader/text-rules.js

@@ -95,7 +95,7 @@ var SAME_HEIGHT_PT = .5;
 * separate table rules is not.
 */
 function joinRules(vectors) {
-	const rules = vectors.filter((v) => isRule(v));
+	const rules = vectors.filter((v) => v.glyph !== true && isRule(v));
 	const byRow = /* @__PURE__ */ new Map();
 	for (const v of rules) {
 		const mid = (v.minY + v.maxY) / 2;

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

@@ -1,4 +1,5 @@
 import { ContentFont, TextRun } from './content.js';
+import { ShownCodes } from './face-outlines.js';
 import { PdfDict } from '../pdf/objects.js';
 import { PdfFile, PdfPage } from './document.js';
 /**
@@ -8,11 +9,13 @@ import { PdfFile, PdfPage } from './document.js';
  * origin falls inside a `/Link` annotation's `/Rect` with that link's URI (EP8)
  * so hyperlinks survive.
  *
- * @param file The owning {@link PdfFile}.
- * @param page The page to extract.
+ * @param file  The owning {@link PdfFile}.
+ * @param page  The page to extract.
+ * @param painted Where to gather the codes each font painted, for a caller
+ *                that embeds the faces (see `./face-outlines`).
  * @returns The page's runs, each carrying an `href` when it sits under a link.
  */
-export declare function extractPageText(file: PdfFile, page: PdfPage): Array<TextRun>;
+export declare function extractPageText(file: PdfFile, page: PdfPage, painted?: ShownCodes): Array<TextRun>;
 /**
  * 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

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

@@ -2,10 +2,11 @@ import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { buildColorSpaceMap, buildShadingMap } from "./shading.js";
 import { IDENTITY, interpretContent, multiply } from "./content.js";
 import { textMarkupOf } from "./annot-draw.js";
-import { collectPageAppearances } from "./annots.js";
-import { hiddenProperties, hiddenXObject } from "./optional-content.js";
+import { appearanceContent, collectPageAppearances } from "./annots.js";
 import { buildContentFont } from "./font.js";
-import { patternTint } from "./pattern-tint.js";
+import { hiddenProperties, hiddenXObject } from "./optional-content.js";
+import { addShown } from "./face-outlines.js";
+import { patternTint, tintedHex } from "./pattern-tint.js";
 //#region src/pdf-reader/text.ts
 var MAX_FORM_DEPTH = 8;
 /**
@@ -15,17 +16,24 @@ var MAX_FORM_DEPTH = 8;
 * origin falls inside a `/Link` annotation's `/Rect` with that link's URI (EP8)
 * so hyperlinks survive.
 *
-* @param file The owning {@link PdfFile}.
-* @param page The page to extract.
+* @param file  The owning {@link PdfFile}.
+* @param page  The page to extract.
+* @param painted Where to gather the codes each font painted, for a caller
+*                that embeds the faces (see `./face-outlines`).
 * @returns The page's runs, each carrying an `href` when it sits under a link.
 */
-function extractPageText(file, page) {
+function extractPageText(file, page, painted) {
 	const runs = [];
-	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs);
-	for (const appearance of collectPageAppearances(file, page)) collectRuns(file, appearance.resources ?? page.resources, file.streamData(appearance.stream), appearance.ctm, 1, new Set([appearance.stream]), runs);
+	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs, painted);
+	const own = runs.length;
+	for (const appearance of collectPageAppearances(file, page)) collectRuns(file, appearance.resources ?? page.resources, appearanceContent(file, appearance), appearance.ctm, 1, new Set([appearance.stream]), runs, painted);
+	for (let i = own; i < runs.length; i++) runs[i] = {
+		...runs[i],
+		annotation: true
+	};
 	const links = collectLinks(file, page);
 	const marks = collectTextMarkup(file, page);
-	const shown = withoutRestrikes(runs);
+	const shown = withAccentsComposed(withoutRestrikes(runs));
 	if (links.length === 0 && marks.length === 0) return shown;
 	return shown.flatMap((run) => {
 		const link = links.find((l) => inRect(run.x, run.y, l.rect));
@@ -163,6 +171,91 @@ function withoutRestrikes(runs) {
 }
 /** How near, in ems, a re-strike of the same text lands to the one it thickens. */
 var RESTRIKE_EM = .08;
+/**
+* §9.4.3 — an accent struck over a letter, composed with it.
+*
+* TeX sets an accented letter its font has no glyph for as two: the accent,
+* and the letter drawn back under it — "ï" is a dieresis and a dotless i.
+* Read as they come, comments.pdf's "naïve" came back "na¨ıve", the accent a
+* character of the word. A run that is one spacing accent, with the pen taken
+* back under it for the run after it, is the accent of that run's first letter
+* — or, where the accent was struck after its letter, of the last letter of the
+* run before it. The two are written as the one character Unicode composes them
+* into, a dotless i or j taking back its dot's place under the accent.
+*
+* @param runs The page's runs, in painting order.
+* @returns The runs with each such accent composed into its letter.
+*/
+function withAccentsComposed(runs) {
+	const out = [];
+	for (let i = 0; i < runs.length; i++) {
+		const run = runs[i];
+		const mark = ACCENTS.get(run.text);
+		const next = runs[i + 1];
+		const prev = out[out.length - 1];
+		if (mark !== void 0 && next !== void 0 && struckOver(run, next, "first")) {
+			const [first = "", ...rest] = [...next.text];
+			out.push({
+				...next,
+				text: accented(first, mark) + rest.join("")
+			});
+			i++;
+			continue;
+		}
+		if (mark !== void 0 && prev !== void 0 && struckOver(run, prev, "last")) {
+			const chars = [...prev.text];
+			const last = chars.pop() ?? "";
+			out[out.length - 1] = {
+				...prev,
+				text: chars.join("") + accented(last, mark)
+			};
+			continue;
+		}
+		out.push(run);
+	}
+	return out;
+}
+/**
+* Whether an accent stands over the first letter of a run (the pen taken back
+* under it) or over the last (the pen taken back to strike it): on one
+* baseline, give or take the lift an accent over a capital takes, and
+* overlapping it by more than a hair.
+*/
+function struckOver(accent, base, which) {
+	if (accent.angleDeg !== void 0 || base.angleDeg !== void 0) return false;
+	const size = base.fontSizePt || accent.fontSizePt || 10;
+	if (Math.abs(accent.y - base.y) > size * ACCENT_LIFT_EM) return false;
+	if (!/^\p{L}/u.test(which === "first" ? base.text : [...base.text].at(-1) ?? "")) return false;
+	const hair = size * ACCENT_OVERLAP_EM;
+	return which === "first" ? base.x < accent.endX - hair && base.x > accent.x - size : accent.x < base.endX - hair && accent.x > base.x;
+}
+/** A letter with an accent composed onto it: a dotless i or j takes back its dot's place. */
+function accented(letter, mark) {
+	return ((letter === "ı" ? "i" : letter === "ȷ" ? "j" : letter) + mark).normalize("NFC");
+}
+/** How far over the line, in ems, TeX lifts an accent to stand over a capital. */
+var ACCENT_LIFT_EM = .6;
+/** How far, in ems, an accent must overlap its letter to stand over it. */
+var ACCENT_OVERLAP_EM = .05;
+/** The spacing accents TeX strikes over a letter, and the combining marks they are. */
+var ACCENTS = new Map([
+	["`", "̀"],
+	["´", "́"],
+	["ˆ", "̂"],
+	["^", "̂"],
+	["˜", "̃"],
+	["~", "̃"],
+	["¯", "̄"],
+	["ˉ", "̄"],
+	["˘", "̆"],
+	["˙", "̇"],
+	["¨", "̈"],
+	["˚", "̊"],
+	["˝", "̋"],
+	["ˇ", "̌"],
+	["¸", "̧"],
+	["˛", "̨"]
+]);
 var spaceCache = /* @__PURE__ */ new WeakMap();
 /** The page's shading patterns, read once per resource dictionary. */
 var shadingCache = /* @__PURE__ */ new WeakMap();
@@ -182,14 +275,15 @@ function spacesOf(file, resources) {
 	spaceCache.set(resources, made);
 	return made;
 }
-function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
+function collectRuns(file, resources, content, baseCtm, depth, visiting, out, shown) {
 	const result = interpretContent(content, buildFonts(file, resources), baseCtm, shadingsOf(file, resources), void 0, spacesOf(file, resources), hiddenProperties(file, resources));
 	out.push(...result.texts.map((r) => withPatternColour(file, resources, r, visiting)));
+	if (shown) addShown(shown, result.shown);
 	if (depth >= MAX_FORM_DEPTH) return;
 	for (const glyph of result.glyphs) {
 		if (visiting.has(glyph.stream)) continue;
 		visiting.add(glyph.stream);
-		collectRuns(file, glyph.resources ?? resources, file.streamData(glyph.stream), glyph.ctm, depth + 1, visiting, out);
+		collectRuns(file, glyph.resources ?? resources, file.streamData(glyph.stream), glyph.ctm, depth + 1, visiting, out, shown);
 		visiting.delete(glyph.stream);
 	}
 	if (!resources) return;
@@ -203,7 +297,7 @@ function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
 		if (!(sub instanceof PdfName) || sub.value !== "Form") continue;
 		visiting.add(stream);
 		const formRes = file.get(stream.dict, "Resources");
-		collectRuns(file, formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, visiting, out);
+		collectRuns(file, formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, visiting, out, shown);
 		visiting.delete(stream);
 	}
 }
@@ -244,16 +338,6 @@ function withPatternColour(file, resources, run, visiting) {
 		visiting.delete(stream);
 	}
 }
-/** A colour laid over white paper at `coverage` strength, as a 6-hex string. */
-function tintedHex(colorHex, coverage) {
-	const k = Math.min(1, Math.max(0, coverage));
-	if (k >= 1) return colorHex;
-	const channel = (at) => {
-		const c = Number.parseInt(colorHex.slice(at, at + 2), 16);
-		return Math.round(255 - (255 - (Number.isFinite(c) ? c : 0)) * k).toString(16).toUpperCase().padStart(2, "0");
-	};
-	return `${channel(0)}${channel(2)}${channel(4)}`;
-}
 /**
 * 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

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

@@ -10,6 +10,17 @@ export interface Type1Font {
     readonly has: (name: string) => boolean;
     /** The program's own `/Encoding`: code → glyph name, where it states one. */
     readonly encoding?: ReadonlyMap<number, string>;
+    /**
+     * The embedding the program's licence allows — the OS/2 `fsType` Adobe
+     * writes into `FontInfo` as `/FSType`, where the program states one.
+     */
+    readonly fsType?: number;
+    /**
+     * §6.4 — how far the pen moves after a glyph, in thousandths of an em: the
+     * width its `hsbw` (or `sbw`) states. `undefined` where the program holds no
+     * such glyph or its charstring states no width first.
+     */
+    readonly advance: (name: string) => number | undefined;
 }
 /**
  * Read an embedded Type 1 program.