pdf-codec 1.6.0 → 1.7.0

package/dist/glyf.js

@@ -1,4 +1,5 @@
 import { f2dot14, hasBytes, i16, sfntTableBytes, u16, u32, u8 } from "./sfnt.js";
+import { unionGlyphInkBounds } from "./glyph-bounds.js";
 //#region src/glyf.ts
 const LOCA_SHORT_ENTRY_SIZE = 2;
 const LOCA_LONG_ENTRY_SIZE = 4;
@@ -20,6 +21,9 @@ const WE_HAVE_A_SCALE = 8;
 const MORE_COMPONENTS = 32;
 const WE_HAVE_AN_X_AND_Y_SCALE = 64;
 const WE_HAVE_A_TWO_BY_TWO = 128;
+const SCALED_COMPONENT_OFFSET = 2048;
+const UNSCALED_COMPONENT_OFFSET = 4096;
+const MAX_COMPOSITE_DEPTH = 5;
 const COMPONENT_RECORD_HEADER_SIZE = 4;
 function signedByte(value) {
 	return value >= 128 ? value - 256 : value;
@@ -87,6 +91,31 @@ function readComponents(glyph) {
 		if ((flags & MORE_COMPONENTS) === 0) return components;
 	}
 }
+function placeComponentBounds(bounds, component) {
+	const [a, b, c, d] = component.transform ?? [
+		1,
+		0,
+		0,
+		1
+	];
+	const corners = [
+		[bounds.xMin, bounds.yMin],
+		[bounds.xMax, bounds.yMin],
+		[bounds.xMin, bounds.yMax],
+		[bounds.xMax, bounds.yMax]
+	];
+	const xs = corners.map(([x, y]) => a * x + c * y);
+	const ys = corners.map(([x, y]) => b * x + d * y);
+	const scaledOffset = (component.flags & SCALED_COMPONENT_OFFSET) !== 0 && (component.flags & UNSCALED_COMPONENT_OFFSET) === 0;
+	const dx = scaledOffset ? a * component.argument1 + c * component.argument2 : component.argument1;
+	const dy = scaledOffset ? b * component.argument1 + d * component.argument2 : component.argument2;
+	return {
+		xMin: Math.min(...xs) + dx,
+		yMin: Math.min(...ys) + dy,
+		xMax: Math.max(...xs) + dx,
+		yMax: Math.max(...ys) + dy
+	};
+}
 function parseGlyf(font, options) {
 	const glyfBytes = sfntTableBytes(font, "glyf");
 	const loca = parseLoca(font, options);
@@ -109,16 +138,43 @@ function parseGlyf(font, options) {
 			yMax: i16(glyph, 8)
 		};
 	};
+	const compositeComponents = (glyphId) => {
+		const header = glyphHeader(glyphId);
+		if (header === void 0 || header.numberOfContours >= 0) return;
+		const glyph = glyphBytes(glyphId);
+		return glyph === void 0 ? void 0 : readComponents(glyph);
+	};
+	const resolveInkBounds = (glyphId, depth) => {
+		const header = glyphHeader(glyphId);
+		if (header === void 0) return;
+		if (header.numberOfContours >= 0) return {
+			xMin: header.xMin,
+			yMin: header.yMin,
+			xMax: header.xMax,
+			yMax: header.yMax
+		};
+		if (depth >= MAX_COMPOSITE_DEPTH) return;
+		const components = compositeComponents(glyphId);
+		if (components === void 0) return;
+		let bounds;
+		for (const component of components) {
+			if (!component.argsAreXyValues) return;
+			const componentBytes = glyphBytes(component.glyphIndex);
+			if (componentBytes === void 0) return;
+			if (componentBytes.length === 0) continue;
+			const componentBounds = resolveInkBounds(component.glyphIndex, depth + 1);
+			if (componentBounds === void 0) return;
+			const placed = placeComponentBounds(componentBounds, component);
+			bounds = bounds === void 0 ? placed : unionGlyphInkBounds(bounds, placed);
+		}
+		return bounds;
+	};
 	return {
 		numGlyphs: options.numGlyphs,
 		glyphBytes,
 		glyphHeader,
-		compositeComponents(glyphId) {
-			const header = glyphHeader(glyphId);
-			if (header === void 0 || header.numberOfContours >= 0) return;
-			const glyph = glyphBytes(glyphId);
-			return glyph === void 0 ? void 0 : readComponents(glyph);
-		}
+		compositeComponents,
+		glyphInkBounds: (glyphId) => resolveInkBounds(glyphId, 0)
 	};
 }
 //#endregion

package/dist/glyph-bounds-BV_Z40KS.d.cts

