pdf-codec 1.5.0 → 1.7.0

package/dist/glyf.js

@@ -0,0 +1,181 @@
+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;
+const LOCA_SHORT_OFFSET_SCALE = 2;
+function parseLoca(font, options) {
+	const bytes = sfntTableBytes(font, "loca");
+	if (bytes === void 0) return;
+	const entryCount = options.numGlyphs + 1;
+	const entrySize = options.indexToLocFormat === 0 ? LOCA_SHORT_ENTRY_SIZE : LOCA_LONG_ENTRY_SIZE;
+	if (!hasBytes(bytes, 0, entryCount * entrySize)) return;
+	const offsets = [];
+	for (let i = 0; i < entryCount; i++) offsets.push(options.indexToLocFormat === 0 ? u16(bytes, i * LOCA_SHORT_ENTRY_SIZE) * LOCA_SHORT_OFFSET_SCALE : u32(bytes, i * LOCA_LONG_ENTRY_SIZE));
+	return offsets;
+}
+const GLYPH_HEADER_SIZE = 10;
+const ARG_1_AND_2_ARE_WORDS = 1;
+const ARGS_ARE_XY_VALUES = 2;
+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;
+}
+function readComponents(glyph) {
+	const components = [];
+	let offset = GLYPH_HEADER_SIZE;
+	for (;;) {
+		if (!hasBytes(glyph, offset, COMPONENT_RECORD_HEADER_SIZE)) return;
+		const flags = u16(glyph, offset);
+		const glyphIndex = u16(glyph, offset + 2);
+		offset += COMPONENT_RECORD_HEADER_SIZE;
+		const argsAreWords = (flags & ARG_1_AND_2_ARE_WORDS) !== 0;
+		const argsAreXyValues = (flags & ARGS_ARE_XY_VALUES) !== 0;
+		const argsSize = argsAreWords ? 4 : 2;
+		if (!hasBytes(glyph, offset, argsSize)) return;
+		let argument1;
+		let argument2;
+		if (argsAreWords) {
+			argument1 = argsAreXyValues ? i16(glyph, offset) : u16(glyph, offset);
+			argument2 = argsAreXyValues ? i16(glyph, offset + 2) : u16(glyph, offset + 2);
+		} else {
+			argument1 = argsAreXyValues ? signedByte(u8(glyph, offset)) : u8(glyph, offset);
+			argument2 = argsAreXyValues ? signedByte(u8(glyph, offset + 1)) : u8(glyph, offset + 1);
+		}
+		offset += argsSize;
+		let transform;
+		if ((flags & WE_HAVE_A_SCALE) !== 0) {
+			if (!hasBytes(glyph, offset, 2)) return;
+			const scale = f2dot14(glyph, offset);
+			transform = [
+				scale,
+				0,
+				0,
+				scale
+			];
+			offset += 2;
+		} else if ((flags & WE_HAVE_AN_X_AND_Y_SCALE) !== 0) {
+			if (!hasBytes(glyph, offset, 4)) return;
+			transform = [
+				f2dot14(glyph, offset),
+				0,
+				0,
+				f2dot14(glyph, offset + 2)
+			];
+			offset += 4;
+		} else if ((flags & WE_HAVE_A_TWO_BY_TWO) !== 0) {
+			if (!hasBytes(glyph, offset, 8)) return;
+			transform = [
+				f2dot14(glyph, offset),
+				f2dot14(glyph, offset + 2),
+				f2dot14(glyph, offset + 4),
+				f2dot14(glyph, offset + 6)
+			];
+			offset += 8;
+		}
+		components.push({
+			flags,
+			glyphIndex,
+			argument1,
+			argument2,
+			argsAreXyValues,
+			transform
+		});
+		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);
+	if (glyfBytes === void 0 || loca === void 0) return;
+	const glyphBytes = (glyphId) => {
+		if (!Number.isInteger(glyphId) || glyphId < 0 || glyphId >= options.numGlyphs) return;
+		const start = loca[glyphId];
+		const end = loca[glyphId + 1];
+		if (end < start || !hasBytes(glyfBytes, start, end - start)) return;
+		return glyfBytes.subarray(start, end);
+	};
+	const glyphHeader = (glyphId) => {
+		const glyph = glyphBytes(glyphId);
+		if (glyph === void 0 || !hasBytes(glyph, 0, GLYPH_HEADER_SIZE)) return;
+		return {
+			numberOfContours: i16(glyph, 0),
+			xMin: i16(glyph, 2),
+			yMin: i16(glyph, 4),
+			xMax: i16(glyph, 6),
+			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,
+		glyphInkBounds: (glyphId) => resolveInkBounds(glyphId, 0)
+	};
+}
+//#endregion
+export { parseGlyf, parseLoca };

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/{math-hmtx.cjs → hmtx-table.cjs}

@@ -1,12 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sfnt = require("./sfnt.cjs");
-//#region src/math-hmtx.ts
+//#region src/hmtx-table.ts
 function parseHmtx(font) {
 	const hheaBytes = require_sfnt.sfntTableBytes(font, "hhea");
 	const hmtxBytes = require_sfnt.sfntTableBytes(font, "hmtx");
-	if (hheaBytes === void 0 || hmtxBytes === void 0) throw new Error("math font has no hhea/hmtx table");
+	if (hheaBytes === void 0 || hmtxBytes === void 0) throw new Error("font has no hhea/hmtx table");
 	const numberOfHMetrics = require_sfnt.u16(hheaBytes, 34);
-	if (numberOfHMetrics === 0) throw new Error("math font hhea numberOfHMetrics is zero");
+	if (numberOfHMetrics === 0) throw new Error("font hhea numberOfHMetrics is zero");
 	const lastWidth = require_sfnt.u16(hmtxBytes, (numberOfHMetrics - 1) * 4);
 	return { advanceWidth(glyphId) {
 		if (glyphId < numberOfHMetrics) return require_sfnt.u16(hmtxBytes, glyphId * 4);

package/dist/{math-hmtx.d.ts → hmtx-table.d.cts}

@@ -1,5 +1,5 @@
-import { SfntFont } from "./sfnt.js";
-//#region src/math-hmtx.d.ts
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/hmtx-table.d.ts
 interface HmtxTable {
   advanceWidth(glyphId: number): number;
 }

package/dist/{math-hmtx.d.cts → hmtx-table.d.ts}

@@ -1,5 +1,5 @@
-import { SfntFont } from "./sfnt.cjs";
-//#region src/math-hmtx.d.ts
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/hmtx-table.d.ts
 interface HmtxTable {
   advanceWidth(glyphId: number): number;
 }

package/dist/{math-hmtx.js → hmtx-table.js}

@@ -1,11 +1,11 @@
 import { sfntTableBytes, u16 } from "./sfnt.js";
-//#region src/math-hmtx.ts
+//#region src/hmtx-table.ts
 function parseHmtx(font) {
 	const hheaBytes = sfntTableBytes(font, "hhea");
 	const hmtxBytes = sfntTableBytes(font, "hmtx");
-	if (hheaBytes === void 0 || hmtxBytes === void 0) throw new Error("math font has no hhea/hmtx table");
+	if (hheaBytes === void 0 || hmtxBytes === void 0) throw new Error("font has no hhea/hmtx table");
 	const numberOfHMetrics = u16(hheaBytes, 34);
-	if (numberOfHMetrics === 0) throw new Error("math font hhea numberOfHMetrics is zero");
+	if (numberOfHMetrics === 0) throw new Error("font hhea numberOfHMetrics is zero");
 	const lastWidth = u16(hmtxBytes, (numberOfHMetrics - 1) * 4);
 	return { advanceWidth(glyphId) {
 		if (glyphId < numberOfHMetrics) return u16(hmtxBytes, glyphId * 4);

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;