reamkit 1.30.0 → 1.32.0

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

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

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

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

package/dist/esm/markdown/markdown-writer.js

@@ -32,6 +32,7 @@ function writeMarkdown(flow, options = {}) {
 		anchors: referencedAnchors(flow.body),
 		notes: noteNumbers(flow),
 		mediaNames: /* @__PURE__ */ new Map(),
+		drawn: /* @__PURE__ */ new Set(),
 		...flow.numbering ? { numbering: flow.numbering } : {}
 	};
 	if (flow.headersFooters && flow.headersFooters.size > 0) lose(ctx, "dropped", FEATURES.headersFooters, "markdown has no pages to band headers onto");
@@ -98,8 +99,14 @@ function emitBlock(out, el, ctx) {
 		return;
 	}
 	ctx.list.length = 0;
-	if (el.kind === "table") emitTable(out, el.table, ctx);
-	else if (el.kind === "image") {
+	if (el.kind === "table") {
+		emitTable(out, el.table, ctx);
+		for (const drawing of el.table.overlay?.drawings ?? []) {
+			if (ctx.drawn.has(drawing)) continue;
+			ctx.drawn.add(drawing);
+			emitBlock(out, drawing, ctx);
+		}
+	} else if (el.kind === "image") {
 		const img = pictureMarkdown(el.image.resource, el.image.altText, ctx);
 		if (img.length > 0) out.push(img);
 	} else if (el.kind === "chart") lose(ctx, "dropped", FEATURES.charts, "markdown cannot draw a chart");
@@ -275,8 +282,10 @@ function noteNumbers(flow) {
 			add(r.endnoteRef, endnotes, flow.endnotes);
 			add(r.commentRef, comments, flow.comments);
 		}
-		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
-		else if (el.kind === "shape") visitShape(el.shape);
+		else if (el.kind === "table") {
+			for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
+			visit(el.table.overlay?.drawings ?? []);
+		} else if (el.kind === "shape") visitShape(el.shape);
 	};
 	visit(flow.body);
 	return {
@@ -370,8 +379,10 @@ function referencedAnchors(body) {
 	const visit = (els) => {
 		for (const el of els) if (el.kind === "paragraph") {
 			for (const r of el.paragraph.runs) if (r.anchor !== void 0) out.add(r.anchor);
-		} else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
-		else if (el.kind === "shape") visitShape(el.shape);
+		} else if (el.kind === "table") {
+			for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
+			visit(el.table.overlay?.drawings ?? []);
+		} else if (el.kind === "shape") visitShape(el.shape);
 	};
 	visit(body);
 	return out;

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

@@ -1,10 +1,10 @@
 import { dict, name, ref, stream, unicodeString } from "./objects.js";
 import { embedTtfFont } from "./cid-font.js";
 import { preparePdfEncryption } from "./encryption.js";
-import { reorderVisual } from "../core/bidi/algorithm.js";
+import { pageLayers, paintPlan } from "../layout/page-doc.js";
 import { reverseByCodePoint } from "../core/bidi/index.js";
-import { GLUE_SHRINK_RATIO } from "../layout/styled-layout.js";
-import { paintPlan } from "../layout/page-doc.js";
+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";
@@ -16,16 +16,6 @@ import { addSignaturePlaceholder } from "./signature.js";
 import { buildXmpPacket } from "./xmp.js";
 //#region src/pdf/styled-page-emitter.ts
 var encoder = new TextEncoder();
-function washVeil(wash) {
-	if (!wash) return void 0;
-	const alpha = 1 - wash.gain;
-	if (!(alpha > .004)) return void 0;
-	const offset = .5 * (1 - wash.gain) + wash.black;
-	return {
-		alpha: Math.min(1, alpha),
-		grey: Math.max(0, Math.min(1, offset / alpha))
-	};
-}
 /**
 * The veil operators for a washed picture, to follow its own `/Im Do`: the
 * placement matrix maps the unit square onto the picture as drawn, so the wash
@@ -268,7 +258,7 @@ function assembleStyledPdf(laid, options, doc) {
 				tagFor: (structId) => builder.node(structId).type
 			};
 		}
-		const { content: contentBytes, links } = emitPageContent(page, pageTagging, gradientNames, alphaStateNames, wantDuotone, gradientMaskNames);
+		const { content: contentBytes, links } = emitPageLayers(page, pageTagging, gradientNames, alphaStateNames, wantDuotone, gradientMaskNames);
 		const contentsRef = doc.add(stream({}, contentBytes));
 		const pageEntries = {
 			Type: name("Page"),
@@ -611,31 +601,56 @@ function emitTaggedRuns(out, cmds, tagging, body) {
 * 24. Scaling them by the width instead drew page-borders-export-case-2.docx's
 * half-point frame as a row of specks a quarter the length it should be.
 */
-var BORDER_DASHES = new Map([
-	["dashed", [8, 2.5]],
-	["dashSmallGap", [3, 1]],
-	["dotted", [.5, 1]],
-	["dashDot", [
-		8,
-		2.5,
-		2.5,
-		2.5
-	]],
-	["dashDotDot", [
-		8,
-		2.5,
-		2.5,
-		2.5,
-		2.5,
-		2.5
-	]]
-]);
-var FAUX_ITALIC_SHEAR = .2126;
 /** The PDF dash array for a border style; an empty string means a solid rule. */
 function dashPatternFor(style) {
 	const pattern = style !== void 0 ? BORDER_DASHES.get(style) : void 0;
 	return pattern ? `[${pattern.map(formatNumber).join(" ")}]` : "";
 }
+/**
+* A page's content stream in its layers (pageLayers): its own items, then —
+* when some of them stand IN FRONT of its text (PageItemBase.over) — those,
+* painted again pass by pass over what the first layer left, their own text
+* last; and each group seen through a window of its own (PageItemBase.window)
+* inside a clip to it. Each layer is a balanced stream of its own, so they
+* simply follow one another.
+*/
+function emitPageLayers(page, ...rest) {
+	const layers = pageLayers(page.commands);
+	if (layers.length === 1 && !layers[0].window) return emitPageContent(page, ...rest);
+	const parts = [];
+	const links = [];
+	for (const layer of layers) {
+		const emitted = emitPageContent({
+			...page,
+			commands: layer.items
+		}, ...rest);
+		links.push(...emitted.links);
+		const w = layer.window;
+		if (!w) {
+			parts.push(emitted.content);
+			continue;
+		}
+		if (emitted.content.length === 0) continue;
+		const rect = [
+			w.x,
+			page.height - w.y - w.height,
+			w.width,
+			w.height
+		].map(formatNumber);
+		parts.push(encoder.encode(`q ${rect.join(" ")} re W n`), emitted.content, encoder.encode("Q"));
+	}
+	const content = new Uint8Array(parts.reduce((sum, p) => sum + p.length, 0) + Math.max(0, parts.length - 1));
+	let at = 0;
+	parts.forEach((p, i) => {
+		if (i > 0) content[at++] = 10;
+		content.set(p, at);
+		at += p.length;
+	});
+	return {
+		content,
+		links
+	};
+}
 function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneStateFor, gradientMaskNames) {
 	const commands = page.commands;
 	const links = [];
@@ -676,12 +691,13 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			}
 			lastStroke = strokeHex;
 		}