@@ -0,0 +1,10 @@
+//#region src/glyph-bounds.d.ts
+interface GlyphInkBounds {
+  readonly xMin: number;
+  readonly yMin: number;
+  readonly xMax: number;
+  readonly yMax: number;
+}
+declare function unionGlyphInkBounds(a: GlyphInkBounds, b: GlyphInkBounds): GlyphInkBounds;
+//#endregion
+export { unionGlyphInkBounds as n, GlyphInkBounds as t };

package/dist/glyph-bounds-BV_Z40KS.d.ts

@@ -0,0 +1,10 @@
+//#region src/glyph-bounds.d.ts
+interface GlyphInkBounds {
+  readonly xMin: number;
+  readonly yMin: number;
+  readonly xMax: number;
+  readonly yMax: number;
+}
+declare function unionGlyphInkBounds(a: GlyphInkBounds, b: GlyphInkBounds): GlyphInkBounds;
+//#endregion
+export { unionGlyphInkBounds as n, GlyphInkBounds as t };

package/dist/glyph-bounds.cjs

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/glyph-bounds.ts
+function unionGlyphInkBounds(a, b) {
+	return {
+		xMin: Math.min(a.xMin, b.xMin),
+		yMin: Math.min(a.yMin, b.yMin),
+		xMax: Math.max(a.xMax, b.xMax),
+		yMax: Math.max(a.yMax, b.yMax)
+	};
+}
+//#endregion
+exports.unionGlyphInkBounds = unionGlyphInkBounds;

package/dist/glyph-bounds.d.cts

