roxify 1.6.5 → 1.6.7

package/dist/cli.js

@@ -6,7 +6,7 @@ import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInP
 import { packPathsGenerator, unpackBuffer } from './pack.js';
 import * as cliProgress from './stub-progress.js';
 import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
-const VERSION = '1.6.2';
+const VERSION = '1.6.1';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {
@@ -52,22 +52,25 @@ async function readLargeFile(filePath) {
 }
 function showHelp() {
     console.log(`
-ROX CLI — Encode/decode binary in PNG
+ROX CLI — Encode/decode binary in PNG or WAV
 
 Usage:
   npx rox <command> [options]
 
 Commands:
-  encode <input>... [output]   Encode one or more files/directories into a PNG
-  decode <input> [output]   Decode PNG to original file
-  list <input>               List files in a Rox PNG archive
-  havepassphrase <input>     Check whether the PNG requires a passphrase
+  encode <input>... [output]   Encode one or more files/directories
+  decode <input> [output]      Decode PNG/WAV to original file
+  list <input>                 List files in a Rox archive
+  havepassphrase <input>       Check whether the archive requires a passphrase
 
 Options:
+  --image                   Use PNG container (default)
+  --sound                   Use WAV audio container (smaller overhead, faster)
   -p, --passphrase <pass>   Use passphrase (AES-256-GCM)
   -m, --mode <mode>         Mode: screenshot (default)
   -e, --encrypt <type>      auto|aes|xor|none
   --no-compress             Disable compression
+  --dict <file>             Use zstd dictionary when compressing
   --force-ts                Force TypeScript encoder (slower but supports encryption)
   -o, --output <path>       Output file path
   -s, --sizes               Show file sizes in 'list' output (default)
@@ -115,6 +118,14 @@ function parseArgs(args) {
                 parsed.forceTs = true;
                 i++;
             }
+            else if (key === 'sound') {
+                parsed.container = 'sound';
+                i++;
+            }
+            else if (key === 'image') {
+                parsed.container = 'image';
+                i++;
+            }
             else if (key === 'debug-dir') {
                 parsed.debugDir = args[i + 1];
                 i += 2;
@@ -123,6 +134,10 @@ function parseArgs(args) {
                 parsed.files = args[i + 1].split(',');
                 i += 2;
             }
+            else if (key === 'dict') {
+                parsed.dict = args[i + 1];
+                i += 2;
+            }
             else {
                 const value = args[i + 1];
                 parsed[key] = value;
@@ -175,15 +190,11 @@ function parseArgs(args) {
 }
 async function encodeCommand(args) {
     const parsed = parseArgs(args);
-    const inputPaths = parsed.output
-        ? parsed._
-        : parsed._.length > 1
-            ? parsed._.slice(0, -1)
+    const inputPaths = parsed.output ? parsed._
+        : parsed._.length > 1 ? parsed._.slice(0, -1)
             : parsed._;
-    const outputPath = parsed.output
-        ? undefined
-        : parsed._.length > 1
-            ? parsed._[parsed._.length - 1]
+    const outputPath = parsed.output ? undefined
+        : parsed._.length > 1 ? parsed._[parsed._.length - 1]
             : undefined;
     const firstInput = inputPaths[0];
     if (!firstInput) {
@@ -200,12 +211,14 @@ async function encodeCommand(args) {
         safeCwd = '/';
     }
     const resolvedInputs = inputPaths.map((p) => resolve(safeCwd, p));
+    const containerMode = parsed.container || 'image'; // default: image (PNG)
+    const containerExt = containerMode === 'sound' ? '.wav' : '.png';
     let outputName = inputPaths.length === 1 ? basename(firstInput) : 'archive';
     if (inputPaths.length === 1 && !statSync(resolvedInputs[0]).isDirectory()) {
-        outputName = outputName.replace(/(\.[^.]+)?$/, '.png');
+        outputName = outputName.replace(/(\.[^.]+)?$/, containerExt);
     }
     else {
-        outputName += '.png';
+        outputName += containerExt;
     }
     let resolvedOutput;
     try {
@@ -240,7 +253,7 @@ async function encodeCommand(args) {
     catch (e) {
         anyInputDir = false;
     }
-    if (isRustBinaryAvailable() && !parsed.forceTs && !anyInputDir) {
+    if (isRustBinaryAvailable() && !parsed.forceTs && containerMode !== 'sound') {
         try {
             console.log(`Encoding to ${resolvedOutput} (Using native Rust encoder)\n`);
             const startTime = Date.now();
@@ -257,7 +270,7 @@ async function encodeCommand(args) {
             }, 500);
             const encryptType = parsed.encrypt === 'xor' ? 'xor' : 'aes';
             const fileName = basename(inputPaths[0]);
-            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 12, parsed.passphrase, encryptType, fileName);
+            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 19, parsed.passphrase, encryptType, fileName);
             clearInterval(progressInterval);
             const encodeTime = Date.now() - startTime;
             encodeBar.update(100, {
@@ -290,6 +303,15 @@ async function encodeCommand(args) {
         }
     }
     let options = {};
+    if (parsed.dict) {
+        try {
+            options.dict = readFileSync(parsed.dict);
+        }
+        catch (e) {
+            console.error(`failed to read dictionary file: ${parsed.dict}`);
+            process.exit(1);
+        }
+    }
     try {
         const encodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
@@ -326,8 +348,9 @@ async function encodeCommand(args) {
             mode,
             name: parsed.outputName || 'archive',
             skipOptimization: false,
-            compressionLevel: 12,
+            compressionLevel: 19,
             outputFormat: 'auto',
+            container: containerMode,
         });
         if (parsed.verbose)
             options.verbose = true;
@@ -337,7 +360,7 @@ async function encodeCommand(args) {
             options.passphrase = parsed.passphrase;
             options.encrypt = parsed.encrypt || 'aes';
         }
-        console.log(`Encoding to ${resolvedOutput} (Mode: ${mode})\n`);
+        console.log(`Encoding to ${resolvedOutput} (Mode: ${mode}, Container: ${containerMode === 'sound' ? 'WAV' : 'PNG'})\n`);
         let inputData;
         let inputSizeVal = 0;
         let displayName;
@@ -347,9 +370,8 @@ async function encodeCommand(args) {
                 totalBytes = total;
             const packPct = Math.floor((readBytes / totalBytes) * 25);
             targetPct = Math.max(targetPct, packPct);
-            currentEncodeStep = currentFile
-                ? `Reading files: ${currentFile}`
-                : 'Reading files';
+            currentEncodeStep =
+                currentFile ? `Reading files: ${currentFile}` : 'Reading files';
         };
         if (inputPaths.length > 1) {
             currentEncodeStep = 'Reading files';
@@ -511,6 +533,15 @@ async function decodeCommand(args) {
         if (parsed.files) {
             options.files = parsed.files;
         }
+        if (parsed.dict) {
+            try {
+                options.dict = readFileSync(parsed.dict);
+            }
+            catch (e) {
+                console.error(`Failed to read dictionary file: ${parsed.dict}`);
+                process.exit(1);
+            }
+        }
         console.log(' ');
         console.log(`Decoding...`);
         console.log(' ');

package/dist/index.d.ts

@@ -1,6 +1,8 @@
+export * from './utils/audio.js';
 export * from './utils/constants.js';
 export * from './utils/crc.js';
 export * from './utils/decoder.js';
+export * from './utils/ecc.js';
 export * from './utils/encoder.js';
 export * from './utils/errors.js';
 export * from './utils/helpers.js';
@@ -8,7 +10,9 @@ export * from './utils/inspection.js';
 export { native } from './utils/native.js';
 export * from './utils/optimization.js';
 export * from './utils/reconstitution.js';
-export { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
+export * from './utils/robust-audio.js';
+export * from './utils/robust-image.js';
+export { encodeWithRustCLI, isRustBinaryAvailable } from './utils/rust-cli-wrapper.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
 export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/dist/index.js

@@ -1,6 +1,8 @@
+export * from './utils/audio.js';
 export * from './utils/constants.js';
 export * from './utils/crc.js';
 export * from './utils/decoder.js';
+export * from './utils/ecc.js';
 export * from './utils/encoder.js';
 export * from './utils/errors.js';
 export * from './utils/helpers.js';
@@ -8,7 +10,9 @@ export * from './utils/inspection.js';
 export { native } from './utils/native.js';
 export * from './utils/optimization.js';
 export * from './utils/reconstitution.js';
-export { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
+export * from './utils/robust-audio.js';
+export * from './utils/robust-image.js';
+export { encodeWithRustCLI, isRustBinaryAvailable } from './utils/rust-cli-wrapper.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
 export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/dist/pack.d.ts

@@ -27,3 +27,4 @@ export declare function packPathsGenerator(paths: string[], baseDir?: string, on
     stream: AsyncGenerator<Buffer>;
     totalSize: number;
 }>;
+export declare function isTar(buf: Buffer): boolean;

package/dist/pack.js

@@ -58,6 +58,9 @@ export function packPaths(paths, baseDir, onProgress) {
 export function unpackBuffer(buf, fileList) {
     if (buf.length < 8)
         return null;
+    if (isTar(buf)) {
+        return unpackTar(buf, fileList);
+    }
     const magic = buf.readUInt32BE(0);
     if (magic === 0x524f5849) {
         const indexLen = buf.readUInt32BE(4);
@@ -65,9 +68,7 @@ export function unpackBuffer(buf, fileList) {
         const index = JSON.parse(indexBuf.toString('utf8'));
         const dataStart = 8 + indexLen;
         const files = [];
-        const entriesToProcess = fileList
-            ? index.filter((e) => fileList.includes(e.path))
-            : index;
+        const entriesToProcess = fileList ? index.filter((e) => fileList.includes(e.path)) : index;
         for (const entry of entriesToProcess) {
             const entryStart = dataStart + entry.offset;
             let ptr = entryStart;
@@ -203,3 +204,51 @@ export async function packPathsGenerator(paths, baseDir, onProgress) {
     }
     return { index, stream: streamGenerator(), totalSize };
 }
+export function isTar(buf) {
+    if (buf.length < 263)
+        return false;
+    return buf.slice(257, 262).toString('ascii') === 'ustar';
+}
+function unpackTar(buf, fileList) {
+    const files = [];
+    let offset = 0;
+    while (offset + 512 <= buf.length) {
+        const header = buf.slice(offset, offset + 512);
+        let allZero = true;
+        for (let i = 0; i < 512; i++) {
+            if (header[i] !== 0) {
+                allZero = false;
+                break;
+            }
+        }
+        if (allZero)
+            break;
+        const nameRaw = header.slice(0, 100).toString('ascii');
+        const name = nameRaw.replace(/\0+$/, '');
+        const sizeOctal = header
+            .slice(124, 136)
+            .toString('ascii')
+            .replace(/\0+$/, '')
+            .trim();
+        const size = parseInt(sizeOctal, 8) || 0;
+        const typeFlag = header[156];
+        const prefix = header.slice(345, 500).toString('ascii').replace(/\0+$/, '');
+        const fullPath = prefix ? `${prefix}/${name}` : name;
+        const cleanPath = fullPath
+            .split('/')
+            .filter((c) => c && c !== '.' && c !== '..')
+            .join('/');
+        offset += 512;
+        if (typeFlag === 0 || typeFlag === 0x30) {
+            if (offset + size > buf.length)
+                break;
+            const content = buf.slice(offset, offset + size);
+            if (!fileList || fileList.includes(cleanPath)) {
+                files.push({ path: cleanPath, buf: Buffer.from(content) });
+            }
+        }
+        const blocks = Math.ceil(size / 512);
+        offset += blocks * 512;
+    }
+    return files.length > 0 ? { files } : null;
+}

package/dist/utils/audio.d.ts

@@ -0,0 +1,23 @@
+/**
+ * WAV container for binary data.
+ *
+ * Encodes raw bytes as 8-bit unsigned PCM mono samples (44100 Hz).
+ * Header is exactly 44 bytes. Total container overhead: 44 bytes (constant).
+ *
+ * Compared to PNG (stored deflate): PNG overhead grows with data size
+ * (zlib framing, filter bytes, chunk CRCs). WAV overhead is constant.
+ */
+/**
+ * Pack raw bytes into a WAV file (8-bit PCM, mono, 44100 Hz).
+ * The bytes are stored directly as unsigned PCM samples.
+ */
+export declare function bytesToWav(data: Buffer): Buffer;
+/**
+ * Extract raw bytes from a WAV file.
+ * Returns the PCM data (the original bytes).
+ */
+export declare function wavToBytes(wav: Buffer): Buffer;
+/**
+ * Check if a buffer starts with a RIFF/WAVE header.
+ */
+export declare function isWav(buf: Buffer): boolean;

package/dist/utils/audio.js

@@ -0,0 +1,98 @@
+/**
+ * WAV container for binary data.
+ *
+ * Encodes raw bytes as 8-bit unsigned PCM mono samples (44100 Hz).
+ * Header is exactly 44 bytes. Total container overhead: 44 bytes (constant).
+ *
+ * Compared to PNG (stored deflate): PNG overhead grows with data size
+ * (zlib framing, filter bytes, chunk CRCs). WAV overhead is constant.
+ */
+const WAV_HEADER_SIZE = 44;
+const SAMPLE_RATE = 44100;
+const BITS_PER_SAMPLE = 8;
+const NUM_CHANNELS = 1;
+/**
+ * Pack raw bytes into a WAV file (8-bit PCM, mono, 44100 Hz).
+ * The bytes are stored directly as unsigned PCM samples.
+ */
+export function bytesToWav(data) {
+    const dataSize = data.length;
+    const fileSize = WAV_HEADER_SIZE - 8 + dataSize;
+    const byteRate = SAMPLE_RATE * NUM_CHANNELS * (BITS_PER_SAMPLE / 8);
+    const blockAlign = NUM_CHANNELS * (BITS_PER_SAMPLE / 8);
+    const wav = Buffer.alloc(WAV_HEADER_SIZE + dataSize);
+    let offset = 0;
+    // RIFF header
+    wav.write('RIFF', offset, 'ascii');
+    offset += 4;
+    wav.writeUInt32LE(fileSize, offset);
+    offset += 4;
+    wav.write('WAVE', offset, 'ascii');
+    offset += 4;
+    // fmt sub-chunk
+    wav.write('fmt ', offset, 'ascii');
+    offset += 4;
+    wav.writeUInt32LE(16, offset);
+    offset += 4; // sub-chunk size (PCM = 16)
+    wav.writeUInt16LE(1, offset);
+    offset += 2; // audio format (1 = PCM)
+    wav.writeUInt16LE(NUM_CHANNELS, offset);
+    offset += 2;
+    wav.writeUInt32LE(SAMPLE_RATE, offset);
+    offset += 4;
+    wav.writeUInt32LE(byteRate, offset);
+    offset += 4;
+    wav.writeUInt16LE(blockAlign, offset);
+    offset += 2;
+    wav.writeUInt16LE(BITS_PER_SAMPLE, offset);
+    offset += 2;
+    // data sub-chunk
+    wav.write('data', offset, 'ascii');
+    offset += 4;
+    wav.writeUInt32LE(dataSize, offset);
+    offset += 4;
+    data.copy(wav, offset);
+    return wav;
+}
+/**
+ * Extract raw bytes from a WAV file.
+ * Returns the PCM data (the original bytes).
+ */
+export function wavToBytes(wav) {
+    if (wav.length < WAV_HEADER_SIZE) {
+        throw new Error('WAV data too short');
+    }
+    if (wav.toString('ascii', 0, 4) !== 'RIFF') {
+        throw new Error('Not a RIFF file');
+    }
+    if (wav.toString('ascii', 8, 12) !== 'WAVE') {
+        throw new Error('Not a WAVE file');
+    }
+    // Find the "data" sub-chunk
+    let offset = 12;
+    while (offset + 8 <= wav.length) {
+        const chunkId = wav.toString('ascii', offset, offset + 4);
+        const chunkSize = wav.readUInt32LE(offset + 4);
+        if (chunkId === 'data') {
+            const dataStart = offset + 8;
+            const dataEnd = dataStart + chunkSize;
+            if (dataEnd > wav.length) {
+                return wav.subarray(dataStart);
+            }
+            return wav.subarray(dataStart, dataEnd);
+        }
+        offset += 8 + chunkSize;
+        if (chunkSize % 2 !== 0)
+            offset += 1; // RIFF word alignment
+    }
+    throw new Error('data chunk not found in WAV');
+}
+/**
+ * Check if a buffer starts with a RIFF/WAVE header.
+ */
+export function isWav(buf) {
+    return (buf.length >= 12 &&
+        buf[0] === 0x52 && buf[1] === 0x49 && buf[2] === 0x46 && buf[3] === 0x46 && // RIFF
+        buf[8] === 0x57 && buf[9] === 0x41 && buf[10] === 0x56 && buf[11] === 0x45 // WAVE
+    );
+}

package/dist/utils/decoder.js

@@ -3,12 +3,18 @@ import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { unpackBuffer } from '../pack.js';
+import { isWav, wavToBytes } from './audio.js';
 import { CHUNK_TYPE, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PIXEL_MAGIC_BLOCK, PNG_HEADER, } from './constants.js';
 import { DataFormatError, IncorrectPassphraseError, PassphraseRequiredError, } from './errors.js';
 import { colorsToBytes, deltaDecode, tryDecryptIfNeeded } from './helpers.js';
 import { native } from './native.js';
 import { cropAndReconstitute } from './reconstitution.js';
+import { decodeRobustAudio, isRobustAudioWav } from './robust-audio.js';
+import { decodeRobustImage, isRobustImage } from './robust-image.js';
 import { parallelZstdDecompress, tryZstdDecompress } from './zstd.js';
+function isColorMatch(r1, g1, b1, r2, g2, b2) {
+    return Math.abs(r1 - r2) + Math.abs(g1 - g2) + Math.abs(b1 - b2) < 50;
+}
 async function tryDecompress(payload, onProgress) {
     return await parallelZstdDecompress(payload, onProgress);
 }
@@ -150,6 +156,107 @@ export async function decodePngToBinary(input, opts = {}) {
     }
     if (opts.onProgress)
         opts.onProgress({ phase: 'processed' });
+    // ─── Robust audio detection (lossy-resilient WAV) ──────────────────────────
+    if (isWav(processedBuf) && isRobustAudioWav(processedBuf)) {
+        try {
+            const result = decodeRobustAudio(processedBuf);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'done' });
+            progressBar?.stop();
+            // Try unpack multi-file archive
+            try {
+                const unpack = unpackBuffer(result.data);
+                if (unpack && unpack.files && unpack.files.length > 0) {
+                    return { files: unpack.files, correctedErrors: result.correctedErrors };
+                }
+            }
+            catch (e) { }
+            return { buf: result.data, correctedErrors: result.correctedErrors };
+        }
+        catch (e) {
+            // Fall through to legacy WAV decoding
+        }
+    }
+    // ─── WAV container detection ───────────────────────────────────────────────
+    if (isWav(processedBuf)) {
+        const pcmData = wavToBytes(processedBuf);
+        // The WAV payload starts with PIXEL_MAGIC ("PXL1")
+        if (pcmData.length >= 4 && pcmData.subarray(0, 4).equals(PIXEL_MAGIC)) {
+            let idx = 4; // skip PIXEL_MAGIC
+            const version = pcmData[idx++];
+            const nameLen = pcmData[idx++];
+            let name;
+            if (nameLen > 0) {
+                name = pcmData.subarray(idx, idx + nameLen).toString('utf8');
+                idx += nameLen;
+            }
+            const payloadLen = pcmData.readUInt32BE(idx);
+            idx += 4;
+            const rawPayload = pcmData.subarray(idx, idx + payloadLen);
+            idx += payloadLen;
+            // Check for rXFL file list after payload
+            let fileListJson;
+            if (idx + 8 < pcmData.length &&
+                pcmData.subarray(idx, idx + 4).toString('utf8') === 'rXFL') {
+                idx += 4;
+                const jsonLen = pcmData.readUInt32BE(idx);
+                idx += 4;
+                fileListJson = pcmData.subarray(idx, idx + jsonLen).toString('utf8');
+            }
+            let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'decompress_start' });
+            try {
+                payload = await tryDecompress(payload, (info) => {
+                    if (opts.onProgress)
+                        opts.onProgress(info);
+                });
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                if (opts.passphrase)
+                    throw new IncorrectPassphraseError('Incorrect passphrase (WAV mode, zstd failed: ' + errMsg + ')');
+                throw new DataFormatError('WAV mode zstd decompression failed: ' + errMsg);
+            }
+            if (!payload.subarray(0, MAGIC.length).equals(MAGIC)) {
+                throw new DataFormatError('Invalid ROX format in WAV (missing ROX1 magic after decompression)');
+            }
+            payload = payload.subarray(MAGIC.length);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'done' });
+            progressBar?.stop();
+            // Try unpack multi-file archive
+            try {
+                const unpack = unpackBuffer(payload);
+                if (unpack && unpack.files && unpack.files.length > 0) {
+                    return { files: unpack.files, meta: { name } };
+                }
+            }
+            catch (e) { }
+            return { buf: payload, meta: { name } };
+        }
+    }
+    // ─── Robust image detection (lossy-resilient PNG) ──────────────────────────
+    try {
+        if (isRobustImage(processedBuf)) {
+            const result = decodeRobustImage(processedBuf);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'done' });
+            progressBar?.stop();
+            try {
+                const unpack = unpackBuffer(result.data);
+                if (unpack && unpack.files && unpack.files.length > 0) {
+                    return { files: unpack.files, correctedErrors: result.correctedErrors };
+                }
+            }
+            catch (e) { }
+            return { buf: result.data, correctedErrors: result.correctedErrors };
+        }
+    }
+    catch (e) {
+        // Fall through to standard decoding
+    }
+    // ─── MAGIC header (compact mode) ──────────────────────────────────────────
     if (processedBuf.subarray(0, MAGIC.length).equals(MAGIC)) {
         const d = processedBuf.subarray(MAGIC.length);
         const nameLen = d[0];
@@ -331,9 +438,7 @@ export async function decodePngToBinary(input, opts = {}) {
         if (firstPixels.length === MARKER_START.length) {
             hasMarkerStart = true;
             for (let i = 0; i < MARKER_START.length; i++) {
-                if (firstPixels[i].r !== MARKER_START[i].r ||
-                    firstPixels[i].g !== MARKER_START[i].g ||
-                    firstPixels[i].b !== MARKER_START[i].b) {
+                if (!isColorMatch(firstPixels[i].r, firstPixels[i].g, firstPixels[i].b, MARKER_START[i].r, MARKER_START[i].g, MARKER_START[i].b)) {
                     hasMarkerStart = false;
                     break;
                 }
@@ -422,9 +527,7 @@ export async function decodePngToBinary(input, opts = {}) {
             let match = true;
             for (let mi = 0; mi < MARKER_START.length && match; mi++) {
                 const offset = (i + mi) * 3;
-                if (logicalData[offset] !== MARKER_START[mi].r ||
-                    logicalData[offset + 1] !== MARKER_START[mi].g ||
-                    logicalData[offset + 2] !== MARKER_START[mi].b) {
+                if (!isColorMatch(logicalData[offset], logicalData[offset + 1], logicalData[offset + 2], MARKER_START[mi].r, MARKER_START[mi].g, MARKER_START[mi].b)) {
                     match = false;
                 }
             }
@@ -445,9 +548,7 @@ export async function decodePngToBinary(input, opts = {}) {
                     for (let mi = 0; mi < MARKER_START.length && match; mi++) {
                         const idx = (y * logicalWidth + (x + mi)) * 3;
                         if (idx + 2 >= logicalData.length ||
-                            logicalData[idx] !== MARKER_START[mi].r ||
-                            logicalData[idx + 1] !== MARKER_START[mi].g ||
-                            logicalData[idx + 2] !== MARKER_START[mi].b) {
+                            !isColorMatch(logicalData[idx], logicalData[idx + 1], logicalData[idx + 2], MARKER_START[mi].r, MARKER_START[mi].g, MARKER_START[mi].b)) {
                             match = false;
                         }
                     }
@@ -540,9 +641,7 @@ export async function decodePngToBinary(input, opts = {}) {
         }
         for (let i = 0; i < MARKER_START.length; i++) {
             const offset = (startIdx + i) * 3;
-            if (logicalData[offset] !== MARKER_START[i].r ||
-                logicalData[offset + 1] !== MARKER_START[i].g ||
-                logicalData[offset + 2] !== MARKER_START[i].b) {
+            if (!isColorMatch(logicalData[offset], logicalData[offset + 1], logicalData[offset + 2], MARKER_START[i].r, MARKER_START[i].g, MARKER_START[i].b)) {
                 throw new Error('Marker START not found - image format not supported');
             }
         }
@@ -576,9 +675,7 @@ export async function decodePngToBinary(input, opts = {}) {
                     break;
                 }
                 const offset = pixelIdx * 3;
-                if (logicalData[offset] !== MARKER_END[mi].r ||
-                    logicalData[offset + 1] !== MARKER_END[mi].g ||
-                    logicalData[offset + 2] !== MARKER_END[mi].b) {
+                if (!isColorMatch(logicalData[offset], logicalData[offset + 1], logicalData[offset + 2], MARKER_END[mi].r, MARKER_END[mi].g, MARKER_END[mi].b)) {
                     matchEnd = false;
                 }
             }
@@ -730,9 +827,7 @@ export async function decodePngToBinary(input, opts = {}) {
                                     for (let mi = 0; mi < MARKER_START.length && match; mi++) {
                                         const idx = (y * logicalWidth2 + (x + mi)) * 3;
                                         if (idx + 2 >= logicalData2.length ||
-                                            logicalData2[idx] !== MARKER_START[mi].r ||
-                                            logicalData2[idx + 1] !== MARKER_START[mi].g ||
-                                            logicalData2[idx + 2] !== MARKER_START[mi].b) {
+                                            !isColorMatch(logicalData2[idx], logicalData2[idx + 1], logicalData2[idx + 2], MARKER_START[mi].r, MARKER_START[mi].g, MARKER_START[mi].b)) {
                                             match = false;
                                         }
                                     }
@@ -809,9 +904,7 @@ export async function decodePngToBinary(input, opts = {}) {
                                     break;
                                 }
                                 const offset = pixelIdx * 3;
-                                if (logicalData2[offset] !== MARKER_END[mi].r ||
-                                    logicalData2[offset + 1] !== MARKER_END[mi].g ||
-                                    logicalData2[offset + 2] !== MARKER_END[mi].b) {
+                                if (!isColorMatch(logicalData2[offset], logicalData2[offset + 1], logicalData2[offset + 2], MARKER_END[mi].r, MARKER_END[mi].g, MARKER_END[mi].b)) {
                                     matchEnd2 = false;
                                 }
                             }