pdf-codec 1.3.0 → 1.4.0

package/dist/document.js

@@ -0,0 +1,161 @@
+import { ByteReader } from "./bytes/reader.js";
+import { nextToken } from "./lexer.js";
+import { PdfEncryptedError, PdfParseError } from "./diagnostics.js";
+import { asArray, asDict, asNumber, dictGet, isName, pdfNull } from "./objects.js";
+import { decodeStream } from "./filters.js";
+import { parseIndirectObject, parseValue } from "./parse.js";
+import { readXref } from "./xref.js";
+//#region src/document.ts
+const MAX_RESOLVE_DEPTH = 64;
+const INHERITABLE_PAGE_KEYS = [
+	"Resources",
+	"MediaBox",
+	"CropBox",
+	"Rotate"
+];
+function openPdfDocument(bytes, sink) {
+	const xref = readXref(bytes, sink);
+	if (dictGet(xref.trailer, "Encrypt") !== void 0) throw new PdfEncryptedError();
+	const objectCache = /* @__PURE__ */ new Map();
+	const objStmCache = /* @__PURE__ */ new Map();
+	function fetchDirect(num, entry) {
+		const reader = new ByteReader(bytes);
+		reader.seek(entry.offset);
+		const indirect = parseIndirectObject(reader, sink);
+		if (indirect === void 0) {
+			sink({
+				code: "pdf/object-missing-value",
+				severity: "warning",
+				message: `object ${String(num)} could not be parsed at its recorded offset`
+			});
+			return pdfNull();
+		}
+		return indirect.value;
+	}
+	function decodeObjectStream(streamObjNum) {
+		const cached = objStmCache.get(streamObjNum);
+		if (cached !== void 0) return cached;
+		const streamEntry = xref.entries.get(streamObjNum);
+		const streamObj = streamEntry?.type === "offset" ? fetchDirect(streamObjNum, streamEntry) : void 0;
+		if (streamObj?.kind !== "stream") {
+			sink({
+				code: "pdf/object-missing-value",
+				severity: "warning",
+				message: `object ${String(streamObjNum)} referenced as an object stream is not directly-located, or is not actually a stream`
+			});
+			objStmCache.set(streamObjNum, []);
+			return [];
+		}
+		const decoded = decodeStream(streamObj.raw, streamObj.dict, sink);
+		const n = asNumber(dictGet(streamObj.dict, "N")) ?? 0;
+		const first = asNumber(dictGet(streamObj.dict, "First")) ?? 0;
+		const headerReader = new ByteReader(decoded.bytes);
+		const relativeOffsets = [];
+		for (let i = 0; i < n; i++) {
+			const numTok = nextToken(headerReader);
+			const offTok = nextToken(headerReader);
+			if (numTok?.kind !== "number" || offTok?.kind !== "number") {
+				sink({
+					code: "pdf/object-missing-value",
+					severity: "warning",
+					message: `object stream ${String(streamObjNum)} header is truncated at entry ${String(i)}`
+				});
+				break;
+			}
+			relativeOffsets.push(offTok.value);
+		}
+		const values = relativeOffsets.map((relativeOffset) => {
+			const valueReader = new ByteReader(decoded.bytes);
+			valueReader.seek(first + relativeOffset);
+			return parseValue(valueReader, sink) ?? pdfNull();
+		});
+		objStmCache.set(streamObjNum, values);
+		return values;
+	}
+	function fetch(num) {
+		const cached = objectCache.get(num);
+		if (cached !== void 0) return cached;
+		const entry = xref.entries.get(num);
+		if (entry === void 0) {
+			sink({
+				code: "pdf/object-missing-value",
+				severity: "warning",
+				message: `object ${String(num)} is referenced but not present in the cross-reference table`
+			});
+			return pdfNull();
+		}
+		const value = entry.type === "offset" ? fetchDirect(num, entry) : decodeObjectStream(entry.streamObjNum)[entry.indexInStream] ?? pdfNull();
+		objectCache.set(num, value);
+		return value;
+	}
+	function resolve(obj) {
+		let current = obj;
+		let depth = 0;
+		while (current?.kind === "ref" && depth < MAX_RESOLVE_DEPTH) {
+			current = fetch(current.num);
+			depth++;
+		}
+		if (depth >= MAX_RESOLVE_DEPTH) {
+			sink({
+				code: "pdf/reference-cycle",
+				severity: "warning",
+				message: "a chain of indirect references did not resolve within the depth limit; treating it as null"
+			});
+			return pdfNull();
+		}
+		return current;
+	}
+	function resolveDict(obj) {
+		return asDict(resolve(obj));
+	}
+	function requireCatalog(dict) {
+		if (dict === void 0 || !isName(dictGet(dict, "Type"), "Catalog")) throw new PdfParseError("pdf/no-root", "no resolvable /Root catalog was found, even after cross-reference recovery");
+		return dict;
+	}
+	const catalog = requireCatalog(resolveDict(dictGet(xref.trailer, "Root")));
+	function pages() {
+		const pagesRoot = resolveDict(dictGet(catalog, "Pages"));
+		if (pagesRoot === void 0) return [];
+		const result = [];
+		walkPageTree(pagesRoot, {}, /* @__PURE__ */ new Set(), result);
+		return result;
+	}
+	function walkPageTree(node, inherited, visited, result) {
+		if (visited.has(node)) {
+			sink({
+				code: "pdf/page-tree-cycle",
+				severity: "warning",
+				message: "the page tree contains a cycle; stopping descent at the repeated node"
+			});
+			return;
+		}
+		visited.add(node);
+		const merged = { ...inherited };
+		for (const key of INHERITABLE_PAGE_KEYS) {
+			const own = dictGet(node, key);
+			if (own !== void 0) merged[key] = own;
+		}
+		const kids = asArray(dictGet(node, "Kids"));
+		if (kids === void 0) {
+			const entries = new Map(node.entries);
+			for (const key of INHERITABLE_PAGE_KEYS) if (!entries.has(key) && merged[key] !== void 0) entries.set(key, merged[key]);
+			result.push({
+				kind: "dict",
+				entries
+			});
+			return;
+		}
+		for (const kid of kids) {
+			const kidDict = resolveDict(kid);
+			if (kidDict !== void 0) walkPageTree(kidDict, merged, visited, result);
+		}
+	}
+	return {
+		trailer: xref.trailer,
+		resolve,
+		resolveDict,
+		pages
+	};
+}
+//#endregion
+export { openPdfDocument };