@@ -0,0 +1,2 @@
+import { n as unionGlyphInkBounds, t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.cjs";
+export { GlyphInkBounds, unionGlyphInkBounds };

package/dist/glyph-bounds.d.ts

@@ -0,0 +1,2 @@
+import { n as unionGlyphInkBounds, t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.js";
+export { GlyphInkBounds, unionGlyphInkBounds };

package/dist/glyph-bounds.js

@@ -0,0 +1,11 @@
+//#region src/glyph-bounds.ts
+function unionGlyphInkBounds(a, b) {
+	return {
+		xMin: Math.min(a.xMin, b.xMin),
+		yMin: Math.min(a.yMin, b.yMin),
+		xMax: Math.max(a.xMax, b.xMax),
+		yMax: Math.max(a.yMax, b.yMax)
+	};
+}
+//#endregion
+export { unionGlyphInkBounds };

package/dist/image/jbig2-arith.cjs

@@ -0,0 +1,432 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/image/jbig2-arith.ts
+const QE_STATES = [
+	[
+		22017,
+		1,
+		1,
+		1
+	],
+	[
+		13313,
+		2,
+		6,
+		0
+	],
+	[
+		6145,
+		3,
+		9,
+		0
+	],
+	[
+		2753,
+		4,
+		12,
+		0
+	],
+	[
+		1313,
+		5,
+		29,
+		0
+	],
+	[
+		545,
+		38,
+		33,
+		0
+	],
+	[
+		22017,
+		7,
+		6,
+		1
+	],
+	[
+		21505,
+		8,
+		14,
+		0
+	],
+	[
+		18433,
+		9,
+		14,
+		0
+	],
+	[
+		14337,
+		10,
+		14,
+		0
+	],
+	[
+		12289,
+		11,
+		17,
+		0
+	],
+	[
+		9217,
+		12,
+		18,
+		0
+	],
+	[
+		7169,
+		13,
+		20,
+		0
+	],
+	[
+		5633,
+		29,
+		21,
+		0
+	],
+	[
+		22017,
+		15,
+		14,
+		1
+	],
+	[
+		21505,
+		16,
+		14,
+		0
+	],
+	[
+		20737,
+		17,
+		15,
+		0
+	],
+	[
+		18433,
+		18,
+		16,
+		0
+	],
+	[
+		14337,
+		19,
+		17,
+		0
+	],
+	[
+		13313,
+		20,
+		18,
+		0
+	],
+	[
+		12289,
+		21,
+		19,
+		0
+	],
+	[
+		10241,
+		22,
+		19,
+		0
+	],
+	[
+		9217,
+		23,
+		20,
+		0
+	],
+	[
+		8705,
+		24,
+		21,
+		0
+	],
+	[
+		7169,
+		25,
+		22,
+		0
+	],
+	[
+		6145,
+		26,
+		23,
+		0
+	],
+	[
+		5633,
+		27,
+		24,
+		0
+	],
+	[
+		5121,
+		28,
+		25,
+		0
+	],
+	[
+		4609,
+		29,
+		26,
+		0
+	],
+	[
+		4353,
+		30,
+		27,
+		0
+	],
+	[
+		2753,
+		31,
+		28,
+		0
+	],
+	[
+		2497,
+		32,
+		29,
+		0
+	],
+	[
+		2209,
+		33,
+		30,
+		0
+	],
+	[
+		1313,
+		34,
+		31,
+		0
+	],
+	[
+		1089,
+		35,
+		32,
+		0
+	],
+	[
+		673,
+		36,
+		33,
+		0
+	],
+	[
+		545,
+		37,
+		34,
+		0
+	],
+	[
+		321,
+		38,
+		35,
+		0
+	],
+	[
+		273,
+		39,
+		36,
+		0
+	],
+	[
+		133,
+		40,
+		37,
+		0
+	],
+	[
+		73,
+		41,
+		38,
+		0
+	],
+	[
+		37,
+		42,
+		39,
+		0
+	],
+	[
+		21,
+		43,
+		40,
+		0
+	],
+	[
+		9,
+		44,
+		41,
+		0
+	],
+	[
+		5,
+		45,
+		42,
+		0
+	],
+	[
+		1,
+		45,
+		43,
+		0
+	],
+	[
+		22017,
+		46,
+		46,
+		0
+	]
+];
+const QE_VALUE = Uint16Array.from(QE_STATES, (row) => row[0]);
+const QE_NMPS = Uint8Array.from(QE_STATES, (row) => row[1]);
+const QE_NLPS = Uint8Array.from(QE_STATES, (row) => row[2]);
+const QE_SWITCH = Uint8Array.from(QE_STATES, (row) => row[3]);
+function createArithContexts(contextBits) {
+	return new Uint8Array(1 << contextBits);
+}
+const A_INITIAL = 32768;
+const C_INITIAL_SHIFT = 16;
+const INITDEC_C_SHIFT = 7;
+const PAST_END_BYTE = 255;
+var MqDecoder = class {
+	data;
+	start;
+	end;
+	bp;
+	c = 0;
+	a = 0;
+	ct = 0;
+	constructor(data, start = 0, end = data.length) {
+		this.data = data;
+		this.start = start;
+		this.end = end;
+		this.bp = start;
+		this.c = this.byteAt(this.bp) << C_INITIAL_SHIFT >>> 0;
+		this.byteIn();
+		this.c = this.c << INITDEC_C_SHIFT >>> 0;
+		this.ct -= INITDEC_C_SHIFT;
+		this.a = A_INITIAL;
+	}
+	byteAt(index) {
+		return index >= this.start && index < this.end ? this.data[index] ?? PAST_END_BYTE : PAST_END_BYTE;
+	}
+	byteIn() {
+		if (this.byteAt(this.bp) === 255) {
+			if (this.byteAt(this.bp + 1) > 143) {
+				this.c = this.c + 65280 >>> 0;
+				this.ct = 8;
+				return;
+			}
+			this.bp++;
+			this.c = this.c + (this.byteAt(this.bp) << 9) >>> 0;
+			this.ct = 7;
+			return;
+		}
+		this.bp++;
+		this.c = this.c + (this.byteAt(this.bp) << 8) >>> 0;
+		this.ct = 8;
+	}
+	renormalise() {
+		do {
+			if (this.ct === 0) this.byteIn();
+			this.a = this.a << 1 & 65535;
+			this.c = this.c << 1 >>> 0;
+			this.ct--;
+		} while ((this.a & A_INITIAL) === 0);
+	}
+	decode(contexts, contextIndex) {
+		const state = contexts[contextIndex] ?? 0;
+		let index = state >> 1;
+		let mps = state & 1;
+		const qe = QE_VALUE[index] ?? 0;
+		this.a -= qe;
+		let decision;
+		if (this.c >>> 16 < qe) {
+			if (this.a < qe) {
+				decision = mps;
+				index = QE_NMPS[index] ?? 0;
+			} else {
+				decision = 1 - mps;
+				if (QE_SWITCH[index] === 1) mps = 1 - mps;
+				index = QE_NLPS[index] ?? 0;
+			}
+			this.a = qe;
+		} else {
+			this.c = this.c - (qe << 16) >>> 0;
+			if ((this.a & A_INITIAL) !== 0) return mps;
+			if (this.a < qe) {
+				decision = 1 - mps;
+				if (QE_SWITCH[index] === 1) mps = 1 - mps;
+				index = QE_NLPS[index] ?? 0;
+			} else {
+				decision = mps;
+				index = QE_NMPS[index] ?? 0;
+			}
+		}
+		this.renormalise();
+		contexts[contextIndex] = index << 1 | mps;
+		return decision;
+	}
+};
+const INTEGER_CONTEXT_BITS = 9;
+function createIntegerContexts() {
+	return createArithContexts(INTEGER_CONTEXT_BITS);
+}
+const INTEGER_RANGES = [
+	[2, 0],
+	[4, 4],
+	[6, 20],
+	[8, 84],
+	[12, 340],
+	[32, 4436]
+];
+function decodeInteger(mq, contexts) {
+	let prev = 1;
+	const nextBit = () => {
+		const bit = mq.decode(contexts, prev);
+		prev = prev < 256 ? prev << 1 | bit : (prev << 1 | bit) & 511 | 256;
+		return bit;
+	};
+	const readBits = (count) => {
+		let value = 0;
+		for (let i = 0; i < count; i++) value = value * 2 + nextBit();
+		return value;
+	};
+	const sign = nextBit();
+	let magnitude = 0;
+	let matched = false;
+	for (let i = 0; i < INTEGER_RANGES.length - 1; i++) if (nextBit() === 0) {
+		const [bits, offset] = INTEGER_RANGES[i] ?? [0, 0];
+		magnitude = readBits(bits) + offset;
+		matched = true;
+		break;
+	}
+	if (!matched) {
+		const [bits, offset] = INTEGER_RANGES[INTEGER_RANGES.length - 1] ?? [0, 0];
+		magnitude = readBits(bits) + offset;
+	}
+	if (sign === 1) return magnitude === 0 ? void 0 : -magnitude;
+	return magnitude;
+}
+function createSymbolIdContexts(codeLength) {
+	return createArithContexts(codeLength + 1);
+}
+function decodeSymbolId(mq, contexts, codeLength) {
+	let prev = 1;
+	for (let i = 0; i < codeLength; i++) prev = prev << 1 | mq.decode(contexts, prev);
+	return prev - (1 << codeLength);
+}
+//#endregion
+exports.MqDecoder = MqDecoder;
+exports.createArithContexts = createArithContexts;
+exports.createIntegerContexts = createIntegerContexts;
+exports.createSymbolIdContexts = createSymbolIdContexts;
+exports.decodeInteger = decodeInteger;
+exports.decodeSymbolId = decodeSymbolId;

package/dist/image/jbig2-arith.d.cts

@@ -0,0 +1,23 @@
+//#region src/image/jbig2-arith.d.ts
+type ArithContexts = Uint8Array<ArrayBuffer>;
+declare function createArithContexts(contextBits: number): ArithContexts;
+declare class MqDecoder {
+  private readonly data;
+  private readonly start;
+  private readonly end;
+  private bp;
+  private c;
+  private a;
+  private ct;
+  constructor(data: Uint8Array<ArrayBuffer>, start?: number, end?: number);
+  private byteAt;
+  private byteIn;
+  private renormalise;
+  decode(contexts: ArithContexts, contextIndex: number): number;
+}
+declare function createIntegerContexts(): ArithContexts;
+declare function decodeInteger(mq: MqDecoder, contexts: ArithContexts): number | undefined;
+declare function createSymbolIdContexts(codeLength: number): ArithContexts;
+declare function decodeSymbolId(mq: MqDecoder, contexts: ArithContexts, codeLength: number): number;
+//#endregion
+export { ArithContexts, MqDecoder, createArithContexts, createIntegerContexts, createSymbolIdContexts, decodeInteger, decodeSymbolId };

package/dist/image/jbig2-arith.d.ts

@@ -0,0 +1,23 @@
+//#region src/image/jbig2-arith.d.ts
+type ArithContexts = Uint8Array<ArrayBuffer>;
+declare function createArithContexts(contextBits: number): ArithContexts;
+declare class MqDecoder {
+  private readonly data;
+  private readonly start;
+  private readonly end;
+  private bp;
+  private c;
+  private a;
+  private ct;
+  constructor(data: Uint8Array<ArrayBuffer>, start?: number, end?: number);
+  private byteAt;
+  private byteIn;
+  private renormalise;
+  decode(contexts: ArithContexts, contextIndex: number): number;
+}
+declare function createIntegerContexts(): ArithContexts;
+declare function decodeInteger(mq: MqDecoder, contexts: ArithContexts): number | undefined;
+declare function createSymbolIdContexts(codeLength: number): ArithContexts;
+declare function decodeSymbolId(mq: MqDecoder, contexts: ArithContexts, codeLength: number): number;
+//#endregion
+export { ArithContexts, MqDecoder, createArithContexts, createIntegerContexts, createSymbolIdContexts, decodeInteger, decodeSymbolId };