byte-codec 1.0.0 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,563 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let fflate = require("fflate");
+//#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
+//#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
+//#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
+//#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 && 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: concatBytes(chunks),
+		recovered: true
+	};
+}
+//#endregion
+//#region src/image/png-filter.ts
+function paethPredictor(a, b, c) {
+	const p = a + b - c;
+	const pa = Math.abs(p - a);
+	const pb = Math.abs(p - b);
+	const pc = Math.abs(p - c);
+	if (pa <= pb && pa <= pc) return a;
+	if (pb <= pc) return b;
+	return c;
+}
+function isPngFilterType(value) {
+	return value === 0 || value === 1 || value === 2 || value === 3 || value === 4;
+}
+function predictorValue(filterType, a, b, c) {
+	if (filterType === 1) return a;
+	if (filterType === 2) return b;
+	if (filterType === 3) return Math.floor((a + b) / 2);
+	if (filterType === 4) return paethPredictor(a, b, c);
+	return 0;
+}
+function unfilterScanlines(data, height, bytesPerRow, bpp) {
+	const stride = bytesPerRow + 1;
+	if (data.length < height * stride) throw new Error(`PNG scanline data too short: expected at least ${height * stride} bytes, got ${data.length}`);
+	const out = new Uint8Array(height * bytesPerRow);
+	for (let y = 0; y < height; y++) {
+		const filterByte = data[y * stride];
+		if (filterByte === void 0 || !isPngFilterType(filterByte)) throw new Error(`unknown PNG filter type: ${String(filterByte)}`);
+		const rowStart = y * stride + 1;
+		const outRowStart = y * bytesPerRow;
+		const prevOutRowStart = y > 0 ? outRowStart - bytesPerRow : void 0;
+		for (let x = 0; x < bytesPerRow; x++) {
+			const raw = data[rowStart + x];
+			const a = x >= bpp ? out[outRowStart + x - bpp] : 0;
+			const b = prevOutRowStart === void 0 ? 0 : out[prevOutRowStart + x];
+			const c = x >= bpp && prevOutRowStart !== void 0 ? out[prevOutRowStart + x - bpp] : 0;
+			out[outRowStart + x] = raw + predictorValue(filterByte, a, b, c) & 255;
+		}
+	}
+	return out;
+}
+function sumOfAbsSigned(bytes) {
+	let sum = 0;
+	for (const byte of bytes) sum += byte < 128 ? byte : 256 - byte;
+	return sum;
+}
+function filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, filterType, out, outOffset) {
+	for (let x = 0; x < bytesPerRow; x++) {
+		const rawByte = raw[rowStart + x];
+		const a = x >= bpp ? raw[rowStart + x - bpp] : 0;
+		const b = prevRowStart === void 0 ? 0 : raw[prevRowStart + x];
+		const c = x >= bpp && prevRowStart !== void 0 ? raw[prevRowStart + x - bpp] : 0;
+		out[outOffset + x] = rawByte - predictorValue(filterType, a, b, c) & 255;
+	}
+}
+const ALL_FILTER_TYPES = [
+	0,
+	1,
+	2,
+	3,
+	4
+];
+function filterScanlines(raw, height, bytesPerRow, bpp, strategy = "adaptive") {
+	const stride = bytesPerRow + 1;
+	const out = new Uint8Array(height * stride);
+	const candidate = new Uint8Array(bytesPerRow);
+	for (let y = 0; y < height; y++) {
+		const rowStart = y * bytesPerRow;
+		const prevRowStart = y > 0 ? rowStart - bytesPerRow : void 0;
+		const outRowStart = y * stride;
+		if (strategy === "none") {
+			out[outRowStart] = 0;
+			filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, 0, out, outRowStart + 1);
+			continue;
+		}
+		let bestType = 0;
+		let bestSum = Number.POSITIVE_INFINITY;
+		let best;
+		for (const filterType of ALL_FILTER_TYPES) {
+			filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, filterType, candidate, 0);
+			const sum = sumOfAbsSigned(candidate);
+			if (sum < bestSum) {
+				bestSum = sum;
+				bestType = filterType;
+				best = candidate.slice();
+			}
+		}
+		out[outRowStart] = bestType;
+		if (best !== void 0) out.set(best, outRowStart + 1);
+	}
+	return out;
+}
+//#endregion
+//#region src/image/png-encode.ts
+const PNG_SIGNATURE$1 = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function u32be(value) {
+	const bytes = /* @__PURE__ */ new Uint8Array(4);
+	new DataView(bytes.buffer).setUint32(0, value);
+	return bytes;
+}
+function writeChunk(writer, type, data) {
+	const typeBytes = new TextEncoder().encode(type);
+	writer.writeBytes(u32be(data.length));
+	writer.writeBytes(typeBytes);
+	writer.writeBytes(data);
+	writer.writeBytes(u32be(crc32(concatBytes([typeBytes, data]))));
+}
+function colorTypeFor(image) {
+	if (image.channels === 1) return image.alpha === void 0 ? 0 : 4;
+	return image.alpha === void 0 ? 2 : 6;
+}
+function encodePng(image, options = {}) {
+	const { width, height, channels, data, alpha } = image;
+	const outChannels = alpha === void 0 ? channels : channels + 1;
+	const bytesPerRow = width * outChannels;
+	const pixelCount = width * height;
+	const interleaved = new Uint8Array(pixelCount * outChannels);
+	for (let i = 0; i < pixelCount; i++) {
+		const srcBase = i * channels;
+		const dstBase = i * outChannels;
+		for (let c = 0; c < channels; c++) interleaved[dstBase + c] = data[srcBase + c];
+		if (alpha !== void 0) interleaved[dstBase + channels] = alpha[i];
+	}
+	const compressed = deflate(filterScanlines(interleaved, height, bytesPerRow, outChannels, options.filter ?? "adaptive"));
+	const ihdr = /* @__PURE__ */ new Uint8Array(13);
+	const ihdrView = new DataView(ihdr.buffer);
+	ihdrView.setUint32(0, width);
+	ihdrView.setUint32(4, height);
+	ihdr[8] = 8;
+	ihdr[9] = colorTypeFor(image);
+	ihdr[10] = 0;
+	ihdr[11] = 0;
+	ihdr[12] = 0;
+	const writer = new ByteWriter();
+	writer.writeBytes(PNG_SIGNATURE$1);
+	writeChunk(writer, "IHDR", ihdr);
+	writeChunk(writer, "IDAT", compressed);
+	writeChunk(writer, "IEND", /* @__PURE__ */ new Uint8Array(0));
+	return writer.toBytes();
+}
+//#endregion
+//#region src/image/png-decode.ts
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+function requireDataView(bytes) {
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function readChunks(bytes, onWarning) {
+	const chunks = [];
+	const view = requireDataView(bytes);
+	let offset = PNG_SIGNATURE.length;
+	while (offset + 8 <= bytes.length) {
+		const length = view.getUint32(offset);
+		const typeBytes = bytes.subarray(offset + 4, offset + 8);
+		const type = new TextDecoder("latin1").decode(typeBytes);
+		const dataStart = offset + 8;
+		const dataEnd = dataStart + length;
+		if (dataEnd + 4 > bytes.length) throw new Error(`PNG chunk '${type}' declares a length that runs past the end of the file`);
+		const data = bytes.subarray(dataStart, dataEnd);
+		if (onWarning !== void 0) {
+			if (view.getUint32(dataEnd) !== crc32(concatBytes([typeBytes, data]))) onWarning(`PNG chunk '${type}' failed its CRC32 check`);
+		}
+		chunks.push({
+			type,
+			data
+		});
+		offset = dataEnd + 4;
+		if (type === "IEND") break;
+	}
+	return chunks;
+}
+function parseIhdr(data) {
+	const view = requireDataView(data);
+	return {
+		width: view.getUint32(0),
+		height: view.getUint32(4),
+		bitDepth: data[8],
+		colorType: data[9],
+		interlace: data[12]
+	};
+}
+function channelsForColorType(colorType) {
+	if (colorType === 0) return 1;
+	if (colorType === 2) return 3;
+	if (colorType === 3) return 1;
+	if (colorType === 4) return 2;
+	if (colorType === 6) return 4;
+	throw new Error(`unsupported PNG colour type: ${colorType}`);
+}
+function filterBpp(bitDepth, channels) {
+	return Math.max(1, Math.ceil(bitDepth * channels / 8));
+}
+function unpackRow(rowBytes, width, channels, bitDepth) {
+	const sampleCount = width * channels;
+	const samples = new Array(sampleCount);
+	if (bitDepth === 8) for (let i = 0; i < sampleCount; i++) samples[i] = rowBytes[i];
+	else if (bitDepth === 16) for (let i = 0; i < sampleCount; i++) samples[i] = rowBytes[i * 2];
+	else {
+		const mask = (1 << bitDepth) - 1;
+		for (let i = 0; i < sampleCount; i++) {
+			const bitOffset = i * bitDepth;
+			const byteIndex = bitOffset >> 3;
+			const shift = 8 - bitDepth - (bitOffset & 7);
+			samples[i] = rowBytes[byteIndex] >> shift & mask;
+		}
+	}
+	return samples;
+}
+function readTrnsGrayValue(trns) {
+	return requireDataView(trns).getUint16(0);
+}
+function readTrnsRgbKey(trns) {
+	const view = requireDataView(trns);
+	return [
+		view.getUint16(0),
+		view.getUint16(2),
+		view.getUint16(4)
+	];
+}
+function scaleToByte(sample, bitDepth) {
+	if (bitDepth === 16) return sample;
+	const maxSample = (1 << bitDepth) - 1;
+	return Math.round(sample * 255 / maxSample);
+}
+function decodePng(bytes, options = {}) {
+	for (let i = 0; i < PNG_SIGNATURE.length; i++) if (bytes[i] !== PNG_SIGNATURE[i]) throw new Error("not a valid PNG file: bad signature");
+	const chunks = readChunks(bytes, options.onWarning);
+	const ihdrChunk = chunks[0];
+	if (ihdrChunk?.type !== "IHDR") throw new Error("PNG file does not begin with an IHDR chunk");
+	const ihdr = parseIhdr(ihdrChunk.data);
+	if (ihdr.interlace !== 0) throw new Error("Adam7-interlaced PNG images are not supported");
+	const channels = channelsForColorType(ihdr.colorType);
+	const bpp = filterBpp(ihdr.bitDepth, channels);
+	const bytesPerRow = Math.ceil(ihdr.width * channels * ihdr.bitDepth / 8);
+	const idatChunks = chunks.filter((c) => c.type === "IDAT").map((c) => c.data);
+	if (idatChunks.length === 0) throw new Error("PNG file has no IDAT chunks");
+	const { bytes: inflated, recovered } = inflateTolerant(concatBytes(idatChunks));
+	if (recovered && options.onWarning !== void 0) options.onWarning("PNG IDAT stream required tolerant recovery (truncated or malformed)");
+	const unfiltered = unfilterScanlines(inflated, ihdr.height, bytesPerRow, bpp);
+	const palette = ihdr.colorType === 3 ? chunks.find((c) => c.type === "PLTE")?.data : void 0;
+	if (ihdr.colorType === 3 && palette === void 0) throw new Error("indexed-colour PNG has no PLTE chunk");
+	const trns = chunks.find((c) => c.type === "tRNS")?.data;
+	return buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns);
+}
+function buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns) {
+	const { width, height, bitDepth, colorType } = ihdr;
+	const outChannels = colorType === 0 || colorType === 4 ? 1 : 3;
+	const data = new Uint8Array(width * height * outChannels);
+	const alpha = colorType === 4 || colorType === 6 || trns !== void 0 ? new Uint8Array(width * height).fill(255) : void 0;
+	const trnsGray = colorType === 0 && trns !== void 0 ? readTrnsGrayValue(trns) : void 0;
+	const trnsRgb = colorType === 2 && trns !== void 0 ? readTrnsRgbKey(trns) : void 0;
+	for (let y = 0; y < height; y++) {
+		const rowStart = y * bytesPerRow;
+		const samples = unpackRow(unfiltered.subarray(rowStart, rowStart + bytesPerRow), width, channels, bitDepth);
+		for (let x = 0; x < width; x++) {
+			const pixelBase = x * channels;
+			const outBase = (y * width + x) * outChannels;
+			const alphaIndex = y * width + x;
+			if (colorType === 0) {
+				const g = samples[pixelBase];
+				data[outBase] = scaleToByte(g, bitDepth);
+				if (alpha !== void 0 && trnsGray !== void 0) alpha[alphaIndex] = g === trnsGray ? 0 : 255;
+			} else if (colorType === 2) {
+				const r = samples[pixelBase];
+				const g = samples[pixelBase + 1];
+				const b = samples[pixelBase + 2];
+				data[outBase] = r;
+				data[outBase + 1] = g;
+				data[outBase + 2] = b;
+				if (alpha !== void 0 && trnsRgb !== void 0) {
+					const [kr, kg, kb] = trnsRgb;
+					alpha[alphaIndex] = r === kr && g === kg && b === kb ? 0 : 255;
+				}
+			} else if (colorType === 3) {
+				const index = samples[pixelBase];
+				if (palette === void 0) throw new Error("indexed-colour PNG has no PLTE chunk");
+				data[outBase] = palette[index * 3];
+				data[outBase + 1] = palette[index * 3 + 1];
+				data[outBase + 2] = palette[index * 3 + 2];
+				if (alpha !== void 0 && trns !== void 0) alpha[alphaIndex] = index < trns.length ? trns[index] : 255;
+			} else if (colorType === 4) {
+				const g = samples[pixelBase];
+				const a = samples[pixelBase + 1];
+				data[outBase] = scaleToByte(g, bitDepth);
+				if (alpha !== void 0) alpha[alphaIndex] = scaleToByte(a, bitDepth);
+			} else {
+				data[outBase] = samples[pixelBase];
+				data[outBase + 1] = samples[pixelBase + 1];
+				data[outBase + 2] = samples[pixelBase + 2];
+				if (alpha !== void 0) alpha[alphaIndex] = samples[pixelBase + 3];
+			}
+		}
+	}
+	return alpha === void 0 ? {
+		width,
+		height,
+		channels: outChannels,
+		data
+	} : {
+		width,
+		height,
+		channels: outChannels,
+		data,
+		alpha
+	};
+}
+//#endregion
+//#region src/image/jpeg-info.ts
+const SOI = 216;
+const EOI = 217;
+const APP14 = 238;
+const SOF_MARKERS = /* @__PURE__ */ new Set([
+	192,
+	193,
+	194,
+	201,
+	202
+]);
+const PROGRESSIVE_SOF_MARKERS = /* @__PURE__ */ new Set([194, 202]);
+const NO_PAYLOAD_MARKERS = /* @__PURE__ */ new Set([
+	1,
+	216,
+	217,
+	208,
+	209,
+	210,
+	211,
+	212,
+	213,
+	214,
+	215
+]);
+function requireByte(bytes, index) {
+	const value = bytes[index];
+	if (value === void 0) throw new Error("unexpected end of JPEG data");
+	return value;
+}
+function readUint16BE(bytes, offset) {
+	return requireByte(bytes, offset) << 8 | requireByte(bytes, offset + 1);
+}
+function readJpegInfo(bytes) {
+	if (requireByte(bytes, 0) !== 255 || requireByte(bytes, 1) !== SOI) throw new Error("not a valid JPEG file: missing SOI marker");
+	let offset = 2;
+	let adobeTransform;
+	while (offset < bytes.length) {
+		if (bytes[offset] !== 255) {
+			offset++;
+			continue;
+		}
+		let markerOffset = offset + 1;
+		while (bytes[markerOffset] === 255) markerOffset++;
+		const marker = bytes[markerOffset];
+		if (marker === void 0) break;
+		offset = markerOffset + 1;
+		if (marker === EOI) break;
+		if (NO_PAYLOAD_MARKERS.has(marker)) continue;
+		const segmentLength = readUint16BE(bytes, offset);
+		if (marker === APP14 && segmentLength >= 14) adobeTransform = requireByte(bytes, offset + 2 + 11);
+		if (SOF_MARKERS.has(marker)) {
+			const p = offset + 2;
+			const precision = requireByte(bytes, p);
+			const height = readUint16BE(bytes, p + 1);
+			return {
+				width: readUint16BE(bytes, p + 3),
+				height,
+				components: requireByte(bytes, p + 5),
+				precision,
+				progressive: PROGRESSIVE_SOF_MARKERS.has(marker),
+				adobeTransform
+			};
+		}
+		offset += segmentLength;
+	}
+	throw new Error("no SOF marker found in JPEG file");
+}
+//#endregion
+exports.ByteReader = ByteReader;
+exports.ByteWriter = ByteWriter;
+exports.MAX_INFLATE_OUTPUT_BYTES = MAX_INFLATE_OUTPUT_BYTES;
+exports.concatBytes = concatBytes;
+exports.crc32 = crc32;
+exports.decodePng = decodePng;
+exports.deflate = deflate;
+exports.encodePng = encodePng;
+exports.filterScanlines = filterScanlines;
+exports.inflate = inflate;
+exports.inflateTolerant = inflateTolerant;
+exports.isAsciiWhitespace = isAsciiWhitespace;
+exports.readJpegInfo = readJpegInfo;
+exports.unfilterScanlines = unfilterScanlines;

