roxify 1.2.4 → 1.2.6

package/dist/utils/encoder.js

@@ -0,0 +1,348 @@
+import cliProgress from 'cli-progress';
+import { createCipheriv, pbkdf2Sync, randomBytes } from 'crypto';
+import encode from 'png-chunks-encode';
+import sharp from 'sharp';
+import * as zlib from 'zlib';
+import { unpackBuffer } from '../pack.js';
+import { COMPRESSION_MARKERS, ENC_AES, ENC_NONE, ENC_XOR, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PNG_HEADER, PNG_HEADER_HEX, } from './constants.js';
+import { applyXor, colorsToBytes } from './helpers.js';
+import { optimizePngBuffer } from './optimization.js';
+import { parallelZstdCompress } from './zstd.js';
+export async function encodeBinaryToPng(input, opts = {}) {
+    let progressBar = null;
+    if (opts.showProgress) {
+        progressBar = new cliProgress.SingleBar({
+            format: ' {bar} {percentage}% | {step} | {elapsed}s',
+        }, cliProgress.Presets.shades_classic);
+        progressBar.start(100, 0, { step: 'Starting', elapsed: '0' });
+        const startTime = Date.now();
+        if (!opts.onProgress) {
+            opts.onProgress = (info) => {
+                let pct = 0;
+                if (info.phase === 'compress_progress' && info.loaded && info.total) {
+                    pct = (info.loaded / info.total) * 50;
+                }
+                else if (info.phase === 'compress_done') {
+                    pct = 50;
+                }
+                else if (info.phase === 'encrypt_done') {
+                    pct = 80;
+                }
+                else if (info.phase === 'png_gen') {
+                    pct = 90;
+                }
+                else if (info.phase === 'done') {
+                    pct = 100;
+                }
+                progressBar.update(Math.floor(pct), {
+                    step: info.phase.replace('_', ' '),
+                    elapsed: String(Math.floor((Date.now() - startTime) / 1000)),
+                });
+            };
+        }
+    }
+    let payload = Buffer.concat([MAGIC, input]);
+    if (opts.onProgress)
+        opts.onProgress({ phase: 'compress_start', total: payload.length });
+    const deltaEncoded = payload;
+    payload = await parallelZstdCompress(deltaEncoded, 19, (loaded, total) => {
+        if (opts.onProgress) {
+            opts.onProgress({
+                phase: 'compress_progress',
+                loaded,
+                total,
+            });
+        }
+    });
+    if (opts.onProgress)
+        opts.onProgress({ phase: 'compress_done', loaded: payload.length });
+    if (opts.passphrase && !opts.encrypt) {
+        opts.encrypt = 'aes';
+    }
+    if (opts.encrypt === 'auto' && !opts._skipAuto) {
+        const candidates = ['none', 'xor', 'aes'];
+        const candidateBufs = [];
+        for (const c of candidates) {
+            const testBuf = await encodeBinaryToPng(input, {
+                ...opts,
+                encrypt: c,
+                _skipAuto: true,
+            });
+            candidateBufs.push({ enc: c, buf: testBuf });
+        }
+        candidateBufs.sort((a, b) => a.buf.length - b.buf.length);
+        return candidateBufs[0].buf;
+    }
+    if (opts.passphrase && opts.encrypt && opts.encrypt !== 'auto') {
+        const encChoice = opts.encrypt;
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'encrypt_start' });
+        if (encChoice === 'aes') {
+            const salt = randomBytes(16);
+            const iv = randomBytes(12);
+            const PBKDF2_ITERS = 1000000;
+            const key = pbkdf2Sync(opts.passphrase, salt, PBKDF2_ITERS, 32, 'sha256');
+            const cipher = createCipheriv('aes-256-gcm', key, iv);
+            const enc = Buffer.concat([cipher.update(payload), cipher.final()]);
+            const tag = cipher.getAuthTag();
+            payload = Buffer.concat([Buffer.from([ENC_AES]), salt, iv, tag, enc]);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'encrypt_done' });
+        }
+        else if (encChoice === 'xor') {
+            const xored = applyXor(payload, opts.passphrase);
+            payload = Buffer.concat([Buffer.from([ENC_XOR]), xored]);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'encrypt_done' });
+        }
+        else if (encChoice === 'none') {
+            payload = Buffer.concat([Buffer.from([ENC_NONE]), payload]);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'encrypt_done' });
+        }
+    }
+    else {
+        payload = Buffer.concat([Buffer.from([ENC_NONE]), payload]);
+    }
+    if (opts.onProgress)
+        opts.onProgress({ phase: 'meta_prep_done', loaded: payload.length });
+    const metaParts = [];
+    const includeName = opts.includeName === undefined ? true : !!opts.includeName;
+    if (includeName && opts.name) {
+        const nameBuf = Buffer.from(opts.name, 'utf8');
+        metaParts.push(Buffer.from([nameBuf.length]));
+        metaParts.push(nameBuf);
+    }
+    else {
+        metaParts.push(Buffer.from([0]));
+    }
+    metaParts.push(payload);
+    let meta = Buffer.concat(metaParts);
+    if (opts.includeFileList && opts.fileList) {
+        let sizeMap = null;
+        try {
+            const unpack = unpackBuffer(input);
+            if (unpack) {
+                sizeMap = {};
+                for (const ef of unpack.files)
+                    sizeMap[ef.path] = ef.buf.length;
+            }
+        }
+        catch (e) { }
+        const normalized = opts.fileList.map((f) => {
+            if (typeof f === 'string')
+                return { name: f, size: sizeMap && sizeMap[f] ? sizeMap[f] : 0 };
+            if (f && typeof f === 'object') {
+                if (f.name)
+                    return { name: f.name, size: f.size ?? 0 };
+                if (f.path)
+                    return { name: f.path, size: f.size ?? 0 };
+            }
+            return { name: String(f), size: 0 };
+        });
+        const jsonBuf = Buffer.from(JSON.stringify(normalized), 'utf8');
+        const lenBuf = Buffer.alloc(4);
+        lenBuf.writeUInt32BE(jsonBuf.length, 0);
+        meta = Buffer.concat([meta, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf]);
+    }
+    if (opts.output === 'rox') {
+        return Buffer.concat([MAGIC, meta]);
+    }
+    {
+        const nameBuf = opts.name
+            ? Buffer.from(opts.name, 'utf8')
+            : Buffer.alloc(0);
+        const nameLen = nameBuf.length;
+        const payloadLenBuf = Buffer.alloc(4);
+        payloadLenBuf.writeUInt32BE(payload.length, 0);
+        const version = 1;
+        let metaPixel = Buffer.concat([
+            Buffer.from([version]),
+            Buffer.from([nameLen]),
+            nameBuf,
+            payloadLenBuf,
+            payload,
+        ]);
+        if (opts.includeFileList && opts.fileList) {
+            let sizeMap2 = null;
+            try {
+                const unpack = unpackBuffer(input);
+                if (unpack) {
+                    sizeMap2 = {};
+                    for (const ef of unpack.files)
+                        sizeMap2[ef.path] = ef.buf.length;
+                }
+            }
+            catch (e) { }
+            const normalized = opts.fileList.map((f) => {
+                if (typeof f === 'string')
+                    return { name: f, size: sizeMap2 && sizeMap2[f] ? sizeMap2[f] : 0 };
+                if (f && typeof f === 'object') {
+                    if (f.name)
+                        return { name: f.name, size: f.size ?? 0 };
+                    if (f.path)
+                        return { name: f.path, size: f.size ?? 0 };
+                }
+                return { name: String(f), size: 0 };
+            });
+            const jsonBuf = Buffer.from(JSON.stringify(normalized), 'utf8');
+            const lenBuf = Buffer.alloc(4);
+            lenBuf.writeUInt32BE(jsonBuf.length, 0);
+            metaPixel = Buffer.concat([
+                metaPixel,
+                Buffer.from('rXFL', 'utf8'),
+                lenBuf,
+                jsonBuf,
+            ]);
+        }
+        const dataWithoutMarkers = Buffer.concat([PIXEL_MAGIC, metaPixel]);
+        const padding = (3 - (dataWithoutMarkers.length % 3)) % 3;
+        const paddedData = padding > 0
+            ? Buffer.concat([dataWithoutMarkers, Buffer.alloc(padding)])
+            : dataWithoutMarkers;
+        const markerStartBytes = colorsToBytes(MARKER_START);
+        const compressionMarkerBytes = colorsToBytes(COMPRESSION_MARKERS.zstd);
+        const dataWithMarkers = Buffer.concat([
+            markerStartBytes,
+            compressionMarkerBytes,
+            paddedData,
+        ]);
+        const bytesPerPixel = 3;
+        const dataPixels = Math.ceil(dataWithMarkers.length / 3);
+        const totalPixels = dataPixels + MARKER_END.length;
+        const maxWidth = 16384;
+        let side = Math.ceil(Math.sqrt(totalPixels));
+        if (side < MARKER_END.length)
+            side = MARKER_END.length;
+        let logicalWidth;
+        let logicalHeight;
+        if (side <= maxWidth) {
+            logicalWidth = side;
+            logicalHeight = side;
+        }
+        else {
+            logicalWidth = Math.min(maxWidth, totalPixels);
+            logicalHeight = Math.ceil(totalPixels / logicalWidth);
+        }
+        const scale = 1;
+        const width = logicalWidth * scale;
+        const height = logicalHeight * scale;
+        const raw = Buffer.alloc(width * height * bytesPerPixel);
+        for (let ly = 0; ly < logicalHeight; ly++) {
+            for (let lx = 0; lx < logicalWidth; lx++) {
+                const linearIdx = ly * logicalWidth + lx;
+                let r = 0, g = 0, b = 0;
+                if (ly === logicalHeight - 1 &&
+                    lx >= logicalWidth - MARKER_END.length) {
+                    const markerIdx = lx - (logicalWidth - MARKER_END.length);
+                    r = MARKER_END[markerIdx].r;
+                    g = MARKER_END[markerIdx].g;
+                    b = MARKER_END[markerIdx].b;
+                }
+                else if (linearIdx < dataPixels) {
+                    const srcIdx = linearIdx * 3;
+                    r = srcIdx < dataWithMarkers.length ? dataWithMarkers[srcIdx] : 0;
+                    g =
+                        srcIdx + 1 < dataWithMarkers.length
+                            ? dataWithMarkers[srcIdx + 1]
+                            : 0;
+                    b =
+                        srcIdx + 2 < dataWithMarkers.length
+                            ? dataWithMarkers[srcIdx + 2]
+                            : 0;
+                }
+                for (let sy = 0; sy < scale; sy++) {
+                    for (let sx = 0; sx < scale; sx++) {
+                        const px = lx * scale + sx;
+                        const py = ly * scale + sy;
+                        const dstIdx = (py * width + px) * 3;
+                        raw[dstIdx] = r;
+                        raw[dstIdx + 1] = g;
+                        raw[dstIdx + 2] = b;
+                    }
+                }
+            }
+        }
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'png_gen', loaded: 0, total: 100 });
+        let loaded = 0;
+        const progressInterval = setInterval(() => {
+            loaded = Math.min(loaded + 2, 98);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'png_gen', loaded, total: 100 });
+        }, 50);
+        let bufScr;
+        const LARGE_IMAGE_PIXELS = 50000000;
+        if (width * height > LARGE_IMAGE_PIXELS || process.env.ROX_FAST_PNG) {
+            const idatData = zlib.deflateSync(raw, {
+                level: 6,
+                memLevel: 8,
+                strategy: zlib.constants.Z_DEFAULT_STRATEGY,
+            });
+            const ihdrData2 = Buffer.alloc(13);
+            ihdrData2.writeUInt32BE(width, 0);
+            ihdrData2.writeUInt32BE(height, 4);
+            ihdrData2[8] = 8;
+            ihdrData2[9] = 2;
+            ihdrData2[10] = 0;
+            ihdrData2[11] = 0;
+            ihdrData2[12] = 0;
+            const chunks2 = [];
+            chunks2.push({ name: 'IHDR', data: ihdrData2 });
+            chunks2.push({ name: 'IDAT', data: idatData });
+            chunks2.push({ name: 'IEND', data: Buffer.alloc(0) });
+            const tmp = Buffer.from(encode(chunks2));
+            bufScr =
+                tmp.slice(0, 8).toString('hex') === PNG_HEADER_HEX
+                    ? tmp
+                    : Buffer.concat([PNG_HEADER, tmp]);
+        }
+        else {
+            bufScr = await sharp(raw, {
+                raw: { width, height, channels: 3 },
+            })
+                .png({
+                compressionLevel: 6,
+                palette: false,
+                effort: 1,
+                adaptiveFiltering: false,
+            })
+                .toBuffer();
+        }
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'png_gen', loaded: 100, total: 100 });
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'optimizing', loaded: 0, total: 100 });
+        let optInterval = null;
+        if (opts.onProgress) {
+            let optLoaded = 0;
+            optInterval = setInterval(() => {
+                optLoaded = Math.min(optLoaded + 5, 95);
+                opts.onProgress?.({
+                    phase: 'optimizing',
+                    loaded: optLoaded,
+                    total: 100,
+                });
+            }, 100);
+        }
+        try {
+            const optimized = await optimizePngBuffer(bufScr, true);
+            clearInterval(progressInterval);
+            if (optInterval) {
+                clearInterval(optInterval);
+                optInterval = null;
+            }
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'optimizing', loaded: 100, total: 100 });
+            progressBar?.stop();
+            return optimized;
+        }
+        catch (e) {
+            clearInterval(progressInterval);
+            if (optInterval)
+                clearInterval(optInterval);
+            progressBar?.stop();
+            return bufScr;
+        }
+    }
+}

