pdf-codec 1.5.0 → 1.7.0

package/dist/cff-bounds.js

@@ -0,0 +1,431 @@
+import { hasBytes, u16, u32, u8 } from "./sfnt.js";
+import { parseCffDict, readCffIndex } from "./cff.js";
+//#region src/cff-bounds.ts
+const CFF_HEADER_MIN_SIZE = 4;
+const CFF_MAJOR_VERSION = 1;
+const CFF_HEADER_SIZE_OFFSET = 2;
+const CS_OPERAND_INT16 = 28;
+const CS_OPERAND_FIXED = 255;
+const CS_OPERAND_SMALL_FIRST = 32;
+const CS_OPERAND_SMALL_LAST = 246;
+const CS_OPERAND_MEDIUM_FIRST = 247;
+const CS_OPERAND_MEDIUM_LAST = 250;
+const CS_OPERAND_NEGATIVE_MEDIUM_FIRST = 251;
+const CS_OPERAND_NEGATIVE_MEDIUM_LAST = 254;
+const CS_OPERAND_SMALL_BIAS = 139;
+const CS_OPERAND_MEDIUM_BIAS = 108;
+const CS_OPERAND_MEDIUM_FIRST_BYTE_BIAS = 247;
+const CS_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS = 251;
+const BYTE_RADIX = 256;
+const FIXED_POINT_SCALE = 65536;
+const OP_HSTEM = 1;
+const OP_VSTEM = 3;
+const OP_VMOVETO = 4;
+const OP_RLINETO = 5;
+const OP_HLINETO = 6;
+const OP_VLINETO = 7;
+const OP_RRCURVETO = 8;
+const OP_CALLSUBR = 10;
+const OP_RETURN = 11;
+const OP_ESCAPE = 12;
+const OP_ENDCHAR = 14;
+const OP_HSTEMHM = 18;
+const OP_HINTMASK = 19;
+const OP_CNTRMASK = 20;
+const OP_RMOVETO = 21;
+const OP_HMOVETO = 22;
+const OP_VSTEMHM = 23;
+const OP_RCURVELINE = 24;
+const OP_RLINECURVE = 25;
+const OP_VVCURVETO = 26;
+const OP_HHCURVETO = 27;
+const OP_CALLGSUBR = 29;
+const OP_VHCURVETO = 30;
+const OP_HVCURVETO = 31;
+const CHARSTRING_OPERATOR_LIMIT = 31;
+const ESC_HFLEX = 34;
+const ESC_FLEX = 35;
+const ESC_HFLEX1 = 36;
+const ESC_FLEX1 = 37;
+const SUBR_BIAS_SMALL_LIMIT = 1240;
+const SUBR_BIAS_MEDIUM_LIMIT = 33900;
+const SUBR_BIAS_SMALL = 107;
+const SUBR_BIAS_MEDIUM = 1131;
+const SUBR_BIAS_LARGE = 32768;
+const HINT_MASK_BITS_PER_BYTE = 8;
+const STEM_ARGS_PER_STEM = 2;
+const MAX_OPERAND_STACK = 48;
+const MAX_SUBR_DEPTH = 10;
+const MAX_OPERATIONS_PER_GLYPH = 1e5;
+const ENDCHAR_SEAC_ARG_COUNT = 4;
+function subrBias(count) {
+	if (count < SUBR_BIAS_SMALL_LIMIT) return SUBR_BIAS_SMALL;
+	if (count < SUBR_BIAS_MEDIUM_LIMIT) return SUBR_BIAS_MEDIUM;
+	return SUBR_BIAS_LARGE;
+}
+function includePoint(box, x, y) {
+	box.minX = Math.min(box.minX, x);
+	box.minY = Math.min(box.minY, y);
+	box.maxX = Math.max(box.maxX, x);
+	box.maxY = Math.max(box.maxY, y);
+	box.drawn = true;
+}
+function cubicAt(p0, p1, p2, p3, t) {
+	const s = 1 - t;
+	return s * s * s * p0 + 3 * s * s * t * p1 + 3 * s * t * t * p2 + t * t * t * p3;
+}
+function includeCubicAxis(p0, p1, p2, p3, apply) {
+	apply(p0);
+	apply(p3);
+	const a = -p0 + 3 * p1 - 3 * p2 + p3;
+	const b = 2 * (p0 - 2 * p1 + p2);
+	const c = p1 - p0;
+	const roots = [];
+	if (a === 0) {
+		if (b !== 0) roots.push(-c / b);
+	} else {
+		const discriminant = b * b - 4 * a * c;
+		if (discriminant >= 0) {
+			const root = Math.sqrt(discriminant);
+			roots.push((-b + root) / (2 * a), (-b - root) / (2 * a));
+		}
+	}
+	for (const t of roots) if (t > 0 && t < 1) apply(cubicAt(p0, p1, p2, p3, t));
+}
+function includeCubic(box, x0, y0, x1, y1, x2, y2, x3, y3) {
+	includeCubicAxis(x0, x1, x2, x3, (value) => {
+		box.minX = Math.min(box.minX, value);
+		box.maxX = Math.max(box.maxX, value);
+	});
+	includeCubicAxis(y0, y1, y2, y3, (value) => {
+		box.minY = Math.min(box.minY, value);
+		box.maxY = Math.max(box.maxY, value);
+	});
+	box.drawn = true;
+}
+function curveTo(state, dx1, dy1, dx2, dy2, dx3, dy3) {
+	const x0 = state.x;
+	const y0 = state.y;
+	const x1 = x0 + dx1;
+	const y1 = y0 + dy1;
+	const x2 = x1 + dx2;
+	const y2 = y1 + dy2;
+	const x3 = x2 + dx3;
+	const y3 = y2 + dy3;
+	includeCubic(state.box, x0, y0, x1, y1, x2, y2, x3, y3);
+	state.x = x3;
+	state.y = y3;
+}
+function lineTo(state, dx, dy) {
+	includePoint(state.box, state.x, state.y);
+	state.x += dx;
+	state.y += dy;
+	includePoint(state.box, state.x, state.y);
+}
+function moveTo(state, dx, dy) {
+	state.x += dx;
+	state.y += dy;
+}
+function takeWidth(state, evenArgs, expected) {
+	if (state.widthParsed) return;
+	state.widthParsed = true;
+	if (evenArgs ? state.stack.length % STEM_ARGS_PER_STEM !== 0 : state.stack.length > expected) state.stack.shift();
+}
+function readOperand(code, offset) {
+	const b0 = code[offset];
+	if (b0 === CS_OPERAND_INT16) {
+		if (!hasBytes(code, offset + 1, 2)) return;
+		const raw = u16(code, offset + 1);
+		return {
+			value: raw >= 32768 ? raw - 65536 : raw,
+			endOffset: offset + 3
+		};
+	}
+	if (b0 === CS_OPERAND_FIXED) {
+		if (!hasBytes(code, offset + 1, 4)) return;
+		return {
+			value: (u32(code, offset + 1) | 0) / FIXED_POINT_SCALE,
+			endOffset: offset + 5
+		};
+	}
+	if (b0 >= CS_OPERAND_SMALL_FIRST && b0 <= CS_OPERAND_SMALL_LAST) return {
+		value: b0 - CS_OPERAND_SMALL_BIAS,
+		endOffset: offset + 1
+	};
+	if (b0 >= CS_OPERAND_MEDIUM_FIRST && b0 <= CS_OPERAND_MEDIUM_LAST) {
+		if (!hasBytes(code, offset + 1, 1)) return;
+		return {
+			value: (b0 - CS_OPERAND_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX + u8(code, offset + 1) + CS_OPERAND_MEDIUM_BIAS,
+			endOffset: offset + 2
+		};
+	}
+	if (b0 >= CS_OPERAND_NEGATIVE_MEDIUM_FIRST && b0 <= CS_OPERAND_NEGATIVE_MEDIUM_LAST) {
+		if (!hasBytes(code, offset + 1, 1)) return;
+		return {
+			value: -(b0 - CS_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX - u8(code, offset + 1) - CS_OPERAND_MEDIUM_BIAS,
+			endOffset: offset + 2
+		};
+	}
+}
+function execute(code, state, context, depth) {
+	if (depth > MAX_SUBR_DEPTH) return false;
+	const stack = state.stack;
+	let i = 0;
+	while (i < code.length) {
+		state.operations += 1;
+		if (state.operations > MAX_OPERATIONS_PER_GLYPH) return false;
+		const b0 = code[i];
+		const operand = readOperand(code, i);
+		if (operand !== void 0) {
+			if (stack.length >= MAX_OPERAND_STACK) return false;
+			stack.push(operand.value);
+			i = operand.endOffset;
+			continue;
+		}
+		if (b0 > CHARSTRING_OPERATOR_LIMIT) return false;
+		i += 1;
+		switch (b0) {
+			case OP_HSTEM:
+			case OP_VSTEM:
+			case OP_HSTEMHM:
+			case OP_VSTEMHM:
+				takeWidth(state, true, 0);
+				state.stems += Math.floor(stack.length / STEM_ARGS_PER_STEM);
+				stack.length = 0;
+				break;
+			case OP_HINTMASK:
+			case OP_CNTRMASK: {
+				takeWidth(state, true, 0);
+				state.stems += Math.floor(stack.length / STEM_ARGS_PER_STEM);
+				stack.length = 0;
+				const maskBytes = Math.ceil(state.stems / HINT_MASK_BITS_PER_BYTE);
+				if (!hasBytes(code, i, maskBytes)) return false;
+				i += maskBytes;
+				break;
+			}
+			case OP_RMOVETO:
+				takeWidth(state, false, 2);
+				if (stack.length < 2) return false;
+				moveTo(state, stack[stack.length - 2], stack[stack.length - 1]);
+				stack.length = 0;
+				break;
+			case OP_HMOVETO:
+			case OP_VMOVETO: {
+				takeWidth(state, false, 1);
+				if (stack.length < 1) return false;
+				const delta = stack[stack.length - 1];
+				moveTo(state, b0 === OP_HMOVETO ? delta : 0, b0 === OP_HMOVETO ? 0 : delta);
+				stack.length = 0;
+				break;
+			}
+			case OP_RLINETO:
+				for (let k = 0; k + 1 < stack.length; k += 2) lineTo(state, stack[k], stack[k + 1]);
+				stack.length = 0;
+				break;
+			case OP_HLINETO:
+			case OP_VLINETO: {
+				let horizontal = b0 === OP_HLINETO;
+				for (const delta of stack) {
+					lineTo(state, horizontal ? delta : 0, horizontal ? 0 : delta);
+					horizontal = !horizontal;
+				}
+				stack.length = 0;
+				break;
+			}
+			case OP_RRCURVETO:
+				for (let k = 0; k + 5 < stack.length; k += 6) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + 3], stack[k + 4], stack[k + 5]);
+				stack.length = 0;
+				break;
+			case OP_RCURVELINE: {
+				let k = 0;
+				for (; k + 5 < stack.length - 2; k += 6) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + 3], stack[k + 4], stack[k + 5]);
+				if (k + 1 < stack.length) lineTo(state, stack[k], stack[k + 1]);
+				stack.length = 0;
+				break;
+			}
+			case OP_RLINECURVE: {
+				let k = 0;
+				for (; k + 1 < stack.length - 6; k += 2) lineTo(state, stack[k], stack[k + 1]);
+				if (k + 5 < stack.length) curveTo(state, stack[k], stack[k + 1], stack[k + 2], stack[k + 3], stack[k + 4], stack[k + 5]);
+				stack.length = 0;
+				break;
+			}
+			case OP_VVCURVETO:
+			case OP_HHCURVETO: {
+				let k = 0;
+				let firstCross = 0;
+				if (stack.length % 4 === 1) {
+					firstCross = stack[0];
+					k = 1;
+				}
+				for (; k + 3 < stack.length; k += 4) {
+					const cross = k <= 1 ? firstCross : 0;
+					if (b0 === OP_VVCURVETO) curveTo(state, cross, stack[k], stack[k + 1], stack[k + 2], 0, stack[k + 3]);
+					else curveTo(state, stack[k], cross, stack[k + 1], stack[k + 2], stack[k + 3], 0);
+				}
+				stack.length = 0;
+				break;
+			}
+			case OP_VHCURVETO:
+			case OP_HVCURVETO: {
+				let horizontal = b0 === OP_HVCURVETO;
+				let k = 0;
+				while (stack.length - k >= 4) {
+					const extra = stack.length - k === 5 ? stack[k + 4] : 0;
+					if (horizontal) curveTo(state, stack[k], 0, stack[k + 1], stack[k + 2], extra, stack[k + 3]);
+					else curveTo(state, 0, stack[k], stack[k + 1], stack[k + 2], stack[k + 3], extra);
+					k += 4;
+					horizontal = !horizontal;
+				}
+				stack.length = 0;
+				break;
+			}
+			case OP_CALLSUBR:
+			case OP_CALLGSUBR: {
+				const index = stack.pop();
+				if (index === void 0) return false;
+				const subrs = b0 === OP_CALLSUBR ? context.localSubrs : context.globalSubrs;
+				const bias = b0 === OP_CALLSUBR ? context.localBias : context.globalBias;
+				const code2 = subrs?.entry(index + bias);
+				if (code2 === void 0) return false;
+				if (!execute(code2, state, context, depth + 1)) return false;
+				break;
+			}
+			case OP_RETURN: return true;
+			case OP_ENDCHAR:
+				if (!state.widthParsed) {
+					state.widthParsed = true;
+					if (stack.length === 1 || stack.length === 5) stack.shift();
+				}
+				return stack.length < ENDCHAR_SEAC_ARG_COUNT;
+			case OP_ESCAPE: {
+				if (i >= code.length) return false;
+				const b1 = code[i];
+				i += 1;
+				if (!executeEscaped(b1, state)) return false;
+				break;
+			}
+			default: return false;
+		}
+	}
+	return true;
+}
+function executeEscaped(operator, state) {
+	const stack = state.stack;
+	const startY = state.y;
+	if (operator === ESC_FLEX) {
+		if (stack.length < 13) return false;
+		curveTo(state, stack[0], stack[1], stack[2], stack[3], stack[4], stack[5]);
+		curveTo(state, stack[6], stack[7], stack[8], stack[9], stack[10], stack[11]);
+		stack.length = 0;
+		return true;
+	}
+	if (operator === ESC_HFLEX) {
+		if (stack.length < 7) return false;
+		curveTo(state, stack[0], 0, stack[1], stack[2], stack[3], 0);
+		curveTo(state, stack[4], 0, stack[5], -stack[2], stack[6], 0);
+		stack.length = 0;
+		return true;
+	}
+	if (operator === ESC_HFLEX1) {
+		if (stack.length < 9) return false;
+		curveTo(state, stack[0], stack[1], stack[2], stack[3], stack[4], 0);
+		const dy5 = stack[7];
+		curveTo(state, stack[5], 0, stack[6], dy5, stack[8], startY - (state.y + dy5));
+		stack.length = 0;
+		return true;
+	}
+	if (operator === ESC_FLEX1) {
+		if (stack.length < 11) return false;
+		const startX = state.x;
+		let dx = 0;
+		let dy = 0;
+		for (let k = 0; k < 10; k += 2) {
+			dx += stack[k];
+			dy += stack[k + 1];
+		}
+		curveTo(state, stack[0], stack[1], stack[2], stack[3], stack[4], stack[5]);
+		const controlX = state.x + stack[6] + stack[8];
+		const controlY = state.y + stack[7] + stack[9];
+		if (Math.abs(dx) > Math.abs(dy)) curveTo(state, stack[6], stack[7], stack[8], stack[9], stack[10], startY - controlY);
+		else curveTo(state, stack[6], stack[7], stack[8], stack[9], startX - controlX, stack[10]);
+		stack.length = 0;
+		return true;
+	}
+	return false;
+}
+function readPrivateSubrs(bytes, privateOperands) {
+	if (privateOperands === void 0 || privateOperands.length < 2) return;
+	const size = privateOperands[0];
+	const offset = privateOperands[1];
+	if (!Number.isInteger(size) || !Number.isInteger(offset) || !hasBytes(bytes, offset, size)) return;
+	const subrsOffset = parseCffDict(bytes.subarray(offset, offset + size))?.get(19)?.[0];
+	if (subrsOffset === void 0 || !Number.isInteger(subrsOffset)) return;
+	return readCffIndex(bytes, offset + subrsOffset);
+}
+function parseCffGlyphBounds(bytes) {
+	if (!hasBytes(bytes, 0, CFF_HEADER_MIN_SIZE) || u8(bytes, 0) !== CFF_MAJOR_VERSION) return;
+	const headerSize = u8(bytes, CFF_HEADER_SIZE_OFFSET);
+	if (headerSize < CFF_HEADER_MIN_SIZE) return;
+	const nameIndex = readCffIndex(bytes, headerSize);
+	if (nameIndex === void 0) return;
+	const topDictIndex = readCffIndex(bytes, nameIndex.endOffset);
+	const topDictBytes = topDictIndex?.entry(0);
+	if (topDictIndex === void 0 || topDictBytes === void 0) return;
+	const topDict = parseCffDict(topDictBytes);
+	if (topDict === void 0 || topDict.has(1230)) return;
+	const stringIndex = readCffIndex(bytes, topDictIndex.endOffset);
+	if (stringIndex === void 0) return;
+	const globalSubrs = readCffIndex(bytes, stringIndex.endOffset);
+	if (globalSubrs === void 0) return;
+	const charStringsOffset = topDict.get(17)?.[0];
+	if (charStringsOffset === void 0 || !Number.isInteger(charStringsOffset)) return;
+	const charStrings = readCffIndex(bytes, charStringsOffset);
+	if (charStrings === void 0) return;
+	const localSubrs = readPrivateSubrs(bytes, topDict.get(18));
+	const context = {
+		charStrings,
+		globalSubrs,
+		localSubrs,
+		globalBias: subrBias(globalSubrs.count),
+		localBias: localSubrs === void 0 ? 0 : subrBias(localSubrs.count)
+	};
+	const memo = /* @__PURE__ */ new Map();
+	return {
+		numGlyphs: charStrings.count,
+		bounds(glyphId) {
+			if (memo.has(glyphId)) return memo.get(glyphId);
+			const computed = computeBounds(glyphId, context);
+			memo.set(glyphId, computed);
+			return computed;
+		}
+	};
+}
+function computeBounds(glyphId, context) {
+	const code = context.charStrings.entry(glyphId);
+	if (code === void 0) return;
+	const state = {
+		x: 0,
+		y: 0,
+		stack: [],
+		stems: 0,
+		widthParsed: false,
+		operations: 0,
+		box: {
+			minX: Infinity,
+			minY: Infinity,
+			maxX: -Infinity,
+			maxY: -Infinity,
+			drawn: false
+		}
+	};
+	if (!execute(code, state, context, 0) || !state.box.drawn) return;
+	return {
+		xMin: state.box.minX,
+		yMin: state.box.minY,
+		xMax: state.box.maxX,
+		yMax: state.box.maxY
+	};
+}
+//#endregion
+export { parseCffGlyphBounds };

