reamkit 1.25.1 → 1.27.0

package/dist/esm/pdf-reader/embedded-fonts.d.ts

@@ -1,5 +1,6 @@
 import { PdfDict } from '../pdf/objects.js';
 import { PdfFile, PdfPage } from './document.js';
+import { Loss } from '../core/ir/index.js';
 import { FontRegistry } from '../core/font/index.js';
 /**
  * Every embedded TrueType program the pages use, by the name a run will ask for
@@ -15,11 +16,19 @@ import { FontRegistry } from '../core/font/index.js';
  * (`/FontFile`) are different formats that the layout's parser does not take;
  * those keep their substitute.
  *
- * @param file  The owning file.
- * @param pages The pages whose fonts are wanted.
+ * And only one whose OUTLINES this pipeline can carry: a program with no
+ * `glyf`/`loca` cannot be subset, and a face offered here is one the writer
+ * will be asked to embed. bug1186827.pdf ships an OpenType/CFF program under
+ * `/FontFile2`, which parses like any other and then killed the whole
+ * conversion — "Subsetting requires a TrueType font with glyf+loca tables" —
+ * rather than losing one face.
+ *
+ * @param file   The owning file.
+ * @param pages  The pages whose fonts are wanted.
+ * @param losses Appended to for a face the page embeds and this cannot carry.
  * @returns Name → a one-face registry holding that program.
  */
-export declare function collectEmbeddedFonts(file: PdfFile, pages: ReadonlyArray<PdfPage>): Map<string, FontRegistry>;
+export declare function collectEmbeddedFonts(file: PdfFile, pages: ReadonlyArray<PdfPage>, losses?: Array<Loss>): Map<string, FontRegistry>;
 /**
  * The name a run set in `fontDict` will ask for: its `/BaseFont` without the
  * six-capital subset prefix (§9.6.4), lowercased.

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

@@ -1,5 +1,7 @@
+import { parseTtf } from "../core/font/ttf-parser.js";
 import { FontRegistry } from "../core/font/font-registry.js";
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { FEATURES } from "../core/ir/features.js";
 //#region src/pdf-reader/embedded-fonts.ts
 var MAX_FORM_DEPTH = 8;
 /**
@@ -16,11 +18,19 @@ var MAX_FORM_DEPTH = 8;
 * (`/FontFile`) are different formats that the layout's parser does not take;
 * those keep their substitute.
 *
-* @param file  The owning file.
-* @param pages The pages whose fonts are wanted.
+* And only one whose OUTLINES this pipeline can carry: a program with no
+* `glyf`/`loca` cannot be subset, and a face offered here is one the writer
+* will be asked to embed. bug1186827.pdf ships an OpenType/CFF program under
+* `/FontFile2`, which parses like any other and then killed the whole
+* conversion — "Subsetting requires a TrueType font with glyf+loca tables" —
+* rather than losing one face.
+*
+* @param file   The owning file.
+* @param pages  The pages whose fonts are wanted.
+* @param losses Appended to for a face the page embeds and this cannot carry.
 * @returns Name → a one-face registry holding that program.
 */
