reamkit 1.23.0 → 1.25.0

package/dist/esm/pdf/shading.js

@@ -284,14 +284,16 @@ function normalizeStops(stops) {
 		colorHex: "000000",
 		alpha: 1
 	}];
-	out[0] = {
-		...out[0],
+	const first = out[0];
+	if (first.offset > 0) out.unshift({
+		...first,
 		offset: 0
-	};
-	out[out.length - 1] = {
-		...out[out.length - 1],
+	});
+	const last = out[out.length - 1];
+	if (last.offset < 1) out.push({
+		...last,
 		offset: 1
-	};
+	});
 	return out;
 }
 function rgb01(hex) {

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

@@ -7,6 +7,7 @@ import { GLUE_SHRINK_RATIO } from "../layout/styled-layout.js";
 import { paintPlan } from "../layout/page-doc.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 { sanitizeHref } from "../core/links.js";
 import { embedAssociatedFile } from "./embedded-file.js";
 import { buildSrgbIccProfile } from "./icc-profile.js";
@@ -111,7 +112,11 @@ function assembleStyledPdf(laid, options, doc) {
 	if (!pdfaProfile) for (const page of renderedPages) {
 		const ph = page.height;
 		const plan = paintPlan(page.commands);
-		const shapesNeedingPatterns = [...plan.shapes, ...[...plan.behind, ...plan.pictures.flat()].filter((i) => i.type === "shape")];
+		const shapesNeedingPatterns = [...plan.shapes, ...[
+			...plan.behind,
+			...plan.pictures.flat(),
+			...plan.ordered.flat()
+		].filter((i) => i.type === "shape")];
 		for (const item of shapesNeedingPatterns) {
 			const gradient = item.shape.fillGradient;
 			if (!gradient) continue;
@@ -211,7 +216,11 @@ function assembleStyledPdf(laid, options, doc) {
 			wantAlpha(img.alpha);
 			wantDuotone(img, page.height);
 		}
-		for (const item of [...plan.behind, ...plan.pictures.flat()]) {
+		for (const item of [
+			...plan.behind,
+			...plan.pictures.flat(),
+			...plan.ordered.flat()
+		]) {
 			if (item.type === "image") {
 				wantAlpha(washVeil(item.wash)?.alpha);
 				wantAlpha(item.alpha);
@@ -644,6 +653,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 	let lastSize = -1;
 	let lastColor = "";
 	let lastFauxWidth = 0;
+	let lastStroke;
 	let lastTz = 100;
 	const switchFontIfNeeded = (tok) => {
 		const fontKey = tok.font.resourceName;
@@ -652,11 +662,20 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			lastFont = fontKey;
 			lastSize = tok.fontSizePt;
 		}
-		const fauxWidth = tok.synthetic?.bold === true ? tok.fontSizePt * .03 : 0;
+		const outline = tok.resolvedRun.textOutline;
+		const fauxWidth = outline !== void 0 ? outline.widthPt : tok.synthetic?.bold === true ? tok.fontSizePt * .03 : 0;
 		if (fauxWidth !== lastFauxWidth) {
 			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;
+		}
 		const tz = Math.round((tok.synthetic?.widthScale ?? 1) * 100);
 		if (tz !== lastTz) {
 			out.push(`${formatNumber(tz)} Tz`);
@@ -713,6 +732,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			}
 			lastFont = "";
 			lastFauxWidth = 0;
+			lastStroke = void 0;
+			lastStroke = void 0;
 			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
@@ -761,6 +782,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		}
 		lastFont = "";
 		lastFauxWidth = 0;
+		lastStroke = void 0;
 		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";
@@ -795,6 +817,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			out.push("Q");
 			lastFont = "";
 			lastFauxWidth = 0;
+			lastStroke = void 0;
+			lastStroke = void 0;
 			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
@@ -822,6 +846,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			for (const op of emitVectorShape(shape)) out.push(op);
 			lastFont = "";
 			lastFauxWidth = 0;
+			lastStroke = void 0;
+			lastStroke = void 0;
 			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
@@ -841,6 +867,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		out.push(`${formatNumber(clip.x)} ${formatNumber(H - clip.y - clip.height)} ${formatNumber(clip.width)} ${formatNumber(clip.height)} re W n`);
 		lastFont = "";
 		lastFauxWidth = 0;
+		lastStroke = void 0;
 		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";
@@ -855,6 +882,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		out.push("Q");
 		lastFont = "";
 		lastFauxWidth = 0;
+		lastStroke = void 0;
 		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";
@@ -1009,6 +1037,34 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		}
 		const hasRise = line.tokens.some((t) => t.kind === "text" && t.risePt !== void 0);
 		const hasFauxItalic = line.tokens.some((t) => t.kind === "text" && t.synthetic?.italic === true);
+		const warp = cmd.warp;
+		if (warp) {
+			if (!inBT) {
+				out.push("BT");
+				inBT = true;
+			}
+			let cursor = originX;
+			for (const tok of line.tokens) {
+				if (tok.kind !== "text" || tok.isSpace) {
+					cursor += tok.widthPt;
+					continue;
+				}
+				switchFontIfNeeded(tok);
+				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);
+				const k = total > 0 ? tok.widthPt / total : 1;
+				for (let i = 0; i < chars.length; i++) {
+					const adv = raw[i] * k;
+					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(tok.font.measure.showText(chars[i]));
+				}
+			}
+			return;
+		}
 		if (rotationDeg !== 0 && !hasImageToken && !hasMathToken) {
 			if (!inBT) {
 				out.push("BT");
@@ -1104,6 +1160,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		if (item.type === "shape") {
 			const t = item.shape.transform;
 			const fillAlpha = item.shape.fillAlpha;
+			const layer = item.shape.shadow ? shadowBlurLayers(item.shape.shadow) : void 0;
 			for (const op of emitVectorShape({
 				...item.shape,
 				transform: [
@@ -1114,7 +1171,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 					t[4],
 					H - t[5]
 				]
-			}, gradientNames?.get(item.shape), void 0, gradientMaskNames?.get(item.shape) ?? (fillAlpha !== void 0 && fillAlpha < 1 ? alphaStateNames?.get(Math.round(fillAlpha * 1e3) / 1e3) : void 0))) out.push(op);
+			}, gradientNames?.get(item.shape), layer && layer.alpha < 1 ? alphaStateNames?.get(Math.round(layer.alpha * 1e3) / 1e3) : void 0, gradientMaskNames?.get(item.shape) ?? (fillAlpha !== void 0 && fillAlpha < 1 ? alphaStateNames?.get(Math.round(fillAlpha * 1e3) / 1e3) : void 0))) out.push(op);
 			return;
 		}
 		if (item.type === "image") {
@@ -1287,6 +1344,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		for (const item of run) emitInOrder(item);
 		if (tagging) out.push("EMC");
 	}
+	for (const run of plan.ordered) for (const item of run) emitInOrder(item);
 	emitLinesPass();
 	return {
 		content: encoder.encode(out.join("\n")),

package/dist/esm/pdf/vector-graphics.js

@@ -31,7 +31,7 @@ function shadowBlurLayers(shadow) {
 	const count = Math.min(8, Math.max(2, Math.round(shadow.blurPt / 2)));
 	return {
 		count,
-		alpha: shadow.alpha / count
+		alpha: 1 - Math.pow(1 - shadow.alpha, 1 / count)
 	};
 }
 function shadowBbox(shape) {

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

@@ -0,0 +1,24 @@
+import { Matrix } from './content.js';
+import { PdfDict, PdfStream } from '../pdf/objects.js';
+import { PdfFile, PdfPage } from './document.js';
+/** One annotation's normal appearance, ready to interpret in page space. */
+export interface Appearance {
+    readonly stream: PdfStream;
+    /** Maps the appearance's own space onto the page (§12.5.5). */
+    readonly ctm: Matrix;
+    /** The appearance's `/Resources`, when it states its own. */
+    readonly resources: PdfDict | undefined;
+}
+/**
+ * Every annotation appearance the page shows, in `/Annots` order — which is
+ * the order they paint in, over the page's own content.
+ *
+ * A `Popup` is a note's window and is never part of the page. An annotation
+ * flagged Hidden or NoView paints nothing. An `/AP` `/N` may be a stream or a
+ * dictionary of states, in which case `/AS` names the one in force.
+ *
+ * @param file The owning file, for resolving references.
+ * @param page The page whose annotations are wanted.
+ * @returns The appearances, each with the matrix that places it on the page.
+ */
+export declare function collectPageAppearances(file: PdfFile, page: PdfPage): Array<Appearance>;

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

@@ -0,0 +1,126 @@
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { IDENTITY, multiply } from "./content.js";
+//#region src/pdf-reader/annots.ts
+/** §12.5.3 `/F` — the annotation is not painted at all. */
+var FLAG_HIDDEN = 2;
+var FLAG_NOVIEW = 32;
+/**
+* Every annotation appearance the page shows, in `/Annots` order — which is
+* the order they paint in, over the page's own content.
+*
+* A `Popup` is a note's window and is never part of the page. An annotation
+* flagged Hidden or NoView paints nothing. An `/AP` `/N` may be a stream or a
+* dictionary of states, in which case `/AS` names the one in force.
+*
+* @param file The owning file, for resolving references.
+* @param page The page whose annotations are wanted.
+* @returns The appearances, each with the matrix that places it on the page.
+*/
+function collectPageAppearances(file, page) {
+	const annots = file.get(page.dict, "Annots");
+	if (!Array.isArray(annots)) return [];
+	const out = [];
+	for (const entry of annots) {
+		const annot = file.resolve(entry);
+		if (!(annot instanceof Map)) continue;
+		const subtype = file.get(annot, "Subtype");
+		if (subtype instanceof PdfName && subtype.value === "Popup") continue;
+		const flags = file.get(annot, "F");
+		if (typeof flags === "number" && (flags & FLAG_HIDDEN || flags & FLAG_NOVIEW)) continue;
+		const stream = normalAppearance(file, annot);
+		if (!stream) continue;
+		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
+		});
+	}
+	return out;
+}
+/** §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");
+	if (!(ap instanceof Map)) return void 0;
+	const normal = file.get(ap, "N");
+	if (normal instanceof PdfStream) return normal;
+	if (!(normal instanceof Map)) return void 0;
+	const state = file.get(annot, "AS");
+	const picked = state instanceof PdfName ? file.resolve(normal.get(state.value) ?? PDF_NULL) : PDF_NULL;
+	if (picked instanceof PdfStream) return picked;
+	const only = [...normal.values()].map((v) => file.resolve(v)).filter((v) => v instanceof PdfStream);
+	return only.length === 1 ? only[0] : void 0;
+}
+/**
+* §12.5.5 — the matrix taking the form's `/Matrix`-transformed `/BBox` onto the
+* annotation's `/Rect`: the two are fitted corner to corner, so an appearance
+* authored at any size lands exactly in the rectangle that owns it.
+*/
+function fitToRect(bbox, matrix, rect) {
+	if (!bbox) return [
+		1,
+		0,
+		0,
+		1,
+		rect[0],
+		rect[1]
+	];
+	const xs = [];
+	const ys = [];
+	for (const [x, y] of [
+		[bbox[0], bbox[1]],
+		[bbox[2], bbox[1]],
+		[bbox[2], bbox[3]],
+		[bbox[0], bbox[3]]
+	]) {
+		xs.push(matrix[0] * x + matrix[2] * y + matrix[4]);
+		ys.push(matrix[1] * x + matrix[3] * y + matrix[5]);
+	}
+	const bw = Math.max(...xs) - Math.min(...xs);
+	const bh = Math.max(...ys) - Math.min(...ys);
+	const sx = bw > 0 ? (rect[2] - rect[0]) / bw : 1;
+	const sy = bh > 0 ? (rect[3] - rect[1]) / bh : 1;
+	return [
+		sx,
+		0,
+		0,
+		sy,
+		rect[0] - Math.min(...xs) * sx,
+		rect[1] - Math.min(...ys) * sy
+	];
+}
+/** §8.10.2 `/Matrix`, or the identity when the form states none. */
+function matrixOf(file, dict) {
+	const m = file.resolve(dict.get("Matrix") ?? PDF_NULL);
+	if (!Array.isArray(m) || m.length !== 6) return IDENTITY;
+	const n = m.map((v) => {
+		const r = file.resolve(v);
+		return typeof r === "number" ? r : 0;
+	});
+	return [
+		n[0],
+		n[1],
+		n[2],
+		n[3],
+		n[4],
+		n[5]
+	];
+}
+/** A four-number array as an ordered rectangle, or `undefined`. */
+function rectangle(v) {
+	if (!Array.isArray(v) || v.length < 4) return void 0;
+	const n = v.slice(0, 4).map((x) => typeof x === "number" ? x : NaN);
+	if (n.some((x) => !Number.isFinite(x))) return void 0;
+	return [
+		Math.min(n[0], n[2]),
+		Math.min(n[1], n[3]),
+		Math.max(n[0], n[2]),
+		Math.max(n[1], n[3])
+	];
+}
+//#endregion
+export { collectPageAppearances };

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

@@ -1,4 +1,5 @@
 import { ShapeGradient } from '../core/vector.js';
+import { PdfDict, PdfStream } from '../pdf/objects.js';
 /**
  * A page font as the interpreter needs it (built from the font dictionaries in
  * EP2b): how wide each code is, and how a run of codes decodes to Unicode. An
@@ -12,6 +13,27 @@ export interface ContentFont {
     decode: (codes: ReadonlyArray<number>) => string;
     /** Glyph advance for one code, in 1000-unit text space. */
     width: (code: number) => number;
+    /** §9.6.2 — the face's own `/BaseFont` name, for a document that embeds it. */
+    readonly name?: string;
+    /** §9.8.1 — the face is a bold one (weight, the ForceBold flag, or its name). */
+    readonly bold?: boolean;
+    /** §9.8.1 — the face is slanted (`/ItalicAngle`, the Italic flag, or its name). */
+    readonly italic?: boolean;
+    /**
+     * §9.6.5 — a Type 3 face, whose glyphs are content streams rather than
+     * outlines. What such a font draws is not type at all: it is whatever the
+     * procedure paints, in the resources the font states.
+     */
+    readonly type3?: Type3Face;
+}
+/** §9.6.5 — the parts of a Type 3 font a caller needs to run its glyphs. */
+export interface Type3Face {
+    /** `/FontMatrix` — glyph space to text space. */
+    readonly matrix: Matrix;
+    /** `/Encoding` + `/CharProcs` — the content stream one code draws. */
+    readonly proc: (code: number) => PdfStream | undefined;
+    /** `/Resources` the procedures draw with, when the font states its own. */
+    readonly resources: PdfDict | undefined;
 }
 /**
  * One positioned text run emitted by a show operator: its decoded text, the
@@ -24,8 +46,63 @@ export interface TextRun {
     readonly x: number;
     /** Glyph origin y in page space (points). */
     readonly y: number;
+    /**
+     * Where the pen stood after the last glyph, in page space (§9.4.4). The
+     * interpreter advances the text matrix by the font's own widths, so this is
+     * a measurement, not the half-em-per-character guess the reader used to make
+     * — and the difference between a word space and a table column is exactly
+     * the kind of thing a guess gets wrong.
+     */
+    readonly endX: number;
+    /** The pen's y after the last glyph — with {@link endX}, the whole advance. */
+    readonly endY: number;
+    /**
+     * The baseline's direction in page space, degrees counter-clockwise from
+     * left-to-right (§9.4.2 — the text matrix may turn as well as move). Absent
+     * for ordinary upright text, which is nearly all of it.
+     */
+    readonly angleDeg?: number;
     readonly fontSizePt: number;
     readonly fontKey: string;
+    /**
+     * §9.6.2 `/BaseFont` — the face's own name, subset prefix dropped and
+     * lowercased, or absent when the font states none. This is what a rebuilt run
+     * asks for, so a page whose faces the file EMBEDS is re-set in them rather
+     * than in a substitute (see `./embedded-fonts`).
+     */
+    readonly fontName?: string;
+    /** §9.8.1 — the face the glyphs were shown in is a bold one. */
+    readonly bold?: boolean;
+    /**
+     * §8.6.6.2 — the glyphs are filled with a tiling PATTERN, named here for the
+     * caller to resolve: a pattern is a content stream, not a colour, and the
+     * fill colour still standing from before is not what the page shows.
+     */
+    readonly fillPatternName?: string;
+    /**
+     * §9.3.6 — the page painted these glyphs NOWHERE: mode 3 shows nothing and
+     * mode 7 only adds to the clip. A scanned page carries its recognised words
+     * that way, under the picture of the page — so the run is kept, because it
+     * is the only text such a document has, and a reader reproducing the page
+     * leaves it to the picture.
+     */
+    readonly invisible?: boolean;
+    /**
+     * §9.3.6 — the colour the glyphs are STROKED in, when the rendering mode
+     * asks for a stroke, and how wide the pen is.
+     */
+    readonly outlineHex?: string;
+    readonly outlineWidthPt?: number;
+    /** §9.8.1 — the face the glyphs were shown in is a slanted one. */
+    readonly italic?: boolean;
+    /**
+     * §9.6.5 — the face is a Type 3 one, so what the page SHOWS here is the
+     * glyph procedures, not type. The run is kept for its words; a reader that
+     * reproduces the page draws the procedures instead of re-setting it.
+     */
+    readonly type3?: boolean;
+    /** §8.6.8 — the non-stroking colour the glyphs were painted in (6-hex). */
+    readonly colorHex: string;
     /**
      * The marked-content id of the enclosing `BDC` sequence (§14.6), if any — the
      * link from this text to the structure element that owns it (E-PDF EP3).
@@ -43,6 +120,8 @@ export interface TextRun {
  * `mcid` links the paint to its structure element (a `/Figure`, E-PDF EP6).
  */
 export interface ImagePlacement {
+    /** Where the `Do` fell in the stream's painting order — see {@link VectorPlacement.order}. */
+    readonly order: number;
     /** XObject resource name (no leading slash). */
     readonly name: string;
     readonly ctm: Matrix;
@@ -72,17 +151,38 @@ export type PathSeg = {
     readonly op: 'close';
 };
 /**
- * A painted path emitted by the path-painting operators (§8.5.3), captured in
- * page space (y-up). The optional fields record only what the paint mode set:
- * a fill colour/gradient (EP10/EP16c) and/or a stroke colour + width (EP11),
- * plus the enclosing structure id.
+ * §8.5.4 — the clipping region in force when a path was painted: the path that
+ * `W`/`W*` installed, plus its page-space bounding box.
  */
+export interface ClipRegion {
+    readonly segs: ReadonlyArray<PathSeg>;
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+}
 export interface VectorPlacement {
+    /**
+     * Where this fell in the stream's painting order (§8.5.3): later covers
+     * earlier, and a `Do` of a form is numbered here too, so a caller walking
+     * into that form knows exactly where its marks belong among these.
+     */
+    readonly order: number;
     readonly segs: ReadonlyArray<PathSeg>;
+    /** §8.5.4 — the clip in force when it was painted, when there was one. */
+    readonly clip?: ClipRegion;
     /** Fill colour (6-hex), present iff the path is filled (`f` / `F` / `f*` / `B` / `b`). */
     readonly fillHex?: string;
     /** Shading pattern, present iff filled with one (EP16c). */
     readonly gradient?: ShapeGradient;
+    /** §11.6.4.4 `/ca` — how opaque the fill is, when the page asked for less. */
+    readonly alpha?: number;
+    /**
+     * §8.7.3 — the TILING pattern resource name the path is filled with. Its
+     * content is a stream of its own, so what the fill actually shows is only
+     * known by walking into it; the `fillHex` beside this is not the fill.
+     */
+    readonly patternName?: string;
     /** Stroke colour (6-hex), present iff the path is stroked (`S` / `s` / `B` / `b`) — EP11. */
     readonly strokeHex?: string;
     /** Stroke width in page-space points — EP11. */
@@ -94,6 +194,19 @@ export interface InterpretResult {
     readonly texts: Array<TextRun>;
     readonly images: Array<ImagePlacement>;
     readonly vectors: Array<VectorPlacement>;
+    /** §9.6.5 — every Type 3 glyph the stream showed, with where to run it. */
+    readonly glyphs: Array<Type3Call>;
+}
+/**
+ * §9.6.5 — one showing of a Type 3 glyph: which procedure, and the matrix that
+ * puts glyph space on the page.
+ */
+export interface Type3Call {
+    readonly stream: PdfStream;
+    readonly resources: PdfDict | undefined;
+    readonly ctm: Matrix;
+    /** §8.5.3 — its place in the stream's painting order, as a form call has. */
+    readonly order: number;
 }
 /**
  * 2D affine matrix `[a b c d e f]`, row-vector convention (`[x y 1] · M`):
@@ -120,6 +233,19 @@ export declare function multiply(a: Matrix, b: Matrix): Matrix;
  *                   an unmapped key falls back to Latin-1 with a half-em advance.
  * @param initialCtm The starting CTM mapping user space to page space.
  * @param shadings   Shading patterns by name, selected by `scn`/`sc` (EP16c).
+ * @param alphas     Constant fill alphas by `/ExtGState` name, selected by `gs`.
  * @returns The extracted text runs, image placements and vector paths.
  */
-export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>): InterpretResult;
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>, alphas?: ReadonlyMap<string, number>): 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.
+ *
+ * Anything mixed — a number inside an Arabic sentence runs left to right —
+ * needs the full bidi algorithm, and guessing at it would be worse than
+ * leaving it alone.
+ *
+ * @param text The string to judge.
+ * @returns Whether it is one run of right-to-left script.
+ */
+export declare function isRightToLeft(text: string): boolean;