roxify 1.2.3 → 1.2.5

package/dist/minpng.js

@@ -19,26 +19,30 @@ function paeth(a, b, c) {
         return b;
     return c;
 }
-function zigzagOrder(width, height) {
-    const coords = [];
+function zigzagOrderIndices(width, height) {
+    const len = width * height;
+    const indices = new Int32Array(len);
+    let i = 0;
     for (let y = 0; y < height; y++) {
         if (y % 2 === 0) {
-            for (let x = 0; x < width; x++)
-                coords.push([x, y]);
+            for (let x = 0; x < width; x++) {
+                indices[i++] = y * width + x;
+            }
         }
         else {
-            for (let x = width - 1; x >= 0; x--)
-                coords.push([x, y]);
+            for (let x = width - 1; x >= 0; x--) {
+                indices[i++] = y * width + x;
+            }
         }
     }
-    return coords;
+    return indices;
 }
 export async function encodeMinPng(rgb, width, height) {
     const w = width, h = height;
     const idx = (x, y) => (y * w + x) * 3;
-    const residualR = Buffer.alloc(w * h);
-    const residualG = Buffer.alloc(w * h);
-    const residualB = Buffer.alloc(w * h);
+    const residualR = new Uint8Array(w * h);
+    const residualG = new Uint8Array(w * h);
+    const residualB = new Uint8Array(w * h);
     for (let y = 0; y < h; y++) {
         for (let x = 0; x < w; x++) {
             const i = idx(x, y);
@@ -65,17 +69,20 @@ export async function encodeMinPng(rgb, width, height) {
             residualB[y * w + x] = (b - predB + 256) & 0xff;
         }
     }
-    const coords = zigzagOrder(w, h);
-    const transformed = [];
-    for (const [x, y] of coords) {
-        const pos = y * w + x;
+    const indices = zigzagOrderIndices(w, h);
+    const transformed = new Uint8Array(w * h * 3);
+    let tIdx = 0;
+    for (let i = 0; i < indices.length; i++) {
+        const pos = indices[i];
         const g = residualG[pos];
         const r = (residualR[pos] - g + 256) & 0xff;
         const b = (residualB[pos] - g + 256) & 0xff;
-        transformed.push(g, r, b);
+        transformed[tIdx++] = g;
+        transformed[tIdx++] = r;
+        transformed[tIdx++] = b;
     }
     const transformedBuf = Buffer.from(transformed);
-    const compressed = Buffer.from(await zstdCompress(transformedBuf, 11));
+    const compressed = Buffer.from(await zstdCompress(transformedBuf, 19));
     const header = Buffer.alloc(4 + 1 + 4 + 4);
     PIXEL_MAGIC.copy(header, 0);
     header[4] = 1;
@@ -174,7 +181,7 @@ export async function decodeMinPng(pngBuf) {
     const headerStart = startIdxBytes;
     if (headerStart + 13 > rawRGB.length)
         return null;
-    if (!rawRGB.slice(headerStart, headerStart + 4).equals(PIXEL_MAGIC))
+    if (!rawRGB.subarray(headerStart, headerStart + 4).equals(PIXEL_MAGIC))
         return null;
     const origW = rawRGB.readUInt32BE(headerStart + 5);
     const origH = rawRGB.readUInt32BE(headerStart + 9);
@@ -182,20 +189,20 @@ export async function decodeMinPng(pngBuf) {
     const compStart = headerStart + 17;
     if (compStart + compressedLen > rawRGB.length)
         return null;
-    const compressed = rawRGB.slice(compStart, compStart + compressedLen);
+    const compressed = rawRGB.subarray(compStart, compStart + compressedLen);
     const decompressed = Buffer.from(await zstdDecompress(compressed));
-    const coords = zigzagOrder(origW, origH);
-    const residualR = Buffer.alloc(origW * origH);
-    const residualG = Buffer.alloc(origW * origH);
-    const residualB = Buffer.alloc(origW * origH);
+    const indices = zigzagOrderIndices(origW, origH);
+    const residualR = new Uint8Array(origW * origH);
+    const residualG = new Uint8Array(origW * origH);
+    const residualB = new Uint8Array(origW * origH);
     let p = 0;
-    for (const [x, y] of coords) {
+    for (let i = 0; i < indices.length; i++) {
         if (p + 3 > decompressed.length)
             break;
         const g = decompressed[p++];
         const rminusg = decompressed[p++];
         const bminusg = decompressed[p++];
-        const pos = y * origW + x;
+        const pos = indices[i];
         residualG[pos] = g;
         residualR[pos] = (rminusg + g) & 0xff;
         residualB[pos] = (bminusg + g) & 0xff;

package/dist/pack.d.ts

@@ -4,6 +4,12 @@ export interface PackedFile {
     path: string;
     buf: Buffer;
 }
+export interface VFSIndexEntry {
+    path: string;
+    blockId: number;
+    offset: number;
+    size: number;
+}
 export declare function packPaths(paths: string[], baseDir?: string, onProgress?: (readBytes: number, totalBytes: number, currentFile?: string) => void): {
     buf: Buffer;
     list: string[];
@@ -14,13 +20,8 @@ export declare function unpackBuffer(buf: Buffer, fileList?: string[]): {
         buf: Buffer;
     }[];
 } | null;
-/**
- * Stream-unpack a packed buffer file on disk into a directory without
- * loading the whole archive into memory.
- */
-export declare function unpackFileToDir(filePath: string, baseDir: string, fileList?: string[]): {
-    files: {
-        path: string;
-        size: number;
-    }[];
-};
+export declare function packPathsGenerator(paths: string[], baseDir?: string, onProgress?: (readBytes: number, totalBytes: number, currentFile?: string) => void): Promise<{
+    index: VFSIndexEntry[];
+    stream: AsyncGenerator<Buffer>;
+    totalSize: number;
+}>;

package/dist/pack.js

@@ -1,23 +1,24 @@
-import { closeSync, createWriteStream, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync, } from 'fs';
-import { dirname, join, relative, resolve, sep } from 'path';
-function collectFiles(paths) {
-    const files = [];
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { extname, join, relative, resolve, sep } from 'path';
+function* collectFilesGenerator(paths) {
     for (const p of paths) {
         const abs = resolve(p);
         const st = statSync(abs);
         if (st.isFile()) {
-            files.push(abs);
+            yield abs;
         }
         else if (st.isDirectory()) {
             const names = readdirSync(abs);
             const childPaths = names.map((n) => join(abs, n));
-            files.push(...collectFiles(childPaths));
+            yield* collectFilesGenerator(childPaths);
         }
     }
-    return files;
 }
 export function packPaths(paths, baseDir, onProgress) {
-    const files = collectFiles(paths);
+    const files = [];
+    for (const f of collectFilesGenerator(paths)) {
+        files.push(f);
+    }
     const base = baseDir ? resolve(baseDir) : process.cwd();
     const parts = [];
     const list = [];
@@ -52,9 +53,35 @@ export function packPaths(paths, baseDir, onProgress) {
 export function unpackBuffer(buf, fileList) {
     if (buf.length < 8)
         return null;
-    const header = buf.slice(0, 8);
-    if (header.readUInt32BE(0) !== 0x524f5850)
+    const magic = buf.readUInt32BE(0);
+    if (magic === 0x524f5849) {
+        const indexLen = buf.readUInt32BE(4);
+        const indexBuf = buf.slice(8, 8 + indexLen);
+        const index = JSON.parse(indexBuf.toString('utf8'));
+        const dataStart = 8 + indexLen;
+        const files = [];
+        const entriesToProcess = fileList
+            ? index.filter((e) => fileList.includes(e.path))
+            : index;
+        for (const entry of entriesToProcess) {
+            const entryStart = dataStart + entry.offset;
+            let ptr = entryStart;
+            if (ptr + 2 > buf.length)
+                continue;
+            const nameLen = buf.readUInt16BE(ptr);
+            ptr += 2;
+            ptr += nameLen;
+            ptr += 8;
+            if (ptr + entry.size > buf.length)
+                continue;
+            const content = buf.slice(ptr, ptr + entry.size);
+            files.push({ path: entry.path, buf: content });
+        }
+        return { files };
+    }
+    if (magic !== 0x524f5850)
         return null;
+    const header = buf.slice(0, 8);
     const fileCount = header.readUInt32BE(4);
     let offset = 8;
     const files = [];
@@ -83,60 +110,75 @@ export function unpackBuffer(buf, fileList) {
     }
     return { files };
 }
-/**
- * Stream-unpack a packed buffer file on disk into a directory without
- * loading the whole archive into memory.
- */
-export function unpackFileToDir(filePath, baseDir, fileList) {
-    const fd = openSync(filePath, 'r');
-    try {
-        const headerBuf = Buffer.alloc(8);
-        let bytes = readSync(fd, headerBuf, 0, 8, 0);
-        if (bytes < 8)
-            throw new Error('Invalid archive');
-        if (headerBuf.readUInt32BE(0) !== 0x524f5850)
-            throw new Error('Not a pack archive');
-        const fileCount = headerBuf.readUInt32BE(4);
-        let offset = 8;
-        const files = [];
-        for (let i = 0; i < fileCount; i++) {
-            const nameLenBuf = Buffer.alloc(2);
-            readSync(fd, nameLenBuf, 0, 2, offset);
-            const nameLen = nameLenBuf.readUInt16BE(0);
-            offset += 2;
-            const nameBuf = Buffer.alloc(nameLen);
-            readSync(fd, nameBuf, 0, nameLen, offset);
-            const name = nameBuf.toString('utf8');
-            offset += nameLen;
+export async function packPathsGenerator(paths, baseDir, onProgress) {
+    const files = [];
+    for (const f of collectFilesGenerator(paths)) {
+        files.push(f);
+    }
+    files.sort((a, b) => {
+        const extA = extname(a);
+        const extB = extname(b);
+        if (extA !== extB)
+            return extA.localeCompare(extB);
+        return a.localeCompare(b);
+    });
+    const base = baseDir ? resolve(baseDir) : process.cwd();
+    const BLOCK_SIZE = 8 * 1024 * 1024;
+    const index = [];
+    let currentBlockId = 0;
+    let currentBlockSize = 0;
+    let globalDataOffset = 0;
+    let totalSize = 0;
+    for (const f of files) {
+        const st = statSync(f);
+        const rel = relative(base, f).split(sep).join('/');
+        const nameBuf = Buffer.from(rel, 'utf8');
+        const entrySize = 2 + nameBuf.length + 8 + st.size;
+        if (currentBlockSize + entrySize > BLOCK_SIZE && currentBlockSize > 0) {
+            currentBlockId++;
+            currentBlockSize = 0;
+        }
+        index.push({
+            path: rel,
+            blockId: currentBlockId,
+            offset: globalDataOffset,
+            size: st.size,
+        });
+        currentBlockSize += entrySize;
+        globalDataOffset += entrySize;
+        totalSize += st.size;
+    }
+    async function* streamGenerator() {
+        const indexBuf = Buffer.from(JSON.stringify(index), 'utf8');
+        const indexHeader = Buffer.alloc(8);
+        indexHeader.writeUInt32BE(0x524f5849, 0);
+        indexHeader.writeUInt32BE(indexBuf.length, 4);
+        yield Buffer.concat([indexHeader, indexBuf]);
+        let currentBuffer = Buffer.alloc(0);
+        let readSoFar = 0;
+        for (let i = 0; i < files.length; i++) {
+            const f = files[i];
+            const rel = relative(base, f).split(sep).join('/');
+            const content = readFileSync(f);
+            const nameBuf = Buffer.from(rel, 'utf8');
+            const nameLen = Buffer.alloc(2);
+            nameLen.writeUInt16BE(nameBuf.length, 0);
             const sizeBuf = Buffer.alloc(8);
-            readSync(fd, sizeBuf, 0, 8, offset);
-            const size = Number(sizeBuf.readBigUInt64BE(0));
-            offset += 8;
-            if (fileList && !fileList.includes(name)) {
-                offset += size;
-                continue;
-            }
-            const outPath = join(baseDir, name);
-            const outDir = dirname(outPath);
-            mkdirSync(outDir, { recursive: true });
-            const ws = createWriteStream(outPath);
-            let remaining = size;
-            const chunk = Buffer.alloc(64 * 1024);
-            while (remaining > 0) {
-                const toRead = Math.min(remaining, chunk.length);
-                const bytesRead = readSync(fd, chunk, 0, toRead, offset);
-                if (bytesRead <= 0)
-                    break;
-                ws.write(chunk.slice(0, bytesRead));
-                offset += bytesRead;
-                remaining -= bytesRead;
+            sizeBuf.writeBigUInt64BE(BigInt(content.length), 0);
+            const entry = Buffer.concat([nameLen, nameBuf, sizeBuf, content]);
+            if (currentBuffer.length + entry.length > BLOCK_SIZE &&
+                currentBuffer.length > 0) {
+                yield currentBuffer;
+                currentBuffer = Buffer.alloc(0);
             }
-            ws.end();
-            files.push({ path: name, size });
+            currentBuffer = Buffer.concat([currentBuffer, entry]);
+            readSoFar += content.length;
+            if (onProgress)
+                onProgress(readSoFar, totalSize, rel);
+        }
+        if (currentBuffer.length > 0) {
+            yield currentBuffer;
         }
-        return { files };
-    }
-    finally {
-        closeSync(fd);
     }
+    return { index, stream: streamGenerator(), totalSize };
 }

package/dist/utils/constants.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare const CHUNK_TYPE = "rXDT";
+export declare const MAGIC: Buffer;
+export declare const PIXEL_MAGIC: Buffer;
+export declare const ENC_NONE = 0;
+export declare const ENC_AES = 1;
+export declare const ENC_XOR = 2;
+export declare const FILTER_ZERO: Buffer;
+export declare const PNG_HEADER: Buffer;
+export declare const PNG_HEADER_HEX: string;
+export declare const MARKER_COLORS: {
+    r: number;
+    g: number;
+    b: number;
+}[];
+export declare const MARKER_START: {
+    r: number;
+    g: number;
+    b: number;
+}[];
+export declare const MARKER_END: {
+    r: number;
+    g: number;
+    b: number;
+}[];
+export declare const COMPRESSION_MARKERS: {
+    zstd: {
+        r: number;
+        g: number;
+        b: number;
+    }[];
+    lzma: {
+        r: number;
+        g: number;
+        b: number;
+    }[];
+};

package/dist/utils/constants.js

@@ -0,0 +1,22 @@
+export const CHUNK_TYPE = 'rXDT';
+export const MAGIC = Buffer.from('ROX1');
+export const PIXEL_MAGIC = Buffer.from('PXL1');
+export const ENC_NONE = 0;
+export const ENC_AES = 1;
+export const ENC_XOR = 2;
+export const FILTER_ZERO = Buffer.from([0]);
+export const PNG_HEADER = Buffer.from([
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+]);
+export const PNG_HEADER_HEX = PNG_HEADER.toString('hex');
+export const MARKER_COLORS = [
+    { r: 255, g: 0, b: 0 },
+    { r: 0, g: 255, b: 0 },
+    { r: 0, g: 0, b: 255 },
+];
+export const MARKER_START = MARKER_COLORS;
+export const MARKER_END = [...MARKER_COLORS].reverse();
+export const COMPRESSION_MARKERS = {
+    zstd: [{ r: 0, g: 255, b: 0 }],
+    lzma: [{ r: 255, g: 255, b: 0 }],
+};

package/dist/utils/crc.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export declare function crc32(buf: Buffer, previous?: number): number;
+export declare function adler32(buf: Buffer, prev?: number): number;

package/dist/utils/crc.js

@@ -0,0 +1,29 @@
+const CRC_TABLE = [];
+for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+        if (c & 1) {
+            c = 0xedb88320 ^ (c >>> 1);
+        }
+        else {
+            c = c >>> 1;
+        }
+    }
+    CRC_TABLE[n] = c;
+}
+export function crc32(buf, previous = 0) {
+    let crc = previous ^ 0xffffffff;
+    for (let i = 0; i < buf.length; i++) {
+        crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+    }
+    return crc ^ 0xffffffff;
+}
+export function adler32(buf, prev = 1) {
+    let s1 = prev & 0xffff;
+    let s2 = (prev >>> 16) & 0xffff;
+    for (let i = 0; i < buf.length; i++) {
+        s1 = (s1 + buf[i]) % 65521;
+        s2 = (s2 + s1) % 65521;
+    }
+    return ((s2 << 16) | s1) >>> 0;
+}

package/dist/utils/decoder.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { DecodeOptions, DecodeResult } from './types.js';
+export declare function decodePngToBinary(input: Buffer | string, opts?: DecodeOptions): Promise<DecodeResult>;