roxify 1.1.2 → 1.1.4

package/dist/cli.js

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 import { readFileSync, writeFileSync } from 'fs';
-import { basename, dirname, join, resolve } from 'path';
-import sharp from 'sharp';
-import { cropAndReconstitute, DataFormatError, decodePngToBinary, encodeBinaryToPng, IncorrectPassphraseError, PassphraseRequiredError, } from './index.js';
-const VERSION = '1.0.4';
+import { basename, dirname, resolve } from 'path';
+import { DataFormatError, decodePngToBinary, encodeBinaryToPng, IncorrectPassphraseError, PassphraseRequiredError, } from './index.js';
+const VERSION = '1.1.4';
 function showHelp() {
     console.log(`
 ROX CLI — Encode/decode binary in PNG
@@ -167,7 +166,6 @@ async function decodeCommand(args) {
     try {
         const inputBuffer = readFileSync(resolvedInput);
         console.log(`Reading: ${resolvedInput}`);
-        const info = await sharp(inputBuffer).metadata();
         const options = {};
         if (parsed.passphrase) {
             options.passphrase = parsed.passphrase;
@@ -177,21 +175,7 @@ async function decodeCommand(args) {
         }
         console.log(`Decoding...`);
         const startDecode = Date.now();
-        if (parsed.verbose)
-            options.verbose = true;
-        const doubledBuffer = await sharp(inputBuffer)
-            .resize({
-            width: info.width * 2,
-            height: info.height * 2,
-            kernel: 'nearest',
-        })
-            .png()
-            .toBuffer();
-        if (options.debugDir) {
-            writeFileSync(join(options.debugDir, 'doubled.png'), doubledBuffer);
-        }
-        const reconstructedBuffer = await cropAndReconstitute(doubledBuffer, options.debugDir);
-        const result = await decodePngToBinary(reconstructedBuffer, options);
+        const result = await decodePngToBinary(inputBuffer, options);
         const decodeTime = Date.now() - startDecode;
         const resolvedOutput = parsed.output || outputPath || result.meta?.name || 'decoded.bin';
         writeFileSync(resolvedOutput, result.buf);

package/dist/index.js

@@ -148,9 +148,8 @@ export async function cropAndReconstitute(input, debugDir) {
         await sharp(doubledBuffer).toFile(join(debugDir, 'doubled.png'));
     }
     const { data: doubledData, info: doubledInfo } = await loadRaw(doubledBuffer);
-    const w = doubledInfo.width;
-    const h = doubledInfo.height;
-    function at(x, y) {
+    const w = doubledInfo.width, h = doubledInfo.height;
+    const at = (x, y) => {
         const i = idxFor(x, y, w);
         return [
             doubledData[i],
@@ -158,178 +157,110 @@ export async function cropAndReconstitute(input, debugDir) {
             doubledData[i + 2],
             doubledData[i + 3],
         ];
-    }
-    let startPoint = null;
-    for (let y = 0; y < h && !startPoint; y++) {
-        for (let x = 0; x < w; x++) {
-            const p = at(x, y);
-            if (p[0] !== 255 || p[1] !== 0 || p[2] !== 0)
-                continue;
-            let nx = x + 1;
-            while (nx < w && eqRGB(at(nx, y), p))
-                nx++;
-            if (nx >= w)
-                continue;
-            const a = at(nx, y);
-            let nx2 = nx + 1;
-            while (nx2 < w && eqRGB(at(nx2, y), a))
-                nx2++;
-            if (nx2 >= w)
-                continue;
-            const b = at(nx2, y);
-            const isRgb = a[0] === 0 &&
-                a[1] === 255 &&
-                a[2] === 0 &&
-                b[0] === 0 &&
-                b[1] === 0 &&
-                b[2] === 255;
-            if (isRgb) {
-                startPoint = { x, y, type: 'rgb' };
-                break;
-            }
-        }
-    }
-    let endPoint = null;
-    for (let y = h - 1; y >= 0 && !endPoint; y--) {
-        for (let x = w - 1; x >= 0; x--) {
-            const p = at(x, y);
-            if (p[0] !== 255 || p[1] !== 0 || p[2] !== 0)
-                continue;
-            let nx = x - 1;
-            while (nx >= 0 && eqRGB(at(nx, y), p))
-                nx--;
-            if (nx < 0)
-                continue;
-            const a = at(nx, y);
-            let nx2 = nx - 1;
-            while (nx2 >= 0 && eqRGB(at(nx2, y), a))
-                nx2--;
-            if (nx2 < 0)
-                continue;
-            const b = at(nx2, y);
-            const isRgbReverse = a[0] === 0 &&
-                a[1] === 255 &&
-                a[2] === 0 &&
-                b[0] === 0 &&
-                b[1] === 0 &&
-                b[2] === 255;
-            if (isRgbReverse) {
-                endPoint = { x, y, type: 'bgr' };
-                break;
+    };
+    const findPattern = (startX, startY, dirX, dirY, pattern) => {
+        for (let y = startY; y >= 0 && y < h; y += dirY) {
+            for (let x = startX; x >= 0 && x < w; x += dirX) {
+                const p = at(x, y);
+                if (p[0] !== 255 || p[1] !== 0 || p[2] !== 0)
+                    continue;
+                let nx = x + dirX;
+                while (nx >= 0 && nx < w && eqRGB(at(nx, y), p))
+                    nx += dirX;
+                if (nx < 0 || nx >= w)
+                    continue;
+                const a = at(nx, y);
+                let nx2 = nx + dirX;
+                while (nx2 >= 0 && nx2 < w && eqRGB(at(nx2, y), a))
+                    nx2 += dirX;
+                if (nx2 < 0 || nx2 >= w)
+                    continue;
+                const b = at(nx2, y);
+                if (a[0] === pattern[0][0] &&
+                    a[1] === pattern[0][1] &&
+                    a[2] === pattern[0][2] &&
+                    b[0] === pattern[1][0] &&
+                    b[1] === pattern[1][1] &&
+                    b[2] === pattern[1][2]) {
+                    return { x, y };
+                }
             }
         }
-    }
-    if (!startPoint)
-        throw new Error('Start pattern (RGB) not found');
-    if (!endPoint)
-        throw new Error('End pattern (BGR) not found');
-    const sx1 = Math.min(startPoint.x, endPoint.x);
-    const sy1 = Math.min(startPoint.y, endPoint.y);
-    const sx2 = Math.max(startPoint.x, endPoint.x);
-    const sy2 = Math.max(startPoint.y, endPoint.y);
-    const cropW = sx2 - sx1 + 1;
-    const cropH = sy2 - sy1 + 1;
+        return null;
+    };
+    const startPoint = findPattern(0, 0, 1, 1, [
+        [0, 255, 0],
+        [0, 0, 255],
+    ]);
+    const endPoint = findPattern(w - 1, h - 1, -1, -1, [
+        [0, 255, 0],
+        [0, 0, 255],
+    ]);
+    if (!startPoint || !endPoint)
+        throw new Error('Patterns not found');
+    const sx1 = Math.min(startPoint.x, endPoint.x), sy1 = Math.min(startPoint.y, endPoint.y);
+    const sx2 = Math.max(startPoint.x, endPoint.x), sy2 = Math.max(startPoint.y, endPoint.y);
+    const cropW = sx2 - sx1 + 1, cropH = sy2 - sy1 + 1;
     if (cropW <= 0 || cropH <= 0)
         throw new Error('Invalid crop dimensions');
     const cropped = await sharp(doubledBuffer)
         .extract({ left: sx1, top: sy1, width: cropW, height: cropH })
         .png()
         .toBuffer();
-    const { data: cdata, info: cinfo } = await sharp(cropped)
-        .ensureAlpha()
-        .raw()
-        .toBuffer({ resolveWithObject: true });
-    const cw = cinfo.width;
-    const ch = cinfo.height;
-    function cat(x, y) {
-        const i = idxFor(x, y, cw);
-        return [cdata[i], cdata[i + 1], cdata[i + 2], cdata[i + 3]];
-    }
-    function eq(a, b) {
-        return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
-    }
-    function lineEq(l1, l2) {
-        if (l1.length !== l2.length)
-            return false;
-        for (let i = 0; i < l1.length; i++)
-            if (!eq(l1[i], l2[i]))
-                return false;
-        return true;
-    }
-    const newWidth = cw;
-    const newHeight = ch + 1;
+    const { data: cdata, info: cinfo } = await loadRaw(cropped);
+    const cw = cinfo.width, ch = cinfo.height;
+    const newWidth = cw, newHeight = ch + 1;
     const out = Buffer.alloc(newWidth * newHeight * 4, 0);
     for (let i = 0; i < out.length; i += 4)
         out[i + 3] = 255;
     for (let y = 0; y < ch; y++) {
         for (let x = 0; x < cw; x++) {
-            const srcI = ((y * cw + x) * 4) | 0;
-            const dstI = ((y * newWidth + x) * 4) | 0;
+            const srcI = (y * cw + x) * 4;
+            const dstI = (y * newWidth + x) * 4;
             out[dstI] = cdata[srcI];
             out[dstI + 1] = cdata[srcI + 1];
             out[dstI + 2] = cdata[srcI + 2];
             out[dstI + 3] = cdata[srcI + 3];
         }
     }
-    const targetY = ch - 1;
-    for (let x = 0; x < cw; x++) {
-        const i = ((targetY * newWidth + x) * 4) | 0;
-        out[i] = 0;
-        out[i + 1] = 0;
-        out[i + 2] = 0;
-        out[i + 3] = 255;
-    }
-    const lastY = ch;
     for (let x = 0; x < newWidth; x++) {
-        const i = ((lastY * newWidth + x) * 4) | 0;
-        out[i] = 0;
-        out[i + 1] = 0;
-        out[i + 2] = 0;
+        const i = ((ch - 1) * newWidth + x) * 4;
+        out[i] = out[i + 1] = out[i + 2] = 0;
         out[i + 3] = 255;
+        const j = (ch * newWidth + x) * 4;
+        out[j] = out[j + 1] = out[j + 2] = 0;
+        out[j + 3] = 255;
     }
     if (newWidth >= 3) {
         const bgrStart = newWidth - 3;
-        let i = ((lastY * newWidth + bgrStart) * 4) | 0;
-        out[i] = 0;
-        out[i + 1] = 0;
-        out[i + 2] = 255;
-        out[i + 3] = 255;
-        i = ((lastY * newWidth + bgrStart + 1) * 4) | 0;
-        out[i] = 0;
-        out[i + 1] = 255;
-        out[i + 2] = 0;
-        out[i + 3] = 255;
-        i = ((lastY * newWidth + bgrStart + 2) * 4) | 0;
-        out[i] = 255;
-        out[i + 1] = 0;
-        out[i + 2] = 0;
-        out[i + 3] = 255;
+        const bgr = [
+            [0, 0, 255],
+            [0, 255, 0],
+            [255, 0, 0],
+        ];
+        for (let k = 0; k < 3; k++) {
+            const i = (ch * newWidth + bgrStart + k) * 4;
+            out[i] = bgr[k][0];
+            out[i + 1] = bgr[k][1];
+            out[i + 2] = bgr[k][2];
+            out[i + 3] = 255;
+        }
     }
-    function getPixel(x, y) {
-        const i = ((y * newWidth + x) * 4) | 0;
+    const getPixel = (x, y) => {
+        const i = (y * newWidth + x) * 4;
         return [out[i], out[i + 1], out[i + 2], out[i + 3]];
-    }
+    };
     const compressedLines = [];
     for (let y = 0; y < newHeight; y++) {
         const line = [];
-        let x = 0;
-        while (x < newWidth) {
-            const current = getPixel(x, y);
-            if (current[0] === 0 && current[1] === 0 && current[2] === 0) {
-                x++;
-                continue;
-            }
-            line.push(current);
-            let nx = x + 1;
-            while (nx < newWidth && eq(getPixel(nx, y), current))
-                nx++;
-            x = nx;
-        }
-        if (line.length === 0)
-            continue;
-        if (compressedLines.length === 0 ||
-            !lineEq(compressedLines[compressedLines.length - 1], line))
+        for (let x = 0; x < newWidth; x++)
+            line.push(getPixel(x, y));
+        const isAllBlack = line.every((p) => p[0] === 0 && p[1] === 0 && p[2] === 0 && p[3] === 255);
+        if (!isAllBlack &&
+            (compressedLines.length === 0 ||
+                !line.every((p, i) => p.every((v, j) => v === compressedLines[compressedLines.length - 1][i][j])))) {
             compressedLines.push(line);
+        }
     }
     if (compressedLines.length === 0) {
         return sharp({
@@ -343,49 +274,116 @@ export async function cropAndReconstitute(input, debugDir) {
             .png()
             .toBuffer();
     }
-    const finalWidth = Math.max(...compressedLines.map((l) => l.length));
-    const finalHeight = compressedLines.length;
-    const finalOut = Buffer.alloc(finalWidth * finalHeight * 4, 0);
+    let finalWidth = newWidth, finalHeight = compressedLines.length;
+    let finalOut = Buffer.alloc(finalWidth * finalHeight * 4, 0);
     for (let i = 0; i < finalOut.length; i += 4)
         finalOut[i + 3] = 255;
-    for (let y = 0; y < compressedLines.length; y++) {
-        const line = compressedLines[y];
-        const isLastLine = y === compressedLines.length - 1;
-        const startX = isLastLine ? finalWidth - line.length : 0;
-        for (let x = 0; x < line.length; x++) {
-            const i = ((y * finalWidth + startX + x) * 4) | 0;
-            finalOut[i] = line[x][0];
-            finalOut[i + 1] = line[x][1];
-            finalOut[i + 2] = line[x][2];
-            finalOut[i + 3] = line[x][3] === 0 ? 255 : line[x][3];
+    for (let y = 0; y < finalHeight; y++) {
+        for (let x = 0; x < finalWidth; x++) {
+            const i = (y * finalWidth + x) * 4;
+            finalOut[i] = compressedLines[y][x][0];
+            finalOut[i + 1] = compressedLines[y][x][1];
+            finalOut[i + 2] = compressedLines[y][x][2];
+            finalOut[i + 3] = compressedLines[y][x][3] || 255;
         }
     }
-    if (finalHeight >= 2) {
-        const secondLastY = finalHeight - 2;
+    if (finalHeight >= 1 && finalWidth >= 3) {
+        const lastY = finalHeight - 1;
+        for (let k = 0; k < 3; k++) {
+            const i = (lastY * finalWidth + finalWidth - 3 + k) * 4;
+            finalOut[i] = finalOut[i + 1] = finalOut[i + 2] = 0;
+            finalOut[i + 3] = 255;
+        }
+    }
+    if (finalWidth >= 2) {
+        const kept = [];
         for (let x = 0; x < finalWidth; x++) {
-            const i = ((secondLastY * finalWidth + x) * 4) | 0;
-            const r = finalOut[i];
-            const g = finalOut[i + 1];
-            const b = finalOut[i + 2];
-            if ((r === 255 && g === 0 && b === 0) ||
-                (r === 0 && g === 255 && b === 0) ||
-                (r === 0 && g === 0 && b === 255)) {
-                finalOut[i] = 0;
-                finalOut[i + 1] = 0;
-                finalOut[i + 2] = 0;
+            if (kept.length === 0) {
+                kept.push(x);
+                continue;
+            }
+            const prevX = kept[kept.length - 1];
+            let same = true;
+            for (let y = 0; y < finalHeight; y++) {
+                const ia = (y * finalWidth + prevX) * 4, ib = (y * finalWidth + x) * 4;
+                if (finalOut[ia] !== finalOut[ib] ||
+                    finalOut[ia + 1] !== finalOut[ib + 1] ||
+                    finalOut[ia + 2] !== finalOut[ib + 2] ||
+                    finalOut[ia + 3] !== finalOut[ib + 3]) {
+                    same = false;
+                    break;
+                }
+            }
+            if (!same)
+                kept.push(x);
+        }
+        if (kept.length !== finalWidth) {
+            const newFinalWidth = kept.length;
+            const newOut = Buffer.alloc(newFinalWidth * finalHeight * 4, 0);
+            for (let i = 0; i < newOut.length; i += 4)
+                newOut[i + 3] = 255;
+            for (let nx = 0; nx < kept.length; nx++) {
+                const sx = kept[nx];
+                for (let y = 0; y < finalHeight; y++) {
+                    const srcI = (y * finalWidth + sx) * 4, dstI = (y * newFinalWidth + nx) * 4;
+                    newOut[dstI] = finalOut[srcI];
+                    newOut[dstI + 1] = finalOut[srcI + 1];
+                    newOut[dstI + 2] = finalOut[srcI + 2];
+                    newOut[dstI + 3] = finalOut[srcI + 3];
+                }
+            }
+            finalOut = newOut;
+            finalWidth = newFinalWidth;
+        }
+    }
+    if (finalHeight >= 2 && finalWidth >= 3) {
+        const secondLastY = finalHeight - 2;
+        const bgrSeq = [
+            [0, 0, 255],
+            [0, 255, 0],
+            [255, 0, 0],
+        ];
+        let hasBGR = true;
+        for (let k = 0; k < 3; k++) {
+            const i = (secondLastY * finalWidth + finalWidth - 3 + k) * 4;
+            if (finalOut[i] !== bgrSeq[k][0] ||
+                finalOut[i + 1] !== bgrSeq[k][1] ||
+                finalOut[i + 2] !== bgrSeq[k][2]) {
+                hasBGR = false;
+                break;
+            }
+        }
+        if (hasBGR) {
+            for (let k = 0; k < 3; k++) {
+                const i = (secondLastY * finalWidth + finalWidth - 3 + k) * 4;
+                finalOut[i] = finalOut[i + 1] = finalOut[i + 2] = 0;
                 finalOut[i + 3] = 255;
             }
         }
     }
-    const resultBuffer = await sharp(finalOut, {
+    if (finalHeight >= 1 && finalWidth >= 1) {
+        const lastYFinal = finalHeight - 1;
+        const bgrSeq = [
+            [0, 0, 255],
+            [0, 255, 0],
+            [255, 0, 0],
+        ];
+        for (let k = 0; k < 3; k++) {
+            const sx = finalWidth - 3 + k;
+            if (sx >= 0) {
+                const i = (lastYFinal * finalWidth + sx) * 4;
+                finalOut[i] = bgrSeq[k][0];
+                finalOut[i + 1] = bgrSeq[k][1];
+                finalOut[i + 2] = bgrSeq[k][2];
+                finalOut[i + 3] = 255;
+            }
+        }
+    }
+    return sharp(finalOut, {
         raw: { width: finalWidth, height: finalHeight, channels: 4 },
     })
         .png()
         .toBuffer();
-    if (debugDir) {
-        await sharp(resultBuffer).toFile(join(debugDir, 'reconstructed.png'));
-    }
-    return resultBuffer;
 }
 /**
  * Encode a Buffer into a PNG wrapper. Supports optional compression and
@@ -652,8 +650,24 @@ export async function encodeBinaryToPng(input, opts = {}) {
  * @public
  */
 export async function decodePngToBinary(pngBuf, opts = {}) {
-    if (pngBuf.slice(0, MAGIC.length).equals(MAGIC)) {
-        const d = pngBuf.slice(MAGIC.length);
+    let processedBuf = pngBuf;
+    try {
+        const info = await sharp(pngBuf).metadata();
+        if (info.width && info.height) {
+            const doubledBuffer = await sharp(pngBuf)
+                .resize({
+                width: info.width * 2,
+                height: info.height * 2,
+                kernel: 'nearest',
+            })
+                .png()
+                .toBuffer();
+            processedBuf = await cropAndReconstitute(doubledBuffer, opts.debugDir);
+        }
+    }
+    catch (e) { }
+    if (processedBuf.slice(0, MAGIC.length).equals(MAGIC)) {
+        const d = processedBuf.slice(MAGIC.length);
         const nameLen = d[0];
         let idx = 1;
         let name;
@@ -680,7 +694,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
     }
     let chunks = [];
     try {
-        const chunksRaw = extract(pngBuf);
+        const chunksRaw = extract(processedBuf);
         chunks = chunksRaw.map((c) => ({
             name: c.name,
             data: Buffer.isBuffer(c.data)
@@ -733,7 +747,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
         return { buf: payload, meta: { name } };
     }
     try {
-        const { data, info } = await sharp(pngBuf)
+        const { data, info } = await sharp(processedBuf)
             .ensureAlpha()
             .raw()
             .toBuffer({ resolveWithObject: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Encode binary data into PNG images with Zstd compression and decode them back. Supports CLI and programmatic API (Node.js ESM).",
   "type": "module",
   "main": "dist/index.js",