package/dist/cff-probe.cjs

@@ -0,0 +1,35 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+const require_cff = require("./cff.cjs");
+//#region src/cff-probe.ts
+const CFF_HEADER_SIZE = 4;
+const CFF_MAJOR_VERSION = 1;
+const CFF_HEADER_SIZE_OFFSET = 2;
+function decodeAscii(bytes) {
+	let text = "";
+	for (const byte of bytes) text += String.fromCharCode(byte);
+	return text;
+}
+function probeCff(bytes) {
+	if (!require_sfnt.hasBytes(bytes, 0, CFF_HEADER_SIZE)) return;
+	const majorVersion = require_sfnt.u8(bytes, 0);
+	const minorVersion = require_sfnt.u8(bytes, 1);
+	const headerSize = require_sfnt.u8(bytes, CFF_HEADER_SIZE_OFFSET);
+	if (majorVersion !== CFF_MAJOR_VERSION || headerSize < CFF_HEADER_SIZE) return;
+	const nameIndex = require_cff.readCffIndex(bytes, headerSize);
+	if (nameIndex === void 0 || nameIndex.count === 0) return;
+	const nameBytes = nameIndex.entry(0);
+	if (nameBytes === void 0) return;
+	const topDictBytes = require_cff.readCffIndex(bytes, nameIndex.endOffset)?.entry(0);
+	if (topDictBytes === void 0) return;
+	const topDict = require_cff.parseCffDict(topDictBytes);
+	if (topDict === void 0) return;
+	return {
+		majorVersion,
+		minorVersion,
+		name: decodeAscii(nameBytes),
+		cidKeyed: topDict.has(require_cff.CFF_DICT_OP_ROS)
+	};
+}
+//#endregion
+exports.probeCff = probeCff;

