reamkit 1.5.0 → 1.7.0

package/dist/esm/pdf-reader/images.js

@@ -0,0 +1,90 @@
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { FEATURES } from "../core/ir/features.js";
+import { interpretContent, multiply } from "./content.js";
+import { decodePdfImage } from "./image-decode.js";
+//#region src/pdf-reader/images.ts
+var NO_FONTS = /* @__PURE__ */ new Map();
+var MAX_FORM_DEPTH = 12;
+var MAX_IMAGES = 4096;
+function collectPageImages(file, page) {
+	const images = [];
+	const lossByDetail = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	const addLoss = (severity, detail) => {
+		if (!lossByDetail.has(detail)) lossByDetail.set(detail, {
+			severity,
+			feature: FEATURES.images,
+			detail
+		});
+	};
+	const walk = (resources, content, baseCtm, depth, inheritedMcid) => {
+		const xobjects = resources ? file.get(resources, "XObject") : PDF_NULL;
+		const xobjDict = xobjects instanceof Map ? xobjects : void 0;
+		for (const placement of interpretContent(content, NO_FONTS, baseCtm).images) {
+			if (images.length >= MAX_IMAGES) return;
+			const stream = xobjDict ? file.resolve(xobjDict.get(placement.name) ?? PDF_NULL) : PDF_NULL;
+			if (!(stream instanceof PdfStream)) continue;
+			const subtype = nameOf(file.get(stream.dict, "Subtype"));
+			const mcid = placement.mcid ?? inheritedMcid;
+			if (subtype === "Image") {
+				const decoded = decodePdfImage(file, stream);
+				if (decoded.ok) {
+					images.push(geometry(placement.ctm, decoded, mcid));
+					if (decoded.degraded) addLoss("degraded", decoded.degraded);
+				} else addLoss(decoded.severity, decoded.detail);
+			} else if (subtype === "Form" && depth < MAX_FORM_DEPTH && !visiting.has(stream)) {
+				visiting.add(stream);
+				const formRes = file.get(stream.dict, "Resources");
+				walk(formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, mcid);
+				visiting.delete(stream);
+			}
+		}
+	};
+	walk(page.resources, file.pageContent(page), [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	], 0, void 0);
+	return {
+		images,
+		losses: [...lossByDetail.values()]
+	};
+}
+function geometry(ctm, decoded, mcid) {
+	return {
+		bytes: decoded.bytes,
+		format: decoded.format,
+		widthPt: Math.hypot(ctm[0], ctm[1]) || 1,
+		heightPt: Math.hypot(ctm[2], ctm[3]) || 1,
+		x: ctm[4],
+		y: ctm[5],
+		...mcid !== void 0 ? { mcid } : {}
+	};
+}
+function matrixOf(file, dict) {
+	const m = file.resolve(dict.get("Matrix") ?? PDF_NULL);
+	if (Array.isArray(m) && m.length >= 6 && m.every((v) => typeof v === "number")) return [
+		m[0],
+		m[1],
+		m[2],
+		m[3],
+		m[4],
+		m[5]
+	];
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+function nameOf(v) {
+	return v instanceof PdfName ? v.value : "";
+}
+//#endregion
+export { collectPageImages };

package/dist/esm/pdf-reader/layout.d.ts

@@ -0,0 +1,3 @@
+import { PdfFile } from './document.js';
+import { Reconstruction } from './flow-build.js';
+export declare function reconstructByLayout(file: PdfFile): Reconstruction;

package/dist/esm/pdf-reader/layout.js

@@ -0,0 +1,103 @@
+import { ResourceStore } from "../core/ir/resources.js";
+import { buildFlowDoc, dedupeLosses, imageBlock, paragraphFromRuns, shapeBlock } from "./flow-build.js";
+import { collectPageImages } from "./images.js";
+import { extractPageText } from "./text.js";
+import { collectPageVectors } from "./vector.js";
+//#region src/pdf-reader/layout.ts
+function reconstructByLayout(file) {
+	const pages = file.pages();
+	const pageLines = pages.map((page) => groupIntoLines(extractPageText(file, page)).filter((l) => l.text.length > 0));
+	const medianFont = median(pageLines.flat().map((l) => l.fontSize)) || 12;
+	const resources = new ResourceStore();
+	const losses = [];
+	const body = [];
+	pages.forEach((page, i) => {
+		const blocks = [];
+		for (const para of groupIntoParagraphs(pageLines[i])) blocks.push({
+			top: para.top,
+			el: paragraphFromRuns(para.spans, headingLevel(para.fontSize, medianFont))
+		});
+		const imgs = collectPageImages(file, page);
+		losses.push(...imgs.losses);
+		for (const img of imgs.images) blocks.push({
+			top: img.y + img.heightPt,
+			el: imageBlock(img, resources)
+		});
+		for (const v of collectPageVectors(file, page)) blocks.push({
+			top: v.maxY,
+			el: shapeBlock(v)
+		});
+		blocks.sort((a, b) => b.top - a.top);
+		for (const block of blocks) body.push(block.el);
+	});
+	return {
+		doc: buildFlowDoc(body, resources),
+		losses: dedupeLosses(losses)
+	};
+}
+function groupIntoLines(runs) {
+	const sorted = [...runs].sort((a, b) => b.y - a.y || a.x - b.x);
+	const clusters = [];
+	for (const run of sorted) {
+		const last = clusters[clusters.length - 1];
+		const tol = Math.max(1, (run.fontSizePt || 10) * .5);
+		if (last && Math.abs(last.y - run.y) <= tol) {
+			last.runs.push(run);
+			last.fontSize = Math.max(last.fontSize, run.fontSizePt || 0);
+		} else clusters.push({
+			y: run.y,
+			fontSize: run.fontSizePt || 10,
+			runs: [run]
+		});
+	}
+	return clusters.map((c) => {
+		const ordered = c.runs.sort((a, b) => a.x - b.x);
+		const fontSize = c.fontSize || 10;
+		const spans = lineSpans(ordered, fontSize);
+		return {
+			y: c.y,
+			fontSize,
+			text: spans.map((s) => s.text).join("").replace(/\s+/g, " ").trim(),
+			spans
+		};
+	});
+}
+function lineSpans(runs, fontSize) {
+	const spans = [];
+	let prevEnd;
+	for (const run of runs) {
+		if (prevEnd !== void 0 && run.x - prevEnd > fontSize * .25) spans.push({ text: " " });
+		spans.push(run.href !== void 0 ? {
+			text: run.text,
+			href: run.href
+		} : { text: run.text });
+		prevEnd = run.x + run.text.length * (run.fontSizePt || fontSize) * .5;
+	}
+	return spans;
+}
+function groupIntoParagraphs(lines) {
+	const groups = [];
+	let prevY;
+	for (const line of lines) {
+		const gap = prevY !== void 0 ? prevY - line.y : 0;
+		if (groups.length === 0 || prevY !== void 0 && gap > line.fontSize * 1.5) groups.push([]);
+		groups[groups.length - 1].push(line);
+		prevY = line.y;
+	}
+	return groups.map((g) => ({
+		spans: g.flatMap((l, i) => i > 0 ? [{ text: " " }, ...l.spans] : [...l.spans]),
+		fontSize: Math.max(...g.map((l) => l.fontSize)),
+		top: g[0].y
+	}));
+}
+function headingLevel(fontSize, medianFont) {
+	if (fontSize >= medianFont * 1.5) return 0;
+	if (fontSize >= medianFont * 1.25) return 1;
+}
+function median(values) {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	return sorted[Math.floor(sorted.length / 2)];
+}
+//#endregion
+export { reconstructByLayout };

package/dist/esm/pdf-reader/lexer.d.ts

@@ -0,0 +1,43 @@
+export type Token = {
+    readonly kind: 'num';
+    readonly value: number;
+} | {
+    readonly kind: 'name';
+    readonly value: string;
+} | {
+    readonly kind: 'str';
+    readonly value: string;
+} | {
+    readonly kind: 'hexstr';
+    readonly bytes: Uint8Array;
+} | {
+    readonly kind: 'arrayOpen';
+} | {
+    readonly kind: 'arrayClose';
+} | {
+    readonly kind: 'dictOpen';
+} | {
+    readonly kind: 'dictClose';
+} | {
+    readonly kind: 'keyword';
+    readonly value: string;
+} | {
+    readonly kind: 'eof';
+};
+export declare class Lexer {
+    private readonly buf;
+    pos: number;
+    constructor(buf: Uint8Array, pos?: number);
+    get length(): number;
+    byteAt(i: number): number;
+    skipWhitespace(): void;
+    nextToken(): Token;
+    private readNumber;
+    private readName;
+    private readKeyword;
+    private readHexString;
+    private readLiteralString;
+    indexOfAscii(needle: string, from: number): number;
+    readStreamBody(length: number | undefined): Uint8Array;
+}
+export declare function latin1(bytes: Uint8Array): string;

package/dist/esm/pdf-reader/lexer.js

@@ -0,0 +1,250 @@
+//#region src/pdf-reader/lexer.ts
+function isWhitespace(b) {
+	return b === 0 || b === 9 || b === 10 || b === 12 || b === 13 || b === 32;
+}
+function isDelimiter(b) {
+	return b === 40 || b === 41 || b === 60 || b === 62 || b === 91 || b === 93 || b === 123 || b === 125 || b === 47 || b === 37;
+}
+function isRegular(b) {
+	return !isWhitespace(b) && !isDelimiter(b);
+}
+function hexVal(b) {
+	if (b >= 48 && b <= 57) return b - 48;
+	if (b >= 65 && b <= 70) return b - 65 + 10;
+	if (b >= 97 && b <= 102) return b - 97 + 10;
+	return -1;
+}
+var Lexer = class {
+	pos;
+	constructor(buf, pos = 0) {
+		this.buf = buf;
+		this.pos = pos;
+	}
+	get length() {
+		return this.buf.length;
+	}
+	byteAt(i) {
+		return i >= 0 && i < this.buf.length ? this.buf[i] : -1;
+	}
+	skipWhitespace() {
+		const buf = this.buf;
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			if (isWhitespace(b)) this.pos++;
+			else if (b === 37) {
+				this.pos++;
+				while (this.pos < buf.length && buf[this.pos] !== 10 && buf[this.pos] !== 13) this.pos++;
+			} else break;
+		}
+	}
+	nextToken() {
+		this.skipWhitespace();
+		const buf = this.buf;
+		if (this.pos >= buf.length) return { kind: "eof" };
+		const b = buf[this.pos];
+		switch (b) {
+			case 91:
+				this.pos++;
+				return { kind: "arrayOpen" };
+			case 93:
+				this.pos++;
+				return { kind: "arrayClose" };
+			case 60:
+				if (buf[this.pos + 1] === 60) {
+					this.pos += 2;
+					return { kind: "dictOpen" };
+				}
+				return this.readHexString();
+			case 62:
+				if (buf[this.pos + 1] === 62) {
+					this.pos += 2;
+					return { kind: "dictClose" };
+				}
+				this.pos++;
+				return this.nextToken();
+			case 40: return this.readLiteralString();
+			case 47: return this.readName();
+			case 123:
+			case 125:
+				this.pos++;
+				return {
+					kind: "keyword",
+					value: String.fromCharCode(b)
+				};
+		}
+		if (b === 43 || b === 45 || b === 46 || b >= 48 && b <= 57) return this.readNumber();
+		if (isRegular(b)) return this.readKeyword();
+		this.pos++;
+		return this.nextToken();
+	}
+	readNumber() {
+		const buf = this.buf;
+		const start = this.pos;
+		if (buf[this.pos] === 43 || buf[this.pos] === 45) this.pos++;
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			if (b >= 48 && b <= 57 || b === 46) this.pos++;
+			else break;
+		}
+		const text = latin1(buf.subarray(start, this.pos));
+		const value = Number(text);
+		return {
+			kind: "num",
+			value: Number.isFinite(value) ? value : 0
+		};
+	}
+	readName() {
+		const buf = this.buf;
+		this.pos++;
+		const out = [];
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			if (!isRegular(b)) break;
+			if (b === 35 && this.pos + 2 < buf.length) {
+				const hi = hexVal(buf[this.pos + 1]);
+				const lo = hexVal(buf[this.pos + 2]);
+				if (hi >= 0 && lo >= 0) {
+					out.push(hi * 16 + lo);
+					this.pos += 3;
+					continue;
+				}
+			}
+			out.push(b);
+			this.pos++;
+		}
+		return {
+			kind: "name",
+			value: latin1(Uint8Array.from(out))
+		};
+	}
+	readKeyword() {
+		const buf = this.buf;
+		const start = this.pos;
+		while (this.pos < buf.length && isRegular(buf[this.pos])) this.pos++;
+		return {
+			kind: "keyword",
+			value: latin1(buf.subarray(start, this.pos))
+		};
+	}
+	readHexString() {
+		const buf = this.buf;
+		this.pos++;
+		const out = [];
+		let hi = -1;
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			this.pos++;
+			if (b === 62) break;
+			const v = hexVal(b);
+			if (v < 0) continue;
+			if (hi < 0) hi = v;
+			else {
+				out.push(hi * 16 + v);
+				hi = -1;
+			}
+		}
+		if (hi >= 0) out.push(hi * 16);
+		return {
+			kind: "hexstr",
+			bytes: Uint8Array.from(out)
+		};
+	}
+	readLiteralString() {
+		const buf = this.buf;
+		this.pos++;
+		const out = [];
+		let depth = 1;
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			this.pos++;
+			if (b === 92) {
+				if (this.pos >= buf.length) break;
+				const e = buf[this.pos];
+				this.pos++;
+				switch (e) {
+					case 110:
+						out.push(10);
+						break;
+					case 114:
+						out.push(13);
+						break;
+					case 116:
+						out.push(9);
+						break;
+					case 98:
+						out.push(8);
+						break;
+					case 102:
+						out.push(12);
+						break;
+					case 10: break;
+					case 13:
+						if (buf[this.pos] === 10) this.pos++;
+						break;
+					default: if (e >= 48 && e <= 55) {
+						let oct = e - 48;
+						for (let k = 0; k < 2 && this.pos < buf.length; k++) {
+							const d = buf[this.pos];
+							if (d < 48 || d > 55) break;
+							oct = oct * 8 + (d - 48);
+							this.pos++;
+						}
+						out.push(oct & 255);
+					} else out.push(e);
+				}
+				continue;
+			}
+			if (b === 40) {
+				depth++;
+				out.push(b);
+				continue;
+			}
+			if (b === 41) {
+				depth--;
+				if (depth === 0) break;
+				out.push(b);
+				continue;
+			}
+			out.push(b);
+		}
+		return {
+			kind: "str",
+			value: latin1(Uint8Array.from(out))
+		};
+	}
+	indexOfAscii(needle, from) {
+		const buf = this.buf;
+		const n = needle.length;
+		outer: for (let i = from; i <= buf.length - n; i++) {
+			for (let j = 0; j < n; j++) if (buf[i + j] !== needle.charCodeAt(j)) continue outer;
+			return i;
+		}
+		return -1;
+	}
+	readStreamBody(length) {
+		const buf = this.buf;
+		if (buf[this.pos] === 13 && buf[this.pos + 1] === 10) this.pos += 2;
+		else if (buf[this.pos] === 10 || buf[this.pos] === 13) this.pos += 1;
+		const start = this.pos;
+		if (length !== void 0 && length >= 0 && start + length <= buf.length) {
+			this.pos = start + length;
+			return buf.subarray(start, start + length);
+		}
+		const es = this.indexOfAscii("endstream", start);
+		const end = es < 0 ? buf.length : es;
+		let dataEnd = end;
+		if (dataEnd > start && buf[dataEnd - 1] === 10) {
+			dataEnd--;
+			if (dataEnd > start && buf[dataEnd - 1] === 13) dataEnd--;
+		} else if (dataEnd > start && buf[dataEnd - 1] === 13) dataEnd--;
+		this.pos = end;
+		return buf.subarray(start, dataEnd);
+	}
+};
+function latin1(bytes) {
+	let s = "";
+	for (const b of bytes) s += String.fromCharCode(b);
+	return s;
+}
+//#endregion
+export { Lexer };

