reamkit 1.30.0 → 1.31.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,193 @@
+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 box = (x, y, w, h) => ({
+		x: pt(sheetWidth - y - h),
+		y: pt(x),
+		width: pt(h),
+		height: pt(w)
+	});
+	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/pdf/styled-page-emitter.js

@@ -676,12 +676,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 +889,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;
@@ -1397,6 +1460,19 @@ 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`;
 }
+/**
+* Whether a line is ONE text matrix and a run of glyphs: nothing in it placed
+* on its own — a tab, a stretched space, a picture, a formula, a right-to-left
+* run, a rise, a faked italic — and nothing drawn beside its glyphs, a run's
+* shading, a highlight or a rule. Only such a line can be turned by its matrix
+* alone; any other is placed token by token in page space.
+*
+* @param line The laid-out line.
+* @returns True when a single `Tm` sets the whole of it.
+*/
+function settableInOneMatrix(line) {
+	return computeJustifyExtra(line) === 0 && line.tokens.every((t) => t.kind === "text" && t.tab !== true && t.bidiLevel % 2 === 0 && t.risePt === void 0 && t.synthetic?.italic !== true && t.highlight !== true && t.resolvedRun.shadingColorHex === void 0 && t.resolvedRun.underline === "none" && !t.resolvedRun.strike);
+}
 function computeJustifyExtra(line) {
 	const alignment = line.resolved.alignment;
 	if (alignment !== "both" && alignment !== "distribute") return 0;

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;

package/dist/esm/pdf-reader/cff-outline.js

@@ -1,3 +1,4 @@
+import { standardEncodingTable } from "./encodings.js";
 //#region src/pdf-reader/cff-outline.ts
 /**
 * Prepare an embedded CFF program for outline reading.
@@ -69,6 +70,90 @@ function cffCidToGid(program) {
 		return;
 	}
 }
+/**
+* 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.
+*/
+function cffSpaceAdvance(program) {
+	try {
+		const font = parseCff(program);
+		const gid = font?.nameToGid?.get("space");
+		if (!font || gid === void 0) return void 0;
+		const width = glyphWidth(font, gid);
+		return width === void 0 ? void 0 : width * font.scale * 1e3;
+	} catch {
+		return;
+	}
+}
+/**
+* TN 5177 §4.1 — a glyph's width: `nominalWidthX` plus the operand a
+* charstring puts before its first stack-clearing operator, or
+* `defaultWidthX` where it puts none. Whether one is there is a matter of
+* COUNT — one more than the operator takes.
+*/
+function glyphWidth(font, gid) {
+	const code = font.charStrings[gid];
+	if (!code) return void 0;
+	const { defaultWidth, nominalWidth } = font.widthsOf(gid);
+	const stack = [];
+	for (let i = 0; i < code.length;) {
+		const b = code[i++];
+		if (b === 28) {
+			stack.push((code[i] << 24 | code[i + 1] << 16) >> 16);
+			i += 2;
+		} else if (b >= 32 && b <= 246) stack.push(b - 139);
+		else if (b >= 247 && b <= 250) stack.push((b - 247) * 256 + code[i++] + 108);
+		else if (b >= 251 && b <= 254) stack.push(-(b - 251) * 256 - code[i++] - 108);
+		else if (b === 255) {
+			stack.push((code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3]) / 65536);
+			i += 4;
+		} else {
+			const takes = b === 21 ? 2 : b === 22 || b === 4 ? 1 : b === 14 ? stack.length >= 4 ? 4 : 0 : -1;
+			if (b === 1 || b === 3 || b === 18 || b === 23 || b === 19 || b === 20) return stack.length % 2 === 1 ? nominalWidth + stack[0] : defaultWidth;
+			if (takes < 0) return void 0;
+			return stack.length > takes ? nominalWidth + stack[0] : defaultWidth;
+		}
+	}
+}
+/**
+* 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.
+*/
+function cffFsType(program) {
+	try {
+		const names = readIndex(program, program[2] ?? 4);
+		const tops = names ? readIndex(program, names.end) : void 0;
+		const strings = tops ? readIndex(program, tops.end) : void 0;
+		const top = tops?.items[0];
+		if (!top || !strings) return void 0;
+		const sid = parseDict(top).get(1221)?.[0];
+		if (sid === void 0 || sid < STANDARD_STRINGS.length) return void 0;
+		const own = strings.items[sid - STANDARD_STRINGS.length];
+		return own ? postScriptFsType(new TextDecoder("latin1").decode(own)) : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* 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.
+*/
+function postScriptFsType(text) {
+	const m = /\/FSType\s+(\d+)\s+def/u.exec(text);
+	return m ? Number(m[1]) : void 0;
+}
 /** The `CFF ` table of an OpenType wrapper, where the program is one. */
 function openTypeCff(program) {
 	if (program.length < 12) return void 0;
@@ -102,27 +187,52 @@ function parseCff(program) {
 	if (!charStrings) return void 0;
 	const matrix = top.get(1207);
 	const scale = matrix && matrix.length >= 4 ? matrix[0] ?? .001 : .001;
-	const privateSubrs = (dict) => {
+	const privateOf = (dict) => {
+		const none = {
+			subrs: [],
+			widths: {
+				defaultWidth: 0,
+				nominalWidth: 0
+			}
+		};
 		const priv = dict.get(18);
-		if (!priv || priv.length < 2) return [];
+		if (!priv || priv.length < 2) return none;
 		const size = priv[0];
 		const offset = priv[1];
-		if (offset < 0 || offset + size > program.length) return [];
-		const subrsAt = parseDict(program.subarray(offset, offset + size)).get(19)?.[0];
-		if (subrsAt === void 0) return [];
-		return readIndex(program, offset + subrsAt)?.items ?? [];
+		if (offset < 0 || offset + size > program.length) return none;
+		const inner = parseDict(program.subarray(offset, offset + size));
+		const widths = {
+			defaultWidth: inner.get(20)?.[0] ?? 0,
+			nominalWidth: inner.get(21)?.[0] ?? 0
+		};
+		const subrsAt = inner.get(19)?.[0];
+		if (subrsAt === void 0) return {
+			subrs: [],
+			widths
+		};
+		return {
+			subrs: readIndex(program, offset + subrsAt)?.items ?? [],
+			widths
+		};
 	};
 	const isCid = top.has(1230);
 	let localSubrs;
+	let widthsOf;
 	if (isCid) {
 		const fdArrayAt = top.get(1236)?.[0];
 		const fdSelectAt = top.get(1237)?.[0];
-		const subrsPerFd = (fdArrayAt !== void 0 ? readIndex(program, fdArrayAt)?.items ?? [] : []).map((fd) => privateSubrs(parseDict(fd)));
+		const privatePerFd = (fdArrayAt !== void 0 ? readIndex(program, fdArrayAt)?.items ?? [] : []).map((fd) => privateOf(parseDict(fd)));
 		const select = fdSelectAt !== void 0 ? readFdSelect(program, fdSelectAt, charStrings.items.length) : void 0;
-		localSubrs = (gid) => subrsPerFd[select ? select[gid] ?? 0 : 0] ?? [];
+		const privateFor = (gid) => privatePerFd[select ? select[gid] ?? 0 : 0];
+		localSubrs = (gid) => privateFor(gid)?.subrs ?? [];
+		widthsOf = (gid) => privateFor(gid)?.widths ?? {
+			defaultWidth: 0,
+			nominalWidth: 0
+		};
 	} else {
-		const only = privateSubrs(top);
-		localSubrs = () => only;
+		const only = privateOf(top);
+		localSubrs = () => only.subrs;
+		widthsOf = () => only.widths;
 	}
 	const charsetAt = top.get(15)?.[0];
 	const sids = charsetAt !== void 0 && charsetAt > 2 ? readCharset(program, charsetAt, charStrings.items.length) : void 0;
@@ -134,7 +244,8 @@ function parseCff(program) {
 		localSubrs,
 		scale,
 		...cidToGid ? { cidToGid } : {},
-		...nameToGid ? { nameToGid } : {}
+		...nameToGid ? { nameToGid } : {},
+		widthsOf
 	};
 }
 /**
@@ -689,9 +800,10 @@ function bias(subrs) {
 /** How deep a charstring may call, and how many operators it may run. */
 var MAX_CALL_DEPTH = 10;
 var MAX_STEPS = 65536;
-function runGlyph(font, gid) {
+function runGlyph(font, gid, part = false) {
 	const program = font.charStrings[gid];
 	if (!program) return void 0;
+	let seac;
 	const local = font.localSubrs(gid);
 	const localBias = bias(local);
 	const globalBias = bias(font.globalSubrs);
@@ -885,7 +997,16 @@ function runGlyph(font, gid) {
 				}
 				case 11: return true;
 				case 14:
-					takeWidth(stack.length > 4 ? 4 : 0);
+					takeWidth(stack.length >= 4 ? 4 : 0);
+					if (stack.length >= 4) {
+						const [adx = 0, ady = 0, bchar = 0, achar = 0] = stack;
+						seac = {
+							adx,
+							ady,
+							bchar,
+							achar
+						};
+					}
 					if (open) out.push({ op: "close" });
 					open = false;
 					return false;
@@ -919,8 +1040,35 @@ function runGlyph(font, gid) {
 	}
 	run(program, 0);
 	if (out.length > 0 && out[out.length - 1]?.op !== "close") out.push({ op: "close" });
-	if (out.length === 0) return void 0;
-	return out.map((seg) => scaleSeg(seg, font.scale));
+	const own = out.map((seg) => scaleSeg(seg, font.scale));
+	if (seac && !part) {
+		const at = seac;
+		const glyphOf = (code) => {
+			const name = standardEncodingTable().get(code);
+			const gid = name !== void 0 ? font.nameToGid?.get(name) : void 0;
+			return gid !== void 0 ? runGlyph(font, gid, true) ?? [] : [];
+		};
+		own.push(...glyphOf(at.bchar), ...glyphOf(at.achar).map((seg) => shiftSeg(seg, at.adx * font.scale, at.ady * font.scale)));
+	}
+	return own.length > 0 ? own : void 0;
+}
+/** A segment moved by `(dx, dy)`: where a `seac` puts its accent. */
+function shiftSeg(seg, dx, dy) {
+	if (seg.op === "close") return seg;
+	if (seg.op === "cubic") return {
+		op: "cubic",
+		x1: seg.x1 + dx,
+		y1: seg.y1 + dy,
+		x2: seg.x2 + dx,
+		y2: seg.y2 + dy,
+		x: seg.x + dx,
+		y: seg.y + dy
+	};
+	return {
+		op: seg.op,
+		x: seg.x + dx,
+		y: seg.y + dy
+	};
 }
 function runEscape(op, stack, trans) {
 	switch (op) {
@@ -1030,8 +1178,8 @@ function flexCurves(op, stack, x0, y0) {
 		]);
 		push([
 			n(4),
-			n(6),
-			0
+			n(5),
+			n(6)
 		], [
 			0,
 			startY - y,
@@ -1051,12 +1199,12 @@ function flexCurves(op, stack, x0, y0) {
 		]);
 		push([
 			n(5),
-			n(7),
+			n(6),
 			n(8)
 		], [
 			0,
-			n(6),
-			startY - (y + n(6))
+			n(7),
+			startY - (y + n(7))
 		]);
 		y = startY;
 	} else if (op === 37) {
@@ -1119,4 +1267,4 @@ function scaleSeg(seg, k) {
 	};
 }
 //#endregion
-export { cffCidToGid, cffNameToGid, cffOutlineSource, openTypeCff };
+export { cffCidToGid, cffFsType, cffNameToGid, cffOutlineSource, cffSpaceAdvance, openTypeCff, postScriptFsType };