package/dist/utils/errors.d.ts

@@ -0,0 +1,9 @@
+export declare class PassphraseRequiredError extends Error {
+    constructor(message?: string);
+}
+export declare class IncorrectPassphraseError extends Error {
+    constructor(message?: string);
+}
+export declare class DataFormatError extends Error {
+    constructor(message?: string);
+}

package/dist/utils/errors.js

@@ -0,0 +1,18 @@
+export class PassphraseRequiredError extends Error {
+    constructor(message = 'Passphrase required') {
+        super(message);
+        this.name = 'PassphraseRequiredError';
+    }
+}
+export class IncorrectPassphraseError extends Error {
+    constructor(message = 'Incorrect passphrase') {
+        super(message);
+        this.name = 'IncorrectPassphraseError';
+    }
+}
+export class DataFormatError extends Error {
+    constructor(message = 'Data format error') {
+        super(message);
+        this.name = 'DataFormatError';
+    }
+}

package/dist/utils/helpers.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare function colorsToBytes(colors: Array<{
+    r: number;
+    g: number;
+    b: number;
+}>): Buffer;
+export declare function deltaEncode(data: Buffer): Buffer;
+export declare function deltaDecode(data: Buffer): Buffer;
+export declare function applyXor(buf: Buffer, passphrase: string): Buffer;
+export declare function tryDecryptIfNeeded(buf: Buffer, passphrase?: string): Buffer;