package/dist/esm/pdf-reader/parser.d.ts

@@ -0,0 +1,10 @@
+import { Lexer } from './lexer.js';
+import { PdfValue, PdfRef } from '../pdf/objects.js';
+export type LengthResolver = (ref: PdfRef) => number | undefined;
+export interface IndirectObject {
+    readonly id: number;
+    readonly generation: number;
+    readonly value: PdfValue;
+}
+export declare function parseObject(lexer: Lexer, resolveLength?: LengthResolver): PdfValue;
+export declare function parseIndirectObject(lexer: Lexer, resolveLength?: LengthResolver): IndirectObject | undefined;

package/dist/esm/pdf-reader/parser.js

@@ -0,0 +1,86 @@
+import { PDF_NULL, PdfHexString, PdfName, PdfRef, PdfStream } from "../pdf/objects.js";
+//#region src/pdf-reader/parser.ts
+function parseObject(lexer, resolveLength) {
+	return parseValue(lexer, lexer.nextToken(), resolveLength);
+}
+function parseIndirectObject(lexer, resolveLength) {
+	const idTok = lexer.nextToken();
+	if (idTok.kind !== "num") return void 0;
+	const genTok = lexer.nextToken();
+	if (genTok.kind !== "num") return void 0;
+	const objTok = lexer.nextToken();
+	if (objTok.kind !== "keyword" || objTok.value !== "obj") return void 0;
+	const value = parseObject(lexer, resolveLength);
+	const save = lexer.pos;
+	const end = lexer.nextToken();
+	if (!(end.kind === "keyword" && end.value === "endobj")) lexer.pos = save;
+	return {
+		id: idTok.value,
+		generation: genTok.value,
+		value
+	};
+}
+function parseValue(lexer, tok, resolveLength) {
+	switch (tok.kind) {
+		case "num": return parseNumberOrRef(lexer, tok.value);
+		case "name": return new PdfName(tok.value);
+		case "str": return tok.value;
+		case "hexstr": return new PdfHexString(tok.bytes);
+		case "arrayOpen": return parseArray(lexer, resolveLength);
+		case "dictOpen": return parseDictOrStream(lexer, resolveLength);
+		case "keyword":
+			if (tok.value === "true") return true;
+			if (tok.value === "false") return false;
+			return PDF_NULL;
+		default: return PDF_NULL;
+	}
+}
+function parseNumberOrRef(lexer, first) {
+	if (!Number.isInteger(first) || first < 0) return first;
+	const save = lexer.pos;
+	const gen = lexer.nextToken();
+	if (gen.kind === "num" && Number.isInteger(gen.value)) {
+		const r = lexer.nextToken();
+		if (r.kind === "keyword" && r.value === "R") return new PdfRef(first, gen.value);
+	}
+	lexer.pos = save;
+	return first;
+}
+function parseArray(lexer, resolveLength) {
+	const out = [];
+	for (;;) {
+		const tok = lexer.nextToken();
+		if (tok.kind === "arrayClose" || tok.kind === "eof") break;
+		out.push(parseValue(lexer, tok, resolveLength));
+	}
+	return out;
+}
+function parseDictOrStream(lexer, resolveLength) {
+	const map = /* @__PURE__ */ new Map();
+	for (;;) {
+		const keyTok = lexer.nextToken();
+		if (keyTok.kind === "dictClose" || keyTok.kind === "eof") break;
+		if (keyTok.kind !== "name") {
+			if (keyTok.kind === "arrayOpen" || keyTok.kind === "dictOpen") parseValue(lexer, keyTok, resolveLength);
+			continue;
+		}
+		const value = parseObject(lexer, resolveLength);
+		map.set(keyTok.value, value);
+	}
+	const save = lexer.pos;
+	const next = lexer.nextToken();
+	if (next.kind === "keyword" && next.value === "stream") {
+		const lengthVal = map.get("Length");
+		let length;
+		if (typeof lengthVal === "number") length = lengthVal;
+		else if (lengthVal instanceof PdfRef && resolveLength) length = resolveLength(lengthVal);
+		const data = lexer.readStreamBody(length);
+		const endTok = lexer.nextToken();
+		if (!(endTok.kind === "keyword" && endTok.value === "endstream")) {}
+		return new PdfStream(map, data);
+	}
+	lexer.pos = save;
+	return map;
+}
+//#endregion
+export { parseIndirectObject, parseObject };

