roxify 1.4.1 → 1.5.1

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import cliProgress from 'cli-progress';
 import { mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { open } from 'fs/promises';
 import { basename, dirname, join, resolve } from 'path';
 import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
 import { packPathsGenerator, unpackBuffer } from './pack.js';
+import * as cliProgress from './stub-progress.js';
 import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
 const VERSION = '1.4.0';
 async function readLargeFile(filePath) {

package/dist/hybrid-compression.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export interface CompressionStats {
     originalSize: number;
     compressedSize: number;

package/dist/hybrid-compression.js

@@ -1,10 +1,10 @@
+import { native } from './utils/native.js';
 let check_gpu_status;
 let entropy_estimate;
 let get_compression_stats;
 let hybrid_compress;
 let hybrid_decompress;
 try {
-    const native = require('../libroxify_native.node');
     check_gpu_status = native.check_gpu_status;
     entropy_estimate = native.entropy_estimate;
     get_compression_stats = native.get_compression_stats;

package/dist/minpng.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export declare function encodeMinPng(rgb: Buffer, width: number, height: number): Promise<Buffer>;
 export declare function decodeMinPng(pngBuf: Buffer): Promise<{
     buf: Buffer;

package/dist/minpng.js

@@ -1,6 +1,20 @@
-import { compress as zstdCompress, decompress as zstdDecompress, } from '@mongodb-js/zstd';
-import encode from 'png-chunks-encode';
 import { deflateSync } from 'zlib';
+import { native } from './utils/native.js';
+let nativeZstdCompress = null;
+let nativeZstdDecompress = null;
+let nativeEncodePngChunks = null;
+try {
+    if (native?.nativeZstdCompress) {
+        nativeZstdCompress = native.nativeZstdCompress;
+    }
+    if (native?.nativeZstdDecompress) {
+        nativeZstdDecompress = native.nativeZstdDecompress;
+    }
+    if (native?.encodePngChunks) {
+        nativeEncodePngChunks = native.encodePngChunks;
+    }
+}
+catch (e) { }
 const PIXEL_MAGIC = Buffer.from('MNPG');
 const MARKER_START = [
     { r: 255, g: 0, b: 0 },
@@ -82,7 +96,10 @@ export async function encodeMinPng(rgb, width, height) {
         transformed[tIdx++] = b;
     }
     const transformedBuf = Buffer.from(transformed);
-    const compressed = Buffer.from(await zstdCompress(transformedBuf, 19));
+    if (!nativeZstdCompress) {
+        throw new Error('Native zstd compression not available');
+    }
+    const compressed = Buffer.from(nativeZstdCompress(transformedBuf, 19));
     const header = Buffer.alloc(4 + 1 + 4 + 4);
     PIXEL_MAGIC.copy(header, 0);
     header[4] = 1;
@@ -142,16 +159,29 @@ export async function encodeMinPng(rgb, width, height) {
         { name: 'IDAT', data: idat },
         { name: 'IEND', data: Buffer.alloc(0) },
     ];
-    return Buffer.from(encode(chunks));
+    if (nativeEncodePngChunks) {
+        return Buffer.from(nativeEncodePngChunks(chunks));
+    }
+    const PNG_SIG = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+    const output = [PNG_SIG];
+    for (const chunk of chunks) {
+        const type = Buffer.from(chunk.name, 'ascii');
+        const length = Buffer.alloc(4);
+        length.writeUInt32BE(chunk.data.length, 0);
+        const crcData = Buffer.concat([type, chunk.data]);
+        const crc = Buffer.alloc(4);
+        const crc32fast = native?.nativeCrc32;
+        const crcVal = crc32fast ? crc32fast(crcData) : 0;
+        crc.writeUInt32BE(crcVal, 0);
+        output.push(length, type, chunk.data, crc);
+    }
+    return Buffer.concat(output);
 }
 export async function decodeMinPng(pngBuf) {
-    const sharp = await import('sharp');
-    const { data, info } = await sharp
-        .default(pngBuf)
-        .raw()
-        .toBuffer({ resolveWithObject: true });
-    const currentWidth = info.width;
-    const currentHeight = info.height;
+    const rawData = native.sharpToRaw(pngBuf);
+    const data = rawData.pixels;
+    const currentWidth = rawData.width;
+    const currentHeight = rawData.height;
     const rawRGB = Buffer.alloc(currentWidth * currentHeight * 3);
     for (let i = 0; i < currentWidth * currentHeight; i++) {
         rawRGB[i * 3] = data[i * 3];
@@ -190,7 +220,10 @@ export async function decodeMinPng(pngBuf) {
     if (compStart + compressedLen > rawRGB.length)
         return null;
     const compressed = rawRGB.subarray(compStart, compStart + compressedLen);
-    const decompressed = Buffer.from(await zstdDecompress(compressed));
+    if (!nativeZstdDecompress) {
+        throw new Error('Native zstd decompression not available');
+    }
+    const decompressed = Buffer.from(nativeZstdDecompress(compressed));
     const indices = zigzagOrderIndices(origW, origH);
     const residualR = new Uint8Array(origW * origH);
     const residualG = new Uint8Array(origW * origH);

package/dist/pack.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export interface PackedFile {
     path: string;
     buf: Buffer;

package/dist/stub-progress.d.ts

@@ -0,0 +1,9 @@
+export declare class SingleBar {
+    constructor(...args: any[]);
+    start(...args: any[]): void;
+    update(...args: any[]): void;
+    stop(...args: any[]): void;
+}
+export declare const Presets: {
+    shades_classic: {};
+};

package/dist/stub-progress.js

@@ -0,0 +1,9 @@
+export class SingleBar {
+    constructor(...args) { }
+    start(...args) { }
+    update(...args) { }
+    stop(...args) { }
+}
+export const Presets = {
+    shades_classic: {},
+};

package/dist/utils/constants.d.ts

@@ -1,14 +1,12 @@
-/// <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 PIXEL_MAGIC_BLOCK: Buffer;
+export declare const MAGIC: Buffer<ArrayBuffer>;
+export declare const PIXEL_MAGIC: Buffer<ArrayBuffer>;
+export declare const PIXEL_MAGIC_BLOCK: Buffer<ArrayBuffer>;
 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 FILTER_ZERO: Buffer<ArrayBuffer>;
+export declare const PNG_HEADER: Buffer<ArrayBuffer>;
 export declare const PNG_HEADER_HEX: string;
 export declare const MARKER_COLORS: {
     r: number;
@@ -31,11 +29,6 @@ export declare const COMPRESSION_MARKERS: {
         g: number;
         b: number;
     }[];
-    lzma: {
-        r: number;
-        g: number;
-        b: number;
-    }[];
 };
 export declare const FORMAT_MARKERS: {
     png: {

package/dist/utils/constants.js

@@ -19,7 +19,6 @@ 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 }],
 };
 export const FORMAT_MARKERS = {
     png: { r: 0, g: 255, b: 255 },

package/dist/utils/crc.d.ts

@@ -1,4 +1,2 @@
-/// <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/decoder.d.ts

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

package/dist/utils/decoder.js

@@ -1,41 +1,16 @@
 import { execFileSync } from 'child_process';
-import cliProgress from 'cli-progress';
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import extract from 'png-chunks-extract';
-import sharp from 'sharp';
 import { unpackBuffer } from '../pack.js';
 import { CHUNK_TYPE, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PIXEL_MAGIC_BLOCK, PNG_HEADER, } from './constants.js';
 import { DataFormatError, IncorrectPassphraseError, PassphraseRequiredError, } from './errors.js';
 import { colorsToBytes, deltaDecode, tryDecryptIfNeeded } from './helpers.js';
+import { native } from './native.js';
 import { cropAndReconstitute } from './reconstitution.js';
 import { parallelZstdDecompress, tryZstdDecompress } from './zstd.js';
 async function tryDecompress(payload, onProgress) {
-    try {
-        return await parallelZstdDecompress(payload, onProgress);
-    }
-    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);
-            return dBuf;
-        }
-        catch (e3) {
-            throw e;
-        }
-    }
+    return await parallelZstdDecompress(payload, onProgress);
 }
 function detectImageFormat(buf) {
     if (buf.length < 12)
@@ -90,11 +65,17 @@ export async function decodePngToBinary(input, opts = {}) {
     }
     else {
         try {
-            const metadata = await sharp(input).metadata();
-            const rawBytesEstimate = (metadata.width || 0) * (metadata.height || 0) * 4;
-            const MAX_RAW_BYTES = 200 * 1024 * 1024;
-            if (rawBytesEstimate > MAX_RAW_BYTES) {
-                pngBuf = readFileSync(input);
+            if (native?.sharpMetadata) {
+                const inputBuf = readFileSync(input);
+                const metadata = native.sharpMetadata(inputBuf);
+                const rawBytesEstimate = metadata.width * metadata.height * 4;
+                const MAX_RAW_BYTES = 200 * 1024 * 1024;
+                if (rawBytesEstimate > MAX_RAW_BYTES) {
+                    pngBuf = inputBuf;
+                }
+                else {
+                    pngBuf = inputBuf;
+                }
             }
             else {
                 pngBuf = readFileSync(input);
@@ -111,10 +92,11 @@ export async function decodePngToBinary(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' });
+        progressBar = {
+            start: () => { },
+            update: () => { },
+            stop: () => { },
+        };
         const startTime = Date.now();
         if (!opts.onProgress) {
             opts.onProgress = (info) => {
@@ -128,10 +110,6 @@ export async function decodePngToBinary(input, opts = {}) {
                 else if (info.phase === 'done') {
                     pct = 100;
                 }
-                progressBar.update(Math.floor(pct), {
-                    step: info.phase.replace('_', ' '),
-                    elapsed: String(Math.floor((Date.now() - startTime) / 1000)),
-                });
             };
         }
     }
@@ -139,28 +117,17 @@ export async function decodePngToBinary(input, opts = {}) {
         opts.onProgress({ phase: 'start' });
     let processedBuf = pngBuf;
     try {
-        const info = await sharp(pngBuf).metadata();
-        if (info.width && info.height) {
-            const MAX_RAW_BYTES = 1200 * 1024 * 1024;
-            const rawBytesEstimate = info.width * info.height * 4;
-            if (rawBytesEstimate > MAX_RAW_BYTES) {
-                throw new DataFormatError(`Image too large to decode in-process (${Math.round(rawBytesEstimate / 1024 / 1024)} MB). Increase Node heap or use a smaller image/compact mode.`);
-            }
-            if (false) {
-                const doubledBuffer = await sharp(pngBuf)
-                    .resize({
-                    width: info.width * 2,
-                    height: info.height * 2,
-                    kernel: 'nearest',
-                })
-                    .png()
-                    .toBuffer();
-                processedBuf = await cropAndReconstitute(doubledBuffer, opts.debugDir);
-            }
-            else {
-                processedBuf = pngBuf;
+        if (native?.sharpMetadata) {
+            const info = native.sharpMetadata(pngBuf);
+            if (info.width && info.height) {
+                const MAX_RAW_BYTES = 1200 * 1024 * 1024;
+                const rawBytesEstimate = info.width * info.height * 4;
+                if (rawBytesEstimate > MAX_RAW_BYTES) {
+                    throw new DataFormatError(`Image too large to decode in-process (${Math.round(rawBytesEstimate / 1024 / 1024)} MB). Increase Node heap or use a smaller image/compact mode.`);
+                }
             }
         }
+        processedBuf = pngBuf;
     }
     catch (e) {
         if (e instanceof DataFormatError)
@@ -204,24 +171,30 @@ export async function decodePngToBinary(input, opts = {}) {
     }
     let chunks = [];
     try {
-        const chunksRaw = extract(processedBuf);
-        chunks = chunksRaw.map((c) => ({
-            name: c.name,
-            data: Buffer.isBuffer(c.data)
-                ? c.data
-                : Buffer.from(c.data),
-        }));
+        if (native?.extractPngChunks) {
+            const chunksRaw = native.extractPngChunks(processedBuf);
+            chunks = chunksRaw.map((c) => ({
+                name: c.name,
+                data: Buffer.from(c.data),
+            }));
+        }
+        else {
+            throw new Error('Native PNG chunk extraction not available');
+        }
     }
     catch (e) {
         try {
             const withHeader = Buffer.concat([PNG_HEADER, pngBuf]);
-            const chunksRaw = extract(withHeader);
-            chunks = chunksRaw.map((c) => ({
-                name: c.name,
-                data: Buffer.isBuffer(c.data)
-                    ? c.data
-                    : Buffer.from(c.data),
-            }));
+            if (native?.extractPngChunks) {
+                const chunksRaw = native.extractPngChunks(withHeader);
+                chunks = chunksRaw.map((c) => ({
+                    name: c.name,
+                    data: Buffer.from(c.data),
+                }));
+            }
+            else {
+                throw new Error('Native PNG chunk extraction not available');
+            }
         }
         catch (e2) {
             chunks = [];
@@ -274,28 +247,21 @@ export async function decodePngToBinary(input, opts = {}) {
         return { buf: payload, meta: { name } };
     }
     try {
-        const metadata = await sharp(processedBuf).metadata();
+        const metadata = native.sharpMetadata(processedBuf);
         const currentWidth = metadata.width;
         const currentHeight = metadata.height;
         let rawRGB = Buffer.alloc(0);
         let isBlockEncoded = false;
         if (currentWidth % 2 === 0 && currentHeight % 2 === 0) {
-            const { data: testData } = await sharp(processedBuf)
-                .extract({
-                left: 0,
-                top: 0,
-                width: Math.min(4, currentWidth),
-                height: Math.min(4, currentHeight),
-            })
-                .raw()
-                .toBuffer({ resolveWithObject: true });
+            const rawData = native.sharpToRaw(processedBuf);
+            const testData = rawData.pixels;
             let hasBlockPattern = true;
             for (let y = 0; y < Math.min(2, currentHeight / 2); y++) {
                 for (let x = 0; x < Math.min(2, currentWidth / 2); x++) {
-                    const px00 = (y * 2 * Math.min(4, currentWidth) + x * 2) * 3;
-                    const px01 = (y * 2 * Math.min(4, currentWidth) + (x * 2 + 1)) * 3;
-                    const px10 = ((y * 2 + 1) * Math.min(4, currentWidth) + x * 2) * 3;
-                    const px11 = ((y * 2 + 1) * Math.min(4, currentWidth) + (x * 2 + 1)) * 3;
+                    const px00 = (y * 2 * currentWidth + x * 2) * 3;
+                    const px01 = (y * 2 * currentWidth + (x * 2 + 1)) * 3;
+                    const px10 = ((y * 2 + 1) * currentWidth + x * 2) * 3;
+                    const px11 = ((y * 2 + 1) * currentWidth + (x * 2 + 1)) * 3;
                     if (testData[px00] !== testData[px01] ||
                         testData[px00] !== testData[px10] ||
                         testData[px00] !== testData[px11] ||
@@ -314,56 +280,28 @@ export async function decodePngToBinary(input, opts = {}) {
                 const blocksWide = currentWidth / 2;
                 const blocksHigh = currentHeight / 2;
                 rawRGB = Buffer.alloc(blocksWide * blocksHigh * 3);
+                const fullRaw = native.sharpToRaw(processedBuf);
+                const fullData = fullRaw.pixels;
                 let outIdx = 0;
                 for (let by = 0; by < blocksHigh; by++) {
                     for (let bx = 0; bx < blocksWide; bx++) {
-                        const { data: blockData } = await sharp(processedBuf)
-                            .extract({ left: bx * 2, top: by * 2, width: 1, height: 1 })
-                            .raw()
-                            .toBuffer({ resolveWithObject: true });
-                        rawRGB[outIdx++] = blockData[0];
-                        rawRGB[outIdx++] = blockData[1];
-                        rawRGB[outIdx++] = blockData[2];
+                        const pixelOffset = (by * 2 * currentWidth + bx * 2) * 3;
+                        rawRGB[outIdx++] = fullData[pixelOffset];
+                        rawRGB[outIdx++] = fullData[pixelOffset + 1];
+                        rawRGB[outIdx++] = fullData[pixelOffset + 2];
                     }
                 }
             }
         }
         if (!isBlockEncoded) {
-            rawRGB = Buffer.allocUnsafe(currentWidth * currentHeight * 3);
-            let writeOffset = 0;
-            const rowsPerChunk = 2000;
-            for (let startRow = 0; startRow < currentHeight; startRow += rowsPerChunk) {
-                const endRow = Math.min(startRow + rowsPerChunk, currentHeight);
-                const chunkHeight = endRow - startRow;
-                const { data: chunkData, info: chunkInfo } = await sharp(processedBuf)
-                    .extract({
-                    left: 0,
-                    top: startRow,
-                    width: currentWidth,
-                    height: chunkHeight,
-                })
-                    .raw()
-                    .toBuffer({ resolveWithObject: true });
-                const channels = chunkInfo.channels;
-                const pixelsInChunk = currentWidth * chunkHeight;
-                if (channels === 3) {
-                    chunkData.copy(rawRGB, writeOffset);
-                    writeOffset += pixelsInChunk * 3;
-                }
-                else if (channels === 4) {
-                    for (let i = 0; i < pixelsInChunk; i++) {
-                        rawRGB[writeOffset++] = chunkData[i * 4];
-                        rawRGB[writeOffset++] = chunkData[i * 4 + 1];
-                        rawRGB[writeOffset++] = chunkData[i * 4 + 2];
-                    }
-                }
-                if (opts.onProgress) {
-                    opts.onProgress({
-                        phase: 'extract_pixels',
-                        loaded: endRow,
-                        total: currentHeight,
-                    });
-                }
+            const rawData = native.sharpToRaw(processedBuf);
+            rawRGB = Buffer.from(rawData.pixels);
+            if (opts.onProgress) {
+                opts.onProgress({
+                    phase: 'extract_pixels',
+                    loaded: currentHeight,
+                    total: currentHeight,
+                });
             }
         }
         const firstPixels = [];
@@ -410,22 +348,10 @@ export async function decodePngToBinary(input, opts = {}) {
         }
         else {
             const reconstructed = await cropAndReconstitute(processedBuf, opts.debugDir);
-            const { data: rdata, info: rinfo } = await sharp(reconstructed)
-                .raw()
-                .toBuffer({ resolveWithObject: true });
-            logicalWidth = rinfo.width;
-            logicalHeight = rinfo.height;
-            logicalData = Buffer.alloc(rinfo.width * rinfo.height * 3);
-            if (rinfo.channels === 3) {
-                rdata.copy(logicalData);
-            }
-            else if (rinfo.channels === 4) {
-                for (let i = 0; i < logicalWidth * logicalHeight; i++) {
-                    logicalData[i * 3] = rdata[i * 4];
-                    logicalData[i * 3 + 1] = rdata[i * 4 + 1];
-                    logicalData[i * 3 + 2] = rdata[i * 4 + 2];
-                }
-            }
+            const rawData = native.sharpToRaw(reconstructed);
+            logicalWidth = rawData.width;
+            logicalHeight = rawData.height;
+            logicalData = Buffer.from(rawData.pixels);
         }
         if (process.env.ROX_DEBUG) {
             console.log('DEBUG: Logical grid reconstructed:', logicalWidth, 'x', logicalHeight, '=', logicalWidth * logicalHeight, 'pixels');

package/dist/utils/encoder.d.ts

@@ -1,4 +1,2 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { EncodeOptions } from './types.js';
 export declare function encodeBinaryToPng(input: Buffer | Buffer[], opts?: EncodeOptions): Promise<Buffer>;

package/dist/utils/encoder.js

@@ -1,20 +1,19 @@
-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, PIXEL_MAGIC_BLOCK, PNG_HEADER, } from './constants.js';
 import { crc32 } from './crc.js';
 import { colorsToBytes } from './helpers.js';
-import { optimizePngBuffer } from './optimization.js';
+import { native } from './native.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' });
+        progressBar = {
+            start: () => { },
+            update: () => { },
+            stop: () => { },
+        };
         const startTime = Date.now();
         if (!opts.onProgress) {
             opts.onProgress = (info) => {
@@ -34,10 +33,6 @@ export async function encodeBinaryToPng(input, opts = {}) {
                 else if (info.phase === 'done') {
                     pct = 100;
                 }
-                progressBar.update(Math.floor(pct), {
-                    step: info.phase.replace('_', ' '),
-                    elapsed: String(Math.floor((Date.now() - startTime) / 1000)),
-                });
             };
         }
     }
@@ -220,7 +215,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
             lenBuf.writeUInt32BE(jsonBuf.length, 0);
             metaPixel = [...metaPixel, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf];
         }
-        const useBlockEncoding = opts.useBlockEncoding ?? true;
+        const useBlockEncoding = false;
         const pixelMagic = useBlockEncoding ? PIXEL_MAGIC_BLOCK : PIXEL_MAGIC;
         const dataWithoutMarkers = [pixelMagic, ...metaPixel];
         const dataWithoutMarkersLen = dataWithoutMarkers.reduce((a, b) => a + b.length, 0);
@@ -261,15 +256,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
                     }
                 }
             }
-            bufScr = await sharp(rgbBuffer, {
-                raw: { width, height, channels: 3 },
-            })
-                .png({
-                compressionLevel: 9,
-                adaptiveFiltering: true,
-                effort: 9,
-            })
-                .toBuffer();
+            bufScr = Buffer.from(native.rgbToPng(rgbBuffer, width, height));
         }
         else {
             const bytesPerPixel = 3;
@@ -394,27 +381,10 @@ export async function encodeBinaryToPng(input, opts = {}) {
             else {
                 const outputFormat = opts.outputFormat || 'png';
                 if (outputFormat === 'webp') {
-                    bufScr = await sharp(raw, {
-                        raw: { width, height, channels: 3 },
-                    })
-                        .webp({
-                        lossless: true,
-                        quality: 100,
-                        effort: 6,
-                    })
-                        .toBuffer();
+                    throw new Error('WebP output format not supported with native backend');
                 }
                 else {
-                    bufScr = await sharp(raw, {
-                        raw: { width, height, channels: 3 },
-                    })
-                        .png({
-                        compressionLevel: 3,
-                        palette: false,
-                        effort: 1,
-                        adaptiveFiltering: false,
-                    })
-                        .toBuffer();
+                    bufScr = Buffer.from(native.rgbToPng(raw, width, height));
                 }
             }
         }
@@ -426,22 +396,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
         dataWithoutMarkers.length = 0;
         if (opts.onProgress)
             opts.onProgress({ phase: 'png_compress', loaded: 100, total: 100 });
-        if (opts.skipOptimization || opts.outputFormat === 'webp') {
-            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;
-        }
+        progressBar?.stop();
+        return bufScr;
     }
 }

package/dist/utils/helpers.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export declare function colorsToBytes(colors: Array<{
     r: number;
     g: number;