roxify 1.2.7 → 1.2.9

package/dist/utils/encoder.js

@@ -1,422 +1,391 @@
-import cliProgress from 'cli-progress';
-import { createCipheriv, pbkdf2Sync, randomBytes } from 'crypto';
-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, } from './constants.js';
-import { crc32 } from './crc.js';
-import { 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 payloadInput;
-    let totalLen = 0;
-    if (Array.isArray(input)) {
-        payloadInput = [MAGIC, ...input];
-        totalLen = MAGIC.length + input.reduce((a, b) => a + b.length, 0);
-    }
-    else {
-        payloadInput = [MAGIC, input];
-        totalLen = MAGIC.length + input.length;
-    }
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'compress_start', total: totalLen });
-    let payload = await parallelZstdCompress(payloadInput, 15, (loaded, total) => {
-        if (opts.onProgress) {
-            opts.onProgress({
-                phase: 'compress_progress',
-                loaded,
-                total,
-            });
-        }
-    });
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'compress_done', loaded: payload.length });
-    if (Array.isArray(input)) {
-        input.length = 0;
-    }
-    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 encParts = [];
-            for (const chunk of payload) {
-                encParts.push(cipher.update(chunk));
-            }
-            encParts.push(cipher.final());
-            const tag = cipher.getAuthTag();
-            payload = [Buffer.from([ENC_AES]), salt, iv, tag, ...encParts];
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'encrypt_done' });
-        }
-        else if (encChoice === 'xor') {
-            const xoredParts = [];
-            let offset = 0;
-            const keyBuf = Buffer.from(opts.passphrase, 'utf8');
-            for (const chunk of payload) {
-                const out = Buffer.alloc(chunk.length);
-                for (let i = 0; i < chunk.length; i++) {
-                    out[i] = chunk[i] ^ keyBuf[(offset + i) % keyBuf.length];
-                }
-                offset += chunk.length;
-                xoredParts.push(out);
-            }
-            payload = [Buffer.from([ENC_XOR]), ...xoredParts];
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'encrypt_done' });
-        }
-        else if (encChoice === 'none') {
-            payload = [Buffer.from([ENC_NONE]), ...payload];
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'encrypt_done' });
-        }
-    }
-    else {
-        payload = [Buffer.from([ENC_NONE]), ...payload];
-    }
-    const payloadTotalLen = payload.reduce((a, b) => a + b.length, 0);
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'meta_prep_done', loaded: payloadTotalLen });
-    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]));
-    }
-    let meta = [...metaParts, ...payload];
-    if (opts.includeFileList && opts.fileList) {
-        let sizeMap = null;
-        if (!Array.isArray(input)) {
-            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 = [...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(payloadTotalLen, 0);
-        const version = 1;
-        let metaPixel = [
-            Buffer.from([version]),
-            Buffer.from([nameLen]),
-            nameBuf,
-            payloadLenBuf,
-            ...payload,
-        ];
-        if (opts.includeFileList && opts.fileList) {
-            let sizeMap2 = null;
-            if (!Array.isArray(input)) {
-                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 = [...metaPixel, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf];
-        }
-        const dataWithoutMarkers = [PIXEL_MAGIC, ...metaPixel];
-        const dataWithoutMarkersLen = dataWithoutMarkers.reduce((a, b) => a + b.length, 0);
-        const padding = (3 - (dataWithoutMarkersLen % 3)) % 3;
-        const paddedData = padding > 0
-            ? [...dataWithoutMarkers, Buffer.alloc(padding)]
-            : dataWithoutMarkers;
-        const markerStartBytes = colorsToBytes(MARKER_START);
-        const compressionMarkerBytes = colorsToBytes(COMPRESSION_MARKERS.zstd);
-        const dataWithMarkers = [
-            markerStartBytes,
-            compressionMarkerBytes,
-            ...paddedData,
-        ];
-        const bytesPerPixel = 3;
-        const dataWithMarkersLen = dataWithMarkers.reduce((a, b) => a + b.length, 0);
-        const dataPixels = Math.ceil(dataWithMarkersLen / 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 LARGE_IMAGE_PIXELS = 50000000;
-        const useManualPng = width * height > LARGE_IMAGE_PIXELS || !!process.env.ROX_FAST_PNG;
-        let raw;
-        let stride = 0;
-        if (useManualPng) {
-            stride = width * 3 + 1;
-            raw = Buffer.alloc(height * stride);
-        }
-        else {
-            raw = Buffer.alloc(width * height * bytesPerPixel);
-        }
-        let currentBufIdx = 0;
-        let currentBufOffset = 0;
-        const getNextByte = () => {
-            while (currentBufIdx < dataWithMarkers.length) {
-                const buf = dataWithMarkers[currentBufIdx];
-                if (currentBufOffset < buf.length) {
-                    return buf[currentBufOffset++];
-                }
-                currentBufIdx++;
-                currentBufOffset = 0;
-            }
-            return 0;
-        };
-        for (let ly = 0; ly < logicalHeight; ly++) {
-            if (useManualPng) {
-                for (let sy = 0; sy < scale; sy++) {
-                    const py = ly * scale + sy;
-                    raw[py * stride] = 0;
-                }
-            }
-            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) {
-                    r = getNextByte();
-                    g = getNextByte();
-                    b = getNextByte();
-                }
-                for (let sy = 0; sy < scale; sy++) {
-                    for (let sx = 0; sx < scale; sx++) {
-                        const px = lx * scale + sx;
-                        const py = ly * scale + sy;
-                        if (useManualPng) {
-                            const dstIdx = py * stride + 1 + px * 3;
-                            raw[dstIdx] = r;
-                            raw[dstIdx + 1] = g;
-                            raw[dstIdx + 2] = b;
-                        }
-                        else {
-                            const dstIdx = (py * width + px) * 3;
-                            raw[dstIdx] = r;
-                            raw[dstIdx + 1] = g;
-                            raw[dstIdx + 2] = b;
-                        }
-                    }
-                }
-            }
-        }
-        payload.length = 0;
-        dataWithMarkers.length = 0;
-        metaPixel.length = 0;
-        meta.length = 0;
-        paddedData.length = 0;
-        dataWithoutMarkers.length = 0;
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', loaded: 0, total: height });
-        let bufScr;
-        if (useManualPng) {
-            const bytesPerRow = width * 3;
-            const scanlinesData = Buffer.alloc(height * (1 + bytesPerRow));
-            const progressStep = Math.max(1, Math.floor(height / 20));
-            for (let row = 0; row < height; row++) {
-                scanlinesData[row * (1 + bytesPerRow)] = 0;
-                const srcStart = row * stride + 1;
-                const dstStart = row * (1 + bytesPerRow) + 1;
-                raw.copy(scanlinesData, dstStart, srcStart, srcStart + bytesPerRow);
-                if (opts.onProgress && row % progressStep === 0) {
-                    opts.onProgress({ phase: 'png_gen', loaded: row, total: height });
-                }
-            }
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'png_compress', loaded: 0, total: 100 });
-            const idatData = zlib.deflateSync(scanlinesData, {
-                level: 3,
-                memLevel: 8,
-                strategy: zlib.constants.Z_DEFAULT_STRATEGY,
-            });
-            raw = Buffer.alloc(0);
-            const ihdrData = Buffer.alloc(13);
-            ihdrData.writeUInt32BE(width, 0);
-            ihdrData.writeUInt32BE(height, 4);
-            ihdrData[8] = 8;
-            ihdrData[9] = 2;
-            ihdrData[10] = 0;
-            ihdrData[11] = 0;
-            ihdrData[12] = 0;
-            const ihdrType = Buffer.from('IHDR', 'utf8');
-            const ihdrCrc = crc32(ihdrData, crc32(ihdrType));
-            const ihdrCrcBuf = Buffer.alloc(4);
-            ihdrCrcBuf.writeUInt32BE(ihdrCrc, 0);
-            const ihdrLen = Buffer.alloc(4);
-            ihdrLen.writeUInt32BE(ihdrData.length, 0);
-            const idatType = Buffer.from('IDAT', 'utf8');
-            const idatCrc = crc32(idatData, crc32(idatType));
-            const idatCrcBuf = Buffer.alloc(4);
-            idatCrcBuf.writeUInt32BE(idatCrc, 0);
-            const idatLen = Buffer.alloc(4);
-            idatLen.writeUInt32BE(idatData.length, 0);
-            const iendType = Buffer.from('IEND', 'utf8');
-            const iendCrc = crc32(Buffer.alloc(0), crc32(iendType));
-            const iendCrcBuf = Buffer.alloc(4);
-            iendCrcBuf.writeUInt32BE(iendCrc, 0);
-            const iendLen = Buffer.alloc(4);
-            iendLen.writeUInt32BE(0, 0);
-            bufScr = Buffer.concat([
-                PNG_HEADER,
-                ihdrLen,
-                ihdrType,
-                ihdrData,
-                ihdrCrcBuf,
-                idatLen,
-                idatType,
-                idatData,
-                idatCrcBuf,
-                iendLen,
-                iendType,
-                iendCrcBuf,
-            ]);
-        }
-        else {
-            bufScr = await sharp(raw, {
-                raw: { width, height, channels: 3 },
-            })
-                .png({
-                compressionLevel: 3,
-                palette: false,
-                effort: 1,
-                adaptiveFiltering: false,
-            })
-                .toBuffer();
-        }
-        raw = Buffer.alloc(0);
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'png_compress', loaded: 100, total: 100 });
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'optimizing', loaded: 0, total: 100 });
-        try {
-            const optimized = await optimizePngBuffer(bufScr, true);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'optimizing', loaded: 100, total: 100 });
-            progressBar?.stop();
-            return optimized;
-        }
-        catch (e) {
-            progressBar?.stop();
-            return bufScr;
-        }
-    }
-}
+import cliProgress from 'cli-progress';
+import { createCipheriv, pbkdf2Sync, randomBytes } from 'crypto';
+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, } from './constants.js';
+import { crc32 } from './crc.js';
+import { 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 payloadInput;
+    let totalLen = 0;
+    if (Array.isArray(input)) {
+        payloadInput = [MAGIC, ...input];
+        totalLen = MAGIC.length + input.reduce((a, b) => a + b.length, 0);
+    }
+    else {
+        payloadInput = [MAGIC, input];
+        totalLen = MAGIC.length + input.length;
+    }
+    if (opts.onProgress)
+        opts.onProgress({ phase: 'compress_start', total: totalLen });
+    const compressionLevel = opts.compressionLevel ?? 3;
+    let payload = await parallelZstdCompress(payloadInput, compressionLevel, (loaded, total) => {
+        if (opts.onProgress) {
+            opts.onProgress({
+                phase: 'compress_progress',
+                loaded,
+                total,
+            });
+        }
+    });
+    if (opts.onProgress)
+        opts.onProgress({ phase: 'compress_done', loaded: payload.length });
+    if (Array.isArray(input)) {
+        input.length = 0;
+    }
+    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 encParts = [];
+            for (const chunk of payload) {
+                encParts.push(cipher.update(chunk));
+            }
+            encParts.push(cipher.final());
+            const tag = cipher.getAuthTag();
+            payload = [Buffer.from([ENC_AES]), salt, iv, tag, ...encParts];
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'encrypt_done' });
+        }
+        else if (encChoice === 'xor') {
+            const xoredParts = [];
+            let offset = 0;
+            const keyBuf = Buffer.from(opts.passphrase, 'utf8');
+            for (const chunk of payload) {
+                const out = Buffer.alloc(chunk.length);
+                for (let i = 0; i < chunk.length; i++) {
+                    out[i] = chunk[i] ^ keyBuf[(offset + i) % keyBuf.length];
+                }
+                offset += chunk.length;
+                xoredParts.push(out);
+            }
+            payload = [Buffer.from([ENC_XOR]), ...xoredParts];
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'encrypt_done' });
+        }
+        else if (encChoice === 'none') {
+            payload = [Buffer.from([ENC_NONE]), ...payload];
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'encrypt_done' });
+        }
+    }
+    else {
+        payload = [Buffer.from([ENC_NONE]), ...payload];
+    }
+    const payloadTotalLen = payload.reduce((a, b) => a + b.length, 0);
+    if (opts.onProgress)
+        opts.onProgress({ phase: 'meta_prep_done', loaded: payloadTotalLen });
+    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]));
+    }
+    let meta = [...metaParts, ...payload];
+    if (opts.includeFileList && opts.fileList) {
+        let sizeMap = null;
+        if (!Array.isArray(input)) {
+            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 = [...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(payloadTotalLen, 0);
+        const version = 1;
+        let metaPixel = [
+            Buffer.from([version]),
+            Buffer.from([nameLen]),
+            nameBuf,
+            payloadLenBuf,
+            ...payload,
+        ];
+        if (opts.includeFileList && opts.fileList) {
+            let sizeMap2 = null;
+            if (!Array.isArray(input)) {
+                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 = [...metaPixel, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf];
+        }
+        const dataWithoutMarkers = [PIXEL_MAGIC, ...metaPixel];
+        const dataWithoutMarkersLen = dataWithoutMarkers.reduce((a, b) => a + b.length, 0);
+        const padding = (3 - (dataWithoutMarkersLen % 3)) % 3;
+        const paddedData = padding > 0
+            ? [...dataWithoutMarkers, Buffer.alloc(padding)]
+            : dataWithoutMarkers;
+        const markerStartBytes = colorsToBytes(MARKER_START);
+        const compressionMarkerBytes = colorsToBytes(COMPRESSION_MARKERS.zstd);
+        const dataWithMarkers = [
+            markerStartBytes,
+            compressionMarkerBytes,
+            ...paddedData,
+        ];
+        const bytesPerPixel = 3;
+        const dataWithMarkersLen = dataWithMarkers.reduce((a, b) => a + b.length, 0);
+        const dataPixels = Math.ceil(dataWithMarkersLen / 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 LARGE_IMAGE_PIXELS = 10000000;
+        const useManualPng = width * height > LARGE_IMAGE_PIXELS || !!process.env.ROX_FAST_PNG;
+        let raw;
+        let stride = 0;
+        if (useManualPng) {
+            stride = width * 3 + 1;
+            raw = Buffer.alloc(height * stride);
+            const flatData = Buffer.concat(dataWithMarkers);
+            const markerEndBytes = Buffer.alloc(MARKER_END.length * 3);
+            for (let i = 0; i < MARKER_END.length; i++) {
+                markerEndBytes[i * 3] = MARKER_END[i].r;
+                markerEndBytes[i * 3 + 1] = MARKER_END[i].g;
+                markerEndBytes[i * 3 + 2] = MARKER_END[i].b;
+            }
+            const totalDataBytes = logicalWidth * logicalHeight * 3;
+            const fullData = Buffer.alloc(totalDataBytes);
+            const markerStartPos = (logicalHeight - 1) * logicalWidth * 3 +
+                (logicalWidth - MARKER_END.length) * 3;
+            flatData.copy(fullData, 0, 0, Math.min(flatData.length, markerStartPos));
+            markerEndBytes.copy(fullData, markerStartPos);
+            for (let row = 0; row < height; row++) {
+                raw[row * stride] = 0;
+                fullData.copy(raw, row * stride + 1, row * width * 3, (row + 1) * width * 3);
+            }
+        }
+        else {
+            raw = Buffer.alloc(width * height * bytesPerPixel);
+            const flatData = Buffer.concat(dataWithMarkers);
+            flatData.copy(raw, 0, 0, Math.min(flatData.length, raw.length));
+        }
+        payload.length = 0;
+        dataWithMarkers.length = 0;
+        metaPixel.length = 0;
+        meta.length = 0;
+        paddedData.length = 0;
+        dataWithoutMarkers.length = 0;
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'png_gen', loaded: 0, total: height });
+        let bufScr;
+        if (useManualPng) {
+            const bytesPerRow = width * 3;
+            const scanlinesData = Buffer.alloc(height * (1 + bytesPerRow));
+            const progressStep = Math.max(1, Math.floor(height / 20));
+            for (let row = 0; row < height; row++) {
+                scanlinesData[row * (1 + bytesPerRow)] = 0;
+                const srcStart = row * stride + 1;
+                const dstStart = row * (1 + bytesPerRow) + 1;
+                raw.copy(scanlinesData, dstStart, srcStart, srcStart + bytesPerRow);
+                if (opts.onProgress && row % progressStep === 0) {
+                    opts.onProgress({ phase: 'png_gen', loaded: row, total: height });
+                }
+            }
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'png_compress', loaded: 0, total: 100 });
+            const idatData = zlib.deflateSync(scanlinesData, {
+                level: 0,
+                memLevel: 8,
+                strategy: zlib.constants.Z_FILTERED,
+            });
+            raw = Buffer.alloc(0);
+            const ihdrData = Buffer.alloc(13);
+            ihdrData.writeUInt32BE(width, 0);
+            ihdrData.writeUInt32BE(height, 4);
+            ihdrData[8] = 8;
+            ihdrData[9] = 2;
+            ihdrData[10] = 0;
+            ihdrData[11] = 0;
+            ihdrData[12] = 0;
+            const ihdrType = Buffer.from('IHDR', 'utf8');
+            const ihdrCrc = crc32(ihdrData, crc32(ihdrType));
+            const ihdrCrcBuf = Buffer.alloc(4);
+            ihdrCrcBuf.writeUInt32BE(ihdrCrc, 0);
+            const ihdrLen = Buffer.alloc(4);
+            ihdrLen.writeUInt32BE(ihdrData.length, 0);
+            const idatType = Buffer.from('IDAT', 'utf8');
+            const idatCrc = crc32(idatData, crc32(idatType));
+            const idatCrcBuf = Buffer.alloc(4);
+            idatCrcBuf.writeUInt32BE(idatCrc, 0);
+            const idatLen = Buffer.alloc(4);
+            idatLen.writeUInt32BE(idatData.length, 0);
+            const iendType = Buffer.from('IEND', 'utf8');
+            const iendCrc = crc32(Buffer.alloc(0), crc32(iendType));
+            const iendCrcBuf = Buffer.alloc(4);
+            iendCrcBuf.writeUInt32BE(iendCrc, 0);
+            const iendLen = Buffer.alloc(4);
+            iendLen.writeUInt32BE(0, 0);
+            bufScr = Buffer.concat([
+                PNG_HEADER,
+                ihdrLen,
+                ihdrType,
+                ihdrData,
+                ihdrCrcBuf,
+                idatLen,
+                idatType,
+                idatData,
+                idatCrcBuf,
+                iendLen,
+                iendType,
+                iendCrcBuf,
+            ]);
+        }
+        else {
+            bufScr = await sharp(raw, {
+                raw: { width, height, channels: 3 },
+            })
+                .png({
+                compressionLevel: 3,
+                palette: false,
+                effort: 1,
+                adaptiveFiltering: false,
+            })
+                .toBuffer();
+        }
+        raw = Buffer.alloc(0);
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'png_compress', loaded: 100, total: 100 });
+        if (opts.skipOptimization) {
+            progressBar?.stop();
+            return bufScr;
+        }
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'optimizing', loaded: 0, total: 100 });
+        try {
+            const optimized = await optimizePngBuffer(bufScr, true);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'optimizing', loaded: 100, total: 100 });
+            progressBar?.stop();
+            return optimized;
+        }
+        catch (e) {
+            progressBar?.stop();
+            return bufScr;
+        }
+    }
+}