byte-codec 0.0.0 → 1.0.1

package/dist/image/png-decode-Dvizumot.d.ts

@@ -0,0 +1,14 @@
+//#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
+export { PngDecodeOptions, RawImage, decodePng };

package/dist/image/png-decode.cjs

@@ -0,0 +1,181 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_writer = require("../bytes/writer.cjs");
+const require_bytes_crc32 = require("../bytes/crc32.cjs");
+const require_bytes_flate = require("../bytes/flate.cjs");
+const require_image_png_filter = require("./png-filter.cjs");
+//#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) !== require_bytes_crc32.crc32(require_bytes_writer.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 compressed = require_bytes_writer.concatBytes(idatChunks);
+	const { bytes: inflated, recovered } = require_bytes_flate.inflateTolerant(compressed);
+	if (recovered && options.onWarning !== void 0) options.onWarning("PNG IDAT stream required tolerant recovery (truncated or malformed)");
+	const unfiltered = require_image_png_filter.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
+exports.decodePng = decodePng;

package/dist/image/png-decode.js

@@ -0,0 +1,180 @@
+import { concatBytes } from "../bytes/writer.js";
+import { crc32 } from "../bytes/crc32.js";
+import { inflateTolerant } from "../bytes/flate.js";
+import { unfilterScanlines } from "./png-filter.js";
+//#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 compressed = concatBytes(idatChunks);
+	const { bytes: inflated, recovered } = inflateTolerant(compressed);
+	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
+export { decodePng };

package/dist/image/png-encode-C5Jj9gBX.d.ts

@@ -0,0 +1,9 @@
+import { RawImage } from "./png-decode-Dvizumot.js";
+
+//#region src/image/png-encode.d.ts
+interface PngEncodeOptions {
+  readonly filter?: 'none' | 'adaptive';
+}
+declare function encodePng(image: RawImage, options?: PngEncodeOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { PngEncodeOptions, encodePng };

package/dist/image/png-encode-CpwBOmkg.d.cts

@@ -0,0 +1,9 @@
+import { RawImage } from "./png-decode-Dvizumot.cjs";
+
+//#region src/image/png-encode.d.ts
+interface PngEncodeOptions {
+  readonly filter?: 'none' | 'adaptive';
+}
+declare function encodePng(image: RawImage, options?: PngEncodeOptions): Uint8Array<ArrayBuffer>;
+//#endregion
+export { PngEncodeOptions, encodePng };

package/dist/image/png-encode.cjs

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_writer = require("../bytes/writer.cjs");
+const require_bytes_crc32 = require("../bytes/crc32.cjs");
+const require_bytes_flate = require("../bytes/flate.cjs");
+const require_image_png_filter = require("./png-filter.cjs");
+//#region src/image/png-encode.ts
+const PNG_SIGNATURE = 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(require_bytes_crc32.crc32(require_bytes_writer.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 filtered = require_image_png_filter.filterScanlines(interleaved, height, bytesPerRow, outChannels, options.filter ?? "adaptive");
+	const compressed = require_bytes_flate.deflate(filtered);
+	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 require_bytes_writer.ByteWriter();
+	writer.writeBytes(PNG_SIGNATURE);
+	writeChunk(writer, "IHDR", ihdr);
+	writeChunk(writer, "IDAT", compressed);
+	writeChunk(writer, "IEND", /* @__PURE__ */ new Uint8Array(0));
+	return writer.toBytes();
+}
+//#endregion
+exports.encodePng = encodePng;

package/dist/image/png-encode.js

@@ -0,0 +1,63 @@
+import { ByteWriter, concatBytes } from "../bytes/writer.js";
+import { crc32 } from "../bytes/crc32.js";
+import { deflate } from "../bytes/flate.js";
+import { filterScanlines } from "./png-filter.js";
+//#region src/image/png-encode.ts
+const PNG_SIGNATURE = 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 filtered = filterScanlines(interleaved, height, bytesPerRow, outChannels, options.filter ?? "adaptive");
+	const compressed = deflate(filtered);
+	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);
+	writeChunk(writer, "IHDR", ihdr);
+	writeChunk(writer, "IDAT", compressed);
+	writeChunk(writer, "IEND", /* @__PURE__ */ new Uint8Array(0));
+	return writer.toBytes();
+}
+//#endregion
+export { encodePng };

package/dist/image/png-filter-5L1Q0PDF.d.cts

@@ -0,0 +1,6 @@
+//#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
+export { PngFilterType, filterScanlines, unfilterScanlines };

package/dist/image/png-filter-5L1Q0PDF.d.ts

@@ -0,0 +1,6 @@
+//#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
+export { PngFilterType, filterScanlines, unfilterScanlines };

package/dist/image/png-filter.cjs

@@ -0,0 +1,95 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.filterScanlines = filterScanlines;
+exports.unfilterScanlines = unfilterScanlines;