package/dist/encoding.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_afm_widths = require("./afm-widths-BoeTOK2r.cjs");
+exports.WINANSI_GLYPH_NAMES = require_afm_widths.WINANSI_GLYPH_NAMES;
+exports.glyphNameToUnicode = require_afm_widths.glyphNameToUnicode;
+exports.winAnsiGlyphName = require_afm_widths.winAnsiGlyphName;

package/dist/encoding.d.cts

@@ -0,0 +1,6 @@
+//#region src/encoding.d.ts
+declare const WINANSI_GLYPH_NAMES: readonly string[];
+declare function winAnsiGlyphName(code: number): string | undefined;
+declare function glyphNameToUnicode(name: string): number | undefined;
+//#endregion
+export { WINANSI_GLYPH_NAMES, glyphNameToUnicode, winAnsiGlyphName };

package/dist/encoding.d.ts

@@ -0,0 +1,6 @@
+//#region src/encoding.d.ts
+declare const WINANSI_GLYPH_NAMES: readonly string[];
+declare function winAnsiGlyphName(code: number): string | undefined;
+declare function glyphNameToUnicode(name: string): number | undefined;
+//#endregion
+export { WINANSI_GLYPH_NAMES, glyphNameToUnicode, winAnsiGlyphName };

package/dist/encoding.js

@@ -0,0 +1,2 @@
+import { a as winAnsiGlyphName, i as glyphNameToUnicode, r as WINANSI_GLYPH_NAMES } from "./afm-widths-Dxucrg7D.js";
+export { WINANSI_GLYPH_NAMES, glyphNameToUnicode, winAnsiGlyphName };