-		const tz = Math.round((tok.synthetic?.widthScale ?? 1) * 100);
+		const scale = (tok.synthetic?.widthScale ?? 1) * (tok.resolvedRun.widthScale ?? 1);
+		const tz = Math.round(scale * 100);
 		if (tz !== lastTz) {
 			out.push(`${formatNumber(tz)} Tz`);
 			lastTz = tz;
 		}
-		const tc = tok.resolvedRun.letterSpacingPt ?? 0;
+		const tc = (tok.resolvedRun.letterSpacingPt ?? 0) / (tz > 0 ? tz / 100 : 1);
 		if (tc !== lastTc) {
 			out.push(`${formatNumber(tc)} Tc`);
 			lastTc = tc;
@@ -888,7 +904,69 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		lastColor = "";
 		lastTc = 0;
 	};
+	const emitTurned = (cmd) => {
+		if (inBT) {
+			out.push("ET");
+			inBT = false;
+		}
+		const rad = (cmd.rotationDeg ?? 0) * Math.PI / 180;
+		const cos = Math.cos(rad);
+		const sin = Math.sin(rad);
+		const ox = cmd.originX;
+		const oy = H - cmd.baselineY;
+		out.push("q");
+		out.push(`${formatNumber(cos)} ${formatNumber(sin)} ${formatNumber(-sin)} ${formatNumber(cos)} ${formatNumber(ox - ox * cos + oy * sin)} ${formatNumber(oy - ox * sin - oy * cos)} cm`);
+		lastFont = "";
+		lastFauxWidth = 0;
+		lastStroke = void 0;
+		lastTz = 100;
+		lastSize = -1;
+		lastColor = "";
+		lastTc = 0;
+		const from = links.length;
+		const { rotationDeg: _turned, ...flat } = cmd;
+		out.push("BT");
+		inBT = true;
+		emitOneLine(flat);
+		if (inBT) {
+			out.push("ET");
+			inBT = false;
+		}
+		out.push("Q");
+		lastFont = "";
+		lastFauxWidth = 0;
+		lastStroke = void 0;
+		lastTz = 100;
+		lastSize = -1;
+		lastColor = "";
+		lastTc = 0;
+		for (let k = from; k < links.length; k++) {
+			const link = links[k];
+			const [x0, y0, x1, y1] = link.rect;
+			const corners = [
+				[x0, y0],
+				[x1, y0],
+				[x1, y1],
+				[x0, y1]
+			].map(([x, y]) => [ox + (x - ox) * cos - (y - oy) * sin, oy + (x - ox) * sin + (y - oy) * cos]);
+			const xs = corners.map((c) => c[0]);
+			const ys = corners.map((c) => c[1]);
+			links[k] = {
+				...link,
+				rect: [
+					Math.min(...xs),
+					Math.min(...ys),
+					Math.max(...xs),
+					Math.max(...ys)
+				]
+			};
+		}
+	};
 	const emitOneLine = (cmd) => {
+		if (cmd.rotationDeg && cmd.warp === void 0 && !settableInOneMatrix(cmd.line)) {
+			emitTurned(cmd);
+			return;
+		}
 		const line = cmd.line;
 		const originX = cmd.originX;
 		const baselineY = H - cmd.baselineY;
@@ -1351,9 +1429,6 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		links
 	};
 }
