roxify 1.2.7 → 1.2.8

package/dist/utils/zstd.js

@@ -1,131 +1,153 @@
-import { compress as zstdCompress, decompress as zstdDecompress, } from '@mongodb-js/zstd';
-import { cpus } from 'os';
-export async function compressStream(stream, level = 19, onProgress) {
-    const compressedChunks = [];
-    let chunkCount = 0;
-    for await (const chunk of stream) {
-        const compressed = await zstdCompress(chunk, level);
-        compressedChunks.push(Buffer.from(compressed));
-        chunkCount++;
-        if (onProgress)
-            onProgress(chunkCount, 0);
-    }
-    const chunkSizes = Buffer.alloc(compressedChunks.length * 4);
-    let totalLength = 8 + chunkSizes.length;
-    for (let i = 0; i < compressedChunks.length; i++) {
-        chunkSizes.writeUInt32BE(compressedChunks[i].length, i * 4);
-        totalLength += compressedChunks[i].length;
-    }
-    const header = Buffer.alloc(8);
-    header.writeUInt32BE(0x5a535444, 0);
-    header.writeUInt32BE(compressedChunks.length, 4);
-    return {
-        chunks: [header, chunkSizes, ...compressedChunks],
-        totalLength,
-    };
-}
-export async function parallelZstdCompress(payload, level = 19, onProgress) {
-    const chunkSize = 8 * 1024 * 1024;
-    const chunks = [];
-    if (Array.isArray(payload)) {
-        for (const p of payload) {
-            if (p.length <= chunkSize) {
-                chunks.push(p);
-            }
-            else {
-                for (let i = 0; i < p.length; i += chunkSize) {
-                    chunks.push(p.subarray(i, Math.min(i + chunkSize, p.length)));
-                }
-            }
-        }
-    }
-    else {
-        if (payload.length <= chunkSize) {
-            if (onProgress)
-                onProgress(0, 1);
-            const result = await zstdCompress(payload, level);
-            if (onProgress)
-                onProgress(1, 1);
-            return [Buffer.from(result)];
-        }
-        for (let i = 0; i < payload.length; i += chunkSize) {
-            chunks.push(payload.subarray(i, Math.min(i + chunkSize, payload.length)));
-        }
-    }
-    const totalChunks = chunks.length;
-    let completedChunks = 0;
-    const concurrency = Math.max(1, Math.min(4, cpus().length));
-    const compressedChunks = new Array(totalChunks);
-    let idx = 0;
-    const worker = async () => {
-        while (true) {
-            const cur = idx++;
-            if (cur >= totalChunks)
-                return;
-            const chunk = chunks[cur];
-            const compressed = await zstdCompress(chunk, level);
-            compressedChunks[cur] = Buffer.from(compressed);
-            completedChunks++;
-            if (onProgress)
-                onProgress(completedChunks, totalChunks);
-        }
-    };
-    await Promise.all(new Array(concurrency).fill(0).map(() => worker()));
-    const chunkSizes = Buffer.alloc(compressedChunks.length * 4);
-    for (let i = 0; i < compressedChunks.length; i++) {
-        chunkSizes.writeUInt32BE(compressedChunks[i].length, i * 4);
-    }
-    const header = Buffer.alloc(8);
-    header.writeUInt32BE(0x5a535444, 0);
-    header.writeUInt32BE(compressedChunks.length, 4);
-    return [header, chunkSizes, ...compressedChunks];
-}
-export async function parallelZstdDecompress(payload, onProgress) {
-    if (payload.length < 8) {
-        onProgress?.({ phase: 'decompress_start', total: 1 });
-        const d = Buffer.from(await zstdDecompress(payload));
-        onProgress?.({ phase: 'decompress_progress', loaded: 1, total: 1 });
-        onProgress?.({ phase: 'decompress_done', loaded: 1, total: 1 });
-        return d;
-    }
-    const magic = payload.readUInt32BE(0);
-    if (magic !== 0x5a535444) {
-        if (process.env.ROX_DEBUG)
-            console.log('tryZstdDecompress: invalid magic');
-        onProgress?.({ phase: 'decompress_start', total: 1 });
-        const d = Buffer.from(await zstdDecompress(payload));
-        onProgress?.({ phase: 'decompress_progress', loaded: 1, total: 1 });
-        onProgress?.({ phase: 'decompress_done', loaded: 1, total: 1 });
-        return d;
-    }
-    const numChunks = payload.readUInt32BE(4);
-    const chunkSizes = [];
-    let offset = 8;
-    for (let i = 0; i < numChunks; i++) {
-        chunkSizes.push(payload.readUInt32BE(offset));
-        offset += 4;
-    }
-    onProgress?.({ phase: 'decompress_start', total: numChunks });
-    const decompressedChunks = [];
-    for (let i = 0; i < numChunks; i++) {
-        const size = chunkSizes[i];
-        const chunk = payload.slice(offset, offset + size);
-        offset += size;
-        const dec = Buffer.from(await zstdDecompress(chunk));
-        decompressedChunks.push(dec);
-        onProgress?.({
-            phase: 'decompress_progress',
-            loaded: i + 1,
-            total: numChunks,
-        });
-    }
-    onProgress?.({
-        phase: 'decompress_done',
-        loaded: numChunks,
-        total: numChunks,
-    });
-    return Buffer.concat(decompressedChunks);
-}
-export async function tryZstdDecompress(payload, onProgress) {
-    return await parallelZstdDecompress(payload, onProgress);
-}
+import { compress as zstdCompress, decompress as zstdDecompress, } from '@mongodb-js/zstd';
+import { cpus } from 'os';
+let nativeZstdCompress = null;
+let nativeZstdDecompress = null;
+try {
+    const native = require('../../libroxify_native.node');
+    if (native?.nativeZstdCompress) {
+        nativeZstdCompress = native.nativeZstdCompress;
+    }
+    if (native?.nativeZstdDecompress) {
+        nativeZstdDecompress = native.nativeZstdDecompress;
+    }
+}
+catch (e) { }
+export async function compressStream(stream, level = 19, onProgress) {
+    const compressedChunks = [];
+    let chunkCount = 0;
+    for await (const chunk of stream) {
+        const compressed = await zstdCompress(chunk, level);
+        compressedChunks.push(Buffer.from(compressed));
+        chunkCount++;
+        if (onProgress)
+            onProgress(chunkCount, 0);
+    }
+    const chunkSizes = Buffer.alloc(compressedChunks.length * 4);
+    let totalLength = 8 + chunkSizes.length;
+    for (let i = 0; i < compressedChunks.length; i++) {
+        chunkSizes.writeUInt32BE(compressedChunks[i].length, i * 4);
+        totalLength += compressedChunks[i].length;
+    }
+    const header = Buffer.alloc(8);
+    header.writeUInt32BE(0x5a535444, 0);
+    header.writeUInt32BE(compressedChunks.length, 4);
+    return {
+        chunks: [header, chunkSizes, ...compressedChunks],
+        totalLength,
+    };
+}
+export async function parallelZstdCompress(payload, level = 19, onProgress) {
+    const chunkSize = 8 * 1024 * 1024;
+    const chunks = [];
+    if (Array.isArray(payload)) {
+        for (const p of payload) {
+            if (p.length <= chunkSize) {
+                chunks.push(p);
+            }
+            else {
+                for (let i = 0; i < p.length; i += chunkSize) {
+                    chunks.push(p.subarray(i, Math.min(i + chunkSize, p.length)));
+                }
+            }
+        }
+    }
+    else {
+        if (payload.length <= chunkSize) {
+            if (onProgress)
+                onProgress(0, 1);
+            const result = nativeZstdCompress
+                ? Buffer.from(nativeZstdCompress(payload, level))
+                : Buffer.from(await zstdCompress(payload, level));
+            if (onProgress)
+                onProgress(1, 1);
+            return [result];
+        }
+        for (let i = 0; i < payload.length; i += chunkSize) {
+            chunks.push(payload.subarray(i, Math.min(i + chunkSize, payload.length)));
+        }
+    }
+    const totalChunks = chunks.length;
+    let completedChunks = 0;
+    const concurrency = Math.max(1, Math.min(4, cpus().length));
+    const compressedChunks = new Array(totalChunks);
+    let idx = 0;
+    const worker = async () => {
+        while (true) {
+            const cur = idx++;
+            if (cur >= totalChunks)
+                return;
+            const chunk = chunks[cur];
+            const compressed = nativeZstdCompress
+                ? Buffer.from(nativeZstdCompress(chunk, level))
+                : Buffer.from(await zstdCompress(chunk, level));
+            compressedChunks[cur] = compressed;
+            completedChunks++;
+            if (onProgress)
+                onProgress(completedChunks, totalChunks);
+        }
+    };
+    await Promise.all(new Array(concurrency).fill(0).map(() => worker()));
+    const chunkSizes = Buffer.alloc(compressedChunks.length * 4);
+    for (let i = 0; i < compressedChunks.length; i++) {
+        chunkSizes.writeUInt32BE(compressedChunks[i].length, i * 4);
+    }
+    const header = Buffer.alloc(8);
+    header.writeUInt32BE(0x5a535444, 0);
+    header.writeUInt32BE(compressedChunks.length, 4);
+    return [header, chunkSizes, ...compressedChunks];
+}
+export async function parallelZstdDecompress(payload, onProgress) {
+    if (payload.length < 8) {
+        onProgress?.({ phase: 'decompress_start', total: 1 });
+        const d = nativeZstdDecompress
+            ? Buffer.from(nativeZstdDecompress(payload))
+            : Buffer.from(await zstdDecompress(payload));
+        onProgress?.({ phase: 'decompress_progress', loaded: 1, total: 1 });
+        onProgress?.({ phase: 'decompress_done', loaded: 1, total: 1 });
+        return d;
+    }
+    const magic = payload.readUInt32BE(0);
+    if (magic !== 0x5a535444) {
+        if (process.env.ROX_DEBUG)
+            console.log('tryZstdDecompress: invalid magic');
+        onProgress?.({ phase: 'decompress_start', total: 1 });
+        const d = nativeZstdDecompress
+            ? Buffer.from(nativeZstdDecompress(payload))
+            : Buffer.from(await zstdDecompress(payload));
+        onProgress?.({ phase: 'decompress_progress', loaded: 1, total: 1 });
+        onProgress?.({ phase: 'decompress_done', loaded: 1, total: 1 });
+        return d;
+    }
+    const numChunks = payload.readUInt32BE(4);
+    const chunkSizes = [];
+    let offset = 8;
+    for (let i = 0; i < numChunks; i++) {
+        chunkSizes.push(payload.readUInt32BE(offset));
+        offset += 4;
+    }
+    onProgress?.({ phase: 'decompress_start', total: numChunks });
+    const decompressedChunks = [];
+    for (let i = 0; i < numChunks; i++) {
+        const size = chunkSizes[i];
+        const chunk = payload.slice(offset, offset + size);
+        offset += size;
+        const dec = nativeZstdDecompress
+            ? Buffer.from(nativeZstdDecompress(chunk))
+            : Buffer.from(await zstdDecompress(chunk));
+        decompressedChunks.push(dec);
+        onProgress?.({
+            phase: 'decompress_progress',
+            loaded: i + 1,
+            total: numChunks,
+        });
+    }
+    onProgress?.({
+        phase: 'decompress_done',
+        loaded: numChunks,
+        total: numChunks,
+    });
+    return Buffer.concat(decompressedChunks);
+}
+export async function tryZstdDecompress(payload, onProgress) {
+    return await parallelZstdDecompress(payload, onProgress);
+}