package/dist/filters.cjs

@@ -0,0 +1,223 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_reader = require("./bytes/reader.cjs");
+const require_bytes_flate = require("./bytes/flate.cjs");
+const require_objects = require("./objects.cjs");
+const require_predictors = require("./predictors.cjs");
+//#region src/filters.ts
+function decodeStream(raw, dict, sink) {
+	const filters = filterNames(dict);
+	const parms = decodeParmsList(dict, filters.length);
+	let bytes = raw;
+	for (let i = 0; i < filters.length; i++) {
+		const filter = filters[i];
+		const parm = parms[i];
+		if (filter === "FlateDecode" || filter === "Fl") bytes = applyPredictorIfPresent(require_bytes_flate.inflateTolerant(bytes).bytes, parm, sink);
+		else if (filter === "LZWDecode" || filter === "LZW") {
+			const earlyChange = (require_objects.asNumber(parm ? require_objects.dictGet(parm, "EarlyChange") : void 0) ?? 1) !== 0;
+			bytes = applyPredictorIfPresent(lzwDecode(bytes, earlyChange, sink), parm, sink);
+		} else if (filter === "ASCII85Decode" || filter === "A85") bytes = ascii85Decode(bytes);
+		else if (filter === "ASCIIHexDecode" || filter === "AHx") bytes = asciiHexDecode(bytes);
+		else if (filter === "RunLengthDecode" || filter === "RL") bytes = runLengthDecode(bytes);
+		else if (filter === "DCTDecode" || filter === "DCT") return {
+			bytes,
+			remainingFilter: "DCTDecode"
+		};
+		else {
+			sink({
+				code: "pdf/unsupported-filter",
+				severity: "warning",
+				message: `unsupported stream filter "${filter}"; leaving remaining bytes undecoded`
+			});
+			return {
+				bytes,
+				remainingFilter: filter
+			};
+		}
+	}
+	return { bytes };
+}
+function applyPredictorIfPresent(data, parm, sink) {
+	return require_predictors.applyPredictor(data, require_predictors.readPredictorParams(parm), sink);
+}
+function filterNames(dict) {
+	const filterObj = require_objects.dictGet(dict, "Filter") ?? require_objects.dictGet(dict, "F");
+	if (filterObj === void 0) return [];
+	const single = require_objects.asName(filterObj);
+	if (single !== void 0) return [single];
+	const arr = require_objects.asArray(filterObj);
+	if (arr === void 0) return [];
+	const names = [];
+	for (const item of arr) {
+		const name = require_objects.asName(item);
+		if (name !== void 0) names.push(name);
+	}
+	return names;
+}
+function decodeParmsList(dict, count) {
+	const parmsObj = require_objects.dictGet(dict, "DecodeParms") ?? require_objects.dictGet(dict, "DP");
+	const empty = () => Array.from({ length: count }, () => void 0);
+	if (parmsObj === void 0) return empty();
+	const single = require_objects.asDict(parmsObj);
+	if (single !== void 0) {
+		const list = empty();
+		list[0] = single;
+		return list;
+	}
+	const arr = require_objects.asArray(parmsObj);
+	if (arr === void 0) return empty();
+	return Array.from({ length: count }, (_, i) => require_objects.asDict(arr[i]));
+}
+const LZW_CLEAR_TABLE = 256;
+const LZW_EOD = 257;
+const LZW_INITIAL_CODE_WIDTH = 9;
+const LZW_FIRST_NEW_CODE = 258;
+function initialLzwDictionary() {
+	return Array.from({ length: 256 }, (_, i) => new Uint8Array([i]));
+}
+function concatTwo(a, b) {
+	const out = new Uint8Array(a.length + b.length);
+	out.set(a, 0);
+	out.set(b, a.length);
+	return out;
+}
+function lzwDecode(data, earlyChange, sink) {
+	const out = [];
+	let dict = initialLzwDictionary();
+	let nextCode = LZW_FIRST_NEW_CODE;
+	let codeWidth = LZW_INITIAL_CODE_WIDTH;
+	let prevEntry;
+	const bias = earlyChange ? 1 : 0;
+	let bitBuffer = 0;
+	let bitCount = 0;
+	let pos = 0;
+	const readCode = () => {
+		while (bitCount < codeWidth) {
+			if (pos >= data.length) return;
+			bitBuffer = bitBuffer << 8 | data[pos];
+			pos++;
+			bitCount += 8;
+		}
+		const value = bitBuffer >>> bitCount - codeWidth & (1 << codeWidth) - 1;
+		bitCount -= codeWidth;
+		return value;
+	};
+	for (;;) {
+		const code = readCode();
+		if (code === void 0 || code === LZW_EOD) break;
+		if (code === LZW_CLEAR_TABLE) {
+			dict = initialLzwDictionary();
+			nextCode = LZW_FIRST_NEW_CODE;
+			codeWidth = LZW_INITIAL_CODE_WIDTH;
+			prevEntry = void 0;
+			continue;
+		}
+		let entry;
+		const existing = dict[code];
+		if (existing !== void 0) entry = existing;
+		else if (code === nextCode && prevEntry !== void 0) entry = concatTwo(prevEntry, new Uint8Array([prevEntry[0] ?? 0]));
+		else {
+			sink({
+				code: "pdf/lzw-corrupt",
+				severity: "warning",
+				message: `LZW stream referenced code ${String(code)} with no valid dictionary entry; stopping decode with what was recovered so far`
+			});
+			break;
+		}
+		for (const byte of entry) out.push(byte);
+		if (prevEntry !== void 0) {
+			dict[nextCode] = concatTwo(prevEntry, new Uint8Array([entry[0] ?? 0]));
+			nextCode++;
+			if (nextCode + bias === 2 ** 9) codeWidth = 10;
+			else if (nextCode + bias === 2 ** 10) codeWidth = 11;
+			else if (nextCode + bias === 2 ** 11) codeWidth = 12;
+		}
+		prevEntry = entry;
+	}
+	return Uint8Array.from(out);
+}
+const ASCII85_ZERO_GROUP_MARKER = 122;
+const ASCII85_END_MARKER = 126;
+const ASCII85_MIN_DIGIT = 33;
+const ASCII85_MAX_DIGIT = 117;
+const ASCII85_MAX_DIGIT_VALUE = 84;
+function pushAscii85Group(out, digits, byteCount) {
+	let value = 0;
+	for (const digit of digits) value = value * 85 + digit;
+	const bytes = [
+		value >>> 24 & 255,
+		value >>> 16 & 255,
+		value >>> 8 & 255,
+		value & 255
+	];
+	for (let i = 0; i < byteCount; i++) out.push(bytes[i]);
+}
+function ascii85Decode(data) {
+	const out = [];
+	let tuple = [];
+	let i = 0;
+	if (data.length >= 2 && data[0] === 60 && data[1] === 126) i = 2;
+	for (; i < data.length; i++) {
+		const byte = data[i];
+		if (byte === ASCII85_END_MARKER) break;
+		if (require_bytes_reader.isAsciiWhitespace(byte)) continue;
+		if (byte === ASCII85_ZERO_GROUP_MARKER && tuple.length === 0) {
+			out.push(0, 0, 0, 0);
+			continue;
+		}
+		if (byte < ASCII85_MIN_DIGIT || byte > ASCII85_MAX_DIGIT) continue;
+		tuple.push(byte - ASCII85_MIN_DIGIT);
+		if (tuple.length === 5) {
+			pushAscii85Group(out, tuple, 4);
+			tuple = [];
+		}
+	}
+	if (tuple.length > 1) {
+		const padded = tuple.slice();
+		while (padded.length < 5) padded.push(ASCII85_MAX_DIGIT_VALUE);
+		pushAscii85Group(out, padded, tuple.length - 1);
+	}
+	return Uint8Array.from(out);
+}
+function hexDigitValue(byte) {
+	if (byte >= 48 && byte <= 57) return byte - 48;
+	if (byte >= 65 && byte <= 70) return byte - 65 + 10;
+	if (byte >= 97 && byte <= 102) return byte - 97 + 10;
+}
+function asciiHexDecode(data) {
+	const digits = [];
+	for (const byte of data) {
+		if (byte === 62) break;
+		const value = hexDigitValue(byte);
+		if (value !== void 0) digits.push(value);
+	}
+	if (digits.length % 2 === 1) digits.push(0);
+	const out = new Uint8Array(digits.length / 2);
+	for (let i = 0; i < out.length; i++) out[i] = digits[i * 2] << 4 | digits[i * 2 + 1];
+	return out;
+}
+const RUN_LENGTH_EOD = 128;
+function runLengthDecode(data) {
+	const out = [];
+	let i = 0;
+	while (i < data.length) {
+		const length = data[i];
+		i++;
+		if (length === RUN_LENGTH_EOD) break;
+		if (length < RUN_LENGTH_EOD) {
+			const count = length + 1;
+			for (let j = 0; j < count && i < data.length; j++, i++) out.push(data[i]);
+		} else {
+			const count = 257 - length;
+			const byte = data[i] ?? 0;
+			i++;
+			for (let j = 0; j < count; j++) out.push(byte);
+		}
+	}
+	return Uint8Array.from(out);
+}
+//#endregion
+exports.ascii85Decode = ascii85Decode;
+exports.asciiHexDecode = asciiHexDecode;
+exports.decodeStream = decodeStream;
+exports.lzwDecode = lzwDecode;
+exports.runLengthDecode = runLengthDecode;

