pdf-codec 1.6.0 → 1.7.0

package/dist/cff-bounds.cjs

@@ -0,0 +1,432 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+const require_cff = require("./cff.cjs");
+//#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 (!require_sfnt.hasBytes(code, offset + 1, 2)) return;
+		const raw = require_sfnt.u16(code, offset + 1);
+		return {
+			value: raw >= 32768 ? raw - 65536 : raw,
+			endOffset: offset + 3
+		};
+	}
+	if (b0 === CS_OPERAND_FIXED) {
+		if (!require_sfnt.hasBytes(code, offset + 1, 4)) return;
+		return {
+			value: (require_sfnt.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 (!require_sfnt.hasBytes(code, offset + 1, 1)) return;
+		return {
+			value: (b0 - CS_OPERAND_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX + require_sfnt.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 (!require_sfnt.hasBytes(code, offset + 1, 1)) return;
+		return {
+			value: -(b0 - CS_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX - require_sfnt.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 (!require_sfnt.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) || !require_sfnt.hasBytes(bytes, offset, size)) return;
+	const subrsOffset = require_cff.parseCffDict(bytes.subarray(offset, offset + size))?.get(19)?.[0];
+	if (subrsOffset === void 0 || !Number.isInteger(subrsOffset)) return;
+	return require_cff.readCffIndex(bytes, offset + subrsOffset);
+}
+function parseCffGlyphBounds(bytes) {
+	if (!require_sfnt.hasBytes(bytes, 0, CFF_HEADER_MIN_SIZE) || require_sfnt.u8(bytes, 0) !== CFF_MAJOR_VERSION) return;
+	const headerSize = require_sfnt.u8(bytes, CFF_HEADER_SIZE_OFFSET);
+	if (headerSize < CFF_HEADER_MIN_SIZE) return;
+	const nameIndex = require_cff.readCffIndex(bytes, headerSize);
+	if (nameIndex === void 0) return;
+	const topDictIndex = require_cff.readCffIndex(bytes, nameIndex.endOffset);
+	const topDictBytes = topDictIndex?.entry(0);
+	if (topDictIndex === void 0 || topDictBytes === void 0) return;
+	const topDict = require_cff.parseCffDict(topDictBytes);
+	if (topDict === void 0 || topDict.has(1230)) return;
+	const stringIndex = require_cff.readCffIndex(bytes, topDictIndex.endOffset);
+	if (stringIndex === void 0) return;
+	const globalSubrs = require_cff.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 = require_cff.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
+exports.parseCffGlyphBounds = parseCffGlyphBounds;

package/dist/cff-bounds.d.cts

@@ -0,0 +1,9 @@
+import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.cjs";
+//#region src/cff-bounds.d.ts
+interface CffGlyphBounds {
+  readonly numGlyphs: number;
+  bounds(glyphId: number): GlyphInkBounds | undefined;
+}
+declare function parseCffGlyphBounds(bytes: Uint8Array<ArrayBuffer>): CffGlyphBounds | undefined;
+//#endregion
+export { CffGlyphBounds, parseCffGlyphBounds };

package/dist/cff-bounds.d.ts

@@ -0,0 +1,9 @@
+import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.js";
+//#region src/cff-bounds.d.ts
+interface CffGlyphBounds {
+  readonly numGlyphs: number;
+  bounds(glyphId: number): GlyphInkBounds | undefined;
+}
+declare function parseCffGlyphBounds(bytes: Uint8Array<ArrayBuffer>): CffGlyphBounds | undefined;
+//#endregion
+export { CffGlyphBounds, parseCffGlyphBounds };