package/dist/esm/pdf-reader/png-encode.d.ts

@@ -0,0 +1,2 @@
+export type PngColor = 'gray' | 'rgb' | 'gray-alpha' | 'rgba';
+export declare function encodePng(width: number, height: number, color: PngColor, samples: Uint8Array): Uint8Array;

package/dist/esm/pdf-reader/png-encode.js

@@ -0,0 +1,98 @@
+import { zlibSync } from "fflate";
+//#region src/pdf-reader/png-encode.ts
+var COLOR_TYPE = {
+	gray: 0,
+	rgb: 2,
+	"gray-alpha": 4,
+	rgba: 6
+};
+var CHANNELS = {
+	gray: 1,
+	rgb: 3,
+	"gray-alpha": 2,
+	rgba: 4
+};
+var SIGNATURE = Uint8Array.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function encodePng(width, height, color, samples) {
+	const stride = width * CHANNELS[color];
+	const raw = new Uint8Array(height * (stride + 1));
+	for (let y = 0; y < height; y++) {
+		const dst = y * (stride + 1);
+		raw[dst] = 0;
+		raw.set(samples.subarray(y * stride, y * stride + stride), dst + 1);
+	}
+	const idat = zlibSync(raw);
+	const ihdr = new Uint8Array(13);
+	writeU32(ihdr, 0, width);
+	writeU32(ihdr, 4, height);
+	ihdr[8] = 8;
+	ihdr[9] = COLOR_TYPE[color];
+	ihdr[10] = 0;
+	ihdr[11] = 0;
+	ihdr[12] = 0;
+	return concat([
+		SIGNATURE,
+		chunk("IHDR", ihdr),
+		chunk("IDAT", idat),
+		chunk("IEND", new Uint8Array(0))
+	]);
+}
+function chunk(type, data) {
+	const typeBytes = Uint8Array.from([
+		type.charCodeAt(0),
+		type.charCodeAt(1),
+		type.charCodeAt(2),
+		type.charCodeAt(3)
+	]);
+	const out = new Uint8Array(12 + data.length);
+	writeU32(out, 0, data.length);
+	out.set(typeBytes, 4);
+	out.set(data, 8);
+	const crcInput = new Uint8Array(4 + data.length);
+	crcInput.set(typeBytes, 0);
+	crcInput.set(data, 4);
+	writeU32(out, 8 + data.length, crc32(crcInput));
+	return out;
+}
+function writeU32(buf, offset, value) {
+	buf[offset] = value >>> 24 & 255;
+	buf[offset + 1] = value >>> 16 & 255;
+	buf[offset + 2] = value >>> 8 & 255;
+	buf[offset + 3] = value & 255;
+}
+function concat(parts) {
+	let total = 0;
+	for (const p of parts) total += p.length;
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const p of parts) {
+		out.set(p, off);
+		off += p.length;
+	}
+	return out;
+}
+var crcTable;
+function crc32(bytes) {
+	if (!crcTable) {
+		crcTable = new Uint32Array(256);
+		for (let n = 0; n < 256; n++) {
+			let c = n;
+			for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+			crcTable[n] = c >>> 0;
+		}
+	}
+	let crc = 4294967295;
+	for (const b of bytes) crc = crcTable[(crc ^ b) & 255] ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+//#endregion
+export { encodePng };

package/dist/esm/pdf-reader/predictor.d.ts

@@ -0,0 +1,7 @@
+export interface PredictorParams {
+    readonly predictor: number;
+    readonly colors: number;
+    readonly bitsPerComponent: number;
+    readonly columns: number;
+}
+export declare function reversePredictor(data: Uint8Array, p: PredictorParams): Uint8Array;