package/dist/filters.d.cts

@@ -0,0 +1,14 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { PdfDict } from "./objects.cjs";
+//#region src/filters.d.ts
+interface DecodedStream {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly remainingFilter?: string;
+}
+declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink): DecodedStream;
+declare function lzwDecode(data: Uint8Array<ArrayBuffer>, earlyChange: boolean, sink: PdfDiagnosticSink): Uint8Array<ArrayBuffer>;
+declare function ascii85Decode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function asciiHexDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function runLengthDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { DecodedStream, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };

package/dist/filters.d.ts

@@ -0,0 +1,14 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { PdfDict } from "./objects.js";
+//#region src/filters.d.ts
+interface DecodedStream {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly remainingFilter?: string;
+}
+declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink): DecodedStream;
+declare function lzwDecode(data: Uint8Array<ArrayBuffer>, earlyChange: boolean, sink: PdfDiagnosticSink): Uint8Array<ArrayBuffer>;
+declare function ascii85Decode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function asciiHexDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function runLengthDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { DecodedStream, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };

package/dist/filters.js

@@ -0,0 +1,218 @@
+import { isAsciiWhitespace } from "./bytes/reader.js";
+import { inflateTolerant } from "./bytes/flate.js";
+import { asArray, asDict, asName, asNumber, dictGet } from "./objects.js";
+import { applyPredictor, readPredictorParams } from "./predictors.js";
+//#region src/filters.ts
+function decodeStream(raw, dict, sink) {
+	const filters = filterNames(dict);
+	const parms = decodeParmsList(dict, filters.length);
+	let bytes = raw;
+	for (let i = 0; i < filters.length; i++) {
+		const filter = filters[i];
+		const parm = parms[i];
+		if (filter === "FlateDecode" || filter === "Fl") bytes = applyPredictorIfPresent(inflateTolerant(bytes).bytes, parm, sink);
+		else if (filter === "LZWDecode" || filter === "LZW") {
+			const earlyChange = (asNumber(parm ? dictGet(parm, "EarlyChange") : void 0) ?? 1) !== 0;
+			bytes = applyPredictorIfPresent(lzwDecode(bytes, earlyChange, sink), parm, sink);
+		} else if (filter === "ASCII85Decode" || filter === "A85") bytes = ascii85Decode(bytes);
+		else if (filter === "ASCIIHexDecode" || filter === "AHx") bytes = asciiHexDecode(bytes);
+		else if (filter === "RunLengthDecode" || filter === "RL") bytes = runLengthDecode(bytes);
+		else if (filter === "DCTDecode" || filter === "DCT") return {
+			bytes,
+			remainingFilter: "DCTDecode"
+		};
+		else {
+			sink({
+				code: "pdf/unsupported-filter",
+				severity: "warning",
+				message: `unsupported stream filter "${filter}"; leaving remaining bytes undecoded`
+			});
+			return {
+				bytes,
+				remainingFilter: filter
+			};
+		}
+	}
+	return { bytes };
+}
+function applyPredictorIfPresent(data, parm, sink) {
+	return applyPredictor(data, readPredictorParams(parm), sink);
+}
+function filterNames(dict) {
+	const filterObj = dictGet(dict, "Filter") ?? dictGet(dict, "F");
+	if (filterObj === void 0) return [];
+	const single = asName(filterObj);
+	if (single !== void 0) return [single];
+	const arr = asArray(filterObj);
+	if (arr === void 0) return [];
+	const names = [];
+	for (const item of arr) {
+		const name = asName(item);
+		if (name !== void 0) names.push(name);
+	}
+	return names;
+}
+function decodeParmsList(dict, count) {
+	const parmsObj = dictGet(dict, "DecodeParms") ?? dictGet(dict, "DP");
+	const empty = () => Array.from({ length: count }, () => void 0);
+	if (parmsObj === void 0) return empty();
+	const single = asDict(parmsObj);
+	if (single !== void 0) {
+		const list = empty();
+		list[0] = single;
+		return list;
+	}
+	const arr = asArray(parmsObj);
+	if (arr === void 0) return empty();
+	return Array.from({ length: count }, (_, i) => asDict(arr[i]));
+}
+const LZW_CLEAR_TABLE = 256;
+const LZW_EOD = 257;
+const LZW_INITIAL_CODE_WIDTH = 9;
+const LZW_FIRST_NEW_CODE = 258;
+function initialLzwDictionary() {
+	return Array.from({ length: 256 }, (_, i) => new Uint8Array([i]));
+}
+function concatTwo(a, b) {
+	const out = new Uint8Array(a.length + b.length);
+	out.set(a, 0);
+	out.set(b, a.length);
+	return out;
+}
+function lzwDecode(data, earlyChange, sink) {
+	const out = [];
+	let dict = initialLzwDictionary();
+	let nextCode = LZW_FIRST_NEW_CODE;
+	let codeWidth = LZW_INITIAL_CODE_WIDTH;
+	let prevEntry;
+	const bias = earlyChange ? 1 : 0;
+	let bitBuffer = 0;
+	let bitCount = 0;
+	let pos = 0;
+	const readCode = () => {
+		while (bitCount < codeWidth) {
+			if (pos >= data.length) return;
+			bitBuffer = bitBuffer << 8 | data[pos];
+			pos++;
+			bitCount += 8;
+		}
+		const value = bitBuffer >>> bitCount - codeWidth & (1 << codeWidth) - 1;
+		bitCount -= codeWidth;
+		return value;
+	};
+	for (;;) {
+		const code = readCode();
+		if (code === void 0 || code === LZW_EOD) break;
+		if (code === LZW_CLEAR_TABLE) {
+			dict = initialLzwDictionary();
+			nextCode = LZW_FIRST_NEW_CODE;
+			codeWidth = LZW_INITIAL_CODE_WIDTH;
+			prevEntry = void 0;
+			continue;
+		}
+		let entry;
+		const existing = dict[code];
+		if (existing !== void 0) entry = existing;
+		else if (code === nextCode && prevEntry !== void 0) entry = concatTwo(prevEntry, new Uint8Array([prevEntry[0] ?? 0]));
+		else {
+			sink({
+				code: "pdf/lzw-corrupt",
+				severity: "warning",
+				message: `LZW stream referenced code ${String(code)} with no valid dictionary entry; stopping decode with what was recovered so far`
+			});
+			break;
+		}
+		for (const byte of entry) out.push(byte);
+		if (prevEntry !== void 0) {
+			dict[nextCode] = concatTwo(prevEntry, new Uint8Array([entry[0] ?? 0]));
+			nextCode++;
+			if (nextCode + bias === 2 ** 9) codeWidth = 10;
+			else if (nextCode + bias === 2 ** 10) codeWidth = 11;
+			else if (nextCode + bias === 2 ** 11) codeWidth = 12;
+		}
+		prevEntry = entry;
+	}
+	return Uint8Array.from(out);
+}
+const ASCII85_ZERO_GROUP_MARKER = 122;
+const ASCII85_END_MARKER = 126;
+const ASCII85_MIN_DIGIT = 33;
+const ASCII85_MAX_DIGIT = 117;
+const ASCII85_MAX_DIGIT_VALUE = 84;
+function pushAscii85Group(out, digits, byteCount) {
+	let value = 0;
+	for (const digit of digits) value = value * 85 + digit;
+	const bytes = [
+		value >>> 24 & 255,
+		value >>> 16 & 255,
+		value >>> 8 & 255,
+		value & 255
+	];
+	for (let i = 0; i < byteCount; i++) out.push(bytes[i]);
+}
+function ascii85Decode(data) {
+	const out = [];
+	let tuple = [];
+	let i = 0;
+	if (data.length >= 2 && data[0] === 60 && data[1] === 126) i = 2;
+	for (; i < data.length; i++) {
+		const byte = data[i];
+		if (byte === ASCII85_END_MARKER) break;
+		if (isAsciiWhitespace(byte)) continue;
+		if (byte === ASCII85_ZERO_GROUP_MARKER && tuple.length === 0) {
+			out.push(0, 0, 0, 0);
+			continue;
+		}
+		if (byte < ASCII85_MIN_DIGIT || byte > ASCII85_MAX_DIGIT) continue;
+		tuple.push(byte - ASCII85_MIN_DIGIT);
+		if (tuple.length === 5) {
+			pushAscii85Group(out, tuple, 4);
+			tuple = [];
+		}
+	}
+	if (tuple.length > 1) {
+		const padded = tuple.slice();
+		while (padded.length < 5) padded.push(ASCII85_MAX_DIGIT_VALUE);
+		pushAscii85Group(out, padded, tuple.length - 1);
+	}
+	return Uint8Array.from(out);
+}
+function hexDigitValue(byte) {
+	if (byte >= 48 && byte <= 57) return byte - 48;
+	if (byte >= 65 && byte <= 70) return byte - 65 + 10;
+	if (byte >= 97 && byte <= 102) return byte - 97 + 10;
+}
+function asciiHexDecode(data) {
+	const digits = [];
+	for (const byte of data) {
+		if (byte === 62) break;
+		const value = hexDigitValue(byte);
+		if (value !== void 0) digits.push(value);
+	}
+	if (digits.length % 2 === 1) digits.push(0);
+	const out = new Uint8Array(digits.length / 2);
+	for (let i = 0; i < out.length; i++) out[i] = digits[i * 2] << 4 | digits[i * 2 + 1];
+	return out;
+}
+const RUN_LENGTH_EOD = 128;
+function runLengthDecode(data) {
+	const out = [];
+	let i = 0;
+	while (i < data.length) {
+		const length = data[i];
+		i++;
+		if (length === RUN_LENGTH_EOD) break;
+		if (length < RUN_LENGTH_EOD) {
+			const count = length + 1;
+			for (let j = 0; j < count && i < data.length; j++, i++) out.push(data[i]);
+		} else {
+			const count = 257 - length;
+			const byte = data[i] ?? 0;
+			i++;
+			for (let j = 0; j < count; j++) out.push(byte);
+		}
+	}
+	return Uint8Array.from(out);
+}
+//#endregion
+export { ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };