pdf-codec 1.3.1 → 1.4.0

package/dist/bytes/crc32.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/bytes/crc32.ts
+const CRC32_POLYNOMIAL = 3988292384;
+const BYTE_VALUES = 256;
+const BITS_PER_BYTE = 8;
+const CRC32_TABLE = (() => {
+	const table = new Uint32Array(BYTE_VALUES);
+	for (let n = 0; n < BYTE_VALUES; n++) {
+		let c = n;
+		for (let k = 0; k < BITS_PER_BYTE; k++) c = (c & 1) === 1 ? CRC32_POLYNOMIAL ^ c >>> 1 : c >>> 1;
+		table[n] = c >>> 0;
+	}
+	return table;
+})();
+function crc32(bytes) {
+	let crc = 4294967295;
+	for (const byte of bytes) crc = CRC32_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+//#endregion
+exports.crc32 = crc32;

package/dist/bytes/crc32.d.cts

@@ -0,0 +1,4 @@
+//#region src/bytes/crc32.d.ts
+declare function crc32(bytes: Uint8Array<ArrayBuffer>): number;
+//#endregion
+export { crc32 };

package/dist/bytes/crc32.d.ts

@@ -0,0 +1,4 @@
+//#region src/bytes/crc32.d.ts
+declare function crc32(bytes: Uint8Array<ArrayBuffer>): number;
+//#endregion
+export { crc32 };

package/dist/bytes/crc32.js

@@ -0,0 +1,20 @@
+//#region src/bytes/crc32.ts
+const CRC32_POLYNOMIAL = 3988292384;
+const BYTE_VALUES = 256;
+const BITS_PER_BYTE = 8;
+const CRC32_TABLE = (() => {
+	const table = new Uint32Array(BYTE_VALUES);
+	for (let n = 0; n < BYTE_VALUES; n++) {
+		let c = n;
+		for (let k = 0; k < BITS_PER_BYTE; k++) c = (c & 1) === 1 ? CRC32_POLYNOMIAL ^ c >>> 1 : c >>> 1;
+		table[n] = c >>> 0;
+	}
+	return table;
+})();
+function crc32(bytes) {
+	let crc = 4294967295;
+	for (const byte of bytes) crc = CRC32_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+//#endregion
+export { crc32 };

package/dist/bytes/flate.cjs

@@ -0,0 +1,53 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_reader = require("./reader.cjs");
+const require_bytes_writer = require("./writer.cjs");
+let fflate = require("fflate");
+//#region src/bytes/flate.ts
+const MAX_INFLATE_OUTPUT_BYTES = 536870912;
+function deflate(data, level) {
+	return (0, fflate.zlibSync)(data, level === void 0 ? void 0 : { level });
+}
+function inflate(data) {
+	const out = (0, fflate.unzlibSync)(data);
+	if (out.length > 536870912) throw new Error(`inflated output exceeds the ${MAX_INFLATE_OUTPUT_BYTES}-byte limit`);
+	return out;
+}
+function inflateTolerant(data) {
+	try {
+		return {
+			bytes: inflate(data),
+			recovered: false
+		};
+	} catch {}
+	let offset = 0;
+	while (offset < data.length && require_bytes_reader.isAsciiWhitespace(data[offset])) offset++;
+	if (offset > 0) try {
+		return {
+			bytes: inflate(data.subarray(offset)),
+			recovered: true
+		};
+	} catch {}
+	try {
+		return {
+			bytes: (0, fflate.inflateSync)(data),
+			recovered: true
+		};
+	} catch {}
+	const chunks = [];
+	const unzlib = new fflate.Unzlib((chunk) => {
+		chunks.push(chunk);
+	});
+	try {
+		unzlib.push(data, false);
+	} catch {}
+	if (chunks.length === 0) throw new Error("unable to inflate stream: no data could be recovered");
+	return {
+		bytes: require_bytes_writer.concatBytes(chunks),
+		recovered: true
+	};
+}
+//#endregion
+exports.MAX_INFLATE_OUTPUT_BYTES = MAX_INFLATE_OUTPUT_BYTES;
+exports.deflate = deflate;
+exports.inflate = inflate;
+exports.inflateTolerant = inflateTolerant;

package/dist/bytes/flate.d.cts

@@ -0,0 +1,12 @@
+//#region src/bytes/flate.d.ts
+declare const MAX_INFLATE_OUTPUT_BYTES: number;
+type DeflateLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+declare function deflate(data: Uint8Array<ArrayBuffer>, level?: DeflateLevel): Uint8Array<ArrayBuffer>;
+declare function inflate(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+interface InflateResult {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly recovered: boolean;
+}
+declare function inflateTolerant(data: Uint8Array<ArrayBuffer>): InflateResult;
+//#endregion
+export { DeflateLevel, InflateResult, MAX_INFLATE_OUTPUT_BYTES, deflate, inflate, inflateTolerant };

package/dist/bytes/flate.d.ts

@@ -0,0 +1,12 @@
+//#region src/bytes/flate.d.ts
+declare const MAX_INFLATE_OUTPUT_BYTES: number;
+type DeflateLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+declare function deflate(data: Uint8Array<ArrayBuffer>, level?: DeflateLevel): Uint8Array<ArrayBuffer>;
+declare function inflate(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+interface InflateResult {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly recovered: boolean;
+}
+declare function inflateTolerant(data: Uint8Array<ArrayBuffer>): InflateResult;
+//#endregion
+export { DeflateLevel, InflateResult, MAX_INFLATE_OUTPUT_BYTES, deflate, inflate, inflateTolerant };

package/dist/bytes/flate.js

@@ -0,0 +1,49 @@
+import { isAsciiWhitespace } from "./reader.js";
+import { concatBytes } from "./writer.js";
+import { Unzlib, inflateSync, unzlibSync, zlibSync } from "fflate";
+//#region src/bytes/flate.ts
+const MAX_INFLATE_OUTPUT_BYTES = 536870912;
+function deflate(data, level) {
+	return zlibSync(data, level === void 0 ? void 0 : { level });
+}
+function inflate(data) {
+	const out = unzlibSync(data);
+	if (out.length > 536870912) throw new Error(`inflated output exceeds the ${MAX_INFLATE_OUTPUT_BYTES}-byte limit`);
+	return out;
+}
+function inflateTolerant(data) {
+	try {
+		return {
+			bytes: inflate(data),
+			recovered: false
+		};
+	} catch {}
+	let offset = 0;
+	while (offset < data.length && isAsciiWhitespace(data[offset])) offset++;
+	if (offset > 0) try {
+		return {
+			bytes: inflate(data.subarray(offset)),
+			recovered: true
+		};
+	} catch {}
+	try {
+		return {
+			bytes: inflateSync(data),
+			recovered: true
+		};
+	} catch {}
+	const chunks = [];
+	const unzlib = new Unzlib((chunk) => {
+		chunks.push(chunk);
+	});
+	try {
+		unzlib.push(data, false);
+	} catch {}
+	if (chunks.length === 0) throw new Error("unable to inflate stream: no data could be recovered");
+	return {
+		bytes: concatBytes(chunks),
+		recovered: true
+	};
+}
+//#endregion
+export { MAX_INFLATE_OUTPUT_BYTES, deflate, inflate, inflateTolerant };

package/dist/bytes/reader.cjs

@@ -0,0 +1,60 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/bytes/reader.ts
+const ASCII_WHITESPACE_BYTES = /* @__PURE__ */ new Set([
+	0,
+	9,
+	10,
+	12,
+	13,
+	32
+]);
+function isAsciiWhitespace(byte) {
+	return byte !== void 0 && ASCII_WHITESPACE_BYTES.has(byte);
+}
+var ByteReader = class {
+	bytes;
+	position = 0;
+	constructor(bytes) {
+		this.bytes = bytes;
+	}
+	get offset() {
+		return this.position;
+	}
+	get length() {
+		return this.bytes.length;
+	}
+	atEnd() {
+		return this.position >= this.bytes.length;
+	}
+	peek(aheadBy = 0) {
+		return this.bytes[this.position + aheadBy];
+	}
+	next() {
+		const byte = this.bytes[this.position];
+		if (byte !== void 0) this.position++;
+		return byte;
+	}
+	mark() {
+		return this.position;
+	}
+	reset(mark) {
+		this.position = mark;
+	}
+	seek(offset) {
+		this.position = offset;
+	}
+	slice(start, end) {
+		return this.bytes.subarray(start, end);
+	}
+	skipWhitespace() {
+		while (isAsciiWhitespace(this.peek())) this.position++;
+	}
+	matchKeyword(keyword) {
+		for (let i = 0; i < keyword.length; i++) if (this.peek(i) !== keyword.charCodeAt(i)) return false;
+		this.position += keyword.length;
+		return true;
+	}
+};
+//#endregion
+exports.ByteReader = ByteReader;
+exports.isAsciiWhitespace = isAsciiWhitespace;

package/dist/bytes/reader.d.cts

@@ -0,0 +1,20 @@
+//#region src/bytes/reader.d.ts
+declare function isAsciiWhitespace(byte: number | undefined): boolean;
+declare class ByteReader {
+  private readonly bytes;
+  private position;
+  constructor(bytes: Uint8Array<ArrayBuffer>);
+  get offset(): number;
+  get length(): number;
+  atEnd(): boolean;
+  peek(aheadBy?: number): number | undefined;
+  next(): number | undefined;
+  mark(): number;
+  reset(mark: number): void;
+  seek(offset: number): void;
+  slice(start: number, end: number): Uint8Array<ArrayBuffer>;
+  skipWhitespace(): void;
+  matchKeyword(keyword: string): boolean;
+}
+//#endregion
+export { ByteReader, isAsciiWhitespace };

package/dist/bytes/reader.d.ts

@@ -0,0 +1,20 @@
+//#region src/bytes/reader.d.ts
+declare function isAsciiWhitespace(byte: number | undefined): boolean;
+declare class ByteReader {
+  private readonly bytes;
+  private position;
+  constructor(bytes: Uint8Array<ArrayBuffer>);
+  get offset(): number;
+  get length(): number;
+  atEnd(): boolean;
+  peek(aheadBy?: number): number | undefined;
+  next(): number | undefined;
+  mark(): number;
+  reset(mark: number): void;
+  seek(offset: number): void;
+  slice(start: number, end: number): Uint8Array<ArrayBuffer>;
+  skipWhitespace(): void;
+  matchKeyword(keyword: string): boolean;
+}
+//#endregion
+export { ByteReader, isAsciiWhitespace };

package/dist/bytes/reader.js

@@ -0,0 +1,58 @@
+//#region src/bytes/reader.ts
+const ASCII_WHITESPACE_BYTES = /* @__PURE__ */ new Set([
+	0,
+	9,
+	10,
+	12,
+	13,
+	32
+]);
+function isAsciiWhitespace(byte) {
+	return byte !== void 0 && ASCII_WHITESPACE_BYTES.has(byte);
+}
+var ByteReader = class {
+	bytes;
+	position = 0;
+	constructor(bytes) {
+		this.bytes = bytes;
+	}
+	get offset() {
+		return this.position;
+	}
+	get length() {
+		return this.bytes.length;
+	}
+	atEnd() {
+		return this.position >= this.bytes.length;
+	}
+	peek(aheadBy = 0) {
+		return this.bytes[this.position + aheadBy];
+	}
+	next() {
+		const byte = this.bytes[this.position];
+		if (byte !== void 0) this.position++;
+		return byte;
+	}
+	mark() {
+		return this.position;
+	}
+	reset(mark) {
+		this.position = mark;
+	}
+	seek(offset) {
+		this.position = offset;
+	}
+	slice(start, end) {
+		return this.bytes.subarray(start, end);
+	}
+	skipWhitespace() {
+		while (isAsciiWhitespace(this.peek())) this.position++;
+	}
+	matchKeyword(keyword) {
+		for (let i = 0; i < keyword.length; i++) if (this.peek(i) !== keyword.charCodeAt(i)) return false;
+		this.position += keyword.length;
+		return true;
+	}
+};
+//#endregion
+export { ByteReader, isAsciiWhitespace };

package/dist/bytes/writer.cjs

@@ -0,0 +1,37 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/bytes/writer.ts
+var ByteWriter = class {
+	chunks = [];
+	byteLength = 0;
+	get length() {
+		return this.byteLength;
+	}
+	writeBytes(bytes) {
+		if (bytes.length === 0) return;
+		this.chunks.push(bytes);
+		this.byteLength += bytes.length;
+	}
+	writeByte(byte) {
+		this.writeBytes(new Uint8Array([byte]));
+	}
+	writeAscii(text) {
+		this.writeBytes(new TextEncoder().encode(text));
+	}
+	toBytes() {
+		const out = new Uint8Array(this.byteLength);
+		let offset = 0;
+		for (const chunk of this.chunks) {
+			out.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return out;
+	}
+};
+function concatBytes(chunks) {
+	const writer = new ByteWriter();
+	for (const chunk of chunks) writer.writeBytes(chunk);
+	return writer.toBytes();
+}
+//#endregion
+exports.ByteWriter = ByteWriter;
+exports.concatBytes = concatBytes;

package/dist/bytes/writer.d.cts

@@ -0,0 +1,13 @@
+//#region src/bytes/writer.d.ts
+declare class ByteWriter {
+  private readonly chunks;
+  private byteLength;
+  get length(): number;
+  writeBytes(bytes: Uint8Array<ArrayBuffer>): void;
+  writeByte(byte: number): void;
+  writeAscii(text: string): void;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function concatBytes(chunks: readonly Uint8Array<ArrayBuffer>[]): Uint8Array<ArrayBuffer>;
+//#endregion
+export { ByteWriter, concatBytes };

package/dist/bytes/writer.d.ts

@@ -0,0 +1,13 @@
+//#region src/bytes/writer.d.ts
+declare class ByteWriter {
+  private readonly chunks;
+  private byteLength;
+  get length(): number;
+  writeBytes(bytes: Uint8Array<ArrayBuffer>): void;
+  writeByte(byte: number): void;
+  writeAscii(text: string): void;
+  toBytes(): Uint8Array<ArrayBuffer>;
+}
+declare function concatBytes(chunks: readonly Uint8Array<ArrayBuffer>[]): Uint8Array<ArrayBuffer>;
+//#endregion
+export { ByteWriter, concatBytes };

package/dist/bytes/writer.js

@@ -0,0 +1,35 @@
+//#region src/bytes/writer.ts
+var ByteWriter = class {
+	chunks = [];
+	byteLength = 0;
+	get length() {
+		return this.byteLength;
+	}
+	writeBytes(bytes) {
+		if (bytes.length === 0) return;
+		this.chunks.push(bytes);
+		this.byteLength += bytes.length;
+	}
+	writeByte(byte) {
+		this.writeBytes(new Uint8Array([byte]));
+	}
+	writeAscii(text) {
+		this.writeBytes(new TextEncoder().encode(text));
+	}
+	toBytes() {
+		const out = new Uint8Array(this.byteLength);
+		let offset = 0;
+		for (const chunk of this.chunks) {
+			out.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return out;
+	}
+};
+function concatBytes(chunks) {
+	const writer = new ByteWriter();
+	for (const chunk of chunks) writer.writeBytes(chunk);
+	return writer.toBytes();
+}
+//#endregion
+export { ByteWriter, concatBytes };

package/dist/cmap.cjs

@@ -0,0 +1,110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_reader = require("./bytes/reader.cjs");
+const require_lexer = require("./lexer.cjs");
+//#region src/cmap.ts
+function hexBytesToNumber(bytes) {
+	let value = 0;
+	for (const byte of bytes) value = value * 256 + byte;
+	return value;
+}
+function decodeUtf16BEString(bytes) {
+	const units = [];
+	for (let i = 0; i + 1 < bytes.length; i += 2) units.push((bytes[i] ?? 0) << 8 | (bytes[i + 1] ?? 0));
+	return String.fromCharCode(...units);
+}
+function parseToUnicodeCMap(bytes, sink) {
+	const reader = new require_bytes_reader.ByteReader(bytes);
+	const map = /* @__PURE__ */ new Map();
+	for (;;) {
+		const token = require_lexer.nextToken(reader);
+		if (token === void 0) break;
+		if (token.kind === "keyword" && token.value === "beginbfchar") readBfChar(reader, map, sink);
+		else if (token.kind === "keyword" && token.value === "beginbfrange") readBfRange(reader, map, sink);
+	}
+	return { lookup: (code) => map.get(code) };
+}
+function readBfChar(reader, map, sink) {
+	for (;;) {
+		const srcTok = require_lexer.nextToken(reader);
+		if (srcTok === void 0) {
+			sink({
+				code: "pdf/cmap-truncated",
+				severity: "warning",
+				message: "bfchar section was truncated before endbfchar"
+			});
+			return;
+		}
+		if (srcTok.kind === "keyword" && srcTok.value === "endbfchar") return;
+		if (srcTok.kind !== "hexString") continue;
+		const dstTok = require_lexer.nextToken(reader);
+		if (dstTok?.kind !== "hexString") {
+			sink({
+				code: "pdf/cmap-entry-invalid",
+				severity: "warning",
+				message: "bfchar entry had no valid destination hex string"
+			});
+			continue;
+		}
+		map.set(hexBytesToNumber(srcTok.value), decodeUtf16BEString(dstTok.value));
+	}
+}
+function readBfRange(reader, map, sink) {
+	for (;;) {
+		const loTok = require_lexer.nextToken(reader);
+		if (loTok === void 0) {
+			sink({
+				code: "pdf/cmap-truncated",
+				severity: "warning",
+				message: "bfrange section was truncated before endbfrange"
+			});
+			return;
+		}
+		if (loTok.kind === "keyword" && loTok.value === "endbfrange") return;
+		if (loTok.kind !== "hexString") continue;
+		const hiTok = require_lexer.nextToken(reader);
+		if (hiTok?.kind !== "hexString") {
+			sink({
+				code: "pdf/cmap-entry-invalid",
+				severity: "warning",
+				message: "bfrange entry had no valid high-end hex string"
+			});
+			continue;
+		}
+		const lo = hexBytesToNumber(loTok.value);
+		const hi = hexBytesToNumber(hiTok.value);
+		const dstTok = require_lexer.nextToken(reader);
+		if (dstTok?.kind === "hexString") registerBfRangeSingle(map, lo, hi, dstTok.value);
+		else if (dstTok?.kind === "arrayStart") readBfRangeArray(reader, map, lo, sink);
+		else sink({
+			code: "pdf/cmap-entry-invalid",
+			severity: "warning",
+			message: "bfrange entry had no valid destination"
+		});
+	}
+}
+function registerBfRangeSingle(map, lo, hi, dstBytes) {
+	if (dstBytes.length < 2) return;
+	const prefix = decodeUtf16BEString(dstBytes.subarray(0, dstBytes.length - 2));
+	const baseUnit = (dstBytes[dstBytes.length - 2] ?? 0) << 8 | (dstBytes[dstBytes.length - 1] ?? 0);
+	for (let code = lo; code <= hi; code++) map.set(code, prefix + String.fromCharCode(baseUnit + (code - lo)));
+}
+function readBfRangeArray(reader, map, lo, sink) {
+	let code = lo;
+	for (;;) {
+		const token = require_lexer.nextToken(reader);
+		if (token === void 0) {
+			sink({
+				code: "pdf/cmap-truncated",
+				severity: "warning",
+				message: "bfrange array destination was truncated"
+			});
+			return;
+		}
+		if (token.kind === "arrayEnd") return;
+		if (token.kind !== "hexString") continue;
+		map.set(code, decodeUtf16BEString(token.value));
+		code++;
+	}
+}
+//#endregion
+exports.parseToUnicodeCMap = parseToUnicodeCMap;

package/dist/cmap.d.cts

@@ -0,0 +1,8 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+//#region src/cmap.d.ts
+interface ToUnicodeCMap {
+  lookup(code: number): string | undefined;
+}
+declare function parseToUnicodeCMap(bytes: Uint8Array<ArrayBuffer>, sink: PdfDiagnosticSink): ToUnicodeCMap;
+//#endregion
+export { ToUnicodeCMap, parseToUnicodeCMap };

package/dist/cmap.d.ts

@@ -0,0 +1,8 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+//#region src/cmap.d.ts
+interface ToUnicodeCMap {
+  lookup(code: number): string | undefined;
+}
+declare function parseToUnicodeCMap(bytes: Uint8Array<ArrayBuffer>, sink: PdfDiagnosticSink): ToUnicodeCMap;
+//#endregion
+export { ToUnicodeCMap, parseToUnicodeCMap };

package/dist/cmap.js

@@ -0,0 +1,109 @@
+import { ByteReader } from "./bytes/reader.js";
+import { nextToken } from "./lexer.js";
+//#region src/cmap.ts
+function hexBytesToNumber(bytes) {
+	let value = 0;
+	for (const byte of bytes) value = value * 256 + byte;
+	return value;
+}
+function decodeUtf16BEString(bytes) {
+	const units = [];
+	for (let i = 0; i + 1 < bytes.length; i += 2) units.push((bytes[i] ?? 0) << 8 | (bytes[i + 1] ?? 0));
+	return String.fromCharCode(...units);
+}
+function parseToUnicodeCMap(bytes, sink) {
+	const reader = new ByteReader(bytes);
+	const map = /* @__PURE__ */ new Map();
+	for (;;) {
+		const token = nextToken(reader);
+		if (token === void 0) break;
+		if (token.kind === "keyword" && token.value === "beginbfchar") readBfChar(reader, map, sink);
+		else if (token.kind === "keyword" && token.value === "beginbfrange") readBfRange(reader, map, sink);
+	}
+	return { lookup: (code) => map.get(code) };
+}
+function readBfChar(reader, map, sink) {
+	for (;;) {
+		const srcTok = nextToken(reader);
+		if (srcTok === void 0) {
+			sink({
+				code: "pdf/cmap-truncated",
+				severity: "warning",
+				message: "bfchar section was truncated before endbfchar"
+			});
+			return;
+		}
+		if (srcTok.kind === "keyword" && srcTok.value === "endbfchar") return;
+		if (srcTok.kind !== "hexString") continue;
+		const dstTok = nextToken(reader);
+		if (dstTok?.kind !== "hexString") {
+			sink({
+				code: "pdf/cmap-entry-invalid",
+				severity: "warning",
+				message: "bfchar entry had no valid destination hex string"
+			});
+			continue;
+		}
+		map.set(hexBytesToNumber(srcTok.value), decodeUtf16BEString(dstTok.value));
+	}
+}
+function readBfRange(reader, map, sink) {
+	for (;;) {
+		const loTok = nextToken(reader);
+		if (loTok === void 0) {
+			sink({
+				code: "pdf/cmap-truncated",
+				severity: "warning",
+				message: "bfrange section was truncated before endbfrange"
+			});
+			return;
+		}
+		if (loTok.kind === "keyword" && loTok.value === "endbfrange") return;
+		if (loTok.kind !== "hexString") continue;
+		const hiTok = nextToken(reader);
+		if (hiTok?.kind !== "hexString") {
+			sink({
+				code: "pdf/cmap-entry-invalid",
+				severity: "warning",
+				message: "bfrange entry had no valid high-end hex string"
+			});
+			continue;
+		}
+		const lo = hexBytesToNumber(loTok.value);
+		const hi = hexBytesToNumber(hiTok.value);
+		const dstTok = nextToken(reader);
+		if (dstTok?.kind === "hexString") registerBfRangeSingle(map, lo, hi, dstTok.value);
+		else if (dstTok?.kind === "arrayStart") readBfRangeArray(reader, map, lo, sink);
+		else sink({
+			code: "pdf/cmap-entry-invalid",
+			severity: "warning",
+			message: "bfrange entry had no valid destination"
+		});
+	}
+}
+function registerBfRangeSingle(map, lo, hi, dstBytes) {
+	if (dstBytes.length < 2) return;
+	const prefix = decodeUtf16BEString(dstBytes.subarray(0, dstBytes.length - 2));
+	const baseUnit = (dstBytes[dstBytes.length - 2] ?? 0) << 8 | (dstBytes[dstBytes.length - 1] ?? 0);
+	for (let code = lo; code <= hi; code++) map.set(code, prefix + String.fromCharCode(baseUnit + (code - lo)));
+}
+function readBfRangeArray(reader, map, lo, sink) {
+	let code = lo;
+	for (;;) {
+		const token = nextToken(reader);
+		if (token === void 0) {
+			sink({
+				code: "pdf/cmap-truncated",
+				severity: "warning",
+				message: "bfrange array destination was truncated"
+			});
+			return;
+		}
+		if (token.kind === "arrayEnd") return;
+		if (token.kind !== "hexString") continue;
+		map.set(code, decodeUtf16BEString(token.value));
+		code++;
+	}
+}
+//#endregion
+export { parseToUnicodeCMap };