-function lineVisualOrder(line) {
-	return reorderVisual(line.tokens.map((t) => t.bidiLevel));
-}
 /**
 * The operators that put an image XObject in a box — ISO 32000-1 §8.9.5.1: the
 * unit square scaled to the box and moved to `(x, y)`, its bottom-left corner.
@@ -1397,27 +1472,6 @@ function rotateAboutCm(cx, cy, deg) {
 	const s = Math.sin(rad);
 	return `${formatNumber(c)} ${formatNumber(s)} ${formatNumber(-s)} ${formatNumber(c)} ${formatNumber(cx - cx * c + cy * s)} ${formatNumber(cy - cx * s - cy * c)} cm`;
 }
-function computeJustifyExtra(line) {
-	const alignment = line.resolved.alignment;
-	if (alignment !== "both" && alignment !== "distribute") return 0;
-	if (line.noJustify === true) return 0;
-	if (line.isLastInParagraph && alignment !== "distribute") return 0;
-	let last = line.tokens.length - 1;
-	while (last >= 0 && line.tokens[last].kind === "text" && line.tokens[last].isSpace) last--;
-	let spaces = 0;
-	let narrowest = Infinity;
-	let contentWidthPt = 0;
-	for (let i = 0; i <= last; i++) {
-		const tok = line.tokens[i];
-		contentWidthPt += tok.widthPt;
-		if (!tok.isSpace) continue;
-		spaces++;
-		if (tok.widthPt < narrowest) narrowest = tok.widthPt;
-	}
-	if (spaces === 0) return 0;
-	const extra = (line.availableWidthPt - contentWidthPt) / spaces;
-	return extra < 0 ? Math.max(extra, -narrowest * GLUE_SHRINK_RATIO) : extra;
-}
 function hexToRgb01(hex) {
 	return [
 		parseInt(hex.slice(0, 2), 16) / 255,

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

@@ -1,6 +1,6 @@
 import { PdfDocument } from "./writer.js";
-import { layoutStyledDocument } from "../layout/styled-layout.js";
 import "../layout/page-doc.js";
+import { layoutStyledDocument } from "../layout/styled-layout.js";
 import { emitStyledPdf, emitStyledPdfEncrypted } from "./styled-page-emitter.js";
 //#region src/pdf/styled-page-renderer.ts
 /**

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

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