roxify 1.1.12 → 1.2.1

package/dist/index.js

@@ -1,7 +1,8 @@
 import { compress as zstdCompress, decompress as zstdDecompress, } from '@mongodb-js/zstd';
+import { spawn, spawnSync } from 'child_process';
 import cliProgress from 'cli-progress';
 import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes, } from 'crypto';
-import { createReadStream, createWriteStream, readFileSync, unlinkSync, } from 'fs';
+import { createReadStream, createWriteStream, existsSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import encode from 'png-chunks-encode';
@@ -55,6 +56,7 @@ async function writeInChunks(ws, buf, chunkSize = CHUNK_SIZE) {
 }
 const COMPRESSION_MARKERS = {
     zstd: [{ r: 0, g: 255, b: 0 }],
+    lzma: [{ r: 255, g: 255, b: 0 }],
 };
 function colorsToBytes(colors) {
     const buf = Buffer.alloc(colors.length * 3);
@@ -88,7 +90,12 @@ function deltaDecode(data) {
 async function parallelZstdCompress(payload, level = 22, onProgress) {
     const chunkSize = 1024 * 1024 * 1024;
     if (payload.length <= chunkSize) {
-        return Buffer.from(await zstdCompress(payload, level));
+        if (onProgress)
+            onProgress(0, 1);
+        const result = await zstdCompress(payload, level);
+        if (onProgress)
+            onProgress(1, 1);
+        return Buffer.from(result);
     }
     const promises = [];
     const totalChunks = Math.ceil(payload.length / chunkSize);
@@ -204,6 +211,665 @@ async function parallelZstdDecompress(payload, onProgress, onChunk, outPath) {
     }
     return Buffer.alloc(0);
 }
+export async function optimizePngBuffer(pngBuf, fast = false) {
+    const runCommandAsync = (cmd, args, timeout = 120000) => {
+        return new Promise((resolve) => {
+            try {
+                const child = spawn(cmd, args, { windowsHide: true, stdio: 'ignore' });
+                let killed = false;
+                const to = setTimeout(() => {
+                    killed = true;
+                    try {
+                        child.kill('SIGTERM');
+                    }
+                    catch (e) { }
+                }, timeout);
+                child.on('close', (code) => {
+                    clearTimeout(to);
+                    if (killed)
+                        resolve({ error: new Error('timeout') });
+                    else
+                        resolve({ code: code ?? 0 });
+                });
+                child.on('error', (err) => {
+                    clearTimeout(to);
+                    resolve({ error: err });
+                });
+            }
+            catch (err) {
+                resolve({ error: err });
+            }
+        });
+    };
+    try {
+        const inPath = join(tmpdir(), `rox_zop_in_${Date.now()}_${Math.random().toString(36).slice(2)}.png`);
+        const outPath = inPath + '.out.png';
+        writeFileSync(inPath, pngBuf);
+        const args = [
+            '-y',
+            '--iterations=500',
+            '--filters=01234mepb',
+            inPath,
+            outPath,
+        ];
+        const runCommandAsync = (cmd, args, timeout = 120000) => {
+            return new Promise((resolve) => {
+                try {
+                    const child = spawn(cmd, args, {
+                        windowsHide: true,
+                        stdio: 'ignore',
+                    });
+                    let killed = false;
+                    const to = setTimeout(() => {
+                        killed = true;
+                        try {
+                            child.kill('SIGTERM');
+                        }
+                        catch (e) { }
+                    }, timeout);
+                    child.on('close', (code) => {
+                        clearTimeout(to);
+                        if (killed)
+                            resolve({ error: new Error('timeout') });
+                        else
+                            resolve({ code: code ?? 0 });
+                    });
+                    child.on('error', (err) => {
+                        clearTimeout(to);
+                        resolve({ error: err });
+                    });
+                }
+                catch (err) {
+                    resolve({ error: err });
+                }
+            });
+        };
+        const res = await runCommandAsync('zopflipng', args, 120000);
+        if (!res.error && existsSync(outPath)) {
+            const outBuf = readFileSync(outPath);
+            try {
+                unlinkSync(inPath);
+                unlinkSync(outPath);
+            }
+            catch (e) { }
+            return outBuf.length < pngBuf.length ? outBuf : pngBuf;
+        }
+        if (fast)
+            return pngBuf;
+    }
+    catch (e) { }
+    try {
+        const chunksRaw = extract(pngBuf);
+        const ihdr = chunksRaw.find((c) => c.name === 'IHDR');
+        if (!ihdr)
+            return pngBuf;
+        const ihdrData = Buffer.isBuffer(ihdr.data)
+            ? ihdr.data
+            : Buffer.from(ihdr.data);
+        const width = ihdrData.readUInt32BE(0);
+        const height = ihdrData.readUInt32BE(4);
+        const bitDepth = ihdrData[8];
+        const colorType = ihdrData[9];
+        if (bitDepth !== 8 || colorType !== 2)
+            return pngBuf;
+        const idatChunks = chunksRaw.filter((c) => c.name === 'IDAT');
+        const idatData = Buffer.concat(idatChunks.map((c) => Buffer.isBuffer(c.data)
+            ? c.data
+            : Buffer.from(c.data)));
+        let raw;
+        try {
+            raw = zlib.inflateSync(idatData);
+        }
+        catch (e) {
+            return pngBuf;
+        }
+        const bytesPerPixel = 3;
+        const rowBytes = width * bytesPerPixel;
+        const inRowLen = rowBytes + 1;
+        if (raw.length !== inRowLen * height)
+            return pngBuf;
+        function paethPredict(a, b, c) {
+            const p = a + b - c;
+            const pa = Math.abs(p - a);
+            const pb = Math.abs(p - b);
+            const pc = Math.abs(p - c);
+            if (pa <= pb && pa <= pc)
+                return a;
+            if (pb <= pc)
+                return b;
+            return c;
+        }
+        const outRows = [];
+        let prevRow = null;
+        for (let y = 0; y < height; y++) {
+            const rowStart = y * inRowLen + 1;
+            const row = raw.slice(rowStart, rowStart + rowBytes);
+            let bestSum = Infinity;
+            let bestFiltered = null;
+            for (let f = 0; f <= 4; f++) {
+                const filtered = Buffer.alloc(rowBytes);
+                let sum = 0;
+                for (let i = 0; i < rowBytes; i++) {
+                    const val = row[i];
+                    let outv = 0;
+                    const left = i - bytesPerPixel >= 0 ? row[i - bytesPerPixel] : 0;
+                    const up = prevRow ? prevRow[i] : 0;
+                    const upLeft = prevRow && i - bytesPerPixel >= 0 ? prevRow[i - bytesPerPixel] : 0;
+                    if (f === 0) {
+                        outv = val;
+                    }
+                    else if (f === 1) {
+                        outv = (val - left + 256) & 0xff;
+                    }
+                    else if (f === 2) {
+                        outv = (val - up + 256) & 0xff;
+                    }
+                    else if (f === 3) {
+                        const avg = Math.floor((left + up) / 2);
+                        outv = (val - avg + 256) & 0xff;
+                    }
+                    else {
+                        const p = paethPredict(left, up, upLeft);
+                        outv = (val - p + 256) & 0xff;
+                    }
+                    filtered[i] = outv;
+                    const signed = outv > 127 ? outv - 256 : outv;
+                    sum += Math.abs(signed);
+                }
+                if (sum < bestSum) {
+                    bestSum = sum;
+                    bestFiltered = filtered;
+                }
+            }
+            const rowBuf = Buffer.alloc(1 + rowBytes);
+            let chosenFilter = 0;
+            for (let f = 0; f <= 4; f++) {
+                const filtered = Buffer.alloc(rowBytes);
+                for (let i = 0; i < rowBytes; i++) {
+                    const val = row[i];
+                    const left = i - bytesPerPixel >= 0 ? row[i - bytesPerPixel] : 0;
+                    const up = prevRow ? prevRow[i] : 0;
+                    const upLeft = prevRow && i - bytesPerPixel >= 0 ? prevRow[i - bytesPerPixel] : 0;
+                    if (f === 0)
+                        filtered[i] = val;
+                    else if (f === 1)
+                        filtered[i] = (val - left + 256) & 0xff;
+                    else if (f === 2)
+                        filtered[i] = (val - up + 256) & 0xff;
+                    else if (f === 3)
+                        filtered[i] = (val - Math.floor((left + up) / 2) + 256) & 0xff;
+                    else
+                        filtered[i] = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
+                }
+                if (filtered.equals(bestFiltered)) {
+                    chosenFilter = f;
+                    break;
+                }
+            }
+            rowBuf[0] = chosenFilter;
+            bestFiltered.copy(rowBuf, 1);
+            outRows.push(rowBuf);
+            prevRow = row;
+        }
+        const filteredAll = Buffer.concat(outRows);
+        const compressed = zlib.deflateSync(filteredAll, {
+            level: 9,
+            memLevel: 9,
+            strategy: zlib.constants.Z_DEFAULT_STRATEGY,
+        });
+        const newChunks = [];
+        for (const c of chunksRaw) {
+            if (c.name === 'IDAT')
+                continue;
+            newChunks.push({
+                name: c.name,
+                data: Buffer.isBuffer(c.data)
+                    ? c.data
+                    : Buffer.from(c.data),
+            });
+        }
+        const iendIndex = newChunks.findIndex((c) => c.name === 'IEND');
+        const insertIndex = iendIndex >= 0 ? iendIndex : newChunks.length;
+        newChunks.splice(insertIndex, 0, { name: 'IDAT', data: compressed });
+        function ensurePng(buf) {
+            return buf.slice(0, 8).toString('hex') === PNG_HEADER_HEX
+                ? buf
+                : Buffer.concat([PNG_HEADER, buf]);
+        }
+        const out = ensurePng(Buffer.from(encode(newChunks)));
+        let bestBuf = out.length < pngBuf.length ? out : pngBuf;
+        const strategies = [
+            zlib.constants.Z_DEFAULT_STRATEGY,
+            zlib.constants.Z_FILTERED,
+            zlib.constants.Z_RLE,
+            ...(zlib.constants.Z_HUFFMAN_ONLY ? [zlib.constants.Z_HUFFMAN_ONLY] : []),
+            ...(zlib.constants.Z_FIXED ? [zlib.constants.Z_FIXED] : []),
+        ];
+        for (const strat of strategies) {
+            try {
+                const comp = zlib.deflateSync(raw, {
+                    level: 9,
+                    memLevel: 9,
+                    strategy: strat,
+                });
+                const altChunks = newChunks.map((c) => ({
+                    name: c.name,
+                    data: c.data,
+                }));
+                const idx = altChunks.findIndex((c) => c.name === 'IDAT');
+                if (idx !== -1)
+                    altChunks[idx] = { name: 'IDAT', data: comp };
+                const candidate = ensurePng(Buffer.from(encode(altChunks)));
+                if (candidate.length < bestBuf.length)
+                    bestBuf = candidate;
+            }
+            catch (e) { }
+        }
+        try {
+            const fflate = await import('fflate');
+            const fflateDeflateSync = fflate.deflateSync;
+            try {
+                const comp = fflateDeflateSync(filteredAll);
+                const altChunks = newChunks.map((c) => ({
+                    name: c.name,
+                    data: c.data,
+                }));
+                const idx = altChunks.findIndex((c) => c.name === 'IDAT');
+                if (idx !== -1)
+                    altChunks[idx] = { name: 'IDAT', data: Buffer.from(comp) };
+                const candidate = ensurePng(Buffer.from(encode(altChunks)));
+                if (candidate.length < bestBuf.length)
+                    bestBuf = candidate;
+            }
+            catch (e) { }
+        }
+        catch (e) { }
+        const windowBitsOpts = [15, 12, 9];
+        const memLevelOpts = [9, 8];
+        for (let f = 0; f <= 4; f++) {
+            try {
+                const filteredAllGlobalRows = [];
+                let prevRowG = null;
+                for (let y = 0; y < height; y++) {
+                    const row = raw.slice(y * inRowLen + 1, y * inRowLen + 1 + rowBytes);
+                    const filtered = Buffer.alloc(rowBytes);
+                    for (let i = 0; i < rowBytes; i++) {
+                        const val = row[i];
+                        const left = i - bytesPerPixel >= 0 ? row[i - bytesPerPixel] : 0;
+                        const up = prevRowG ? prevRowG[i] : 0;
+                        const upLeft = prevRowG && i - bytesPerPixel >= 0
+                            ? prevRowG[i - bytesPerPixel]
+                            : 0;
+                        if (f === 0)
+                            filtered[i] = val;
+                        else if (f === 1)
+                            filtered[i] = (val - left + 256) & 0xff;
+                        else if (f === 2)
+                            filtered[i] = (val - up + 256) & 0xff;
+                        else if (f === 3)
+                            filtered[i] = (val - Math.floor((left + up) / 2) + 256) & 0xff;
+                        else
+                            filtered[i] = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
+                    }
+                    const rowBuf = Buffer.alloc(1 + rowBytes);
+                    rowBuf[0] = f;
+                    filtered.copy(rowBuf, 1);
+                    filteredAllGlobalRows.push(rowBuf);
+                    prevRowG = row;
+                }
+                const filteredAllGlobal = Buffer.concat(filteredAllGlobalRows);
+                for (const strat2 of strategies) {
+                    for (const wb of windowBitsOpts) {
+                        for (const ml of memLevelOpts) {
+                            try {
+                                const comp = zlib.deflateSync(filteredAllGlobal, {
+                                    level: 9,
+                                    memLevel: ml,
+                                    strategy: strat2,
+                                    windowBits: wb,
+                                });
+                                const altChunks = newChunks.map((c) => ({
+                                    name: c.name,
+                                    data: c.data,
+                                }));
+                                const idx = altChunks.findIndex((c) => c.name === 'IDAT');
+                                if (idx !== -1)
+                                    altChunks[idx] = { name: 'IDAT', data: comp };
+                                const candidate = ensurePng(Buffer.from(encode(altChunks)));
+                                if (candidate.length < bestBuf.length)
+                                    bestBuf = candidate;
+                            }
+                            catch (e) { }
+                        }
+                    }
+                }
+            }
+            catch (e) { }
+        }
+        try {
+            const zopIterations = [1000, 2000];
+            zopIterations.push(5000, 10000, 20000);
+            for (const iters of zopIterations) {
+                try {
+                    const zIn = join(tmpdir(), `rox_zop_in_${Date.now()}_${Math.random()
+                        .toString(36)
+                        .slice(2)}.png`);
+                    const zOut = zIn + '.out.png';
+                    writeFileSync(zIn, bestBuf);
+                    const args2 = [
+                        '-y',
+                        `--iterations=${iters}`,
+                        '--filters=01234mepb',
+                        zIn,
+                        zOut,
+                    ];
+                    try {
+                        const r2 = await runCommandAsync('zopflipng', args2, 240000);
+                        if (!r2.error && existsSync(zOut)) {
+                            const zbuf = readFileSync(zOut);
+                            try {
+                                unlinkSync(zIn);
+                                unlinkSync(zOut);
+                            }
+                            catch (e) { }
+                            if (zbuf.length < bestBuf.length)
+                                bestBuf = zbuf;
+                        }
+                    }
+                    catch (e) { }
+                }
+                catch (e) { }
+            }
+        }
+        catch (e) { }
+        try {
+            const advIn = join(tmpdir(), `rox_adv_in_${Date.now()}_${Math.random().toString(36).slice(2)}.png`);
+            writeFileSync(advIn, bestBuf);
+            const rAdv = spawnSync('advdef', ['-z4', '-i10', advIn], {
+                windowsHide: true,
+                stdio: 'ignore',
+                timeout: 120000,
+            });
+            if (!rAdv.error && existsSync(advIn)) {
+                const advBuf = readFileSync(advIn);
+                try {
+                    unlinkSync(advIn);
+                }
+                catch (e) { }
+                if (advBuf.length < bestBuf.length)
+                    bestBuf = advBuf;
+            }
+        }
+        catch (e) { }
+        for (const strat of strategies) {
+            try {
+                const comp = zlib.deflateSync(filteredAll, {
+                    level: 9,
+                    memLevel: 9,
+                    strategy: strat,
+                });
+                const altChunks = newChunks.map((c) => ({
+                    name: c.name,
+                    data: c.data,
+                }));
+                const idx = altChunks.findIndex((c) => c.name === 'IDAT');
+                if (idx !== -1)
+                    altChunks[idx] = { name: 'IDAT', data: comp };
+                const candidate = ensurePng(Buffer.from(encode(altChunks)));
+                if (candidate.length < bestBuf.length)
+                    bestBuf = candidate;
+            }
+            catch (e) { }
+        }
+        try {
+            const pixels = Buffer.alloc(width * height * 3);
+            let prev = null;
+            for (let y = 0; y < height; y++) {
+                const f = raw[y * inRowLen];
+                const row = raw.slice(y * inRowLen + 1, y * inRowLen + 1 + rowBytes);
+                const recon = Buffer.alloc(rowBytes);
+                for (let i = 0; i < rowBytes; i++) {
+                    const left = i - 3 >= 0 ? recon[i - 3] : 0;
+                    const up = prev ? prev[i] : 0;
+                    const upLeft = prev && i - 3 >= 0 ? prev[i - 3] : 0;
+                    let v = row[i];
+                    if (f === 0) {
+                    }
+                    else if (f === 1)
+                        v = (v + left) & 0xff;
+                    else if (f === 2)
+                        v = (v + up) & 0xff;
+                    else if (f === 3)
+                        v = (v + Math.floor((left + up) / 2)) & 0xff;
+                    else
+                        v = (v + paethPredict(left, up, upLeft)) & 0xff;
+                    recon[i] = v;
+                }
+                recon.copy(pixels, y * rowBytes);
+                prev = recon;
+            }
+            const paletteMap = new Map();
+            const palette = [];
+            for (let i = 0; i < pixels.length; i += 3) {
+                const key = `${pixels[i]},${pixels[i + 1]},${pixels[i + 2]}`;
+                if (!paletteMap.has(key)) {
+                    paletteMap.set(key, paletteMap.size);
+                    palette.push(pixels[i], pixels[i + 1], pixels[i + 2]);
+                    if (paletteMap.size > 256)
+                        break;
+                }
+            }
+            if (paletteMap.size <= 256) {
+                const idxRowLen = 1 + width * 1;
+                const idxRows = [];
+                for (let y = 0; y < height; y++) {
+                    const rowIdx = Buffer.alloc(width);
+                    for (let x = 0; x < width; x++) {
+                        const pos = (y * width + x) * 3;
+                        const key = `${pixels[pos]},${pixels[pos + 1]},${pixels[pos + 2]}`;
+                        rowIdx[x] = paletteMap.get(key);
+                    }
+                    let bestRowFilter = 0;
+                    let bestRowSum = Infinity;
+                    let bestRowFiltered = null;
+                    for (let f = 0; f <= 4; f++) {
+                        const filteredRow = Buffer.alloc(width);
+                        let sum = 0;
+                        for (let i = 0; i < width; i++) {
+                            const val = rowIdx[i];
+                            let outv = 0;
+                            const left = i - 1 >= 0 ? rowIdx[i - 1] : 0;
+                            const up = y > 0 ? idxRows[y - 1][i] : 0;
+                            const upLeft = y > 0 && i - 1 >= 0 ? idxRows[y - 1][i - 1] : 0;
+                            if (f === 0)
+                                outv = val;
+                            else if (f === 1)
+                                outv = (val - left + 256) & 0xff;
+                            else if (f === 2)
+                                outv = (val - up + 256) & 0xff;
+                            else if (f === 3)
+                                outv = (val - Math.floor((left + up) / 2) + 256) & 0xff;
+                            else
+                                outv = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
+                            filteredRow[i] = outv;
+                            const signed = outv > 127 ? outv - 256 : outv;
+                            sum += Math.abs(signed);
+                        }
+                        if (sum < bestRowSum) {
+                            bestRowSum = sum;
+                            bestRowFilter = f;
+                            bestRowFiltered = filteredRow;
+                        }
+                    }
+                    const rowBuf = Buffer.alloc(idxRowLen);
+                    rowBuf[0] = bestRowFilter;
+                    bestRowFiltered.copy(rowBuf, 1);
+                    idxRows.push(rowBuf);
+                }
+                const freqMap = new Map();
+                for (let i = 0; i < pixels.length; i += 3) {
+                    const key = `${pixels[i]},${pixels[i + 1]},${pixels[i + 2]}`;
+                    freqMap.set(key, (freqMap.get(key) || 0) + 1);
+                }
+                const paletteVariants = [];
+                paletteVariants.push({
+                    paletteArr: palette.slice(),
+                    map: new Map(paletteMap),
+                });
+                const freqSorted = Array.from(freqMap.entries()).sort((a, b) => b[1] - a[1]);
+                if (freqSorted.length > 0) {
+                    const pal2 = [];
+                    const map2 = new Map();
+                    let pi = 0;
+                    for (const [k] of freqSorted) {
+                        const parts = k.split(',').map((s) => Number(s));
+                        pal2.push(parts[0], parts[1], parts[2]);
+                        map2.set(k, pi++);
+                        if (pi >= 256)
+                            break;
+                    }
+                    if (map2.size <= 256)
+                        paletteVariants.push({ paletteArr: pal2, map: map2 });
+                }
+                for (const variant of paletteVariants) {
+                    const pSize = variant.map.size;
+                    const bitDepth = pSize <= 2 ? 1 : pSize <= 4 ? 2 : pSize <= 16 ? 4 : 8;
+                    const idxRowsVar = [];
+                    for (let y = 0; y < height; y++) {
+                        const rowIdx = Buffer.alloc(width);
+                        for (let x = 0; x < width; x++) {
+                            const pos = (y * width + x) * 3;
+                            const key = `${pixels[pos]},${pixels[pos + 1]},${pixels[pos + 2]}`;
+                            rowIdx[x] = variant.map.get(key);
+                        }
+                        idxRowsVar.push(rowIdx);
+                    }
+                    function packRowIndices(rowIdx, bitDepth) {
+                        if (bitDepth === 8)
+                            return rowIdx;
+                        const bitsPerRow = width * bitDepth;
+                        const outLen = Math.ceil(bitsPerRow / 8);
+                        const out = Buffer.alloc(outLen);
+                        let bitPos = 0;
+                        for (let i = 0; i < width; i++) {
+                            const val = rowIdx[i] & ((1 << bitDepth) - 1);
+                            for (let b = 0; b < bitDepth; b++) {
+                                const bit = (val >> (bitDepth - 1 - b)) & 1;
+                                const byteIdx = Math.floor(bitPos / 8);
+                                const shift = 7 - (bitPos % 8);
+                                out[byteIdx] |= bit << shift;
+                                bitPos++;
+                            }
+                        }
+                        return out;
+                    }
+                    const packedRows = [];
+                    for (let y = 0; y < height; y++) {
+                        const packed = packRowIndices(idxRowsVar[y], bitDepth);
+                        let bestRowFilter = 0;
+                        let bestRowSum = Infinity;
+                        let bestRowFiltered = null;
+                        for (let f = 0; f <= 4; f++) {
+                            const filteredRow = Buffer.alloc(packed.length);
+                            let sum = 0;
+                            for (let i = 0; i < packed.length; i++) {
+                                const val = packed[i];
+                                const left = i - 1 >= 0 ? packed[i - 1] : 0;
+                                const up = y > 0 ? packedRows[y - 1][i] : 0;
+                                const upLeft = y > 0 && i - 1 >= 0 ? packedRows[y - 1][i - 1] : 0;
+                                let outv = 0;
+                                if (f === 0)
+                                    outv = val;
+                                else if (f === 1)
+                                    outv = (val - left + 256) & 0xff;
+                                else if (f === 2)
+                                    outv = (val - up + 256) & 0xff;
+                                else if (f === 3)
+                                    outv = (val - Math.floor((left + up) / 2) + 256) & 0xff;
+                                else
+                                    outv = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
+                                filteredRow[i] = outv;
+                                const signed = outv > 127 ? outv - 256 : outv;
+                                sum += Math.abs(signed);
+                            }
+                            if (sum < bestRowSum) {
+                                bestRowSum = sum;
+                                bestRowFilter = f;
+                                bestRowFiltered = filteredRow;
+                            }
+                        }
+                        const rowBuf = Buffer.alloc(1 + packed.length);
+                        rowBuf[0] = bestRowFilter;
+                        bestRowFiltered.copy(rowBuf, 1);
+                        packedRows.push(rowBuf);
+                    }
+                    const idxFilteredAllVar = Buffer.concat(packedRows);
+                    const palettesBufVar = Buffer.from(variant.paletteArr);
+                    const palChunksVar = [];
+                    const ihdr = Buffer.alloc(13);
+                    ihdr.writeUInt32BE(width, 0);
+                    ihdr.writeUInt32BE(height, 4);
+                    ihdr[8] = bitDepth;
+                    ihdr[9] = 3;
+                    ihdr[10] = 0;
+                    ihdr[11] = 0;
+                    ihdr[12] = 0;
+                    palChunksVar.push({ name: 'IHDR', data: ihdr });
+                    palChunksVar.push({ name: 'PLTE', data: palettesBufVar });
+                    palChunksVar.push({
+                        name: 'IDAT',
+                        data: zlib.deflateSync(idxFilteredAllVar, { level: 9 }),
+                    });
+                    palChunksVar.push({ name: 'IEND', data: Buffer.alloc(0) });
+                    const palOutVar = ensurePng(Buffer.from(encode(palChunksVar)));
+                    if (palOutVar.length < bestBuf.length)
+                        bestBuf = palOutVar;
+                }
+            }
+        }
+        catch (e) { }
+        const externalAttempts = [
+            { cmd: 'oxipng', args: ['-o', '6', '--strip', 'all'] },
+            { cmd: 'optipng', args: ['-o7'] },
+            { cmd: 'pngcrush', args: ['-brute', '-reduce'] },
+            { cmd: 'pngout', args: [] },
+        ];
+        for (const tool of externalAttempts) {
+            try {
+                const tIn = join(tmpdir(), `rox_ext_in_${Date.now()}_${Math.random().toString(36).slice(2)}.png`);
+                const tOut = tIn + '.out.png';
+                writeFileSync(tIn, bestBuf);
+                const args = tool.args.concat([tIn, tOut]);
+                const r = spawnSync(tool.cmd, args, {
+                    windowsHide: true,
+                    stdio: 'ignore',
+                    timeout: 240000,
+                });
+                if (!r.error && existsSync(tOut)) {
+                    const outb = readFileSync(tOut);
+                    try {
+                        unlinkSync(tIn);
+                        unlinkSync(tOut);
+                    }
+                    catch (e) { }
+                    if (outb.length < bestBuf.length)
+                        bestBuf = outb;
+                }
+                else {
+                    try {
+                        unlinkSync(tIn);
+                    }
+                    catch (e) { }
+                }
+            }
+            catch (e) { }
+        }
+        return bestBuf;
+    }
+    catch (e) {
+        return pngBuf;
+    }
+}
 function applyXor(buf, passphrase) {
     const key = Buffer.from(passphrase, 'utf8');
     const out = Buffer.alloc(buf.length);
@@ -215,6 +881,42 @@ function applyXor(buf, passphrase) {
 async function tryZstdDecompress(payload, onProgress, onChunk, outPath) {
     return await parallelZstdDecompress(payload, onProgress, onChunk, outPath);
 }
+async function tryDecompress(payload, onProgress, onChunk, outPath) {
+    try {
+        return await parallelZstdDecompress(payload, onProgress, onChunk, outPath);
+    }
+    catch (e) {
+        try {
+            const mod = await import('lzma-purejs');
+            const decompressFn = mod && (mod.decompress || (mod.LZMA && mod.LZMA.decompress));
+            if (!decompressFn)
+                throw new Error('No lzma decompress');
+            const dec = await new Promise((resolve, reject) => {
+                try {
+                    decompressFn(Buffer.from(payload), (out) => resolve(out));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            const dBuf = Buffer.isBuffer(dec) ? dec : Buffer.from(dec);
+            if (onChunk) {
+                await onChunk(dBuf, 1, 1);
+                return Buffer.alloc(0);
+            }
+            if (outPath) {
+                const ws = createWriteStream(outPath);
+                await writeInChunks(ws, dBuf);
+                ws.end();
+                return Buffer.alloc(0);
+            }
+            return dBuf;
+        }
+        catch (e2) {
+            throw e;
+        }
+    }
+}
 function tryDecryptIfNeeded(buf, passphrase) {
     if (!buf || buf.length === 0)
         return buf;
@@ -575,7 +1277,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
         opts.onProgress({ phase: 'compress_start', total: payload.length });
     const useDelta = mode !== 'screenshot';
     const deltaEncoded = useDelta ? deltaEncode(payload) : payload;
-    payload = await parallelZstdCompress(deltaEncoded, 1, (loaded, total) => {
+    payload = await parallelZstdCompress(deltaEncoded, 22, (loaded, total) => {
         if (opts.onProgress) {
             opts.onProgress({
                 phase: 'compress_progress',
@@ -752,7 +1454,13 @@ export async function encodeBinaryToPng(input, opts = {}) {
             }
         }
         if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen' });
+            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 = await sharp(raw, {
             raw: { width, height, channels: 3 },
         })
@@ -764,9 +1472,53 @@ export async function encodeBinaryToPng(input, opts = {}) {
         })
             .toBuffer();
         if (opts.onProgress)
-            opts.onProgress({ phase: 'done', loaded: bufScr.length });
-        progressBar?.stop();
-        return bufScr;
+            opts.onProgress({ phase: 'png_gen', loaded: 100, total: 100 });
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'optimizing', loaded: 0, total: 100 });
+        let optInterval = null;
+        const MIN_OPT_MS = 8000;
+        let optStart = Date.now();
+        if (opts.onProgress) {
+            let optLoaded = 0;
+            optStart = Date.now();
+            optInterval = setInterval(() => {
+                optLoaded = Math.min(optLoaded + 2, 99);
+                opts.onProgress?.({
+                    phase: 'optimizing',
+                    loaded: optLoaded,
+                    total: 100,
+                });
+            }, 100);
+        }
+        try {
+            const optimizedPromise = optimizePngBuffer(bufScr, !!opts.onProgress);
+            const optimized = await optimizedPromise;
+            const elapsedOpt = Date.now() - optStart;
+            if (elapsedOpt < MIN_OPT_MS) {
+                await new Promise((r) => setTimeout(r, MIN_OPT_MS - elapsedOpt));
+            }
+            clearInterval(progressInterval);
+            if (optInterval) {
+                clearInterval(optInterval);
+                optInterval = null;
+            }
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'optimizing', loaded: 100, total: 100 });
+            try {
+                const verified = await decodePngToBinary(optimized);
+                if (verified.buf && verified.buf.equals(input)) {
+                    progressBar?.stop();
+                    return optimized;
+                }
+            }
+            catch (e) { }
+            progressBar?.stop();
+            return bufScr;
+        }
+        catch (e) {
+            progressBar?.stop();
+            return bufScr;
+        }
     }
     if (mode === 'pixel') {
         const nameBuf = opts.name
@@ -838,15 +1590,34 @@ export async function encodeBinaryToPng(input, opts = {}) {
         chunksPixel.push({ name: 'IDAT', data: idatData });
         chunksPixel.push({ name: 'IEND', data: Buffer.alloc(0) });
         if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen' });
+            opts.onProgress({ phase: 'png_gen', loaded: 0, total: 2 });
         const tmp = Buffer.from(encode(chunksPixel));
         const outPng = tmp.slice(0, 8).toString('hex') === PNG_HEADER_HEX
             ? tmp
             : Buffer.concat([PNG_HEADER, tmp]);
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'png_gen', loaded: 1, total: 2 });
         if (opts.onProgress)
             opts.onProgress({ phase: 'done', loaded: outPng.length });
-        progressBar?.stop();
-        return outPng;
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'done', loaded: outPng.length });
+        try {
+            const optimized = await optimizePngBuffer(outPng);
+            try {
+                const verified = await decodePngToBinary(optimized);
+                if (verified.buf && verified.buf.equals(input)) {
+                    progressBar?.stop();
+                    return optimized;
+                }
+            }
+            catch (e) { }
+            progressBar?.stop();
+            return outPng;
+        }
+        catch (e) {
+            progressBar?.stop();
+            return outPng;
+        }
     }
     if (mode === 'compact') {
         const bytesPerPixel = 4;
@@ -877,15 +1648,34 @@ export async function encodeBinaryToPng(input, opts = {}) {
         chunks2.push({ name: CHUNK_TYPE, data: meta });
         chunks2.push({ name: 'IEND', data: Buffer.alloc(0) });
         if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen' });
+            opts.onProgress({ phase: 'png_gen', loaded: 0, total: 2 });
         const out = Buffer.from(encode(chunks2));
         const outBuf = out.slice(0, 8).toString('hex') === PNG_HEADER_HEX
             ? out
             : Buffer.concat([PNG_HEADER, out]);
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'png_gen', loaded: 1, total: 2 });
         if (opts.onProgress)
             opts.onProgress({ phase: 'done', loaded: outBuf.length });
-        progressBar?.stop();
-        return outBuf;
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'done', loaded: outBuf.length });
+        try {
+            const optimized = await optimizePngBuffer(outBuf);
+            try {
+                const verified = await decodePngToBinary(optimized);
+                if (verified.buf && verified.buf.equals(input)) {
+                    progressBar?.stop();
+                    return optimized;
+                }
+            }
+            catch (e) { }
+            progressBar?.stop();
+            return outBuf;
+        }
+        catch (e) {
+            progressBar?.stop();
+            return outBuf;
+        }
     }
     throw new Error(`Unsupported mode: ${mode}`);
 }
@@ -976,7 +1766,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
             const ws = createWriteStream(opts.outPath, { highWaterMark: 64 * 1024 });
             let headerBuf = Buffer.alloc(0);
             let headerSkipped = false;
-            await tryZstdDecompress(payload, (info) => {
+            await tryDecompress(payload, (info) => {
                 if (opts.onProgress)
                     opts.onProgress(info);
             }, async (decChunk) => {
@@ -1010,7 +1800,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
         if (opts.onProgress)
             opts.onProgress({ phase: 'decompress_start' });
         try {
-            payload = await tryZstdDecompress(payload, (info) => {
+            payload = await tryDecompress(payload, (info) => {
                 if (opts.onProgress)
                     opts.onProgress(info);
             });
@@ -1073,7 +1863,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
             const ws = createWriteStream(opts.outPath, { highWaterMark: 64 * 1024 });
             let headerBuf = Buffer.alloc(0);
             let headerSkipped = false;
-            await tryZstdDecompress(payload, (info) => {
+            await tryDecompress(payload, (info) => {
                 if (opts.onProgress)
                     opts.onProgress(info);
             }, async (decChunk) => {
@@ -1235,7 +2025,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
             let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
             try {
                 if (opts.outPath) {
-                    await tryZstdDecompress(payload, (info) => {
+                    await tryDecompress(payload, (info) => {
                         if (opts.onProgress)
                             opts.onProgress(info);
                     }, undefined, opts.outPath);
@@ -1538,7 +2328,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
                         return { meta: { name } };
                     }
                     else {
-                        payload = await tryZstdDecompress(payload, (info) => {
+                        payload = await tryDecompress(payload, (info) => {
                             if (opts.onProgress)
                                 opts.onProgress(info);
                         });
@@ -1595,6 +2385,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
     }
     throw new DataFormatError('No valid data found in image');
 }
+export { decodeMinPng, encodeMinPng } from './minpng.js';
 export { packPaths, unpackBuffer } from './pack.js';
 /**
  * List files in a Rox PNG archive without decoding the full payload.