package/package.json

@@ -1,65 +1,47 @@
-{
-  "name": "roxify",
-  "version": "1.2.7",
-  "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",
-  "types": "dist/index.d.ts",
-  "bin": {
-    "rox": "dist/cli.js",
-    "roxify": "dist/cli.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "check-publish": "node ../scripts/check-publish.js roxify",
-    "cli": "node dist/cli.js",
-    "test": "npm run build && node test/pack.test.js && node test/screenshot.test.js && node test/list.test.js && node test/minpng.test.js && node test/optimize.test.js"
-  },
-  "keywords": [
-    "steganography",
-    "png",
-    "zstd",
-    "compression",
-    "encryption",
-    "encode",
-    "decode",
-    "cli",
-    "nodejs",
-    "esm",
-    "data-embedding",
-    "file-archive",
-    "lossless",
-    "aes-gcm",
-    "binary-data"
-  ],
-  "author": "RoxCompressor",
-  "license": "UNLICENSED",
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@mongodb-js/zstd": "^2.0.1",
-    "fflate": "^0.7.4",
-    "lzma-purejs": "^0.9.3",
-    "png-chunks-encode": "^1.0.0",
-    "png-chunks-extract": "^1.0.0",
-    "sharp": "^0.34.5",
-    "cli-progress": "^3.9.1"
-  },
-  "optionalDependencies": {
-    "zopflipng-bin": "^1.0.1"
-  },
-  "overrides": {
-    "graceful-fs": "^4.2.10"
-  },
-  "devDependencies": {
-    "typescript": "^4.9.5",
-    "@types/cli-progress": "^3.9.0"
-  }
-}
+{
+  "name": "roxify",
+  "version": "1.2.8",
+  "description": "Encode binary data into PNG images and decode them back. CLI and programmatic API with native Rust acceleration.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "rox": "dist/cli.js",
+    "roxify": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "libroxify_native.node",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:native": "cargo build --release --lib && cp target/release/libroxify_native.so libroxify_native.node",
+    "build:all": "npm run build:native && npm run build",
+    "prepublishOnly": "npm run build:all",
+    "test": "node test/roundtrip.js && node test/pixel-fallback-preview.js && node test/size-fallback-choice.js && node test/screenshot-roundtrip.js && node test/screenshot-fallback.js",
+    "cli": "node dist/cli.js"
+  },
+  "keywords": [
+    "steganography",
+    "png",
+    "brotli",
+    "rox"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@mongodb-js/zstd": "^7.0.0",
+    "cli-progress": "^3.12.0",
+    "png-chunks-encode": "^1.0.0",
+    "png-chunks-extract": "^1.0.0",
+    "sharp": "^0.34.5"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/node": "^25.0.3",
+    "typescript": "^4.9.5"
+  }
+}