package/dist/index.d.cts

@@ -0,0 +1,81 @@
+//#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
+//#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
+//#region src/bytes/crc32.d.ts
+declare function crc32(bytes: Uint8Array<ArrayBuffer>): number;
+//#endregion
+//#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
+//#region src/image/png-decode.d.ts
+interface RawImage {
+  readonly width: number;
+  readonly height: number;
+  readonly channels: 1 | 3;
+  readonly data: Uint8Array<ArrayBuffer>;
+  readonly alpha?: Uint8Array<ArrayBuffer>;
+}
+interface PngDecodeOptions {
+  readonly onWarning?: (message: string) => void;
+}
+declare function decodePng(bytes: Uint8Array<ArrayBuffer>, options?: PngDecodeOptions): RawImage;
+//#endregion
+//#region src/image/png-encode.d.ts
+interface PngEncodeOptions {
+  readonly filter?: 'none' | 'adaptive';
+}
+declare function encodePng(image: RawImage, options?: PngEncodeOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/image/png-filter.d.ts
+type PngFilterType = 0 | 1 | 2 | 3 | 4;
+declare function unfilterScanlines(data: Uint8Array<ArrayBuffer>, height: number, bytesPerRow: number, bpp: number): Uint8Array<ArrayBuffer>;
+declare function filterScanlines(raw: Uint8Array<ArrayBuffer>, height: number, bytesPerRow: number, bpp: number, strategy?: 'none' | 'adaptive'): Uint8Array<ArrayBuffer>;
+//#endregion
+//#region src/image/jpeg-info.d.ts
+interface JpegInfo {
+  readonly width: number;
+  readonly height: number;
+  readonly components: number;
+  readonly precision: number;
+  readonly progressive: boolean;
+  readonly adobeTransform: number | undefined;
+}
+declare function readJpegInfo(bytes: Uint8Array<ArrayBuffer>): JpegInfo;
+//#endregion
+export { ByteReader, ByteWriter, DeflateLevel, InflateResult, JpegInfo, MAX_INFLATE_OUTPUT_BYTES, PngDecodeOptions, PngEncodeOptions, PngFilterType, RawImage, concatBytes, crc32, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, readJpegInfo, unfilterScanlines };