@pi-r/jimp 0.10.3 → 0.11.1

package/index.js

@@ -1,14 +1,18 @@
-"use strict";
+'use strict';
+
+var core = require('@e-mc/core');
+var types = require('@e-mc/types');
+
 const path = require("node:path");
 const fs = require("node:fs");
+const crypto = require("node:crypto");
 const child_process = require("node:child_process");
 const jimp = require("jimp");
+const jimp_utils = require("@jimp/utils");
 const gifwrap = require("gifwrap");
 const bmp = require("bmp-js");
-const node_crypto_1 = require("node:crypto");
-const types_1 = require("@e-mc/types");
-const util_1 = require("@pi-r/jimp/util");
 const Image = require('@e-mc/image');
+const util = require("@pi-r/jimp/util");
 const kJimp = Symbol.for('jimp:constructor');
 let WEBPMUX = null, WEBPMUX_INIT = false;
 try {
@@ -18,6 +22,8 @@ try {
 catch {
 }
 const CACHE_TRANSFORM = {};
+const FONT_DATA = {};
+const WORKER_JIMP = core.WorkerChannel.create(path.join(__dirname, 'worker', 'jimp.js'), 'PIR_JIMP');
 let CACHE_INIT = false;
 let TEMP_DIR = '';
 const METHOD_ALIAS = {
@@ -34,14 +40,11 @@ const METHOD_ALIAS = {
     convolute: 'cl',
     convolution: 'cu',
     flip: 'fl',
-    mirror: 'mi',
     rotate: 'ro',
     brightness: 'br',
     contrast: 'cn',
-    dither565: 'dt',
-    dither16: 'dt',
+    dither: 'dt',
     greyscale: 'gr',
-    grayscale: 'gr',
     invert: 'in',
     normalize: 'no',
     fade: 'fa',
@@ -55,42 +58,59 @@ const METHOD_ALIAS = {
     pixelate: 'px',
     displace: 'dp',
     color: 'co',
-    colour: 'co',
-    backgroundQuiet: 'bq',
     circle: 'ci',
-    colorType: 'ce',
-    cropQuiet: 'cq',
-    deflateLevel: 'dl',
-    deflateStrategy: 'ds',
-    fishEye: 'fe',
-    filterType: 'ft',
-    rgba: 'rg',
-    shadow: 'sh',
-    threshold: 'th'
+    fisheye: 'fe',
+    threshold: 'th',
+    quantize: 'qu',
+    print: 'pr'
 };
+{
+    const fonts = require('jimp/fonts');
+    const tasks = [];
+    const fontName = [];
+    for (const font in fonts) {
+        fontName.push(font);
+        tasks.push(jimp.loadFont(fonts[font]));
+    }
+    void Promise.allSettled(tasks)
+        .then(result => {
+        for (let i = 0; i < result.length; ++i) {
+            const font = result[i];
+            const name = fontName[i];
+            if (font.status === 'fulfilled') {
+                FONT_DATA[name] = font.value;
+            }
+            else {
+                console.error(font.reason);
+            }
+        }
+    });
+}
 function getMethodName(value) {
-    if (value.length === 2) {
-        value = value.toLowerCase();
-        for (const alias in METHOD_ALIAS) {
-            if (METHOD_ALIAS[alias] === value) {
-                return alias;
+    if (types.isString(value)) {
+        if (value.length === 2) {
+            value = value.toLowerCase();
+            for (const alias in METHOD_ALIAS) {
+                if (METHOD_ALIAS[alias] === value) {
+                    return alias;
+                }
             }
         }
-    }
-    else if (METHOD_ALIAS[value] || METHOD_ALIAS[value = value.toLowerCase()]) {
-        return value;
+        else if (METHOD_ALIAS[value] || METHOD_ALIAS[value = value.toLowerCase()]) {
+            return value;
+        }
     }
 }
-async function performCommand(host, instance, localUri, command, outputType, outputAs, { buffer, parent } = {}) {
-    return await jimp.read((buffer || localUri))
-        .then(async (img) => {
-        return await transformCommand(localUri, new JimpHandler(img, instance, host), command, outputType, outputAs, parent);
+async function performCommand(instance, buffer, command, outputType, outputAs, output, { host, file } = {}) {
+    const decodeMap = instance.settings.jimp?.options?.decode;
+    return jimp.Jimp.read(buffer, decodeMap).then(async (img) => {
+        return transformCommand(output, new JimpHandler(img, instance, host), command, outputType, outputAs, file);
     });
 }
 function execOptions(settings) {
     const exec = settings.jimp?.exec;
     let uid, gid;
-    if ((0, types_1.isPlainObject)(exec)) {
+    if (types.isPlainObject(exec)) {
         let { uid: u, gid: g } = exec;
         if ((u = parseInt(u)) >= 0) {
             uid = u;
@@ -101,34 +121,36 @@ function execOptions(settings) {
     }
     return { uid, gid };
 }
-async function transformCommand(localFile, handler, command, outputType, outputAs, parent) {
+async function transformCommand(output, handler, command, outputType, outputAs, file) {
     if (command) {
         handler.instance.setCommand(command, outputAs);
     }
+    handler.instance.outputType = outputType;
     await handler.method();
     handler.resize();
     handler.crop();
-    if (outputType !== jimp.MIME_JPEG) {
+    if (outputType !== Image.MIME_JPEG) {
         handler.opacity();
     }
-    else if (!outputAs) {
-        handler.quality();
-    }
     switch (handler.rotateCount) {
         case 0:
-            return handler;
+            break;
         case 1:
-            return handler.rotate();
+            await handler.rotate();
+            break;
+        default:
+            await handler.rotate(output, (err, result) => {
+                if (!err) {
+                    try {
+                        handler.host?.add(result, file);
+                    }
+                    catch {
+                    }
+                }
+            });
+            break;
     }
-    return handler.rotate(localFile, (err, result) => {
-        if (!err) {
-            try {
-                handler.host?.add(result, parent);
-            }
-            catch {
-            }
-        }
-    });
+    return handler;
 }
 async function setImageCache(instance, tempKey, tempFile, output, localFile) {
     try {
@@ -174,14 +196,26 @@ function getImageCache(instance, tempKey) {
         removeFile(tempFile);
         delete stored[tempKey];
     }
-    TEMP_DIR ||= instance.getTempDir({ moduleDir: true, increment: 5 });
-    return [null, TEMP_DIR ? path.join(TEMP_DIR, (0, node_crypto_1.randomUUID)()) : ''];
+    setTempDir(instance);
+    return [null, path.join(TEMP_DIR, crypto.randomUUID())];
 }
 function getCacheData(instance) {
     if (!CACHE_INIT) {
-        TEMP_DIR = instance.getTempDir({ moduleDir: true, increment: 5 });
+        setTempDir(instance);
         const settings = instance.settings.jimp ||= {};
-        const expires = (0, types_1.parseExpires)(settings.cache_expires || 0);
+        const expires = types.parseExpires(settings.cache_expires || 0);
+        if (settings.worker) {
+            let { min = -1, max = -1, expires: idleTimeout = 0 } = settings.worker;
+            if ((min = Math.trunc(+min)) >= 0) {
+                WORKER_JIMP.min = min;
+            }
+            if ((max = Math.trunc(+max)) >= 0) {
+                WORKER_JIMP.max = max;
+            }
+            if ((idleTimeout = types.parseExpires(idleTimeout)) > 0) {
+                WORKER_JIMP.idleTimeout = idleTimeout;
+            }
+        }
         if (expires === 0) {
             settings.cache_expires = 0;
         }
@@ -197,7 +231,7 @@ function getCacheData(instance) {
                             const pathname = path.join(TEMP_DIR, item.name);
                             try {
                                 const data = JSON.parse(fs.readFileSync(pathname, 'utf8'));
-                                if ((0, types_1.isPlainObject)(data) && fs.existsSync(data.tempFile)) {
+                                if (types.isPlainObject(data) && fs.existsSync(data.tempFile)) {
                                     if (data.ctimeMs + expires > current) {
                                         CACHE_TRANSFORM[data.tempKey] = data;
                                         return;
@@ -219,17 +253,20 @@ function getCacheData(instance) {
     }
     return CACHE_TRANSFORM;
 }
-function formatMessage(instance, value, startTime, failed, cTimeMs) {
+function formatMessage(instance, value, startTime, failed, worker = false, cTimeMs) {
     if (cTimeMs) {
         instance.formatMessage(2048, "jimp", [value, 'cache'], new Date(cTimeMs).toLocaleString(), { ...Image.LOG_STYLE_NOTICE, hintBold: true });
     }
     else if (startTime) {
+        if (worker) {
+            value += ' (worker)';
+        }
         instance.writeTimeProcess("jimp", value, startTime, { type: 2048, failed });
     }
 }
 function getTempPath(instance, ext) {
-    const tempDir = TEMP_DIR || instance.getTempDir({ moduleDir: true, createDir: true }) || instance.getTempDir();
-    return path.join(tempDir, (0, node_crypto_1.randomUUID)() + '.' + ext);
+    setTempDir(instance);
+    return path.join(TEMP_DIR, crypto.randomUUID() + '.' + ext);
 }
 function rotateAnim(cmd) {
     const rotate = cmd.rotate;
@@ -237,10 +274,20 @@ function rotateAnim(cmd) {
         rotate.values = [rotate.values.pop()];
     }
 }
+function setBackground(instance, args) {
+    instance.background = jimp_utils.rgbaToInt(...args);
+}
 function removeFile(pathname) {
     fs.unlink(pathname, () => { });
 }
+function errorParameters(alias, value) {
+    throw types.errorMessage(alias, "Invalid parameters", JSON.stringify(value));
+}
+function setTempDir(instance) {
+    TEMP_DIR ||= instance.getTempDir({ moduleDir: true, createDir: true }) || types.getTempDir(true, "jimp");
+}
 const hasTransform = (cmd) => !!(cmd.rotate || cmd.resize || cmd.crop || cmd.method || typeof cmd.opacity === 'number' && cmd.opacity >= 0 && cmd.opacity < 1);
+const isUnsupported = (value) => value === Image.MIME_GIF || value === Image.MIME_WEBP;
 const emptyResult = (options) => (options.tempFile ? '' : null);
 class JimpHandler {
     handler;
@@ -251,43 +298,38 @@ class JimpHandler {
         this.instance = instance;
         this._host = _host;
     }
-    async rotate(localFile, callback) {
+    async rotate(output, callback) {
         if (this.aborted) {
-            return this;
+            return;
         }
         const data = this.instance.rotateData;
         if (data) {
-            const { values, color } = data;
-            if (!isNaN(color)) {
-                this.handler.background(color);
+            if (!output) {
+                Jimp.applyRotate(this.handler, data);
+                return;
             }
+            Jimp.applyBackground(this.handler, data);
+            const leading = output.substring(0, output.lastIndexOf('.') + 1);
+            const ext = path.extname(output);
             const tasks = [];
-            const length = values.length;
-            const deg = values[0];
-            if (length > 1 && localFile) {
-                const leading = localFile.substring(0, localFile.lastIndexOf('.') + 1);
-                const ext = path.extname(localFile);
-                for (let i = 1; i < length; ++i) {
-                    const value = values[i];
-                    const img = this.handler.clone().rotate(value);
-                    const output = leading + value + ext;
-                    tasks.push(img.writeAsync(output)
-                        .then(() => {
-                        void this.finalize(output, callback, false);
-                    })
-                        .catch((err) => {
-                        this.instance.writeFail(["Unable to rotate image", "jimp"], err, 2048);
-                    }));
+            for (let i = 0; i < data.values.length; i++) {
+                const value = data.values[i];
+                if (i === 0) {
+                    this.handler.rotate(value);
+                    continue;
                 }
+                const img = this.handler.clone().rotate(value);
+                const target = leading + value + ext;
+                tasks.push(img.write(target, this.instance.getEncodeOptions())
+                    .then(() => {
+                    void this.finalize(target, callback, false);
+                })
+                    .catch((err) => {
+                    this.instance.writeFail(["Unable to rotate image", "jimp"], err, 2048);
+                }));
             }
-            if (deg) {
-                this.handler.rotate(deg);
-            }
-            if (tasks.length > 0) {
-                return Promise.all(tasks).then(() => this);
-            }
+            await Promise.all(tasks);
         }
-        return this;
     }
     async method() {
         if (this.aborted) {
@@ -298,20 +340,23 @@ class JimpHandler {
             for (const [name, args = []] of data) {
                 try {
                     const alias = getMethodName(name);
-                    if (!alias) {
-                        throw (0, types_1.errorValue)("Invalid method name", name);
-                    }
                     if (alias === 'composite') {
                         const [src, x, y, opts] = args;
-                        if ((0, types_1.isString)(src) && typeof x === 'number' && typeof y === 'number') {
-                            this.handler.composite(await jimp.read(src), x, y, opts);
+                        if (types.isString(src) && typeof x === 'number' && typeof y === 'number') {
+                            this.handler.composite(await jimp.Jimp.read(src), x, y, opts);
                         }
                         else {
-                            throw (0, types_1.errorValue)("Invalid parameters", alias);
+                            errorParameters(alias, args);
+                        }
+                    }
+                    else if (alias) {
+                        const result = Jimp.applyMethod(this.handler, alias, ...args);
+                        if (result.length > 0) {
+                            this.instance.addLog(this.instance.statusType.WARN, "Invalid parameters" + `: ${result.join(', ')}`, alias);
                         }
                     }
                     else {
-                        this.handler[alias](...args);
+                        throw types.errorValue("Invalid method name", name);
                     }
                 }
                 catch (err) {
@@ -326,86 +371,23 @@ class JimpHandler {
         }
         const data = this.instance.resizeData;
         if (data) {
-            const { width, height, color, algorithm, align, mode } = data;
-            if (!isNaN(color)) {
-                this.handler.background(color);
-            }
-            let flags = 0;
-            switch (align[0]) {
-                case 'left':
-                    flags |= jimp.HORIZONTAL_ALIGN_LEFT;
-                    break;
-                case 'center':
-                    flags |= jimp.HORIZONTAL_ALIGN_CENTER;
-                    break;
-                case 'right':
-                    flags |= jimp.HORIZONTAL_ALIGN_RIGHT;
-                    break;
-            }
-            switch (align[1]) {
-                case 'top':
-                    flags |= jimp.VERTICAL_ALIGN_TOP;
-                    break;
-                case 'middle':
-                    flags |= jimp.VERTICAL_ALIGN_MIDDLE;
-                    break;
-                case 'bottom':
-                    flags |= jimp.VERTICAL_ALIGN_BOTTOM;
-                    break;
-            }
-            switch (mode) {
-                case 'contain':
-                    this.handler.contain(width, height, flags);
-                    break;
-                case 'cover':
-                    this.handler.cover(width, height, flags);
-                    break;
-                case 'scale':
-                    this.handler.scaleToFit(width, height);
-                    break;
-                default: {
-                    let resizeMode = jimp.RESIZE_NEAREST_NEIGHBOR;
-                    switch (algorithm) {
-                        case 'bilinear':
-                            resizeMode = jimp.RESIZE_BILINEAR;
-                            break;
-                        case 'bicubic':
-                            resizeMode = jimp.RESIZE_BICUBIC;
-                            break;
-                        case 'hermite':
-                            resizeMode = jimp.RESIZE_HERMITE;
-                            break;
-                        case 'bezier':
-                            resizeMode = jimp.RESIZE_BEZIER;
-                            break;
-                        case 'none':
-                            resizeMode = undefined;
-                            break;
-                    }
-                    this.handler.resize(width === Infinity ? jimp.AUTO : width, height === Infinity ? jimp.AUTO : height, resizeMode);
-                    break;
-                }
-            }
+            Jimp.applyResize(this.handler, data);
         }
     }
     background(value) {
-        if (Array.isArray(value)) {
-            value = parseInt('0x' + value.map(item => item.toString(16)).join(''), 16);
-        }
-        this.handler.background(value);
+        this.handler.background = Array.isArray(value) ? jimp_utils.rgbaToInt(...value) : value;
     }
     async finalize(output, callback, replace) {
         if (this.aborted) {
             return;
         }
-        const instance = this.instance;
-        if (instance.outputAs === 'webp' && path.extname(output).toLowerCase() !== '.webp') {
-            const settings = instance.settings;
+        if (this.instance.outputAs === 'webp' && path.extname(output).toLowerCase() !== '.webp') {
+            const settings = this.instance.settings;
             const webp = settings.webp ||= {};
-            const data = instance.qualityData;
-            replace ??= instance.getCommand().includes('@');
-            const filename = (0, util_1.renameExt)(output, 'webp', replace);
-            const args = [(0, util_1.normalizePath)(output)];
+            const data = this.instance.qualityData;
+            replace ??= this.instance.getCommand().includes('@');
+            const outFile = util.renameExt(output, 'webp', replace);
+            const args = [util.normalizePath(output)];
             if (data) {
                 const { value, preset, nearLossless } = data;
                 if (preset) {
@@ -446,13 +428,13 @@ class JimpHandler {
                     }
                 }
             }
-            args.push('-o', (0, util_1.normalizePath)(filename));
+            args.push('-o', util.normalizePath(outFile));
             try {
-                child_process.execFile((0, types_1.sanitizeCmd)(await (0, util_1.importBinary)('cwebp', webp.path), args), { shell: true, signal: this.instance.signal, ...execOptions(settings) }, err => {
+                child_process.execFile(types.sanitizeCmd(await util.importBinary('cwebp', webp.path), args), { shell: true, signal: this.instance.signal, ...execOptions(settings) }, err => {
                     if (err) {
-                        this.instance.writeFail(["Unable to convert file", path.basename(filename)], err, 2048);
+                        this.instance.writeFail(["Unable to convert file", path.basename(outFile)], err, 2048);
                     }
-                    else if (webp !== output) {
+                    else if (output !== outFile) {
                         const tempFile = output;
                         queueMicrotask(() => {
                             fs.unlink(tempFile, error => {
@@ -461,7 +443,7 @@ class JimpHandler {
                                 }
                             });
                         });
-                        output = filename;
+                        output = outFile;
                     }
                     if (callback) {
                         callback(err, output);
@@ -469,7 +451,7 @@ class JimpHandler {
                 });
             }
             catch (err) {
-                this.instance.checkPackage(err, 'cwebp-bin', "Unknown", { type: 2048, passThrough: !!callback });
+                this.instance.checkPackage(err, 'cwebp-bin', 2048);
                 if (callback) {
                     callback(err, '');
                 }
@@ -481,16 +463,13 @@ class JimpHandler {
     }
     async getBuffer(tempFile, saveAs) {
         const emptyData = () => tempFile ? '' : null;
-        const output = getTempPath(this.instance, saveAs && util_1.MIME_OUTPUT.has('image/' + (saveAs === 'jpg' ? 'jpeg' : saveAs)) ? saveAs : this.handler.getMIME().split('/').pop());
+        const output = getTempPath(this.instance, saveAs && util.MIME_OUTPUT.has('image/' + (saveAs === 'jpg' ? 'jpeg' : saveAs)) ? saveAs : (this.handler.mime || this.instance.outputType).split('/').pop());
         if (!output) {
             return emptyData();
         }
         return new Promise(resolve => {
-            this.handler.write(output, error => {
-                if (error) {
-                    resolve(emptyData());
-                    return;
-                }
+            this.handler.write(output, this.instance.getEncodeOptions())
+                .then(() => {
                 void this.finalize(output, (error, result) => {
                     if (error) {
                         resolve(emptyData());
@@ -515,6 +494,9 @@ class JimpHandler {
                         }
                     }
                 });
+            })
+                .catch(() => {
+                resolve(emptyData());
             });
         });
     }
@@ -524,51 +506,23 @@ class JimpHandler {
         }
         const data = this.instance.cropData;
         if (data) {
-            this.handler.crop(data.x, data.y, data.width, data.height);
+            Jimp.applyCrop(this.handler, data);
         }
     }
     opacity() {
-        if (this.aborted) {
-            return;
-        }
         const value = this.instance.opacityValue ?? NaN;
-        if (value >= 0) {
+        if (value >= 0 && !this.aborted) {
             this.handler.opacity(value);
         }
     }
-    quality() {
-        if (this.aborted) {
-            return;
-        }
-        const data = this.instance.qualityData;
-        if (data && !isNaN(data.value)) {
-            this.handler.quality(data.value);
-        }
-    }
-    write(output, callback) {
-        if (this.aborted) {
-            if (callback) {
-                callback((0, types_1.createAbortError)(), '');
-            }
-            return;
-        }
-        this.handler.write(output, err => {
-            if (!err) {
-                void this.finalize(output, callback);
-            }
-            else if (callback) {
-                callback(err, '');
-            }
-        });
-    }
-    async writeAsync(output, callback) {
+    async write(output, callback) {
         if (this.aborted) {
             if (callback) {
-                callback((0, types_1.createAbortError)(), '');
+                callback(types.createAbortError(), '');
             }
             return;
         }
-        return this.handler.writeAsync(output)
+        return this.handler.write(output, this.instance.getEncodeOptions())
             .then(() => {
             void this.finalize(output, callback);
         })
@@ -594,31 +548,34 @@ class JimpHandler {
 class Jimp extends Image {
     static [kJimp] = true;
     static async transform(file, command, options = {}) {
-        const [outputType, saveAs, outputAs] = (0, util_1.parseFormat)(command = command.trim(), options.mimeType);
-        if (!outputType) {
-            return emptyResult(options);
-        }
         const instance = new Jimp(options.module);
         let buffer = null;
         if (Buffer.isBuffer(file)) {
-            const tempDir = TEMP_DIR || instance.getTempDir();
-            if (!this.createDir(tempDir)) {
-                return emptyResult(options);
-            }
             try {
-                const { ext } = await this.resolveMime(file) || { ext: 'unknown' };
+                setTempDir(instance);
+                const { mime, ext } = await this.resolveMime(file) || { ext: 'unknown' };
                 buffer = file;
-                fs.writeFileSync(file = path.join(tempDir, (0, node_crypto_1.randomUUID)() + '.' + ext), buffer);
+                fs.writeFileSync(file = path.join(TEMP_DIR, crypto.randomUUID() + '.' + ext), buffer);
+                if (mime) {
+                    options.mimeType = mime;
+                }
             }
             catch {
                 return emptyResult(options);
             }
             options.cache = false;
         }
+        else {
+            options.mimeType ||= Image.lookupMime(file);
+        }
+        const [outputType, saveAs, outputAs] = util.parseFormat(command = command.trim(), options.mimeType);
+        if (!outputType) {
+            return emptyResult(options);
+        }
         const filename = path.basename(file);
         const broadcastId = options.broadcastId;
         if (broadcastId) {
-            if ((0, types_1.isPlainObject)(broadcastId)) {
+            if (types.isPlainObject(broadcastId)) {
                 instance.broadcastId = broadcastId.value;
                 if (broadcastId.stripAnsi === false) {
                     instance.supports('stripAnsi', false);
@@ -630,7 +587,7 @@ class Jimp extends Image {
         }
         const writeMessage = (failed, cTimeMs) => {
             if (cTimeMs || options.startTime) {
-                formatMessage(instance, filename + (0, util_1.showOutputType)(options.mimeType, outputType, outputAs), options.startTime, failed, cTimeMs);
+                formatMessage(instance, filename + util.showOutputType(options.mimeType, outputType, outputAs), options.startTime, failed, false, cTimeMs);
             }
         };
         let tempKey, tempFile;
@@ -644,9 +601,9 @@ class Jimp extends Image {
         }
         instance.formatMessage(Image.LOG_TYPE.IMAGE, "jimp", ["Transforming image...", filename], command);
         Image.initCpuUsage(instance);
-        return performCommand(null, instance, file, command, outputType, outputAs)
-            .then(async (handler) => {
-            const result = await handler.getBuffer(options.tempFile, saveAs);
+        return performCommand(instance, file, command, outputType, outputAs, file)
+            .then(async (img) => {
+            const result = await img.getBuffer(options.tempFile, saveAs);
             instance.flushLog();
             writeMessage(!result || instance.errors.length > 0);
             if (result && tempKey && tempFile) {
@@ -654,15 +611,165 @@ class Jimp extends Image {
             }
             return result;
         })
-            .catch(() => {
-            return emptyResult(options);
-        })
+            .catch(() => emptyResult(options))
             .finally(() => {
             if (buffer && !options.cache) {
                 removeFile(file);
             }
         });
     }
+    static applyBackground(instance, data) {
+        if (!isNaN(data.color)) {
+            instance.background = data.color;
+        }
+    }
+    static applyResize(instance, data) {
+        this.applyBackground(instance, data);
+        const { width: w, height: h } = data;
+        let align = 0;
+        switch (data.align[0]) {
+            case 'left':
+                align |= jimp.HorizontalAlign.LEFT;
+                break;
+            case 'center':
+                align |= jimp.HorizontalAlign.CENTER;
+                break;
+            case 'right':
+                align |= jimp.HorizontalAlign.RIGHT;
+                break;
+        }
+        switch (data.align[1]) {
+            case 'top':
+                align |= jimp.VerticalAlign.TOP;
+                break;
+            case 'middle':
+                align |= jimp.VerticalAlign.MIDDLE;
+                break;
+            case 'bottom':
+                align |= jimp.VerticalAlign.BOTTOM;
+                break;
+        }
+        switch (data.mode) {
+            case 'contain':
+                instance.contain({ w, h, align: align > 0 ? align : undefined });
+                break;
+            case 'cover':
+                instance.cover({ w, h, align: align > 0 ? align : undefined });
+                break;
+            case 'scale':
+                instance.scaleToFit({ w, h });
+                break;
+            default: {
+                let mode;
+                switch (data.algorithm) {
+                    case 'bilinear':
+                        mode = jimp.ResizeStrategy.BILINEAR;
+                        break;
+                    case 'bicubic':
+                        mode = jimp.ResizeStrategy.BICUBIC;
+                        break;
+                    case 'hermite':
+                        mode = jimp.ResizeStrategy.HERMITE;
+                        break;
+                    case 'bezier':
+                        mode = jimp.ResizeStrategy.BEZIER;
+                        break;
+                    case 'nearest':
+                    case 'nearest_neighbor':
+                        mode = jimp.ResizeStrategy.NEAREST_NEIGHBOR;
+                        break;
+                }
+                const options = { mode };
+                if (w < Infinity) {
+                    options.w = w;
+                }
+                if (h < Infinity) {
+                    options.h = h;
+                }
+                instance.resize(options);
+                break;
+            }
+        }
+    }
+    static applyCrop(instance, data) {
+        instance.crop({ x: data.x, y: data.y, w: data.width, h: data.height });
+    }
+    static applyRotate(instance, data) {
+        this.applyBackground(instance, data);
+        instance.rotate(data.values[0]);
+    }
+    static applyMethod(instance, name, ...args) {
+        const alias = getMethodName(name);
+        if (!alias) {
+            throw types.errorValue("Invalid method name", name);
+        }
+        switch (alias) {
+            case 'background':
+                if (args.length === 4) {
+                    setBackground(instance, args);
+                    break;
+                }
+                if (args.length === 1) {
+                    if (typeof args[0] === 'number') {
+                        instance.background = args[0];
+                        break;
+                    }
+                    if (Array.isArray(args[0])) {
+                        setBackground(instance, args[0]);
+                        break;
+                    }
+                }
+                errorParameters(alias, args);
+                break;
+            case 'sepia':
+            case 'normalize':
+            case 'invert':
+            case 'greyscale':
+            case 'dither':
+                instance[alias]();
+                break;
+            default: {
+                const arg = args.shift();
+                switch (alias) {
+                    case 'blur':
+                    case 'gaussian':
+                    case 'brightness':
+                    case 'contrast':
+                    case 'posterize':
+                    case 'opacity':
+                    case 'fade':
+                        if (types.isPlainObject(arg)) {
+                            errorParameters(alias, args);
+                        }
+                        instance[alias](+arg);
+                        break;
+                    case 'pixelate':
+                    case 'convolute':
+                        instance[alias](arg);
+                        break;
+                    case 'print':
+                        if (types.isPlainObject(arg)) {
+                            if (types.isString(arg.font)) {
+                                arg.font = FONT_DATA[arg.font];
+                            }
+                            instance.print(arg);
+                        }
+                        else {
+                            errorParameters(alias, arg);
+                        }
+                        break;
+                    default:
+                        if (!types.isPlainObject(arg)) {
+                            errorParameters(alias, arg);
+                        }
+                        instance[alias](arg);
+                        break;
+                }
+                break;
+            }
+        }
+        return args;
+    }
     _moduleName = "jimp";
     _threadable = true;
     resizeData = null;
@@ -671,6 +778,7 @@ class Jimp extends Image {
     qualityData = null;
     methodData = null;
     opacityValue = NaN;
+    outputType = '';
     parseRotate(value) {
         const data = super.parseRotate(value);
         if (data && this.settings.jimp?.rotate_clockwise) {
@@ -681,43 +789,61 @@ class Jimp extends Image {
         }
         return data;
     }
+    parseWorker(command, outputType) {
+        if (typeof command === 'string') {
+            command = this.parseCommand(command);
+        }
+        if (!isUnsupported(outputType)) {
+            const { method, rotate } = command;
+            if (rotate && rotate.values.length > 1) {
+                return null;
+            }
+            if (method) {
+                const values = method.map(item => [getMethodName(item[0]) || item[0], item[1]]);
+                if (values.find(item => !item[0])) {
+                    return null;
+                }
+                command.method = values;
+            }
+        }
+        return null;
+    }
     async using(data, command) {
         if (this.aborted) {
-            return (0, types_1.createAbortError)(true);
+            return types.createAbortError(true);
         }
         return new Promise(async (resolve, reject) => {
             const { host, file } = data;
             const localUri = host.getLocalUri(data);
             const mimeType = host.getMimeType(data);
-            if (!localUri || !util_1.MIME_INPUT.has(mimeType)) {
-                reject((0, types_1.errorValue)("Unknown", !localUri ? 'URI' : 'MIME'));
+            if (!localUri || !util.MIME_INPUT.has(mimeType)) {
+                reject(types.errorValue("Unknown", !localUri ? 'URI' : 'MIME'));
                 return;
             }
             if (!this.canRead(localUri, { ownPermissionOnly: true })) {
-                reject((0, types_1.errorValue)("Not permitted to read file", localUri));
+                reject(types.errorValue("Not permitted to read file", localUri));
                 return;
             }
-            const [outputType, saveAs, outputAs] = (0, util_1.parseFormat)(command = command.trim(), mimeType, true);
+            const [outputType, saveAs, outputAs] = util.parseFormat(command = command.trim(), mimeType);
             if (!outputType) {
-                reject((0, types_1.errorValue)("Invalid format", /^\w+/.exec(command)?.[0] || "Unknown"));
+                reject(types.errorValue("Invalid format", /^\w+/.exec(command)?.[0] || "Unknown"));
                 return;
             }
             const replace = command.includes('@');
             const output = host.addCopy(data.getObject({ command, outputType }), saveAs, replace);
             if (!output) {
-                reject((0, types_1.errorValue)("Not able to copy file", outputType));
+                reject(types.errorValue("Not able to copy file", outputType));
                 return;
             }
             if (!this.canWrite(output, { ownPermissionOnly: true })) {
-                reject((0, types_1.errorValue)("Not permitted to write file", output));
+                reject(types.errorValue("Not permitted to write file", output));
                 return;
             }
             const startTime = process.hrtime();
-            const success = (result, ctimeMs) => {
+            const success = (result, worker, ctimeMs) => {
                 const filename = path.basename(result);
-                const document = file.document;
-                if (document) {
-                    host.writeImage(document, data.getObject({ command, output: result }));
+                if (file.document) {
+                    host.writeImage(file.document, data.getObject({ command, output: result }));
                 }
                 if (host.getLocalUri(data) !== result) {
                     if (command.includes('%')) {
@@ -739,7 +865,7 @@ class Jimp extends Image {
                 if (replace && file.localUri !== output && !host.assets.find(item => item.localUri === output && !item.invalid)) {
                     host.filesToRemove.add(output);
                 }
-                formatMessage(this, (0, util_1.showInputType)(mimeType, outputType, outputAs) + filename, startTime, false, ctimeMs);
+                formatMessage(this, util.showInputType(mimeType, outputType, outputAs) + filename, startTime, false, worker, ctimeMs);
                 resolve();
             };
             let tempKey, tempFile;
@@ -747,33 +873,30 @@ class Jimp extends Image {
                 let buffer, ctimeMs;
                 [buffer, tempFile] = getImageCache(this, tempKey = (file.etag || Image.asHash(file.buffer)) + command + mimeType);
                 if (buffer) {
-                    const result = outputAs === 'webp' ? (0, util_1.renameExt)(output, 'webp', replace) : output;
+                    const result = outputAs === 'webp' ? util.renameExt(output, 'webp', replace) : output;
                     fs.writeFileSync(result, file.buffer = buffer);
-                    success(result, ctimeMs);
+                    success(result, false, ctimeMs);
                     return;
                 }
             }
-            const finalize = (value) => {
+            const outputData = this.parseCommand(command);
+            const finalize = (value, worker) => {
                 if (tempFile && tempKey) {
                     void setImageCache(this, tempKey, tempFile, value);
                 }
                 if (replace) {
                     delete file.buffer;
                 }
-                success(value);
+                success(value, worker);
             };
             const transformBuffer = (bmpFile) => {
                 startMessage();
-                performCommand(host, this, localUri, command, outputType, outputAs, { buffer: bmpFile || file.buffer, parent: file })
+                performCommand(this, bmpFile || file.buffer || localUri, outputData, outputType, outputAs, output, { host, file })
                     .then(img => {
                     if (typeof bmpFile === 'string') {
                         removeFile(bmpFile);
                     }
-                    const errorResponse = (err) => {
-                        this.writeFail(["Unable to finalize image", "jimp"], err, { type: 2048, startTime });
-                        resolve();
-                    };
-                    if (outputType === jimp.MIME_GIF) {
+                    if (outputType === Image.MIME_GIF) {
                         try {
                             const { GifUtil, GifFrame } = gifwrap;
                             const frame = new GifFrame(img.handler.bitmap);
@@ -782,160 +905,153 @@ class Jimp extends Image {
                                 .then(() => {
                                 finalize(output);
                             })
-                                .catch(errorResponse);
+                                .catch(reject);
                         }
                         catch (err) {
-                            errorResponse(err);
+                            reject(err);
                         }
                     }
                     else {
-                        img.write(output, (err, result) => {
+                        void img.write(output, (err, result) => {
                             if (!err && result) {
                                 finalize(result);
                             }
-                            else if (Image.isErrorCode(err, types_1.ERR_CODE.MODULE_NOT_FOUND)) {
+                            else if (types.isErrorCode(err, types.ERR_CODE.MODULE_NOT_FOUND)) {
                                 resolve();
                             }
                             else {
-                                errorResponse(err || new Error("Unknown"));
+                                reject(err || new Error("Unknown"));
                             }
                         });
                     }
                 })
-                    .catch((err) => {
-                    this.writeFail(["Unable to read buffer", path.basename(localUri)], err, { type: 2048, startTime });
-                    resolve();
-                });
+                    .catch(reject);
             };
             const startMessage = () => {
                 host.formatMessage(2048, "jimp", ["Transforming image...", path.basename(localUri)], command);
             };
-            if (mimeType === jimp.MIME_GIF) {
-                if (outputType === jimp.MIME_GIF || outputType === "image/webp") {
-                    const cmd = this.parseCommand(command);
-                    const transformWebP = async (target, modified) => {
-                        if (outputAs === 'webp') {
-                            if (!modified) {
-                                startMessage();
+            if (mimeType === Image.MIME_GIF && isUnsupported(outputType)) {
+                const transformWebP = async (target, modified) => {
+                    if (outputAs === 'webp') {
+                        if (!modified) {
+                            startMessage();
+                        }
+                        const { path: webp_path, gif2webp } = this.settings.webp ||= {};
+                        const webp = util.renameExt(output, 'webp', replace);
+                        const args = [util.normalizePath(target)];
+                        const quality = outputData.quality;
+                        if (quality) {
+                            const { value, method } = quality;
+                            if (!isNaN(value)) {
+                                args.push('-q', value.toString());
                             }
-                            const { path: webp_path, gif2webp } = this.settings.webp ||= {};
-                            const webp = (0, util_1.renameExt)(output, 'webp', replace);
-                            const args = [(0, util_1.normalizePath)(target)];
-                            const quality = cmd.quality;
-                            if (quality) {
-                                const { value, method } = quality;
-                                if (!isNaN(value)) {
-                                    args.push('-q', value.toString());
-                                }
-                                if (!isNaN(method)) {
-                                    args.push('-m', method.toString());
-                                }
+                            if (!isNaN(method)) {
+                                args.push('-m', method.toString());
                             }
-                            if (Array.isArray(gif2webp)) {
-                                for (let i = 0, length = gif2webp.length; i < length; ++i) {
-                                    const arg = gif2webp[i];
-                                    switch (arg) {
-                                        case '-o':
+                        }
+                        if (Array.isArray(gif2webp)) {
+                            for (let i = 0, length = gif2webp.length; i < length; ++i) {
+                                const arg = gif2webp[i];
+                                switch (arg) {
+                                    case '-o':
+                                        ++i;
+                                    case '-h':
+                                    case '-version':
+                                        continue;
+                                    case '-q':
+                                    case '-m':
+                                        if (args.includes(arg)) {
                                             ++i;
-                                        case '-h':
-                                        case '-version':
                                             continue;
-                                        case '-q':
-                                        case '-m':
-                                            if (args.includes(arg)) {
-                                                ++i;
-                                                continue;
-                                            }
-                                            break;
-                                        case '--':
-                                            i = length;
-                                            continue;
-                                    }
-                                    args.push(arg);
+                                        }
+                                        break;
+                                    case '--':
+                                        i = length;
+                                        continue;
                                 }
+                                args.push(arg);
                             }
-                            args.push('-o', (0, util_1.normalizePath)(webp));
-                            try {
-                                child_process.execFile((0, types_1.sanitizeCmd)(await (0, util_1.importBinary)('gif2webp', webp_path), args), { shell: true, signal: this.signal, ...execOptions(this.settings) }, (err, stdout) => {
-                                    if (!err) {
-                                        this.addLog(4, stdout);
-                                        finalize(webp);
-                                    }
-                                    else {
-                                        reject(err);
-                                    }
-                                });
-                            }
-                            catch (err) {
-                                if (this.checkPackage(err, 'gif2webp-bin', 2048)) {
-                                    resolve();
+                        }
+                        args.push('-o', util.normalizePath(webp));
+                        try {
+                            child_process.execFile(types.sanitizeCmd(await util.importBinary('gif2webp', webp_path), args), { shell: true, signal: this.signal, ...execOptions(this.settings) }, (err, stdout) => {
+                                if (!err) {
+                                    this.addLog(4, stdout);
+                                    finalize(webp);
                                 }
                                 else {
                                     reject(err);
                                 }
-                            }
-                        }
-                        else if (modified) {
-                            finalize(output);
+                            });
                         }
-                        else {
-                            resolve();
+                        catch (err) {
+                            if (this.checkPackage(err, 'gif2webp-bin', 2048)) {
+                                resolve();
+                            }
+                            else {
+                                reject(err);
+                            }
                         }
-                    };
-                    if (hasTransform(cmd)) {
-                        try {
-                            startMessage();
-                            const { GifUtil, BitmapImage } = gifwrap;
-                            GifUtil.read(file.buffer || localUri)
-                                .then(gif => {
-                                rotateAnim(cmd);
-                                Promise.all(gif.frames.map(async (frame) => {
-                                    const handler = new JimpHandler(GifUtil.shareAsJimp(jimp, frame), this);
-                                    return transformCommand(localUri, handler, cmd, jimp.MIME_GIF);
-                                }))
-                                    .then(items => {
-                                    const quantize = this.settings.jimp?.gifwrap_quantize || '';
-                                    const frames = gif.frames;
-                                    for (let i = 0, length = items.length; i < length; ++i) {
-                                        const img = new BitmapImage(items[i].handler.bitmap);
-                                        switch (quantize) {
-                                            case 'none':
-                                                break;
-                                            case 'dekker':
-                                                GifUtil.quantizeDekker(img, 256);
-                                                break;
-                                            case 'wu':
-                                                GifUtil.quantizeWu(img, 256);
-                                                break;
-                                            default:
-                                                GifUtil.quantizeSorokin(img, 256);
-                                                break;
-                                        }
-                                        frames[i].bitmap = img.bitmap;
+                    }
+                    else if (modified) {
+                        finalize(output);
+                    }
+                    else {
+                        resolve();
+                    }
+                };
+                if (hasTransform(outputData)) {
+                    try {
+                        startMessage();
+                        const { GifUtil, BitmapImage } = gifwrap;
+                        GifUtil.read(file.buffer || localUri)
+                            .then(src => {
+                            rotateAnim(outputData);
+                            Promise.all(src.frames.map(async (frame) => {
+                                const bitmap = bmp.encode(frame.bitmap).data;
+                                const instance = await jimp.Jimp.read(bitmap);
+                                const handler = new JimpHandler(instance, this);
+                                return transformCommand(output, handler, outputData, Image.MIME_GIF);
+                            }))
+                                .then(items => {
+                                const quantize = this.settings.jimp?.gifwrap_quantize || '';
+                                const frames = src.frames;
+                                for (let i = 0, length = items.length; i < length; ++i) {
+                                    const img = new BitmapImage(items[i].handler.bitmap);
+                                    switch (quantize) {
+                                        case 'none':
+                                            break;
+                                        case 'dekker':
+                                            GifUtil.quantizeDekker(img, 256);
+                                            break;
+                                        case 'wu':
+                                            GifUtil.quantizeWu(img, 256);
+                                            break;
+                                        default:
+                                            GifUtil.quantizeSorokin(img, 256);
+                                            break;
                                     }
-                                    GifUtil.write(output, frames, gif)
-                                        .then(() => {
-                                        void transformWebP(output, true);
-                                    })
-                                        .catch(reject);
+                                    frames[i].bitmap = img.bitmap;
+                                }
+                                GifUtil.write(output, frames, src)
+                                    .then(() => {
+                                    void transformWebP(output, true);
                                 })
                                     .catch(reject);
                             })
                                 .catch(reject);
-                        }
-                        catch (err) {
-                            reject(err);
-                        }
+                        })
+                            .catch(reject);
                     }
-                    else {
-                        void transformWebP(localUri, false);
+                    catch (err) {
+                        reject(err);
                     }
                 }
                 else {
-                    transformBuffer();
+                    void transformWebP(localUri, false);
                 }
             }
-            else if (mimeType === "image/webp") {
+            else if (mimeType === Image.MIME_WEBP) {
                 const tryWebpMux = async () => {
                     try {
                         const webp = new (WEBPMUX ||= require('node-webpmux')).Image();
@@ -944,21 +1060,25 @@ class Jimp extends Image {
                             WEBPMUX_INIT = true;
                         }
                         await webp.load(host.getBuffer(file));
-                        if (!(webp.hasAnim && (outputType === "image/webp" || outputType === jimp.MIME_GIF))) {
-                            transformBuffer(bmp.encode({ width: webp.width, height: webp.height, data: Image.toABGR(await (!webp.hasAnim ? webp.getImageData() : webp.getFrameData(0))) }).data);
+                        if (!(webp.hasAnim && (outputType === Image.MIME_WEBP || outputType === Image.MIME_GIF))) {
+                            const buffer = Image.toABGR(await (!webp.hasAnim ? webp.getImageData() : webp.getFrameData(0)));
+                            const bitmap = bmp.encode({ width: webp.width, height: webp.height, data: buffer }).data;
+                            transformBuffer(bitmap);
                             return true;
                         }
-                        const cmd = this.parseCommand(command);
-                        if (hasTransform(cmd)) {
+                        if (hasTransform(outputData)) {
                             startMessage();
                             Promise.all(webp.frames.map(async (frame, index) => {
-                                const handler = new JimpHandler(await jimp.read(bmp.encode({ width: frame.width, height: frame.height, data: Image.toABGR(await webp.getFrameData(index)) }).data), this);
+                                const buffer = Image.toABGR(await webp.getFrameData(index));
+                                const bitmap = bmp.encode({ width: frame.width, height: frame.height, data: buffer }).data;
+                                const instance = await jimp.Jimp.read(bitmap);
+                                const handler = new JimpHandler(instance, this);
                                 handler.background(webp.anim.bgColor);
-                                return transformCommand(localUri, handler, cmd, jimp.MIME_BMP);
+                                return transformCommand(output, handler, outputData, Image.MIME_BMP);
                             }))
                                 .then(items => {
                                 const length = items.length;
-                                if (outputType === jimp.MIME_GIF) {
+                                if (outputType === Image.MIME_GIF) {
                                     try {
                                         const { GifFrame, GifUtil, BitmapImage } = gifwrap;
                                         const quantize = this.settings.jimp?.gifwrap_quantize || '';
@@ -992,10 +1112,10 @@ class Jimp extends Image {
                                     }
                                 }
                                 else {
-                                    const { value: q = NaN, method: m = NaN, preset } = cmd.quality || {};
+                                    const { value: q = NaN, method: m = NaN, preset } = outputData.quality || {};
                                     const quality = !isNaN(q) ? q : undefined;
                                     const method = !isNaN(m) ? m : undefined;
-                                    rotateAnim(cmd);
+                                    rotateAnim(outputData);
                                     const frames = new Array(length);
                                     let w = 0, h = 0;
                                     for (let i = 0; i < length; ++i) {
@@ -1006,7 +1126,7 @@ class Jimp extends Image {
                                     }
                                     Promise.all(frames)
                                         .then(() => {
-                                        webp.save(output, { width: w, height: h, bgColor: cmd.rotate ? [0, 0, 0, 0] : undefined })
+                                        webp.save(output, { width: w, height: h, bgColor: outputData.rotate ? [0, 0, 0, 0] : undefined })
                                             .then(() => {
                                             finalize(output);
                                         })
@@ -1033,11 +1153,9 @@ class Jimp extends Image {
                     }
                     return false;
                 };
-                const settings = this.settings;
-                const { path: webp_path } = settings.webp ||= {};
                 const bmpFile = getTempPath(this, 'bmp');
                 try {
-                    child_process.execFile((0, types_1.sanitizeCmd)(await (0, util_1.importBinary)('dwebp', webp_path), [(0, util_1.normalizePath)(localUri), '-bmp', '-o', (0, util_1.normalizePath)(bmpFile)]), { shell: true, signal: this.signal, ...execOptions(settings) }, err => {
+                    child_process.execFile(types.sanitizeCmd(await util.importBinary('dwebp', this.settings.webp?.path), [util.normalizePath(localUri), '-bmp', '-o', util.normalizePath(bmpFile)]), { shell: true, signal: this.signal, ...execOptions(this.settings) }, err => {
                         if (!err) {
                             transformBuffer(bmpFile);
                         }
@@ -1063,10 +1181,47 @@ class Jimp extends Image {
                 }
             }
             else {
+                if (core.WorkerChannel.hasPermission(file) && this.parseWorker(outputData, outputType)) {
+                    try {
+                        let timer = null;
+                        const failed = (message) => {
+                            reject(types.errorMessage("jimp", message, localUri));
+                        };
+                        const worker = WORKER_JIMP.sendObject({ data: file.buffer || localUri, commandData: outputData, outputType, output, options: this.getEncodeOptions() }, [], (value) => {
+                            if (timer) {
+                                clearTimeout(timer);
+                            }
+                            if (value) {
+                                finalize(value, true);
+                            }
+                            else {
+                                failed("Worker did not finish");
+                            }
+                        });
+                        if (worker) {
+                            if (typeof file.worker === 'number') {
+                                timer = setTimeout(() => {
+                                    void worker.terminate();
+                                    failed("Worker timeout was exceeded");
+                                }, core.WorkerGroup.checkTimeout(file.worker, true));
+                            }
+                            return;
+                        }
+                    }
+                    catch (err) {
+                        this.addLog(3, err, { source: 'worker' });
+                    }
+                }
                 transformBuffer();
             }
         });
     }
+    getEncodeOptions() {
+        if (this.qualityData && this.outputType === Image.MIME_JPEG) {
+            return { quality: this.qualityData.value };
+        }
+        return this.settings.jimp?.options?.encode?.[this.outputType];
+    }
     get settings() {
         return this.module.settings ||= {};
     }