package/dist/utils/helpers.js

@@ -0,0 +1,76 @@
+import { createDecipheriv, pbkdf2Sync } from 'crypto';
+import { ENC_AES, ENC_NONE, ENC_XOR } from './constants.js';
+import { IncorrectPassphraseError, PassphraseRequiredError } from './errors.js';
+export function colorsToBytes(colors) {
+    const buf = Buffer.alloc(colors.length * 3);
+    for (let i = 0; i < colors.length; i++) {
+        buf[i * 3] = colors[i].r;
+        buf[i * 3 + 1] = colors[i].g;
+        buf[i * 3 + 2] = colors[i].b;
+    }
+    return buf;
+}
+export function deltaEncode(data) {
+    if (data.length === 0)
+        return data;
+    const out = Buffer.alloc(data.length);
+    out[0] = data[0];
+    for (let i = 1; i < data.length; i++) {
+        out[i] = (data[i] - data[i - 1] + 256) & 0xff;
+    }
+    return out;
+}
+export function deltaDecode(data) {
+    if (data.length === 0)
+        return data;
+    const out = Buffer.alloc(data.length);
+    out[0] = data[0];
+    for (let i = 1; i < data.length; i++) {
+        out[i] = (out[i - 1] + data[i]) & 0xff;
+    }
+    return out;
+}
+export function applyXor(buf, passphrase) {
+    const key = Buffer.from(passphrase, 'utf8');
+    const out = Buffer.alloc(buf.length);
+    for (let i = 0; i < buf.length; i++) {
+        out[i] = buf[i] ^ key[i % key.length];
+    }
+    return out;
+}
+export function tryDecryptIfNeeded(buf, passphrase) {
+    if (!buf || buf.length === 0)
+        return buf;
+    const flag = buf[0];
+    if (flag === ENC_AES) {
+        const MIN_AES_LEN = 1 + 16 + 12 + 16 + 1;
+        if (buf.length < MIN_AES_LEN)
+            throw new IncorrectPassphraseError();
+        if (!passphrase)
+            throw new PassphraseRequiredError();
+        const salt = buf.slice(1, 17);
+        const iv = buf.slice(17, 29);
+        const tag = buf.slice(29, 45);
+        const enc = buf.slice(45);
+        const PBKDF2_ITERS = 1000000;
+        const key = pbkdf2Sync(passphrase, salt, PBKDF2_ITERS, 32, 'sha256');
+        const dec = createDecipheriv('aes-256-gcm', key, iv);
+        dec.setAuthTag(tag);
+        try {
+            const decrypted = Buffer.concat([dec.update(enc), dec.final()]);
+            return decrypted;
+        }
+        catch (e) {
+            throw new IncorrectPassphraseError();
+        }
+    }
+    if (flag === ENC_XOR) {
+        if (!passphrase)
+            throw new PassphraseRequiredError();
+        return applyXor(buf.slice(1), passphrase);
+    }
+    if (flag === ENC_NONE) {
+        return buf.slice(1);
+    }
+    return buf;
+}

package/dist/utils/inspection.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * List files in a Rox PNG archive without decoding the full payload.
+ * Returns the file list if available, otherwise null.
+ * @param pngBuf - PNG data
+ * @public
+ */
+export declare function listFilesInPng(pngBuf: Buffer, opts?: {
+    includeSizes?: boolean;
+}): Promise<string[] | {
+    name: string;
+    size: number;
+}[] | null>;
+/**
+ * Detect if a PNG/ROX buffer contains an encrypted payload (requires passphrase)
+ * Returns true if encryption flag indicates AES or XOR.
+ */
+export declare function hasPassphraseInPng(pngBuf: Buffer): Promise<boolean>;