@e-mc/compress 0.11.7 → 0.12.0

package/README.md

@@ -1,7 +1,7 @@
 # @e-mc/compress
 
-* NodeJS 16 LTS
-* ES2021
+* NodeJS 18
+* ES2022
 
 ## General Usage
 
@@ -9,16 +9,16 @@
 
 ## Interface
 
-* [View Source](https://www.unpkg.com/@e-mc/types@0.11.7/lib/index.d.ts)
+* [View Source](https://www.unpkg.com/@e-mc/types@0.12.0/lib/index.d.ts)
 
 ```typescript
 import type { IModule, ModuleConstructor } from "./index";
-import type { BufferResult, CompressFormat, CompressLevel, ReadableOptions, TryFileCompressor } from "./compress";
+import type { BrotliCompressLevel, BufferResult, CompressFormat, CompressLevel, ReadableOptions, TryFileCompressor } from "./compress";
 import type { CompressModule, CompressSettings } from "./settings";
 
 import type { WriteStream } from "node:fs";
 import type { Readable } from "node:stream";
-import type { BrotliCompress, Gzip } from "node:zlib";
+import type { BrotliCompress, BrotliOptions, Gzip, ZlibOptions } from "node:zlib";
 
 interface ICompress extends IModule {
     module: CompressModule;
@@ -30,15 +30,18 @@ interface ICompress extends IModule {
     getLevel(value: string, fallback?: number): number | undefined;
     getReadable(file: string | URL | Buffer, options?: ReadableOptions): Readable;
     createGzip(file: string | Buffer, options?: CompressLevel): Gzip;
-    createBrotliCompress(file: string | Buffer, options?: CompressLevel): BrotliCompress;
+    createBrotliCompress(file: string | Buffer, options?: BrotliCompressLevel): BrotliCompress;
     createWriteStreamAsGzip(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
     createWriteStreamAsBrotli(file: string | Buffer, output: string, options?: CompressLevel): WriteStream;
+    intoGzipStream(output: string, options?: ZlibOptions): WriteStream;
+    intoBrotliStream(output: string, options?: BrotliOptions): WriteStream;
     writeGzip(file: string | Buffer, output: string, options?: CompressLevel): Promise<void>;
     writeBrotli(file: string | Buffer, output: string, options?: CompressLevel): Promise<void>;
     tryFile(file: string | Buffer, options: CompressFormat): Promise<BufferResult>;
     tryFile(file: string | Buffer, output: string, options?: CompressFormat): Promise<BufferResult>;
     tryImage(file: string, options: CompressFormat): Promise<BufferResult>;
     tryImage(file: string | Buffer, output: string, options?: CompressFormat): Promise<BufferResult>;
+    hasPermission(type: string, options?: unknown): boolean;
     set chunkSize(value: number | string | undefined): void;
     get chunkSize(): number | undefined;
     get settings(): CompressSettings;
@@ -46,6 +49,7 @@ interface ICompress extends IModule {
 
 interface CompressConstructor extends ModuleConstructor {
     singleton(): ICompress;
+    asBuffer(data: Buffer | Uint8Array): Buffer;
     readonly prototype: ICompress;
     new(module?: CompressModule): ICompress;
 }
@@ -116,9 +120,9 @@ instance.tryImage("/tmp/image.png", "/path/output/compressed.png", options)
 
 ## References
 
-- https://www.unpkg.com/@e-mc/types@0.11.7/lib/squared.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.7/lib/compress.d.ts
-- https://www.unpkg.com/@e-mc/types@0.11.7/lib/settings.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.0/lib/squared.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.0/lib/compress.d.ts
+- https://www.unpkg.com/@e-mc/types@0.12.0/lib/settings.d.ts
 
 * https://www.npmjs.com/package/@types/node
 

package/index.js

@@ -1,14 +1,17 @@
 "use strict";
-var _a;
 const path = require("node:path");
 const fs = require("node:fs");
 const stream = require("node:stream");
 const zlib = require("node:zlib");
 const wawoff2 = require("wawoff2");
 const types_1 = require("@e-mc/types");
-const module_1 = require("@e-mc/module");
+const core_1 = require("@e-mc/core");
 const { toSfnt, toWoff } = require('woff2sfnt-sfnt2woff');
-const kChunkSize = Symbol('chunkSize');
+const kCompress = Symbol.for('compress:constructor');
+function createWorker(filename) {
+    return core_1.WorkerChannel.create(path.join(__dirname, 'worker', filename), 'EMC_COMPRESS');
+}
+const SUPPORTED_NODE21 = (0, types_1.supported)(21);
 const CACHE_IMAGE = {};
 const CACHE_FONT = Object.create(null);
 const CACHE_FONTFROM = {};
@@ -16,14 +19,15 @@ const CACHE_FONTTO = {};
 const CACHE_INIT = [false, false];
 let SINGLETON_INSTANCE;
 let TEMP_DIR = '';
-const GZIP_ZOPFLI = (function () {
-    try {
-        return require('node-zopfli');
-    }
-    catch {
-        return null;
-    }
-})();
+const WORKER = new core_1.WorkerGroup(parseInt(process.env.EMC_COMPRESS_WORKER_GROUP_MAX || '0'));
+WORKER
+    .add('otf', createWorker('sfnt2woff.js'))
+    .add('woff', createWorker('woff2sfnt.js'))
+    .add('woff2', createWorker('wawoff2-decompress.js'))
+    .add('ttf', createWorker('wawoff2-compress.js'))
+    .add('image', createWorker('plugin-image.js'))
+    .add('gz', createWorker('system-gzip.js'))
+    .add('br', createWorker('system-brotli.js'));
 function setCacheData(instance, index) {
     if (CACHE_INIT[index]) {
         return true;
@@ -34,7 +38,7 @@ function setCacheData(instance, index) {
     if (TEMP_DIR) {
         if (expires === 0) {
             if (CACHE_INIT.every(value => !value)) {
-                module_1.removeDir(TEMP_DIR, true);
+                core_1.Module.removeDir(TEMP_DIR, true);
             }
             settings.cache_expires = 0;
         }
@@ -79,15 +83,19 @@ function setCacheData(instance, index) {
     }
     return CACHE_INIT[index] = true;
 }
-function getOutputSize(startLength, data) {
+function getOutputSize(startLength, data, worker) {
     if (startLength === 0 || !data) {
-        return '';
+        return worker ? ' (worker)' : '';
     }
     const offset = Buffer.byteLength(data) - startLength;
-    return ` (${(offset > 0 ? '+' : '') + (0, types_1.formatSize)(offset)})`;
+    return ` (${(worker ? 'worker: ' : '') + (offset > 0 ? '+' : '') + (0, types_1.formatSize)(offset)})`;
 }
 const sanitizePath = (value) => value.replace(/[\\/]/g, '_');
-class Compress extends module_1 {
+const getWorkerTimeout = (options, value) => core_1.WorkerGroup.checkTimeout(typeof options.worker === 'number' && options.worker > 0 ? options.worker : value, true);
+const applyBrotliMode = (params, value) => params[zlib.constants.BROTLI_PARAM_MODE] = value.includes('text/') ? zlib.constants.BROTLI_MODE_TEXT : value.includes('font/') ? zlib.constants.BROTLI_MODE_FONT : zlib.constants.BROTLI_MODE_GENERIC;
+class Compress extends core_1.Module {
+    module;
+    static [kCompress] = true;
     static singleton() {
         if (!SINGLETON_INSTANCE) {
             SINGLETON_INSTANCE = new Compress();
@@ -99,17 +107,20 @@ class Compress extends module_1 {
         }
         return SINGLETON_INSTANCE;
     }
+    static asBuffer(data) {
+        return data instanceof Uint8Array ? Buffer.from(data.buffer, data.byteOffset, data.byteLength) : data;
+    }
+    level = {
+        gz: 9,
+        br: 11,
+        zopfli: 15
+    };
+    compressors = {};
+    _moduleName = 'compress';
+    #chunkSize = undefined;
     constructor(module = {}) {
         super();
         this.module = module;
-        this.level = {
-            gz: 9,
-            br: 11,
-            zopfli: 15
-        };
-        this.compressors = {};
-        this._moduleName = 'compress';
-        this[_a] = undefined;
     }
     init(...args) {
         let { gzip_level, brotli_quality, zopfli_iterations, chunk_size } = (0, types_1.isPlainObject)(args[0]) && args[0].settings || this.settings;
@@ -153,14 +164,14 @@ class Compress extends module_1 {
             return stream.Readable.from(file);
         }
         try {
-            if (!options?.throwsPermission || this.canRead(file, { ownPermissionOnly: true })) {
+            if (!options?.throwsPermission && !process.permission || this.canRead(file, { ownPermissionOnly: true })) {
                 return fs.createReadStream(file);
             }
             options = undefined;
             throw (0, types_1.errorValue)("Operation not permitted", file.toString());
         }
         catch (err) {
-            if (!options || options.throwsPermission && module_1.isErrorCode(err, 'EACCES') || options.throwsDoesNotExist && module_1.isErrorCode(err, 'ENOENT')) {
+            if (!options || options.throwsPermission && core_1.Module.isErrorCode(err, 'EACCES') || options.throwsDoesNotExist && core_1.Module.isErrorCode(err, 'ENOENT')) {
                 throw err;
             }
         }
@@ -172,15 +183,18 @@ class Compress extends module_1 {
             ({ algorithm, level, chunkSize } = options);
         }
         if (algorithm === 'zopfli') {
-            if (GZIP_ZOPFLI) {
-                const zopfli = (0, types_1.isPlainObject)(this.module.zopfli) ? { ...this.module.zopfli } : {};
+            try {
+                const lib = require('node-zopfli');
+                const opts = (0, types_1.isPlainObject)(this.module.zopfli) ? { ...this.module.zopfli } : {};
                 if (typeof level === 'number') {
-                    zopfli.numiterations = level;
+                    opts.numiterations = level;
                 }
                 else {
-                    zopfli.numiterations ??= this.level.zopfli;
+                    opts.numiterations ??= this.level.zopfli;
                 }
-                return this.getReadable(file, options).pipe(GZIP_ZOPFLI.createGzip(zopfli));
+                return this.getReadable(file, options).pipe(lib.createGzip(opts));
+            }
+            catch {
             }
             level = undefined;
         }
@@ -213,7 +227,7 @@ class Compress extends module_1 {
         else {
             brotli = { params };
         }
-        params[zlib.constants.BROTLI_PARAM_MODE] = (mimeType ||= '').includes('text/') ? zlib.constants.BROTLI_MODE_TEXT : mimeType.includes('font/') ? zlib.constants.BROTLI_MODE_FONT : zlib.constants.BROTLI_MODE_GENERIC;
+        applyBrotliMode(params, mimeType || '');
         try {
             params[zlib.constants.BROTLI_PARAM_SIZE_HINT] = typeof file === 'string' ? fs.statSync(file).size : Buffer.byteLength(file);
         }
@@ -233,6 +247,12 @@ class Compress extends module_1 {
     createWriteStreamAsBrotli(file, output, options) {
         return this.createBrotliCompress(file, options).pipe(fs.createWriteStream(output));
     }
+    intoGzipStream(output, options) {
+        return zlib.createGzip(options).pipe(fs.createWriteStream(output));
+    }
+    intoBrotliStream(output, options) {
+        return zlib.createBrotliCompress(options).pipe(fs.createWriteStream(output));
+    }
     async writeGzip(file, output, options) {
         return new Promise((resolve, reject) => {
             this.createWriteStreamAsGzip(file, output, options)
@@ -255,26 +275,34 @@ class Compress extends module_1 {
         if (!(0, types_1.isString)(output)) {
             output = typeof file === 'string' ? file : '';
         }
+        if (output && !this.canWrite(output, { ownPermissionOnly: true })) {
+            return Promise.reject((0, types_1.errorValue)("Operation not permitted", output));
+        }
         options ||= {};
-        const { filename, startTime = process.hrtime.bigint(), timeout = 0, sessionId, broadcastId } = options;
+        const { filename, startTime = process.hrtime.bigint(), timeout = 0 } = options;
         let format = options.format, hash = options.etag;
-        if (!format) {
+        if (!(0, types_1.isString)(format)) {
             return Promise.reject((0, types_1.errorValue)("Missing option \"format\"", output || filename));
         }
-        const cache = this.settings.cache ? !!(hash && (hash = module_1.asHash(hash)) || Buffer.isBuffer(file) && (hash = module_1.asHash(file))) : false;
+        const cache = this.settings.cache ? !!(hash && (hash = core_1.Module.asHash(hash)) || Buffer.isBuffer(file) && (hash = core_1.Module.asHash(file))) : false;
+        format = format.toLowerCase();
         return new Promise((resolve, reject) => {
-            let timer = null, startLength = 0, aborted = false;
+            let timer = null, worker = null, startLength = 0, closed = false;
             const endProcess = (err, data = null, ext, result, fromCache) => {
+                if (closed) {
+                    return;
+                }
                 if (timer) {
                     clearTimeout(timer);
                 }
+                closed = true;
                 if (err) {
                     reject(err);
                     return;
                 }
                 if (!fromCache) {
                     const status = (0, types_1.isString)(result) ? path.basename(result) : filename || "Completed";
-                    this.writeTimeProcess(ext || format, status + getOutputSize(startLength, data), startTime, { type: 8, sessionId, broadcastId });
+                    this.writeTimeProcess(ext || format, status + getOutputSize(startLength, data, !!worker), startTime, { type: 8, sessionId: options.sessionId, broadcastId: options.broadcastId });
                 }
                 if (result) {
                     options.outFile = result;
@@ -287,14 +315,19 @@ class Compress extends module_1 {
             const startProcess = (compressing) => {
                 if (timeout > 0) {
                     timer = setTimeout(() => {
-                        aborted = true;
-                        endProcess((0, types_1.errorValue)("Timeout was exceeded", format));
-                    }, timeout);
+                        if (worker) {
+                            void worker.terminate();
+                        }
+                        endProcess((0, types_1.errorValue)(worker ? "Worker did not finish" : "Timeout was exceeded", format));
+                    }, worker ? getWorkerTimeout(options, timeout) : timeout);
                 }
-                this.formatMessage(8, format, [compressing ? 'Compressing file...' : 'Decompressing file...', filename || (output ? path.basename(output) : '')], (0, types_1.isString)(file) ? file : '', { titleColor: 'magenta', sessionId, broadcastId });
+                this.formatMessage(8, format, [compressing ? 'Compressing file...' : 'Decompressing file...', filename || (output ? path.basename(output) : '')], (0, types_1.isString)(file) ? file : '', { titleColor: 'magenta', sessionId: options.sessionId, broadcastId: options.broadcastId });
             };
             try {
                 const writeFont = (data, ext, from) => {
+                    if (closed) {
+                        return;
+                    }
                     if (output) {
                         const pathname = (0, types_1.renameExt)(output, ext);
                         fs.writeFile(pathname, data, err => {
@@ -312,7 +345,7 @@ class Compress extends module_1 {
                     if (cache) {
                         const pathname = path.join(from, ext);
                         let tempFont;
-                        if (TEMP_DIR && module_1.createDir(tempFont = path.join(TEMP_DIR, pathname))) {
+                        if (TEMP_DIR && core_1.Module.createDir(tempFont = path.join(TEMP_DIR, pathname))) {
                             tempFont = path.join(tempFont, hash);
                         }
                         else {
@@ -332,7 +365,7 @@ class Compress extends module_1 {
                         const cacheKey = from + `_${to}_` + hash;
                         const tempFont = CACHE_FONT[cacheKey];
                         if (tempFont) {
-                            if (module_1.isPath(tempFont[0])) {
+                            if (core_1.Module.isPath(tempFont[0])) {
                                 try {
                                     const data = fs.readFileSync(tempFont[0]);
                                     let pathname;
@@ -343,7 +376,7 @@ class Compress extends module_1 {
                                     else {
                                         endProcess(null, data, to, '', true);
                                     }
-                                    this.formatMessage(8, from, [pathname ? path.basename(pathname) : "Completed" + ` -> font/${to}`, 'cache'], tempFont[1].toLocaleString(), { ...module_1.LOG_STYLE_NOTICE, hintBold: true, sessionId, broadcastId });
+                                    this.formatMessage(8, from, [pathname ? path.basename(pathname) : "Completed" + ` -> font/${to}`, 'cache'], tempFont[1].toLocaleString(), { ...core_1.Module.LOG_STYLE_NOTICE, hintBold: true, sessionId: options.sessionId, broadcastId: options.broadcastId });
                                     return true;
                                 }
                                 catch {
@@ -354,14 +387,50 @@ class Compress extends module_1 {
                         return false;
                     }
                 };
-                const errorResponse = (font) => {
-                    endProcess((0, types_1.errorValue)("Unsupported MIME", (font?.mime || "Unknown") + ': ' + (output || filename || "Unknown")));
+                const errorResponse = (font, message = "Unsupported MIME") => {
+                    endProcess((0, types_1.errorValue)(message, (font?.mime || "Unknown") + ': ' + (output || filename || "Unknown")));
                 };
-                const data = Buffer.isBuffer(file) ? file : fs.readFileSync(file);
+                const shared = Buffer.isBuffer(file);
+                let data;
+                if (shared) {
+                    data = file;
+                }
+                else if (this.canRead(file, { ownPermissionOnly: true })) {
+                    data = fs.readFileSync(file);
+                }
+                else {
+                    reject((0, types_1.errorValue)("Operation not permitted", file));
+                    return;
+                }
                 startLength = Buffer.byteLength(data);
-                switch (format = format.toLowerCase()) {
+                switch (format) {
                     case 'gz':
                     case 'br': {
+                        if (this.hasPermission('worker', options)) {
+                            const workerOptions = { chunkSize: options.chunkSize ?? this.chunkSize };
+                            if (format === 'gz') {
+                                workerOptions.level = options.level ?? this.level.gz;
+                            }
+                            else {
+                                workerOptions.params = { [zlib.constants.BROTLI_PARAM_QUALITY]: options.level ?? this.level.br };
+                                applyBrotliMode(workerOptions.params, options.mimeType || '');
+                            }
+                            const endWorker = (result) => {
+                                if ((0, types_1.isString)(result)) {
+                                    endProcess(null, null, format, result);
+                                }
+                                else if (result) {
+                                    endProcess(null, result, format);
+                                }
+                                else {
+                                    endProcess((0, types_1.errorValue)("Worker did not finish", output));
+                                }
+                            };
+                            if (worker = WORKER.get(format).sendObject({ data, options: workerOptions, output }, shared || SUPPORTED_NODE21 ? [] : [data.buffer], endWorker)) {
+                                startProcess(true);
+                                break;
+                            }
+                        }
                         startProcess(true);
                         let transform, chunks;
                         if (output) {
@@ -376,12 +445,10 @@ class Compress extends module_1 {
                         }
                         transform
                             .on('finish', () => {
-                            if (!aborted) {
-                                endProcess(null, chunks && Buffer.concat(chunks), format, output);
-                            }
+                            endProcess(null, chunks && Buffer.concat(chunks), format, output);
                         })
                             .on('error', (err) => {
-                            aborted = true;
+                            transform.destroy();
                             endProcess(err);
                         });
                         break;
@@ -391,36 +458,52 @@ class Compress extends module_1 {
                         if (hasFont()) {
                             return;
                         }
-                        startProcess(false);
                         const checkResult = (result, from) => {
-                            void module_1.resolveMime(result).then(font => {
-                                switch (font?.mime) {
-                                    case "font/ttf":
-                                    case "font/otf":
-                                        writeFont(result, font.ext, from);
-                                        break;
-                                    default:
-                                        errorResponse(font);
-                                        break;
-                                }
-                            });
+                            if (result) {
+                                void core_1.Module.resolveMime(result).then(font => {
+                                    switch (font?.mime) {
+                                        case "font/ttf":
+                                        case "font/otf":
+                                            writeFont(result, font.ext, from);
+                                            break;
+                                        default:
+                                            errorResponse(font);
+                                            break;
+                                    }
+                                });
+                            }
+                            else {
+                                errorResponse(null, "Worker did not finish");
+                            }
                         };
-                        void module_1.resolveMime(data)
+                        void core_1.Module.resolveMime(data)
                             .then(font => {
                             switch (font?.mime) {
                                 case "font/woff":
                                     if (cache) {
                                         CACHE_FONTFROM[hash] = 'woff';
                                     }
-                                    checkResult(toSfnt(data), 'woff');
+                                    if (this.hasPermission('worker', options) && (worker = WORKER.get('woff').sendBuffer(data, shared, checkResult, 'woff'))) {
+                                        startProcess(false);
+                                    }
+                                    else {
+                                        startProcess(false);
+                                        checkResult(toSfnt(data), 'woff');
+                                    }
                                     break;
                                 case "font/woff2":
                                     if (cache) {
                                         CACHE_FONTFROM[hash] = 'woff2';
                                     }
-                                    void wawoff2.decompress(data).then(woff => {
-                                        checkResult(woff, 'woff2');
-                                    });
+                                    if (this.hasPermission('worker', options) && (worker = WORKER.get('woff2').sendBuffer(data, shared, checkResult, 'woff2'))) {
+                                        startProcess(false);
+                                    }
+                                    else {
+                                        startProcess(false);
+                                        void wawoff2.decompress(data).then(woff => {
+                                            checkResult(woff, 'woff2');
+                                        });
+                                    }
                                     break;
                                 default:
                                     errorResponse(font);
@@ -435,33 +518,50 @@ class Compress extends module_1 {
                         if (hasFont()) {
                             return;
                         }
-                        const checkResult = (result, mimeType, from) => {
-                            void module_1.resolveMime(result).then(font => {
-                                if (font?.mime === mimeType) {
-                                    writeFont(result, font.ext, from);
-                                }
-                                else {
-                                    errorResponse(font);
-                                }
-                            });
+                        const checkResult = (result, from, mimeType) => {
+                            if (result) {
+                                void core_1.Module.resolveMime(result).then(font => {
+                                    if (font?.mime === mimeType) {
+                                        writeFont(result, font.ext, from);
+                                    }
+                                    else {
+                                        errorResponse(font);
+                                    }
+                                });
+                            }
+                            else {
+                                errorResponse(null, "Worker did not finish");
+                            }
                         };
                         startProcess(true);
-                        void module_1.resolveMime(data)
+                        void core_1.Module.resolveMime(data)
                             .then(font => {
                             switch (font?.mime) {
                                 case "font/ttf":
                                     if (cache) {
                                         CACHE_FONTFROM[hash] = 'ttf';
                                     }
-                                    void wawoff2.compress(data).then(result => {
-                                        checkResult(result, "font/woff2", 'ttf');
-                                    });
+                                    if (this.hasPermission('worker', options) && (worker = WORKER.get('ttf').sendBuffer(data, shared, checkResult, 'ttf', "font/woff2"))) {
+                                        startProcess(false);
+                                    }
+                                    else {
+                                        startProcess(false);
+                                        void wawoff2.compress(data).then(result => {
+                                            checkResult(result, 'ttf', "font/woff2");
+                                        });
+                                    }
                                     break;
                                 case "font/otf":
                                     if (cache) {
                                         CACHE_FONTFROM[hash] = 'otf';
                                     }
-                                    checkResult(toWoff(data), "font/woff", 'otf');
+                                    if (this.hasPermission('worker', options) && (worker = WORKER.get('otf').sendBuffer(data, shared, checkResult, 'otf', "font/woff"))) {
+                                        startProcess(false);
+                                    }
+                                    else {
+                                        startProcess(false);
+                                        checkResult(toWoff(data), 'otf', "font/woff");
+                                    }
                                     break;
                                 default:
                                     errorResponse(font);
@@ -472,13 +572,13 @@ class Compress extends module_1 {
                         break;
                     }
                     default: {
-                        const compressor = this.compressors[format]?.bind(this);
+                        const compressor = this.compressors[format];
                         if (typeof compressor !== 'function') {
                             throw (0, types_1.errorValue)("Missing compression plugin", format);
                         }
                         startProcess(true);
                         if (compressor.toString().startsWith('async')) {
-                            compressor.call(this, file, output, options)
+                            compressor.call(this, data, output, options)
                                 .then(result => {
                                 if (typeof result === 'string') {
                                     endProcess(null, null, format, result);
@@ -490,7 +590,7 @@ class Compress extends module_1 {
                                 .catch(endProcess);
                         }
                         else {
-                            void compressor.call(this, file, output, options, endProcess);
+                            void compressor.call(this, data, output, options, endProcess);
                         }
                         break;
                     }
@@ -509,7 +609,13 @@ class Compress extends module_1 {
         else {
             options ||= {};
         }
-        const { filename, startTime = process.hrtime.bigint(), timeout = 0, sessionId, broadcastId } = options;
+        const { filename, startTime = process.hrtime.bigint(), timeout = 0 } = options;
+        if (!(0, types_1.isString)(output)) {
+            output = typeof file === 'string' ? file : '';
+        }
+        if (output && !this.canWrite(output, { ownPermissionOnly: true })) {
+            return Promise.reject((0, types_1.errorValue)("Operation not permitted", output));
+        }
         let plugin = options.plugin;
         if ((0, types_1.isString)(plugin)) {
             if (types_1.IMPORT_MAP[plugin]) {
@@ -517,18 +623,16 @@ class Compress extends module_1 {
             }
         }
         else {
-            return Promise.reject();
-        }
-        if (!(0, types_1.isString)(output)) {
-            output = typeof file === 'string' ? file : '';
+            return Promise.reject((0, types_1.errorValue)("Missing compression plugin", output));
         }
         const ext = output ? path.extname(output).substring(1) : options.format || "Unknown";
         const getFormat = () => output ? path.basename(output) : ext;
-        let data;
+        let data, shared = false;
         if (Buffer.isBuffer(file)) {
             data = file;
+            shared = true;
         }
-        else {
+        else if (this.canRead(file, { ownPermissionOnly: true })) {
             try {
                 data = fs.readFileSync(file);
             }
@@ -536,23 +640,26 @@ class Compress extends module_1 {
                 return Promise.reject(err);
             }
         }
+        else {
+            return Promise.reject((0, types_1.errorValue)("Operation not permitted", file));
+        }
         if (!options.mimeType) {
-            const out = await module_1.resolveMime(data);
+            const out = await core_1.Module.resolveMime(data);
             if (out) {
                 options.mimeType = out.mime;
             }
         }
         const startLength = Buffer.byteLength(data);
         return new Promise(async (resolve, reject) => {
-            let timer = null, hash, cacheKey, aborted = false;
+            let timer = null, hash, cacheKey, closed = false;
             const failed = (err) => {
-                aborted = true;
                 if (timer) {
                     clearTimeout(timer);
                 }
+                closed = true;
                 reject(err);
             };
-            const complete = (err, result, ctime) => {
+            const complete = (err, result, worker, ctime) => {
                 if (err) {
                     reject(err);
                     return;
@@ -560,14 +667,14 @@ class Compress extends module_1 {
                 const value = output ? path.basename(output) : filename || (0, types_1.isString)(file) && path.basename(file);
                 const status = value ? plugin + ': ' + value : "Completed";
                 if (ctime) {
-                    this.formatMessage(8, value ? path.extname(value).substring(1) : '', [status, 'cache'], ctime.toLocaleString(), { ...module_1.LOG_STYLE_NOTICE, hintBold: true, sessionId, broadcastId });
+                    this.formatMessage(8, value ? path.extname(value).substring(1) : '', [status, 'cache'], ctime.toLocaleString(), { ...core_1.Module.LOG_STYLE_NOTICE, hintBold: true, sessionId: options.sessionId, broadcastId: options.broadcastId });
                 }
                 else {
-                    this.writeTimeProcess(ext, status + getOutputSize(startLength, result), startTime, { type: 8, sessionId, broadcastId });
+                    this.writeTimeProcess(ext, status + getOutputSize(startLength, result, worker), startTime, { type: 8, sessionId: options.sessionId, broadcastId: options.broadcastId });
                 }
                 if (!ctime && hash && cacheKey && TEMP_DIR) {
                     const pathname = path.join(TEMP_DIR, sanitizePath(plugin), hash);
-                    if (module_1.createDir(pathname)) {
+                    if (core_1.Module.createDir(pathname)) {
                         fs.writeFile(path.join(pathname, cacheKey), result, error => {
                             if (!error) {
                                 ((CACHE_IMAGE[plugin] ||= {})[hash] ||= {})[cacheKey] = new Date();
@@ -577,8 +684,8 @@ class Compress extends module_1 {
                 }
                 resolve(result);
             };
-            const success = (result, ctime) => {
-                if (aborted) {
+            const success = (result, worker = false, ctime) => {
+                if (closed) {
                     return;
                 }
                 if (timer) {
@@ -586,22 +693,22 @@ class Compress extends module_1 {
                 }
                 if (output) {
                     fs.writeFile(output, result, err => {
-                        complete(err, result, ctime);
+                        complete(err, result, worker, ctime);
                     });
                 }
                 else {
-                    complete(null, result, ctime);
+                    complete(null, result, worker, ctime);
                 }
             };
             if (this.settings.cache && setCacheData(this, 1)) {
                 let stored;
                 try {
-                    hash = module_1.asHash(data);
+                    hash = core_1.Module.asHash(data);
                     stored = (CACHE_IMAGE[plugin] ||= {})[hash];
-                    cacheKey = plugin + ((0, types_1.isPlainObject)(options.options) ? ':' + module_1.asHash(module_1.asString(options.options), 'md5') : '');
+                    cacheKey = plugin + (options.options ? ':' + core_1.Module.asHash(core_1.Module.asString(options.options)) : '') + (options.metadata ? ':' + core_1.Module.asHash(core_1.Module.asString(options.metadata)) : '');
                     const ctime = stored?.[cacheKey];
                     if (ctime) {
-                        success(fs.readFileSync(path.join(TEMP_DIR, sanitizePath(plugin), hash, cacheKey)), ctime);
+                        success(fs.readFileSync(path.join(TEMP_DIR, sanitizePath(plugin), hash, cacheKey)), false, ctime);
                         return;
                     }
                 }
@@ -612,8 +719,40 @@ class Compress extends module_1 {
                     }
                 }
             }
-            this.formatMessage(8, ext, ['Compressing image...', plugin], filename || output, { titleColor: 'magenta', sessionId, broadcastId });
+            this.formatMessage(8, ext, ['Compressing image...', plugin], filename || output, { titleColor: 'magenta', sessionId: options.sessionId, broadcastId: options.broadcastId });
             try {
+                let worker = null;
+                const outData = (result) => {
+                    if (result && result !== data) {
+                        success(result, !!worker);
+                    }
+                    else {
+                        failed((0, types_1.errorMessage)(plugin, "Unsupported MIME", getFormat()));
+                    }
+                };
+                const startTimeout = (value, message) => {
+                    if (value > 0) {
+                        timer = setTimeout(() => {
+                            if (worker) {
+                                void worker.terminate();
+                            }
+                            failed((0, types_1.errorMessage)(plugin, message, options.mimeType));
+                        }, value);
+                    }
+                };
+                if (options.mimeType) {
+                    (options.metadata ||= {}).mimeType ||= options.mimeType;
+                }
+                if (this.hasPermission('worker', options)) {
+                    try {
+                        if (worker = WORKER.get('image').sendObject({ plugin, data, options: options.options, metadata: options.metadata }, shared || SUPPORTED_NODE21 ? [] : [data.buffer], outData)) {
+                            startTimeout(getWorkerTimeout(options, timeout), "Worker timeout was exceeded");
+                            return;
+                        }
+                    }
+                    catch {
+                    }
+                }
                 let transform;
                 try {
                     transform = await (0, types_1.importESM)(plugin, true);
@@ -621,35 +760,29 @@ class Compress extends module_1 {
                 catch {
                     transform = require(plugin);
                 }
-                const out = transform.call(this, options.options, options.mimeType);
-                if (timeout > 0) {
-                    timer = setTimeout(() => {
-                        failed((0, types_1.errorMessage)(plugin, "Timeout was exceeded"));
-                    }, timeout);
-                }
-                void out(data).then(result => {
-                    if (result !== data) {
-                        success(result);
-                    }
-                    else {
-                        failed((0, types_1.errorMessage)(plugin, "Unsupported MIME", getFormat()));
-                    }
-                });
+                startTimeout(timeout, "Timeout was exceeded");
+                const out = transform.call(this, options.options, options.metadata);
+                void out(data).then(outData);
             }
             catch (err) {
                 failed(err);
             }
         });
     }
+    hasPermission(type, options) {
+        if (super.hasPermission(type)) {
+            return type === 'worker' ? core_1.WorkerChannel.hasPermission(options) : true;
+        }
+        return false;
+    }
     set chunkSize(value) {
-        this[kChunkSize] = !isNaN(value = (0, types_1.alignSize)(value, 1)) ? value : undefined;
+        this.#chunkSize = !isNaN(value = (0, types_1.alignSize)(value, 1)) ? value : undefined;
     }
     get chunkSize() {
-        return this[kChunkSize];
+        return this.#chunkSize;
     }
     get settings() {
         return this.module.settings ||= {};
     }
 }
-_a = kChunkSize;
 module.exports = Compress;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/compress",
-  "version": "0.11.7",
+  "version": "0.12.0",
   "description": "Compress constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -23,8 +23,8 @@
   "license": "BSD-3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/module": "0.11.7",
-    "@e-mc/types": "0.11.7",
+    "@e-mc/core": "0.12.0",
+    "@e-mc/types": "0.12.0",
     "wawoff2": "^2.0.1",
     "woff2sfnt-sfnt2woff": "^1.0.0"
   }

package/worker/plugin-image.js

@@ -0,0 +1,34 @@
+"use strict";
+const node_worker_threads_1 = require("node:worker_threads");
+const types_1 = require("@e-mc/types");
+const index_1 = require("@e-mc/compress");
+const PORT = node_worker_threads_1.workerData[0];
+node_worker_threads_1.parentPort.on('message', async (value) => {
+    try {
+        const { plugin, data, options, metadata } = value;
+        let transform;
+        try {
+            transform = await (0, types_1.importESM)(plugin, true);
+        }
+        catch {
+            transform = require(plugin);
+        }
+        transform(options, metadata)(index_1.asBuffer(data))
+            .then(result => {
+            try {
+                PORT.postMessage(result, [result.buffer]);
+            }
+            catch {
+                PORT.postMessage(result);
+            }
+        })
+            .catch((err) => {
+            console.error(err);
+            PORT.postMessage(null);
+        });
+    }
+    catch (err) {
+        console.error(err);
+        PORT.postMessage(null);
+    }
+});

package/worker/sfnt2woff.js

@@ -0,0 +1,14 @@
+"use strict";
+const node_worker_threads_1 = require("node:worker_threads");
+const { toWoff } = require('woff2sfnt-sfnt2woff');
+const PORT = node_worker_threads_1.workerData[0];
+node_worker_threads_1.parentPort.on('message', (value) => {
+    try {
+        const data = toWoff(value);
+        PORT.postMessage(data, [data.buffer]);
+    }
+    catch (err) {
+        console.error(err);
+        PORT.postMessage(null);
+    }
+});

package/worker/system-brotli.js

@@ -0,0 +1,40 @@
+"use strict";
+const node_worker_threads_1 = require("node:worker_threads");
+const fs = require("node:fs");
+const stream = require("node:stream");
+const zlib = require("node:zlib");
+const index_1 = require("@e-mc/compress");
+const PORT = node_worker_threads_1.workerData[0];
+node_worker_threads_1.parentPort.on('message', async (value) => {
+    try {
+        const { data, options, output } = value;
+        const chunks = [];
+        let transform = stream.Readable.from(index_1.asBuffer(data)).pipe(zlib.createBrotliCompress(options));
+        if (output) {
+            transform = transform.pipe(fs.createWriteStream(output));
+        }
+        else {
+            transform.on('data', chunk => {
+                chunks.push(chunk);
+            });
+        }
+        transform
+            .on('finish', () => {
+            if (chunks.length > 0) {
+                const result = Buffer.concat(chunks);
+                PORT.postMessage(result, [result.buffer]);
+            }
+            else {
+                PORT.postMessage(output || null);
+            }
+        })
+            .on('error', (err) => {
+            transform.destroy();
+            throw err;
+        });
+    }
+    catch (err) {
+        console.error(err);
+        PORT.postMessage(null);
+    }
+});

package/worker/system-gzip.js

@@ -0,0 +1,40 @@
+"use strict";
+const node_worker_threads_1 = require("node:worker_threads");
+const fs = require("node:fs");
+const stream = require("node:stream");
+const zlib = require("node:zlib");
+const index_1 = require("@e-mc/compress");
+const PORT = node_worker_threads_1.workerData[0];
+node_worker_threads_1.parentPort.on('message', async (value) => {
+    try {
+        const { data, options, output } = value;
+        const chunks = [];
+        let transform = stream.Readable.from(index_1.asBuffer(data)).pipe(zlib.createGzip(options));
+        if (output) {
+            transform = transform.pipe(fs.createWriteStream(output));
+        }
+        else {
+            transform.on('data', chunk => {
+                chunks.push(chunk);
+            });
+        }
+        transform
+            .on('finish', () => {
+            if (chunks.length > 0) {
+                const result = Buffer.concat(chunks);
+                PORT.postMessage(result, [result.buffer]);
+            }
+            else {
+                PORT.postMessage(output || null);
+            }
+        })
+            .on('error', (err) => {
+            transform.destroy();
+            throw err;
+        });
+    }
+    catch (err) {
+        console.error(err);
+        PORT.postMessage(null);
+    }
+});

package/worker/wawoff2-compress.js

@@ -0,0 +1,14 @@
+"use strict";
+const node_worker_threads_1 = require("node:worker_threads");
+const wawoff2 = require("wawoff2");
+const PORT = node_worker_threads_1.workerData[0];
+node_worker_threads_1.parentPort.on('message', (value) => {
+    wawoff2.compress(value)
+        .then(data => {
+        PORT.postMessage(data);
+    })
+        .catch((err) => {
+        console.error(err);
+        PORT.postMessage(null);
+    });
+});

package/worker/wawoff2-decompress.js

@@ -0,0 +1,14 @@
+"use strict";
+const node_worker_threads_1 = require("node:worker_threads");
+const wawoff2 = require("wawoff2");
+const PORT = node_worker_threads_1.workerData[0];
+node_worker_threads_1.parentPort.on('message', (value) => {
+    wawoff2.decompress(value)
+        .then(data => {
+        PORT.postMessage(data);
+    })
+        .catch((err) => {
+        console.error(err);
+        PORT.postMessage(null);
+    });
+});

package/worker/woff2sfnt.js

@@ -0,0 +1,14 @@
+"use strict";
+const node_worker_threads_1 = require("node:worker_threads");
+const { toSfnt } = require('woff2sfnt-sfnt2woff');
+const PORT = node_worker_threads_1.workerData[0];
+node_worker_threads_1.parentPort.on('message', (value) => {
+    try {
+        const data = toSfnt(value);
+        PORT.postMessage(data, [data.buffer]);
+    }
+    catch (err) {
+        console.error(err);
+        PORT.postMessage(null);
+    }
+});