reamkit 1.27.0 → 1.28.0

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

@@ -0,0 +1,1122 @@
+//#region src/pdf-reader/cff-outline.ts
+/**
+* Prepare an embedded CFF program for outline reading.
+*
+* @param program The raw `/FontFile3` bytes (bare CFF, or the `CFF ` table of
+*                an OpenType wrapper — the caller unwraps that).
+* @returns A reader keyed by GLYPH INDEX, or `undefined` where the program
+*          cannot be read.
+*/
+function cffOutlineSource(program) {
+	let font;
+	try {
+		const parsed = parseCff(program);
+		if (!parsed) return void 0;
+		font = parsed;
+	} catch {
+		return;
+	}
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		count: font.charStrings.length,
+		path: (gid) => {
+			const had = cache.get(gid);
+			if (had !== void 0 || cache.has(gid)) return had;
+			let out;
+			try {
+				out = runGlyph(font, gid);
+			} catch {
+				out = void 0;
+			}
+			cache.set(gid, out);
+			return out;
+		}
+	};
+}
+/**
+* TN 5176 §13 — the NAME a CFF gives each glyph, inverted.
+*
+* A simple font selects its glyphs by name, not by index: `/Differences` says
+* code 2 is `g18`, and only the program's charset says which glyph `g18` is.
+* TAMReview.pdf sets most of its body in a Cambria subset named that way.
+*
+* @param program The raw CFF bytes.
+* @returns Glyph name → glyph index, or `undefined` for a CID-keyed program
+*          (which names nothing) or one that cannot be read.
+*/
+function cffNameToGid(program) {
+	try {
+		return parseCff(program)?.nameToGid;
+	} catch {
+		return;
+	}
+}
+/**
+* TN 5176 §10 — the CID a CID-keyed CFF gives each glyph, inverted.
+*
+* A `CIDFontType0C` program is charset-ordered by CID, not by glyph index, so a
+* composite font's code (its CID) is not the index into `CharStrings`. Where the
+* program is not CID-keyed the two are the same and this gives nothing.
+*
+* @param program The raw CFF bytes.
+* @returns CID → glyph index, or `undefined` for a program that is not
+*          CID-keyed or cannot be read.
+*/
+function cffCidToGid(program) {
+	try {
+		return parseCff(program)?.cidToGid;
+	} catch {
+		return;
+	}
+}
+/** The `CFF ` table of an OpenType wrapper, where the program is one. */
+function openTypeCff(program) {
+	if (program.length < 12) return void 0;
+	const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+	if (view.getUint32(0) !== 1330926671) return void 0;
+	const count = view.getUint16(4);
+	for (let i = 0; i < count; i++) {
+		const at = 12 + i * 16;
+		if (at + 16 > program.length) break;
+		if (String.fromCharCode(program[at], program[at + 1], program[at + 2], program[at + 3]) !== "CFF ") continue;
+		const offset = view.getUint32(at + 8);
+		const length = view.getUint32(at + 12);
+		if (offset + length > program.length) return void 0;
+		return program.subarray(offset, offset + length);
+	}
+}
+function parseCff(program) {
+	if (program.length < 4) return void 0;
+	const names = readIndex(program, program[2] ?? 4);
+	if (!names) return void 0;
+	const tops = readIndex(program, names.end);
+	if (!tops || tops.items.length === 0) return void 0;
+	const strings = readIndex(program, tops.end);
+	if (!strings) return void 0;
+	const gsubrs = readIndex(program, strings.end);
+	if (!gsubrs) return void 0;
+	const top = parseDict(tops.items[0]);
+	const csOffset = top.get(17)?.[0];
+	if (csOffset === void 0) return void 0;
+	const charStrings = readIndex(program, csOffset);
+	if (!charStrings) return void 0;
+	const matrix = top.get(1207);
+	const scale = matrix && matrix.length >= 4 ? matrix[0] ?? .001 : .001;
+	const privateSubrs = (dict) => {
+		const priv = dict.get(18);
+		if (!priv || priv.length < 2) return [];
+		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 ?? [];
+	};
+	const isCid = top.has(1230);
+	let localSubrs;
+	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 select = fdSelectAt !== void 0 ? readFdSelect(program, fdSelectAt, charStrings.items.length) : void 0;
+		localSubrs = (gid) => subrsPerFd[select ? select[gid] ?? 0 : 0] ?? [];
+	} else {
+		const only = privateSubrs(top);
+		localSubrs = () => only;
+	}
+	const charsetAt = top.get(15)?.[0];
+	const sids = charsetAt !== void 0 && charsetAt > 2 ? readCharset(program, charsetAt, charStrings.items.length) : void 0;
+	const cidToGid = isCid ? sids : void 0;
+	const nameToGid = isCid ? void 0 : namesOf(sids, strings.items, charStrings.items.length);
+	return {
+		charStrings: charStrings.items,
+		globalSubrs: gsubrs.items,
+		localSubrs,
+		scale,
+		...cidToGid ? { cidToGid } : {},
+		...nameToGid ? { nameToGid } : {}
+	};
+}
+/**
+* TN 5176 §13 — glyph name → glyph index, from the charset's SIDs.
+*
+* An SID below 391 is one of the standard strings; above it indexes the
+* program's own String INDEX. A font with no charset uses ISOAdobe, which is
+* the standard strings in order — so the SID is the glyph index itself.
+*/
+function namesOf(sids, strings, glyphs) {
+	const nameOf = (sid) => {
+		if (sid < STANDARD_STRINGS.length) return STANDARD_STRINGS[sid];
+		const own = strings[sid - STANDARD_STRINGS.length];
+		return own ? new TextDecoder("latin1").decode(own) : void 0;
+	};
+	const out = /* @__PURE__ */ new Map();
+	if (sids) for (const [sid, gid] of sids) {
+		const name = nameOf(sid);
+		if (name !== void 0 && !out.has(name)) out.set(name, gid);
+	}
+	else for (let gid = 0; gid < glyphs && gid < STANDARD_STRINGS.length; gid++) {
+		const name = STANDARD_STRINGS[gid];
+		if (name !== void 0 && !out.has(name)) out.set(name, gid);
+	}
+	return out.size > 0 ? out : void 0;
+}
+/**
+* TN 5176 Appendix A — the 391 strings every CFF program shares. An SID below
+* this many is one of these; above it indexes the program's own String INDEX.
+*/
+var STANDARD_STRINGS = [
+	".notdef",
+	"space",
+	"exclam",
+	"quotedbl",
+	"numbersign",
+	"dollar",
+	"percent",
+	"ampersand",
+	"quoteright",
+	"parenleft",
+	"parenright",
+	"asterisk",
+	"plus",
+	"comma",
+	"hyphen",
+	"period",
+	"slash",
+	"zero",
+	"one",
+	"two",
+	"three",
+	"four",
+	"five",
+	"six",
+	"seven",
+	"eight",
+	"nine",
+	"colon",
+	"semicolon",
+	"less",
+	"equal",
+	"greater",
+	"question",
+	"at",
+	"A",
+	"B",
+	"C",
+	"D",
+	"E",
+	"F",
+	"G",
+	"H",
+	"I",
+	"J",
+	"K",
+	"L",
+	"M",
+	"N",
+	"O",
+	"P",
+	"Q",
+	"R",
+	"S",
+	"T",
+	"U",
+	"V",
+	"W",
+	"X",
+	"Y",
+	"Z",
+	"bracketleft",
+	"backslash",
+	"bracketright",
+	"asciicircum",
+	"underscore",
+	"quoteleft",
+	"a",
+	"b",
+	"c",
+	"d",
+	"e",
+	"f",
+	"g",
+	"h",
+	"i",
+	"j",
+	"k",
+	"l",
+	"m",
+	"n",
+	"o",
+	"p",
+	"q",
+	"r",
+	"s",
+	"t",
+	"u",
+	"v",
+	"w",
+	"x",
+	"y",
+	"z",
+	"braceleft",
+	"bar",
+	"braceright",
+	"asciitilde",
+	"exclamdown",
+	"cent",
+	"sterling",
+	"fraction",
+	"yen",
+	"florin",
+	"section",
+	"currency",
+	"quotesingle",
+	"quotedblleft",
+	"guillemotleft",
+	"guilsinglleft",
+	"guilsinglright",
+	"fi",
+	"fl",
+	"endash",
+	"dagger",
+	"daggerdbl",
+	"periodcentered",
+	"paragraph",
+	"bullet",
+	"quotesinglbase",
+	"quotedblbase",
+	"quotedblright",
+	"guillemotright",
+	"ellipsis",
+	"perthousand",
+	"questiondown",
+	"grave",
+	"acute",
+	"circumflex",
+	"tilde",
+	"macron",
+	"breve",
+	"dotaccent",
+	"dieresis",
+	"ring",
+	"cedilla",
+	"hungarumlaut",
+	"ogonek",
+	"caron",
+	"emdash",
+	"AE",
+	"ordfeminine",
+	"Lslash",
+	"Oslash",
+	"OE",
+	"ordmasculine",
+	"ae",
+	"dotlessi",
+	"lslash",
+	"oslash",
+	"oe",
+	"germandbls",
+	"onesuperior",
+	"logicalnot",
+	"mu",
+	"trademark",
+	"Eth",
+	"onehalf",
+	"plusminus",
+	"Thorn",
+	"onequarter",
+	"divide",
+	"brokenbar",
+	"degree",
+	"thorn",
+	"threequarters",
+	"twosuperior",
+	"registered",
+	"minus",
+	"eth",
+	"multiply",
+	"threesuperior",
+	"copyright",
+	"Aacute",
+	"Acircumflex",
+	"Adieresis",
+	"Agrave",
+	"Aring",
+	"Atilde",
+	"Ccedilla",
+	"Eacute",
+	"Ecircumflex",
+	"Edieresis",
+	"Egrave",
+	"Iacute",
+	"Icircumflex",
+	"Idieresis",
+	"Igrave",
+	"Ntilde",
+	"Oacute",
+	"Ocircumflex",
+	"Odieresis",
+	"Ograve",
+	"Otilde",
+	"Scaron",
+	"Uacute",
+	"Ucircumflex",
+	"Udieresis",
+	"Ugrave",
+	"Yacute",
+	"Ydieresis",
+	"Zcaron",
+	"aacute",
+	"acircumflex",
+	"adieresis",
+	"agrave",
+	"aring",
+	"atilde",
+	"ccedilla",
+	"eacute",
+	"ecircumflex",
+	"edieresis",
+	"egrave",
+	"iacute",
+	"icircumflex",
+	"idieresis",
+	"igrave",
+	"ntilde",
+	"oacute",
+	"ocircumflex",
+	"odieresis",
+	"ograve",
+	"otilde",
+	"scaron",
+	"uacute",
+	"ucircumflex",
+	"udieresis",
+	"ugrave",
+	"yacute",
+	"ydieresis",
+	"zcaron",
+	"exclamsmall",
+	"Hungarumlautsmall",
+	"dollaroldstyle",
+	"dollarsuperior",
+	"ampersandsmall",
+	"Acutesmall",
+	"parenleftsuperior",
+	"parenrightsuperior",
+	"twodotenleader",
+	"onedotenleader",
+	"zerooldstyle",
+	"oneoldstyle",
+	"twooldstyle",
+	"threeoldstyle",
+	"fouroldstyle",
+	"fiveoldstyle",
+	"sixoldstyle",
+	"sevenoldstyle",
+	"eightoldstyle",
+	"nineoldstyle",
+	"commasuperior",
+	"threequartersemdash",
+	"periodsuperior",
+	"questionsmall",
+	"asuperior",
+	"bsuperior",
+	"centsuperior",
+	"dsuperior",
+	"esuperior",
+	"isuperior",
+	"lsuperior",
+	"msuperior",
+	"nsuperior",
+	"osuperior",
+	"rsuperior",
+	"ssuperior",
+	"tsuperior",
+	"ff",
+	"ffi",
+	"ffl",
+	"parenleftinferior",
+	"parenrightinferior",
+	"Circumflexsmall",
+	"hyphensuperior",
+	"Gravesmall",
+	"Asmall",
+	"Bsmall",
+	"Csmall",
+	"Dsmall",
+	"Esmall",
+	"Fsmall",
+	"Gsmall",
+	"Hsmall",
+	"Ismall",
+	"Jsmall",
+	"Ksmall",
+	"Lsmall",
+	"Msmall",
+	"Nsmall",
+	"Osmall",
+	"Psmall",
+	"Qsmall",
+	"Rsmall",
+	"Ssmall",
+	"Tsmall",
+	"Usmall",
+	"Vsmall",
+	"Wsmall",
+	"Xsmall",
+	"Ysmall",
+	"Zsmall",
+	"colonmonetary",
+	"onefitted",
+	"rupiah",
+	"Tildesmall",
+	"exclamdownsmall",
+	"centoldstyle",
+	"Lslashsmall",
+	"Scaronsmall",
+	"Zcaronsmall",
+	"Dieresissmall",
+	"Brevesmall",
+	"Caronsmall",
+	"Dotaccentsmall",
+	"Macronsmall",
+	"figuredash",
+	"hypheninferior",
+	"Ogoneksmall",
+	"Ringsmall",
+	"Cedillasmall",
+	"questiondownsmall",
+	"oneeighth",
+	"threeeighths",
+	"fiveeighths",
+	"seveneighths",
+	"onethird",
+	"twothirds",
+	"zerosuperior",
+	"foursuperior",
+	"fivesuperior",
+	"sixsuperior",
+	"sevensuperior",
+	"eightsuperior",
+	"ninesuperior",
+	"zeroinferior",
+	"oneinferior",
+	"twoinferior",
+	"threeinferior",
+	"fourinferior",
+	"fiveinferior",
+	"sixinferior",
+	"seveninferior",
+	"eightinferior",
+	"nineinferior",
+	"centinferior",
+	"dollarinferior",
+	"periodinferior",
+	"commainferior",
+	"Agravesmall",
+	"Aacutesmall",
+	"Acircumflexsmall",
+	"Atildesmall",
+	"Adieresissmall",
+	"Aringsmall",
+	"AEsmall",
+	"Ccedillasmall",
+	"Egravesmall",
+	"Eacutesmall",
+	"Ecircumflexsmall",
+	"Edieresissmall",
+	"Igravesmall",
+	"Iacutesmall",
+	"Icircumflexsmall",
+	"Idieresissmall",
+	"Ethsmall",
+	"Ntildesmall",
+	"Ogravesmall",
+	"Oacutesmall",
+	"Ocircumflexsmall",
+	"Otildesmall",
+	"Odieresissmall",
+	"OEsmall",
+	"Oslashsmall",
+	"Ugravesmall",
+	"Uacutesmall",
+	"Ucircumflexsmall",
+	"Udieresissmall",
+	"Yacutesmall",
+	"Thornsmall",
+	"Ydieresissmall",
+	"001.000",
+	"001.001",
+	"001.002",
+	"001.003",
+	"Black",
+	"Bold",
+	"Book",
+	"Light",
+	"Medium",
+	"Regular",
+	"Roman",
+	"Semibold"
+];
+/** TN 5176 §5 — an INDEX: a count, an offset size, the offsets, then the data. */
+function readIndex(data, at) {
+	if (at < 0 || at + 2 > data.length) return void 0;
+	const count = data[at] << 8 | data[at + 1];
+	if (count === 0) return {
+		items: [],
+		end: at + 2
+	};
+	const offSize = data[at + 2] ?? 1;
+	if (offSize < 1 || offSize > 4) return void 0;
+	const offsets = [];
+	let p = at + 3;
+	for (let i = 0; i <= count; i++) {
+		let v = 0;
+		for (let k = 0; k < offSize; k++) v = v << 8 | (data[p++] ?? 0);
+		offsets.push(v);
+	}
+	const base = p - 1;
+	const items = [];
+	for (let i = 0; i < count; i++) {
+		const from = base + (offsets[i] ?? 1);
+		const to = base + (offsets[i + 1] ?? 1);
+		if (from < 0 || to > data.length || to < from) return void 0;
+		items.push(data.subarray(from, to));
+	}
+	return {
+		items,
+		end: base + (offsets[count] ?? 1)
+	};
+}
+/**
+* TN 5176 §4 — a DICT: operands then an operator. Two-byte operators (`12 x`)
+* are keyed as `1200 + x` so one map holds both.
+*/
+function parseDict(data) {
+	const out = /* @__PURE__ */ new Map();
+	let operands = [];
+	for (let i = 0; i < data.length;) {
+		const b = data[i];
+		if (b <= 21) {
+			const key = b === 12 ? 1200 + (data[i + 1] ?? 0) : b;
+			i += b === 12 ? 2 : 1;
+			out.set(key, operands);
+			operands = [];
+		} else if (b === 28) {
+			operands.push((data[i + 1] << 8 | data[i + 2]) << 16 >> 16);
+			i += 3;
+		} else if (b === 29) {
+			operands.push(data[i + 1] << 24 | data[i + 2] << 16 | data[i + 3] << 8 | data[i + 4] | 0);
+			i += 5;
+		} else if (b === 30) {
+			let text = "";
+			i++;
+			let done = false;
+			while (i < data.length && !done) {
+				const byte = data[i++];
+				for (const nibble of [byte >> 4, byte & 15]) if (nibble <= 9) text += String(nibble);
+				else if (nibble === 10) text += ".";
+				else if (nibble === 11) text += "E";
+				else if (nibble === 12) text += "E-";
+				else if (nibble === 14) text += "-";
+				else if (nibble === 15) {
+					done = true;
+					break;
+				}
+			}
+			operands.push(Number.parseFloat(text) || 0);
+		} else if (b >= 32 && b <= 246) {
+			operands.push(b - 139);
+			i++;
+		} else if (b >= 247 && b <= 250) {
+			operands.push((b - 247) * 256 + (data[i + 1] ?? 0) + 108);
+			i += 2;
+		} else if (b >= 251 && b <= 254) {
+			operands.push(-(b - 251) * 256 - (data[i + 1] ?? 0) - 108);
+			i += 2;
+		} else i++;
+	}
+	return out;
+}
+/** TN 5176 §19 — FDSelect: which Private DICT each glyph belongs to. */
+function readFdSelect(data, at, glyphs) {
+	if (at < 0 || at >= data.length) return void 0;
+	const out = new Array(glyphs).fill(0);
+	const format = data[at];
+	if (format === 0) {
+		for (let i = 0; i < glyphs; i++) out[i] = data[at + 1 + i] ?? 0;
+		return out;
+	}
+	if (format !== 3) return void 0;
+	const ranges = data[at + 1] << 8 | data[at + 2];
+	let p = at + 3;
+	let first = data[p] << 8 | data[p + 1];
+	p += 2;
+	for (let r = 0; r < ranges; r++) {
+		const fd = data[p];
+		const next = data[p + 1] << 8 | data[p + 2];
+		p += 3;
+		for (let g = first; g < next && g < glyphs; g++) out[g] = fd;
+		first = next;
+	}
+	return out;
+}
+/** TN 5176 §13 — the charset, which for a CID-keyed font lists CIDs by glyph. */
+function readCharset(data, at, glyphs) {
+	if (at < 0 || at >= data.length) return void 0;
+	const out = /* @__PURE__ */ new Map();
+	out.set(0, 0);
+	const format = data[at];
+	let p = at + 1;
+	if (format === 0) {
+		for (let gid = 1; gid < glyphs && p + 1 < data.length; gid++, p += 2) out.set(data[p] << 8 | data[p + 1], gid);
+		return out;
+	}
+	if (format !== 1 && format !== 2) return void 0;
+	const wide = format === 2;
+	for (let gid = 1; gid < glyphs && p < data.length;) {
+		const first = data[p] << 8 | data[p + 1];
+		const left = wide ? data[p + 2] << 8 | data[p + 3] : data[p + 2];
+		p += wide ? 4 : 3;
+		for (let k = 0; k <= left && gid < glyphs; k++) out.set(first + k, gid++);
+	}
+	return out;
+}
+/** TN 5177 §4.7 — the index a subroutine call is biased by. */
+function bias(subrs) {
+	return subrs.length < 1240 ? 107 : subrs.length < 33900 ? 1131 : 32768;
+}
+/** 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) {
+	const program = font.charStrings[gid];
+	if (!program) return void 0;
+	const local = font.localSubrs(gid);
+	const localBias = bias(local);
+	const globalBias = bias(font.globalSubrs);
+	const out = [];
+	const stack = [];
+	const trans = [];
+	let x = 0;
+	let y = 0;
+	let stems = 0;
+	let open = false;
+	let widthParsed = false;
+	let steps = 0;
+	const moveTo = (nx, ny) => {
+		if (open) out.push({ op: "close" });
+		out.push({
+			op: "move",
+			x: nx,
+			y: ny
+		});
+		open = true;
+	};
+	const lineTo = (nx, ny) => {
+		out.push({
+			op: "line",
+			x: nx,
+			y: ny
+		});
+	};
+	const curveTo = (x1, y1, x2, y2, nx, ny) => {
+		out.push({
+			op: "cubic",
+			x1,
+			y1,
+			x2,
+			y2,
+			x: nx,
+			y: ny
+		});
+	};
+	const takeWidth = (arity) => {
+		if (widthParsed) return;
+		widthParsed = true;
+		if (arity === "even" ? stack.length % 2 === 1 : stack.length > arity) stack.shift();
+	};
+	const run = (code, depth) => {
+		for (let i = 0; i < code.length;) {
+			if (++steps > MAX_STEPS) return false;
+			const b = code[i++];
+			if (b >= 32 || b === 28) {
+				if (b === 28) {
+					stack.push((code[i] << 8 | code[i + 1]) << 16 >> 16);
+					i += 2;
+				} else if (b <= 246) stack.push(b - 139);
+				else if (b <= 250) stack.push((b - 247) * 256 + (code[i++] ?? 0) + 108);
+				else if (b <= 254) stack.push(-(b - 251) * 256 - (code[i++] ?? 0) - 108);
+				else {
+					stack.push((code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3] | 0) / 65536);
+					i += 4;
+				}
+				continue;
+			}
+			switch (b) {
+				case 1:
+				case 3:
+				case 18:
+				case 23:
+					takeWidth("even");
+					stems += stack.length >> 1;
+					stack.length = 0;
+					break;
+				case 19:
+				case 20:
+					takeWidth("even");
+					stems += stack.length >> 1;
+					stack.length = 0;
+					i += stems + 7 >> 3;
+					break;
+				case 21:
+					takeWidth(2);
+					x += stack[stack.length - 2] ?? 0;
+					y += stack[stack.length - 1] ?? 0;
+					moveTo(x, y);
+					stack.length = 0;
+					break;
+				case 22:
+					takeWidth(1);
+					x += stack[stack.length - 1] ?? 0;
+					moveTo(x, y);
+					stack.length = 0;
+					break;
+				case 4:
+					takeWidth(1);
+					y += stack[stack.length - 1] ?? 0;
+					moveTo(x, y);
+					stack.length = 0;
+					break;
+				case 5:
+					for (let k = 0; k + 1 < stack.length; k += 2) {
+						x += stack[k];
+						y += stack[k + 1];
+						lineTo(x, y);
+					}
+					stack.length = 0;
+					break;
+				case 6:
+				case 7: {
+					let horizontal = b === 6;
+					for (const d of stack) {
+						if (horizontal) x += d;
+						else y += d;
+						lineTo(x, y);
+						horizontal = !horizontal;
+					}
+					stack.length = 0;
+					break;
+				}
+				case 8:
+					for (let k = 0; k + 5 < stack.length; k += 6) curve(stack, k);
+					stack.length = 0;
+					break;
+				case 24:
+					{
+						let k = 0;
+						for (; k + 5 < stack.length - 2; k += 6) curve(stack, k);
+						x += stack[k] ?? 0;
+						y += stack[k + 1] ?? 0;
+						lineTo(x, y);
+					}
+					stack.length = 0;
+					break;
+				case 25:
+					{
+						let k = 0;
+						for (; stack.length - k > 6; k += 2) {
+							x += stack[k];
+							y += stack[k + 1];
+							lineTo(x, y);
+						}
+						curve(stack, k);
+					}
+					stack.length = 0;
+					break;
+				case 26:
+				case 27: {
+					let k = 0;
+					let d1 = 0;
+					if (stack.length % 4 === 1) d1 = stack[k++];
+					for (; k + 3 < stack.length; k += 4) {
+						const vertical = b === 26;
+						const x1 = vertical ? x + d1 : x + stack[k];
+						const y1 = vertical ? y + stack[k] : y + d1;
+						const x2 = x1 + stack[k + 1];
+						const y2 = y1 + stack[k + 2];
+						x = vertical ? x2 : x2 + stack[k + 3];
+						y = vertical ? y2 + stack[k + 3] : y2;
+						curveTo(x1, y1, x2, y2, x, y);
+						d1 = 0;
+					}
+					stack.length = 0;
+					break;
+				}
+				case 30:
+				case 31: {
+					let horizontal = b === 31;
+					let k = 0;
+					while (k + 3 < stack.length) {
+						const last = stack.length - k === 5;
+						const x1 = horizontal ? x + stack[k] : x;
+						const y1 = horizontal ? y : y + stack[k];
+						const x2 = x1 + stack[k + 1];
+						const y2 = y1 + stack[k + 2];
+						if (horizontal) {
+							y = y2 + stack[k + 3];
+							x = x2 + (last ? stack[k + 4] : 0);
+						} else {
+							x = x2 + stack[k + 3];
+							y = y2 + (last ? stack[k + 4] : 0);
+						}
+						curveTo(x1, y1, x2, y2, x, y);
+						k += 4;
+						horizontal = !horizontal;
+					}
+					stack.length = 0;
+					break;
+				}
+				case 10:
+				case 29: {
+					const sub = (b === 10 ? local : font.globalSubrs)[(stack.pop() ?? 0) + (b === 10 ? localBias : globalBias)];
+					if (sub && depth < MAX_CALL_DEPTH && !run(sub, depth + 1)) return false;
+					break;
+				}
+				case 11: return true;
+				case 14:
+					takeWidth(stack.length > 4 ? 4 : 0);
+					if (open) out.push({ op: "close" });
+					open = false;
+					return false;
+				case 12: {
+					const op2 = code[i++];
+					runEscape(op2, stack, trans);
+					if (op2 === 35 || op2 === 34 || op2 === 36 || op2 === 37) {
+						const drawn = flexCurves(op2, stack, x, y);
+						for (const c of drawn.curves) curveTo(c[0], c[1], c[2], c[3], c[4], c[5]);
+						x = drawn.x;
+						y = drawn.y;
+					}
+					stack.length = 0;
+					break;
+				}
+				default:
+					stack.length = 0;
+					break;
+			}
+		}
+		return true;
+	};
+	function curve(operands, k) {
+		const x1 = x + (operands[k] ?? 0);
+		const y1 = y + (operands[k + 1] ?? 0);
+		const x2 = x1 + (operands[k + 2] ?? 0);
+		const y2 = y1 + (operands[k + 3] ?? 0);
+		x = x2 + (operands[k + 4] ?? 0);
+		y = y2 + (operands[k + 5] ?? 0);
+		curveTo(x1, y1, x2, y2, x, y);
+	}
+	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));
+}
+function runEscape(op, stack, trans) {
+	switch (op) {
+		case 3:
+		case 4:
+		case 10:
+		case 11:
+		case 12:
+		case 24:
+			{
+				const b = stack.pop() ?? 0;
+				const a = stack.pop() ?? 0;
+				stack.push(op === 3 ? a !== 0 && b !== 0 ? 1 : 0 : op === 4 ? a !== 0 || b !== 0 ? 1 : 0 : op === 10 ? a + b : op === 11 ? a - b : op === 12 ? b === 0 ? 0 : a / b : a * b);
+			}
+			break;
+		case 5:
+			stack.push((stack.pop() ?? 0) === 0 ? 1 : 0);
+			break;
+		case 9:
+			stack.push(Math.abs(stack.pop() ?? 0));
+			break;
+		case 14:
+			stack.push(-(stack.pop() ?? 0));
+			break;
+		case 18:
+			stack.pop();
+			break;
+		case 20: {
+			const index = stack.pop() ?? 0;
+			trans[index & 31] = stack.pop() ?? 0;
+			break;
+		}
+		case 21:
+			stack.push(trans[(stack.pop() ?? 0) & 31] ?? 0);
+			break;
+		case 26:
+			stack.push(Math.sqrt(Math.abs(stack.pop() ?? 0)));
+			break;
+		case 27: {
+			const v = stack[stack.length - 1] ?? 0;
+			stack.push(v);
+			break;
+		}
+		case 28: {
+			const b = stack.pop() ?? 0;
+			const a = stack.pop() ?? 0;
+			stack.push(b, a);
+			break;
+		}
+		default: break;
+	}
+}
+/**
+* TN 5177 §4.2 — the flex operators, which draw two curves as one. `hflex` and
+* friends leave axes implicit; this expands them to the six-tuples to draw.
+*/
+function flexCurves(op, stack, x0, y0) {
+	const n = (i) => stack[i] ?? 0;
+	const curves = [];
+	let x = x0;
+	let y = y0;
+	const push = (dxs, dys) => {
+		const x1 = x + (dxs[0] ?? 0);
+		const y1 = y + (dys[0] ?? 0);
+		const x2 = x1 + (dxs[1] ?? 0);
+		const y2 = y1 + (dys[1] ?? 0);
+		x = x2 + (dxs[2] ?? 0);
+		y = y2 + (dys[2] ?? 0);
+		curves.push([
+			x1,
+			y1,
+			x2,
+			y2,
+			x,
+			y
+		]);
+	};
+	if (op === 35) {
+		push([
+			n(0),
+			n(2),
+			n(4)
+		], [
+			n(1),
+			n(3),
+			n(5)
+		]);
+		push([
+			n(6),
+			n(8),
+			n(10)
+		], [
+			n(7),
+			n(9),
+			n(11)
+		]);
+	} else if (op === 34) {
+		const startY = y;
+		push([
+			n(0),
+			n(1),
+			n(3)
+		], [
+			0,
+			n(2),
+			0
+		]);
+		push([
+			n(4),
+			n(6),
+			0
+		], [
+			0,
+			startY - y,
+			0
+		]);
+		y = startY;
+	} else if (op === 36) {
+		const startY = y;
+		push([
+			n(0),
+			n(2),
+			n(4)
+		], [
+			n(1),
+			n(3),
+			0
+		]);
+		push([
+			n(5),
+			n(7),
+			n(8)
+		], [
+			0,
+			n(6),
+			startY - (y + n(6))
+		]);
+		y = startY;
+	} else if (op === 37) {
+		const startX = x;
+		const startY = y;
+		let dx = 0;
+		let dy = 0;
+		for (let k = 0; k < 10; k += 2) {
+			dx += n(k);
+			dy += n(k + 1);
+		}
+		push([
+			n(0),
+			n(2),
+			n(4)
+		], [
+			n(1),
+			n(3),
+			n(5)
+		]);
+		const lastIsX = Math.abs(dx) > Math.abs(dy);
+		const endX = lastIsX ? x + n(6) + n(8) + n(10) : startX;
+		const endY = lastIsX ? startY : y + n(7) + n(9) + n(10);
+		const x1 = x + n(6);
+		const y1 = y + n(7);
+		const x2 = x1 + n(8);
+		const y2 = y1 + n(9);
+		curves.push([
+			x1,
+			y1,
+			x2,
+			y2,
+			endX,
+			endY
+		]);
+		x = endX;
+		y = endY;
+	}
+	return {
+		curves,
+		x,
+		y
+	};
+}
+function scaleSeg(seg, k) {
+	if (seg.op === "close") return seg;
+	if (seg.op === "cubic") return {
+		op: "cubic",
+		x1: seg.x1 * k,
+		y1: seg.y1 * k,
+		x2: seg.x2 * k,
+		y2: seg.y2 * k,
+		x: seg.x * k,
+		y: seg.y * k
+	};
+	return {
+		op: seg.op,
+		x: seg.x * k,
+		y: seg.y * k
+	};
+}
+//#endregion
+export { cffCidToGid, cffNameToGid, cffOutlineSource, openTypeCff };