package/dist/cff-probe.d.cts

@@ -0,0 +1,10 @@
+//#region src/cff-probe.d.ts
+interface CffProbeResult {
+  readonly majorVersion: number;
+  readonly minorVersion: number;
+  readonly name: string;
+  readonly cidKeyed: boolean;
+}
+declare function probeCff(bytes: Uint8Array<ArrayBuffer>): CffProbeResult | undefined;
+//#endregion
+export { CffProbeResult, probeCff };

package/dist/cff-probe.d.ts

@@ -0,0 +1,10 @@
+//#region src/cff-probe.d.ts
+interface CffProbeResult {
+  readonly majorVersion: number;
+  readonly minorVersion: number;
+  readonly name: string;
+  readonly cidKeyed: boolean;
+}
+declare function probeCff(bytes: Uint8Array<ArrayBuffer>): CffProbeResult | undefined;
+//#endregion
+export { CffProbeResult, probeCff };

package/dist/cff-probe.js

@@ -0,0 +1,34 @@
+import { hasBytes, u8 } from "./sfnt.js";
+import { CFF_DICT_OP_ROS, parseCffDict, readCffIndex } from "./cff.js";
+//#region src/cff-probe.ts
+const CFF_HEADER_SIZE = 4;
+const CFF_MAJOR_VERSION = 1;
+const CFF_HEADER_SIZE_OFFSET = 2;
+function decodeAscii(bytes) {
+	let text = "";
+	for (const byte of bytes) text += String.fromCharCode(byte);
+	return text;
+}
+function probeCff(bytes) {
+	if (!hasBytes(bytes, 0, CFF_HEADER_SIZE)) return;
+	const majorVersion = u8(bytes, 0);
+	const minorVersion = u8(bytes, 1);
+	const headerSize = u8(bytes, CFF_HEADER_SIZE_OFFSET);
+	if (majorVersion !== CFF_MAJOR_VERSION || headerSize < CFF_HEADER_SIZE) return;
+	const nameIndex = readCffIndex(bytes, headerSize);
+	if (nameIndex === void 0 || nameIndex.count === 0) return;
+	const nameBytes = nameIndex.entry(0);
+	if (nameBytes === void 0) return;
+	const topDictBytes = readCffIndex(bytes, nameIndex.endOffset)?.entry(0);
+	if (topDictBytes === void 0) return;
+	const topDict = parseCffDict(topDictBytes);
+	if (topDict === void 0) return;
+	return {
+		majorVersion,
+		minorVersion,
+		name: decodeAscii(nameBytes),
+		cidKeyed: topDict.has(CFF_DICT_OP_ROS)
+	};
+}
+//#endregion
+export { probeCff };