-function collectEmbeddedFonts(file, pages) {
+function collectEmbeddedFonts(file, pages, losses) {
 	const out = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
 	const visiting = /* @__PURE__ */ new Set();
@@ -32,6 +42,15 @@ function collectEmbeddedFonts(file, pages) {
 		const program = fontProgram(file, fontDict);
 		if (!program) return;
 		try {
+			const parsed = parseTtf(program);
+			if (!parsed.tables.has("glyf") || !parsed.tables.has("loca")) {
+				losses?.push({
+					severity: "degraded",
+					feature: FEATURES.text,
+					detail: `embedded font ${name} has no TrueType outlines (a CFF program under /FontFile2); its text is re-set in a substitute face`
+				});
+				return;
+			}
 			out.set(name, FontRegistry.fromBytes({ regular: program }));
 		} catch {}
 	};

package/dist/esm/pdf-reader/flow-build.d.ts

@@ -1,10 +1,12 @@
-import { BodyElement, SectionProperties, TextOutline } from '../core/document-model/index.js';
+import { BodyElement, ParagraphProperties, SectionProperties, TextOutline } from '../core/document-model/index.js';
 import { FlowDoc } from '../core/ir/flow.js';
 import { FontRegistry } from '../core/font/index.js';
 import { Loss, ResourceStore } from '../core/ir/index.js';
 import { PdfImage } from './images.js';
 import { PdfPage } from './document.js';
 import { PdfVector } from './vector.js';
+import { TextMarkup } from './annot-draw.js';
+import { TextRun } from './content.js';
 /**
  * A reconstruction's document plus the losses incurred reading it (e.g. an
  * undecodable image colour space) — surfaced through the reader's `LossReport`.
@@ -49,6 +51,8 @@ export interface TextSpan {
     readonly bold?: boolean;
     /** §9.8.1 — the face was a slanted one. */
     readonly italic?: boolean;
+    /** §12.5.6.10 — a text-markup annotation marks these words. */
+    readonly markup?: TextMarkup;
 }
 /**
  * Build a paragraph {@link BodyElement} from positioned {@link TextSpan}s,
@@ -56,13 +60,13 @@ export interface TextSpan {
  * survives as its own run) and squashing whitespace. With no hrefs this
  * collapses to a single run — the same shape {@link paragraphBlock} produces.
  */
-export declare function paragraphFromRuns(spans: ReadonlyArray<TextSpan>, outlineLevel?: number): BodyElement;
+export declare function paragraphFromRuns(spans: ReadonlyArray<TextSpan>, outlineLevel?: number, placement?: Pick<ParagraphProperties, 'alignment' | 'spacingBefore'>): BodyElement;
 /**
  * Store a {@link PdfImage}'s bytes (content-addressed dedup) and build the image
  * {@link BodyElement} that references them, sized in points from the placement
  * CTM. `alt` becomes the block's alt text when given.
  */
-export declare function imageBlock(image: PdfImage, resources: ResourceStore, alt?: string, frame?: PageFrame, zOrder?: number): BodyElement;
+export declare function imageBlock(image: PdfImage, resources: ResourceStore, alt?: string, frame?: PageFrame, zOrder?: number, behind?: boolean): BodyElement;
 /**
  * A line of text as an anchored box, standing where the page set it.
  *
@@ -100,7 +104,7 @@ export declare function dedupeLosses(losses: ReadonlyArray<Loss>): Array<Loss>;
  * a paragraph: 22060_A1_01_Plans.pdf is one A3 sheet of vectors, and stacking
  * its forty-nine paths one under another spilled it onto a second page.
  */
-export declare function shapeBlock(v: PdfVector, frame?: PageFrame, zOrder?: number): BodyElement;
+export declare function shapeBlock(v: PdfVector, frame?: PageFrame, zOrder?: number, behind?: boolean): BodyElement;
 /**
  * Derive the {@link SectionProperties} geometry from the source pages so a
  * reconstructed PDF re-renders at its real page size and orientation rather than
@@ -113,6 +117,10 @@ export declare function shapeBlock(v: PdfVector, frame?: PageFrame, zOrder?: num
  * `A4`. Returns `undefined` when there is no usable first-page box.
  */
 export declare function sectionFromPdfPages(pages: ReadonlyArray<PdfPage>): SectionProperties | undefined;
+export declare function withMeasuredMargins(section: SectionProperties | undefined, shown: ReadonlyArray<{
+    width: number;
+    height: number;
+}>, pageRuns: ReadonlyArray<ReadonlyArray<TextRun>>): SectionProperties | undefined;
 /**
  * Assemble the final {@link FlowDoc} for a reconstruction: the body elements
  * with their styles resolved against the empty style sheet, the lifted-image

package/dist/esm/pdf-reader/flow-build.js

@@ -27,11 +27,11 @@ function paragraphBlock(text, outlineLevel) {
 * survives as its own run) and squashing whitespace. With no hrefs this
 * collapses to a single run — the same shape {@link paragraphBlock} produces.
 */
-function paragraphFromRuns(spans, outlineLevel) {
+function paragraphFromRuns(spans, outlineLevel, placement) {
 	const merged = [];
 	for (const s of spans) {
 		const last = merged[merged.length - 1];
-		if (last && last.href === s.href && last.sizePt === s.sizePt && last.colorHex === s.colorHex && last.fontName === s.fontName && last.outline?.colorHex === s.outline?.colorHex && last.outline?.widthPt === s.outline?.widthPt && last.bold === s.bold && last.italic === s.italic) last.text += s.text;
+		if (last && last.href === s.href && last.sizePt === s.sizePt && last.colorHex === s.colorHex && last.fontName === s.fontName && last.outline?.colorHex === s.outline?.colorHex && last.outline?.widthPt === s.outline?.widthPt && last.bold === s.bold && last.italic === s.italic && sameMarkup(last.markup, s.markup)) last.text += s.text;
 		else merged.push({
 			text: s.text,
 			...s.href !== void 0 ? { href: s.href } : {},
@@ -40,7 +40,8 @@ function paragraphFromRuns(spans, outlineLevel) {
 			...s.fontName !== void 0 ? { fontName: s.fontName } : {},
 			...s.outline !== void 0 ? { outline: s.outline } : {},
 			...s.bold !== void 0 ? { bold: s.bold } : {},
-			...s.italic !== void 0 ? { italic: s.italic } : {}
+			...s.italic !== void 0 ? { italic: s.italic } : {},
+			...s.markup !== void 0 ? { markup: s.markup } : {}
 		});
 	}
 	const runs = merged.map((m) => ({
@@ -54,7 +55,10 @@ function paragraphFromRuns(spans, outlineLevel) {
 	return {
 		kind: "paragraph",
 		paragraph: {
-			properties: outlineLevel !== void 0 ? { outlineLevel } : {},
+			properties: {
+				...outlineLevel !== void 0 ? { outlineLevel } : {},
+				...placement
+			},
 			runs: runs.filter((r) => r.text.length > 0).map((r) => ({
 				text: r.text,
 				properties: {
@@ -63,22 +67,31 @@ function paragraphFromRuns(spans, outlineLevel) {
 					...r.fontName !== void 0 ? { fontFamily: { ascii: r.fontName } } : {},
 					...r.outline !== void 0 ? { textOutline: r.outline } : {},
 					...r.bold ? { bold: true } : {},
-					...r.italic ? { italic: true } : {}
+					...r.italic ? { italic: true } : {},
+					...r.markup?.highlightHex !== void 0 ? { shadingColorHex: r.markup.highlightHex } : {},
+					...r.markup?.underline !== void 0 ? { underline: r.markup.underline } : {},
+					...r.markup?.underlineHex !== void 0 ? { underlineColorHex: r.markup.underlineHex } : {},
+					...r.markup?.strike === true ? { strike: true } : {}
 				},
 				...r.href ? { href: r.href } : {}
 			}))
 		}
 	};
 }
+/** Whether two runs are marked the same way, so they may join into one. */
+function sameMarkup(a, b) {
+	return a?.highlightHex === b?.highlightHex && a?.underline === b?.underline && a?.underlineHex === b?.underlineHex && a?.strike === b?.strike;
+}
 /**
 * Store a {@link PdfImage}'s bytes (content-addressed dedup) and build the image
 * {@link BodyElement} that references them, sized in points from the placement
 * CTM. `alt` becomes the block's alt text when given.
 */
-function imageBlock(image, resources, alt, frame, zOrder) {
+function imageBlock(image, resources, alt, frame, zOrder, behind = false) {
 	const resource = resources.put(image.bytes);
 	const float = frame !== void 0 ? {
 		wrap: "none",
+		...behind ? { behind: true } : {},
 		...zOrder !== void 0 ? { zOrder } : {},
 		posH: {
 			relativeFrom: "page",
@@ -96,6 +109,8 @@ function imageBlock(image, resources, alt, frame, zOrder) {
 			resource,
 			width: pt(image.widthPt),
 			height: pt(image.heightPt),
+			...image.rotationDeg !== void 0 ? { rotation60k: Math.round(-image.rotationDeg * 6e4) } : {},
+			...image.crop ? { crop: image.crop } : {},
 			paragraphProperties: {},
 			...alt ? { altText: alt } : {}
 		}
@@ -172,7 +187,7 @@ function dedupeLosses(losses) {
 * a paragraph: 22060_A1_01_Plans.pdf is one A3 sheet of vectors, and stacking
 * its forty-nine paths one under another spilled it onto a second page.
 */
-function shapeBlock(v, frame, zOrder) {
+function shapeBlock(v, frame, zOrder, behind = false) {
 	const w = v.maxX - v.minX;
 	const h = v.maxY - v.minY;
 	const fx = (x) => x - v.minX;
@@ -222,6 +237,7 @@ function shapeBlock(v, frame, zOrder) {
 	} : void 0;
 	const float = frame !== void 0 ? {
 		wrap: "none",
+		...behind || v.darkens === true ? { behind: true } : {},
 		...zOrder !== void 0 ? { zOrder } : {},
 		posH: {
 			relativeFrom: "page",
@@ -287,6 +303,84 @@ function sectionFromPdfPages(pages) {
 	};
 }
 /**
+* The margins the SOURCE used, measured off where its words actually sit.
+*
+* A PDF states none — text is placed anywhere on the MediaBox — so the reader
+* used to leave them at zero rather than invent an inch. But the words
+* themselves say where the margin was: the leftmost glyph on the page is the
+* left margin, and reflowing inside it keeps the measure the author set instead
+* of running the text from edge to edge.
+*
+* Measured on the MEDIAN page rather than the extreme one, so a single full-
+* bleed rule or a page number in the corner does not collapse the margin for
+* the whole document, and clamped so a strange page cannot leave no text area
+* at all.
+*
+* @param section  The section the page box gave, or `undefined`.
+* @param shown    Each page as it is shown, for its own width and height.
+* @param pageRuns Each page's runs, already placed on the shown page.
+* @returns The section with measured margins, or `section` when nothing is
+*          measurable.
+*/
+/** What the measure gives back, so the widest line still fits when re-set. */
+var SLACK = .01;
+/** How far a face's ascender stands above its baseline, as a fraction of the size. */
+var ASCENDER = .8;
+/** And its descender below — the two together are a little over one em. */
+var DESCENDER = .22;
+function withMeasuredMargins(section, shown, pageRuns) {
+	if (!section?.pageSize) return section;
+	const width = section.pageSize.width;
+	const height = section.pageSize.height;
+	const lefts = [];
+	const rights = [];
+	const tops = [];
+	const bottoms = [];
+	pageRuns.forEach((runs, i) => {
+		const page = shown[i];
+		if (!page || runs.length === 0) return;
+		let minX = Infinity;
+		let maxX = -Infinity;
+		let minY = Infinity;
+		let maxY = -Infinity;
+		let topSize = 0;
+		let bottomSize = 0;
+		for (const r of runs) {
+			if (!Number.isFinite(r.x) || !Number.isFinite(r.y)) continue;
+			minX = Math.min(minX, r.x);
+			maxX = Math.max(maxX, r.endX);
+			if (r.y < minY) {
+				minY = r.y;
+				bottomSize = r.fontSizePt;
+			}
+			if (r.y > maxY) {
+				maxY = r.y;
+				topSize = r.fontSizePt;
+			}
+		}
+		if (!Number.isFinite(minX) || !Number.isFinite(minY)) return;
+		lefts.push(minX);
+		rights.push(page.width - maxX);
+		tops.push(page.height - maxY - topSize * ASCENDER);
+		bottoms.push(minY - bottomSize * DESCENDER);
+	});
+	if (lefts.length === 0) return section;
+	const median = (xs) => {
+		const s = [...xs].sort((a, b) => a - b);
+		return s[Math.floor(s.length / 2)] ?? 0;
+	};
+	const clamp = (v, span) => pt(Math.max(0, Math.min(v, span / 3)));
+	return {
+		...section,
+		margins: {
+			left: clamp(median(lefts), width),
+			right: clamp(median(rights) - width * SLACK, width),
+			top: clamp(median(tops), height),
+			bottom: clamp(median(bottoms), height)
+		}
+	};
+}
+/**
 * Assemble the final {@link FlowDoc} for a reconstruction: the body elements
 * with their styles resolved against the empty style sheet, the lifted-image
 * resource store, and the optional page {@link SectionProperties}. Shared by
@@ -305,4 +399,4 @@ function buildFlowDoc(body, resources = new ResourceStore(), section, embeddedFo
 	};
 }
 //#endregion
-export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, shapeBlock };
+export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, shapeBlock, withMeasuredMargins };

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

@@ -1,7 +1,9 @@
 import { parseTtf } from "../core/font/ttf-parser.js";
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
-import { embeddedFontName } from "./embedded-fonts.js";
 import { parseToUnicodeCMap } from "./cmap.js";
+import { textForGlyphName } from "./glyph-names.js";
+import { standardFace, standardWidth } from "./standard-widths.js";
+import { embeddedFontName } from "./embedded-fonts.js";
 //#region src/pdf-reader/font.ts
 /**
 * Build a {@link ContentFont} (the interpreter's decode + advance hooks) from a
@@ -25,22 +27,59 @@ function buildContentFont(file, fontDict) {
 		toUnicode = parsed.map;
 		if (isType0) codeBytes = parsed.codeBytes;
 	}
-	const unicode = (isType0 && toUnicode.size === 0 ? embeddedCmap(file, fontDict) : void 0) ?? toUnicode;
+	const fromProgram = isType0 && toUnicode.size === 0 ? embeddedCmap(file, fontDict) : void 0;
+	const fromNames = !isType0 ? namedGlyphs(file, fontDict) : void 0;
+	const unicode = fromProgram ?? (toUnicode.size > 0 ? toUnicode : fromNames ?? toUnicode);
 	const bytesPerCode = codeBytes;
 	const style = faceStyle(file, fontDict, isType0);
 	const name = embeddedFontName(file, fontDict);
 	const type3 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type3" ? type3Face(file, fontDict) : void 0;
-	const simple = simpleWidths(file, fontDict);
+	const speechless = isType0 && unicode.size === 0;
+	const decodeOne = (code) => unicode.get(code) ?? (bytesPerCode === 1 ? latin1(code) : speechless ? "�" : "");
+	const simple = simpleWidths(file, fontDict, decodeOne);
 	const width = isType0 ? cidWidths(file, fontDict) : type3 ? (code) => simple(code) * type3.matrix[0] * 1e3 : simple;
 	return {
 		bytesPerCode,
 		...type3 ? { type3 } : {},
 		...name !== void 0 ? { name } : {},
-		decode: (codes) => codes.map((c) => unicode.get(c) ?? (bytesPerCode === 1 ? String.fromCharCode(c) : "")).join(""),
+		decode: (codes) => codes.map((c) => readable(decodeOne(c))).join(""),
 		width,
 		...style
 	};
 }
+/**
+* The character a code stands for when nothing in the font says.
+*
+* Latin-1 is the only guess there is, and it is a good one for a text font —
+* but a C0 control is not a glyph. §9.4.3 shows GLYPHS, and a code falling back
+* to one has landed there by accident: issue11549_reduced.pdf's one line came
+* back as U+0007 through U+0011 and was drawn as six empty boxes over a page
+* that shows nothing at all. A `/ToUnicode` that STATES a control is stating
+* something and is left alone.
+*/
+function latin1(code) {
+	return code < 32 || code === 127 ? "�" : String.fromCharCode(code);
+}
+/**
+* What a `/ToUnicode` gives, less what Unicode says is not a character.
+*
+* `U+FFFE` and `U+FFFF` are noncharacters and the `U+FDD0`–`U+FDEF` block with
+* them; a lone surrogate is half of a pair that never came. A producer that
+* maps its glyphs to any of these has said "no text here" in the only way the
+* format lets it, and carrying them on writes bytes no reader can show —
+* arial_unicode_ab_cidfont.pdf maps its four Arabic letters to `U+FFFF` and the
+* page came back holding four of them. They become `U+FFFD`, which the
+* reconstruction counts and reports rather than passing along.
+*/
+function readable(text) {
+	let out = "";
+	for (const ch of text) {
+		const cp = ch.codePointAt(0) ?? 0;
+		const noncharacter = (cp & 65534) === 65534 || cp >= 64976 && cp <= 65007 || cp === 0 || cp >= SURROGATE_FIRST && cp <= SURROGATE_LAST;
+		out += noncharacter ? "�" : ch;
+	}
+	return out;
+}
 /** The last Unicode code point in the BMP, and the surrogate block inside it. */
 var BMP_END = 65535;
 var SURROGATE_FIRST = 55296;
@@ -148,6 +187,27 @@ function fontMatrix(file, fontDict) {
 		n[5]
 	];
 }
+/**
+* §9.6.6.1 — code → text for a simple font, out of the glyph names its
+* `/Encoding /Differences` gives.
+*
+* Returns `undefined` where the font names nothing, so the caller keeps its
+* Latin-1 reading rather than replacing it with an empty map.
+*/
+function namedGlyphs(file, fontDict) {
+	const names = differences(file, fontDict);
+	if (names.size === 0) return void 0;
+	const out = /* @__PURE__ */ new Map();
+	for (const [code, name] of names) {
+		const text = textForGlyphName(name);
+		if (text !== void 0) out.set(code, text);
+	}
+	if (out.size > 0) return out;
+	if (asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) !== "Type3") return void 0;
+	const unreadable = /* @__PURE__ */ new Map();
+	for (const code of names.keys()) unreadable.set(code, "�");
+	return unreadable;
+}
 /** §9.6.6.1 `/Encoding` `/Differences` — code → glyph name, as the array runs. */
 function differences(file, fontDict) {
 	const out = /* @__PURE__ */ new Map();
@@ -166,6 +226,8 @@ function differences(file, fontDict) {
 /** §9.8.2 `/Flags` — bit 7 is Italic, bit 19 ForceBold (bits numbered from 1). */
 var FLAG_ITALIC = 64;
 var FLAG_FORCE_BOLD = 1 << 18;
+/** §9.8.1 `/FontWeight` — the lightest a face may state; below it is no weight. */
+var LIGHTEST_WEIGHT = 100;
 /** §9.8.1 `/FontWeight` — 400 is normal, 700 bold; 600 is where "bold" begins. */
 var BOLD_WEIGHT = 600;
 /**
@@ -187,23 +249,38 @@ var BOLD_WEIGHT = 600;
 function faceStyle(file, fontDict, isType0) {
 	const owner = isType0 ? descendantFont(file, fontDict) : fontDict;
 	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+	const named = styleFromName(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
 	if (descriptor instanceof Map) {
 		const flags = asNumber(file.resolve(descriptor.get("Flags") ?? PDF_NULL), 0);
-		const weight = asNumber(file.resolve(descriptor.get("FontWeight") ?? PDF_NULL), 0);
+		const weightVal = file.resolve(descriptor.get("FontWeight") ?? PDF_NULL);
 		const slant = asNumber(file.resolve(descriptor.get("ItalicAngle") ?? PDF_NULL), 0);
-		const bold = weight >= BOLD_WEIGHT || (flags & FLAG_FORCE_BOLD) !== 0;
-		const italic = slant !== 0 || (flags & FLAG_ITALIC) !== 0;
+		const bold = typeof weightVal === "number" && weightVal >= LIGHTEST_WEIGHT ? asNumber(weightVal, 0) >= BOLD_WEIGHT : (flags & FLAG_FORCE_BOLD) !== 0 || named.bold;
+		const italic = slant !== 0 || (flags & FLAG_ITALIC) !== 0 || named.italic;
 		return {
-			...bold ? { bold } : {},
-			...italic ? { italic } : {}
+			...bold ? { bold: true } : {},
+			...italic ? { italic: true } : {}
 		};
 	}
-	const name = asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)).replace(/^[A-Z]{6}\+/u, "");
-	const bold = /bold|black|heavy/iu.test(name);
-	const italic = /italic|oblique/iu.test(name);
 	return {
-		...bold ? { bold } : {},
-		...italic ? { italic } : {}
+		...named.bold ? { bold: true } : {},
+		...named.italic ? { italic: true } : {}
+	};
+}
+/**
+* §9.6.2.2 — the style a font's NAME states, by the PostScript convention:
+* `Family-Style`, or `Family,Style` as Word writes it.
+*
+* The separator is what makes this safe. A family whose name merely CONTAINS
+* the word — "New Basrah Bold", "Damascus Bold", both real faces in
+* ArabicCIDTrueType.pdf — is not a bold cut of anything, and reading it as one
+* set two lines heavy that no reader sets heavy. `Times-Bold` is.
+*/
+function styleFromName(baseFont) {
+	const name = baseFont.replace(/^[A-Z]{6}\+/u, "");
+	const style = /[-,]([A-Za-z]+)$/u.exec(name)?.[1] ?? "";
+	return {
+		bold: /bold|black|heavy|semib|demi/iu.test(style),
+		italic: /italic|oblique/iu.test(style)
 	};
 }
 /** §9.7.4 — a `/Type0` font's one descendant CIDFont, which owns the descriptor. */
@@ -212,15 +289,19 @@ function descendantFont(file, fontDict) {
 	const first = Array.isArray(descFonts) ? file.resolve(descFonts[0] ?? PDF_NULL) : PDF_NULL;
 	return first instanceof Map ? first : /* @__PURE__ */ new Map();
 }
-function simpleWidths(file, fontDict) {
+function simpleWidths(file, fontDict, decodeOne) {
 	const first = asNumber(file.resolve(fontDict.get("FirstChar") ?? PDF_NULL), 0);
 	const widthsVal = file.resolve(fontDict.get("Widths") ?? PDF_NULL);
 	const widths = Array.isArray(widthsVal) ? widthsVal : [];
 	const descriptor = file.resolve(fontDict.get("FontDescriptor") ?? PDF_NULL);
 	const missing = descriptor instanceof Map ? asNumber(file.resolve(descriptor.get("MissingWidth") ?? PDF_NULL), 0) : 0;
+	const face = standardFace(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
 	return (code) => {
 		const w = widths[code - first];
-		return typeof w === "number" ? w : missing > 0 ? missing : 500;
+		if (typeof w === "number") return w;
+		const built = face === void 0 ? void 0 : standardWidth(face, code, decodeOne(code));
+		if (built !== void 0) return built;
+		return missing > 0 ? missing : 500;
 	};
 }
 function cidWidths(file, fontDict) {

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

@@ -0,0 +1,16 @@
+import { PdfValue } from '../pdf/objects.js';
+import { PdfFile } from './document.js';
+/** §7.10 — m numbers in, n numbers out. */
+export type PdfFunction = (inputs: ReadonlyArray<number>) => Array<number>;
+/**
+ * Read a `/Function` entry into something callable (§7.10).
+ *
+ * The entry may also be an ARRAY of functions, each giving one output, which is
+ * what a `/DeviceN` with a per-colorant transform states; that comes back as
+ * one function returning all of them in order.
+ *
+ * @param file  The owning file.
+ * @param value The `/Function` (or `/TintTransform`) entry, unresolved.
+ * @returns The function, or `undefined` for one this cannot run.
+ */
+export declare function readFunction(file: PdfFile, value: PdfValue | undefined): PdfFunction | undefined;