package/dist/cff.cjs

@@ -0,0 +1,158 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/cff.ts
+const CFF_ESCAPED_OPERATOR_BASE = 1200;
+const CFF_DICT_OP_CHARSET = 15;
+const CFF_DICT_OP_CHARSTRINGS = 17;
+const CFF_DICT_OP_PRIVATE = 18;
+const CFF_DICT_OP_SUBRS = 19;
+const CFF_DICT_OP_ROS = 1230;
+const INDEX_COUNT_SIZE = 2;
+const INDEX_OFF_SIZE_SIZE = 1;
+const MIN_OFF_SIZE = 1;
+const MAX_OFF_SIZE = 4;
+const DICT_OPERATOR_MAX = 21;
+const DICT_OPERATOR_ESCAPE = 12;
+const DICT_OPERAND_INT16 = 28;
+const DICT_OPERAND_INT32 = 29;
+const DICT_OPERAND_REAL = 30;
+const DICT_OPERAND_SMALL_FIRST = 32;
+const DICT_OPERAND_SMALL_LAST = 246;
+const DICT_OPERAND_MEDIUM_FIRST = 247;
+const DICT_OPERAND_MEDIUM_LAST = 250;
+const DICT_OPERAND_NEGATIVE_MEDIUM_FIRST = 251;
+const DICT_OPERAND_NEGATIVE_MEDIUM_LAST = 254;
+const DICT_OPERAND_SMALL_BIAS = 139;
+const DICT_OPERAND_MEDIUM_BIAS = 108;
+const DICT_OPERAND_MEDIUM_FIRST_BYTE_BIAS = 247;
+const DICT_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS = 251;
+const BYTE_RADIX = 256;
+const REAL_NIBBLE_DECIMAL_POINT = 10;
+const REAL_NIBBLE_EXPONENT = 11;
+const REAL_NIBBLE_NEGATIVE_EXPONENT = 12;
+const REAL_NIBBLE_RESERVED = 13;
+const REAL_NIBBLE_MINUS = 14;
+const REAL_NIBBLE_TERMINATOR = 15;
+const NIBBLES_PER_BYTE = 2;
+const HIGH_NIBBLE_SHIFT = 4;
+const LOW_NIBBLE_MASK = 15;
+function readOffsetAt(bytes, offset, offSize) {
+	if (offSize === 1) return require_sfnt.u8(bytes, offset);
+	if (offSize === 2) return require_sfnt.u16(bytes, offset);
+	if (offSize === 3) return require_sfnt.u24(bytes, offset);
+	return require_sfnt.u32(bytes, offset);
+}
+function readCffIndex(bytes, offset) {
+	if (!require_sfnt.hasBytes(bytes, offset, INDEX_COUNT_SIZE)) return;
+	const count = require_sfnt.u16(bytes, offset);
+	if (count === 0) return {
+		count: 0,
+		endOffset: offset + INDEX_COUNT_SIZE,
+		entry: () => void 0
+	};
+	if (!require_sfnt.hasBytes(bytes, offset + INDEX_COUNT_SIZE, INDEX_OFF_SIZE_SIZE)) return;
+	const offSize = require_sfnt.u8(bytes, offset + INDEX_COUNT_SIZE);
+	if (offSize < MIN_OFF_SIZE || offSize > MAX_OFF_SIZE) return;
+	const offsetArrayStart = offset + INDEX_COUNT_SIZE + INDEX_OFF_SIZE_SIZE;
+	const offsetArrayLength = (count + 1) * offSize;
+	if (!require_sfnt.hasBytes(bytes, offsetArrayStart, offsetArrayLength)) return;
+	const offsets = [];
+	for (let i = 0; i <= count; i++) offsets.push(readOffsetAt(bytes, offsetArrayStart + i * offSize, offSize));
+	if (offsets[0] !== 1) return;
+	for (let i = 1; i <= count; i++) if (offsets[i] < offsets[i - 1]) return;
+	const dataOrigin = offsetArrayStart + offsetArrayLength - 1;
+	const dataLength = offsets[count] - 1;
+	if (!require_sfnt.hasBytes(bytes, dataOrigin + 1, dataLength)) return;
+	return {
+		count,
+		endOffset: dataOrigin + 1 + dataLength,
+		entry: (index) => index < 0 || index >= count ? void 0 : bytes.subarray(dataOrigin + offsets[index], dataOrigin + offsets[index + 1])
+	};
+}
+function readRealOperand(data, start) {
+	let text = "";
+	for (let i = start; i < data.length; i++) {
+		const byte = data[i];
+		for (let n = 0; n < NIBBLES_PER_BYTE; n++) {
+			const nibble = n === 0 ? byte >> HIGH_NIBBLE_SHIFT : byte & LOW_NIBBLE_MASK;
+			if (nibble === REAL_NIBBLE_TERMINATOR) return {
+				value: Number(text),
+				endOffset: i + 1
+			};
+			if (nibble === REAL_NIBBLE_RESERVED) return;
+			if (nibble <= 9) text += String(nibble);
+			else if (nibble === REAL_NIBBLE_DECIMAL_POINT) text += ".";
+			else if (nibble === REAL_NIBBLE_EXPONENT) text += "E";
+			else if (nibble === REAL_NIBBLE_NEGATIVE_EXPONENT) text += "E-";
+			else if (nibble === REAL_NIBBLE_MINUS) text += "-";
+		}
+	}
+}
+function parseCffDict(data) {
+	const dict = /* @__PURE__ */ new Map();
+	let operands = [];
+	let i = 0;
+	while (i < data.length) {
+		const b0 = data[i];
+		if (b0 <= DICT_OPERATOR_MAX) {
+			let operator = b0;
+			i += 1;
+			if (b0 === DICT_OPERATOR_ESCAPE) {
+				if (i >= data.length) return;
+				operator = CFF_ESCAPED_OPERATOR_BASE + data[i];
+				i += 1;
+			}
+			dict.set(operator, operands);
+			operands = [];
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT16) {
+			if (!require_sfnt.hasBytes(data, i + 1, 2)) return;
+			const raw = require_sfnt.u16(data, i + 1);
+			operands.push(raw >= 32768 ? raw - 65536 : raw);
+			i += 3;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT32) {
+			if (!require_sfnt.hasBytes(data, i + 1, 4)) return;
+			operands.push(require_sfnt.u32(data, i + 1) | 0);
+			i += 5;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_REAL) {
+			const real = readRealOperand(data, i + 1);
+			if (real === void 0) return;
+			operands.push(real.value);
+			i = real.endOffset;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_SMALL_FIRST && b0 <= DICT_OPERAND_SMALL_LAST) {
+			operands.push(b0 - DICT_OPERAND_SMALL_BIAS);
+			i += 1;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_MEDIUM_FIRST && b0 <= DICT_OPERAND_MEDIUM_LAST) {
+			if (!require_sfnt.hasBytes(data, i + 1, 1)) return;
+			operands.push((b0 - DICT_OPERAND_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX + require_sfnt.u8(data, i + 1) + DICT_OPERAND_MEDIUM_BIAS);
+			i += 2;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_NEGATIVE_MEDIUM_FIRST && b0 <= DICT_OPERAND_NEGATIVE_MEDIUM_LAST) {
+			if (!require_sfnt.hasBytes(data, i + 1, 1)) return;
+			operands.push(-(b0 - DICT_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX - require_sfnt.u8(data, i + 1) - DICT_OPERAND_MEDIUM_BIAS);
+			i += 2;
+			continue;
+		}
+		return;
+	}
+	return dict;
+}
+//#endregion
+exports.CFF_DICT_OP_CHARSET = CFF_DICT_OP_CHARSET;
+exports.CFF_DICT_OP_CHARSTRINGS = CFF_DICT_OP_CHARSTRINGS;
+exports.CFF_DICT_OP_PRIVATE = CFF_DICT_OP_PRIVATE;
+exports.CFF_DICT_OP_ROS = CFF_DICT_OP_ROS;
+exports.CFF_DICT_OP_SUBRS = CFF_DICT_OP_SUBRS;
+exports.CFF_ESCAPED_OPERATOR_BASE = CFF_ESCAPED_OPERATOR_BASE;
+exports.parseCffDict = parseCffDict;
+exports.readCffIndex = readCffIndex;

package/dist/cff.d.cts

@@ -0,0 +1,17 @@
+//#region src/cff.d.ts
+interface CffIndex {
+  readonly count: number;
+  readonly endOffset: number;
+  entry(index: number): Uint8Array<ArrayBuffer> | undefined;
+}
+type CffDict = ReadonlyMap<number, readonly number[]>;
+declare const CFF_ESCAPED_OPERATOR_BASE = 1200;
+declare const CFF_DICT_OP_CHARSET = 15;
+declare const CFF_DICT_OP_CHARSTRINGS = 17;
+declare const CFF_DICT_OP_PRIVATE = 18;
+declare const CFF_DICT_OP_SUBRS = 19;
+declare const CFF_DICT_OP_ROS: number;
+declare function readCffIndex(bytes: Uint8Array<ArrayBuffer>, offset: number): CffIndex | undefined;
+declare function parseCffDict(data: Uint8Array<ArrayBuffer>): CffDict | undefined;
+//#endregion
+export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, CffDict, CffIndex, parseCffDict, readCffIndex };