@pi-r/jimp 0.0.1

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 An Pham
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+### @pi-r/jimp
+
+### LICENSE
+
+MIT

package/index.js

@@ -0,0 +1,974 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const child_process = require("child_process");
+const jimp = require("jimp");
+const gifwrap = require("gifwrap");
+const bmp = require("bmp-js");
+const types_1 = require("@e-mc/types");
+const Image = require('@e-mc/image');
+const util_1 = require("./util");
+const CACHE_TRANSFORM = {};
+let CACHE_INIT = false;
+let TEMP_DIR = '';
+const METHOD_ALIAS = {
+    contain: 'ct',
+    cover: 'cv',
+    resize: 're',
+    scale: 'sc',
+    scaleToFit: 'sf',
+    autocrop: 'au',
+    crop: 'cr',
+    blit: 'bt',
+    composite: 'cp',
+    mask: 'ma',
+    convolute: 'cl',
+    flip: 'fl',
+    mirror: 'mi',
+    rotate: 'ro',
+    brightness: 'br',
+    contrast: 'cn',
+    dither565: 'dt',
+    greyscale: 'gr',
+    invert: 'in',
+    normalize: 'no',
+    fade: 'fa',
+    opacity: 'op',
+    opaque: 'oq',
+    background: 'bg',
+    gaussian: 'ga',
+    blur: 'bl',
+    posterize: 'po',
+    sepia: 'se',
+    pixelate: 'px',
+    displace: 'dp',
+    color: 'co'
+};
+function getMethodName(value) {
+    const name = value.toLowerCase();
+    if (METHOD_ALIAS[name]) {
+        return name;
+    }
+    if (name.length === 2) {
+        for (const alias in METHOD_ALIAS) {
+            if (METHOD_ALIAS[alias] === name) {
+                return alias;
+            }
+        }
+    }
+}
+function performCommand(host, instance, localUri, command, outputType, finalAs, buffer, parent) {
+    return jimp.read((buffer || localUri))
+        .then(img => {
+        return transformCommand(localUri, new JimpHandler(img, instance, host), command, outputType, finalAs, parent);
+    });
+}
+async function transformCommand(localFile, handler, command, outputType, outputAs, parent) {
+    if (command) {
+        handler.instance.setCommand(command, outputAs);
+    }
+    await handler.method();
+    handler.resize();
+    handler.crop();
+    if (outputType === jimp.MIME_JPEG) {
+        if (!outputAs) {
+            handler.quality();
+        }
+    }
+    else {
+        handler.opacity();
+    }
+    switch (handler.rotateCount) {
+        case 0:
+            return handler;
+        case 1:
+            return handler.rotate();
+        default:
+            return handler.rotate(localFile, (err, result) => {
+                if (!err && handler.host) {
+                    try {
+                        handler.host.add(result, parent);
+                    }
+                    catch {
+                    }
+                }
+            });
+    }
+}
+function setImageCache(tempKey, tempFile, output, localFile) {
+    try {
+        if (typeof output === 'string') {
+            fs.copyFileSync(output, tempFile);
+        }
+        else {
+            fs.writeFileSync(tempFile, output);
+        }
+        const stored = getCacheData.call(this);
+        if (localFile) {
+            const { ctimeMs, mtimeMs, size } = fs.statSync(localFile);
+            stored[tempKey] = { tempKey, tempFile, ctimeMs, localFile, mtimeMs, size };
+        }
+        else {
+            stored[tempKey] = { tempKey, tempFile, ctimeMs: Date.now() };
+        }
+        if (this.settings.jimp.cache_expires) {
+            fs.writeFile(tempFile + '.json', JSON.stringify(stored[tempKey]), 'utf-8', () => { });
+        }
+    }
+    catch {
+        TEMP_DIR = '';
+    }
+}
+function getImageCache(tempKey) {
+    const stored = getCacheData.call(this);
+    const data = stored[tempKey];
+    if (data) {
+        const { tempFile, localFile, ctimeMs, mtimeMs, size } = data;
+        try {
+            if (!localFile) {
+                return [fs.readFileSync(tempFile), '', ctimeMs];
+            }
+            const stat = fs.statSync(localFile);
+            if (stat.mtimeMs === mtimeMs && stat.size === size) {
+                return [fs.readFileSync(tempFile), '', ctimeMs];
+            }
+        }
+        catch {
+            TEMP_DIR = '';
+        }
+        removeFile(tempFile);
+        delete stored[tempKey];
+    }
+    TEMP_DIR || (TEMP_DIR = this.getTempDir({ moduleDir: true, increment: 5 }));
+    return [null, TEMP_DIR ? path.join(TEMP_DIR, (0, types_1.generateUUID)()) : ''];
+}
+function getCacheData() {
+    var _a;
+    if (!CACHE_INIT) {
+        TEMP_DIR = this.getTempDir({ moduleDir: true, increment: 5 });
+        const settings = (_a = this.settings).jimp || (_a.jimp = {});
+        const expires = (0, types_1.parseExpires)(settings.cache_expires || 0);
+        if (expires === 0) {
+            settings.cache_expires = 0;
+        }
+        if (TEMP_DIR) {
+            if (expires === 0) {
+                Image.removeDir(TEMP_DIR, true);
+            }
+            else {
+                const current = Date.now();
+                try {
+                    fs.readdirSync(TEMP_DIR, { withFileTypes: true }).forEach(item => {
+                        if (item.isFile() && item.name.endsWith('.json')) {
+                            const pathname = path.join(TEMP_DIR, item.name);
+                            try {
+                                const data = JSON.parse(fs.readFileSync(pathname, 'utf-8'));
+                                if ((0, types_1.isPlainObject)(data) && fs.existsSync(data.tempFile)) {
+                                    if (data.ctimeMs + expires > current) {
+                                        CACHE_TRANSFORM[data.tempKey] = data;
+                                        return;
+                                    }
+                                    removeFile(data.tempFile);
+                                }
+                            }
+                            catch {
+                            }
+                            removeFile(pathname);
+                        }
+                    });
+                }
+                catch {
+                }
+            }
+        }
+        CACHE_INIT = true;
+    }
+    return CACHE_TRANSFORM;
+}
+function formatMessage(value, startTime, failed, cTimeMs) {
+    if (cTimeMs) {
+        this.formatMessage(2048 /* LOG_TYPE.IMAGE */, "jimp" /* STRINGS.MODULE_NAME */, [value, 'cache'], new Date(cTimeMs).toLocaleString(), { ...Image.LOG_STYLE_NOTICE, hintBold: true });
+    }
+    else if (startTime) {
+        this.writeTimeProcess("jimp" /* STRINGS.MODULE_NAME */, value, startTime, { type: 2048 /* LOG_TYPE.IMAGE */, failed });
+    }
+}
+function getTempPath(ext) {
+    const tempDir = TEMP_DIR || this.getTempDir({ moduleDir: true, createDir: true }) || this.getTempDir();
+    return path.join(tempDir, (0, types_1.generateUUID)() + '.' + ext);
+}
+const removeFile = (pathname) => fs.unlink(pathname, () => { });
+class JimpHandler {
+    constructor(handler, instance, host) {
+        this.handler = handler;
+        this.instance = instance;
+        this._host = null;
+        if (host) {
+            this._host = host;
+        }
+    }
+    async rotate(localFile, callback) {
+        if (this.aborted) {
+            return this;
+        }
+        const data = this.instance.rotateData;
+        if (data) {
+            const { values, color } = data;
+            const handler = this.handler;
+            if (!isNaN(color)) {
+                handler.background(color);
+            }
+            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 = handler.clone().rotate(value);
+                    const output = leading + value + ext;
+                    tasks.push(img.writeAsync(output)
+                        .then(() => this.finalize(output, callback))
+                        .catch(err => this.instance.writeFail(["Unable to rotate image" /* ERR_IMAGE.ROTATE */, "jimp" /* STRINGS.MODULE_NAME */], err, 2048 /* LOG_TYPE.IMAGE */)));
+                }
+            }
+            if (deg) {
+                handler.rotate(deg);
+            }
+            if (tasks.length) {
+                return Promise.all(tasks).then(() => this);
+            }
+        }
+        return this;
+    }
+    async method() {
+        if (this.aborted) {
+            return;
+        }
+        const data = this.instance.methodData;
+        if (data) {
+            const handler = this.handler;
+            for (const [name, args = []] of data) {
+                try {
+                    const alias = getMethodName(name);
+                    if (!alias) {
+                        throw (0, types_1.errorValue)("Invalid method name" /* ERR_IMAGE.METHOD_NAME */, name);
+                    }
+                    if (alias === 'composite') {
+                        const [src, x, y, opts] = args;
+                        if ((0, types_1.isString)(src) && typeof x === 'number' && typeof y === 'number') {
+                            handler.composite(await jimp.read(src), x, y, opts);
+                        }
+                        else {
+                            throw (0, types_1.errorValue)("Invalid parameters" /* ERR_MESSAGE.PARAMETERS */, alias);
+                        }
+                    }
+                    else {
+                        handler[alias](...args);
+                    }
+                }
+                catch (err) {
+                    this.instance.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, "jimp" /* STRINGS.MODULE_NAME */ + ': ' + name], err, 2048 /* LOG_TYPE.IMAGE */);
+                }
+            }
+        }
+    }
+    resize() {
+        if (this.aborted) {
+            return;
+        }
+        const data = this.instance.resizeData;
+        if (data) {
+            const { width, height, color, algorithm, align, mode } = data;
+            const handler = this.handler;
+            if (!isNaN(color)) {
+                handler.background(color);
+            }
+            let resizeMode = jimp.RESIZE_NEAREST_NEIGHBOR, flags = 0;
+            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;
+            }
+            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':
+                    handler.contain(width, height, flags);
+                    break;
+                case 'cover':
+                    handler.cover(width, height, flags);
+                    break;
+                case 'scale':
+                    handler.scaleToFit(width, height);
+                    break;
+                default:
+                    handler.resize(width === Infinity ? jimp.AUTO : width, height === Infinity ? jimp.AUTO : height, resizeMode);
+                    break;
+            }
+        }
+    }
+    background(value) {
+        if (Array.isArray(value)) {
+            value = parseInt('0x' + value.map(item => item.toString(16)).join(''), 16);
+        }
+        this.handler.background(value);
+    }
+    finalize(output, callback) {
+        var _a;
+        if (this.aborted) {
+            return;
+        }
+        const instance = this.instance;
+        if (instance.outputAs === 'webp' && path.extname(output).toLowerCase() !== '.webp') {
+            const webp = (_a = instance.settings).webp || (_a.webp = {});
+            const data = instance.qualityData;
+            const replace = instance.getCommand().indexOf('@') !== -1;
+            const filename = (0, util_1.renameExt)(output, 'webp', replace);
+            const args = [(0, util_1.normalizePath)(output)];
+            if (data) {
+                const { value, preset, nearLossless } = data;
+                if (preset) {
+                    args.push('-preset', preset);
+                }
+                if (value > 100) {
+                    args.push('-lossless');
+                }
+                else if (value >= 0) {
+                    args.push('-q', value.toString());
+                }
+                if (nearLossless >= 0) {
+                    args.push('-near_lossless', Math.min(nearLossless, 100).toString());
+                }
+            }
+            if (Array.isArray(webp.cwebp)) {
+                for (let i = 0; i < webp.cwebp.length; ++i) {
+                    const arg = webp.cwebp[i];
+                    switch (arg) {
+                        case '-h':
+                        case '-H':
+                        case '-version':
+                            continue;
+                        case '-o':
+                        case '--':
+                            ++i;
+                            break;
+                        case '-preset':
+                        case '-q':
+                        case '-near_lossless':
+                            if (args.includes(arg) || arg !== '-preset' && args.includes('-lossless')) {
+                                ++i;
+                                break;
+                            }
+                        default:
+                            args.push(arg);
+                            break;
+                    }
+                }
+            }
+            args.push('-o', (0, util_1.normalizePath)(filename));
+            try {
+                child_process.execFile((0, util_1.getWebP_bin)('cwebp', webp.path), args, { shell: true, signal: this.instance.signal }, err => {
+                    if (err) {
+                        this.instance.writeFail(["Unable to convert file" /* ERR_MESSAGE.CONVERT_FILE */, path.basename(filename)], err, 2048 /* LOG_TYPE.IMAGE */);
+                    }
+                    else if (webp !== output) {
+                        const tempFile = output;
+                        queueMicrotask(() => {
+                            fs.unlink(tempFile, error => !error && fs.rmdir(path.dirname(tempFile), () => { }));
+                        });
+                        output = filename;
+                    }
+                    if (callback) {
+                        callback(err, output);
+                    }
+                });
+            }
+            catch (err) {
+                this.instance.checkPackage(err, 'cwebp-bin@6.1.2', "Unknown" /* ERR_MESSAGE.UNKNOWN */, { type: 2048 /* LOG_TYPE.IMAGE */, passThrough: !!callback });
+                if (callback) {
+                    callback(err, '');
+                }
+            }
+        }
+        else if (callback) {
+            callback(null, output);
+        }
+    }
+    getBuffer(tempFile, saveAs) {
+        const empty = () => tempFile ? '' : null;
+        const output = getTempPath.call(this.instance, this.instance.outputAs || (saveAs && util_1.MIME_OUTPUT.has('image/' + (saveAs === 'jpg' ? 'jpeg' : saveAs)) ? saveAs : this.handler.getMIME().split('/').pop()));
+        return !output ? Promise.resolve(empty()) : new Promise(resolve => {
+            this.handler.write(output, error => {
+                if (error) {
+                    resolve(empty());
+                    return;
+                }
+                this.finalize(output, (error, result) => {
+                    if (error) {
+                        resolve(empty());
+                    }
+                    else if (tempFile) {
+                        resolve(output);
+                    }
+                    else {
+                        try {
+                            resolve(fs.readFileSync(result));
+                        }
+                        catch (err) {
+                            this.instance.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(result)], err, 32 /* LOG_TYPE.FILE */);
+                            resolve(null);
+                        }
+                        queueMicrotask(() => fs.unlink(result, err => !err && this.instance.emit('file:delete', result)));
+                    }
+                });
+            });
+        });
+    }
+    crop() {
+        if (this.aborted) {
+            return;
+        }
+        const data = this.instance.cropData;
+        if (data) {
+            this.handler = this.handler.crop(data.x, data.y, data.width, data.height);
+        }
+    }
+    opacity() {
+        if (this.aborted) {
+            return;
+        }
+        const value = this.instance.opacityValue ?? NaN;
+        if (value >= 0) {
+            this.handler = this.handler.opacity(value);
+        }
+    }
+    quality() {
+        if (this.aborted) {
+            return;
+        }
+        const data = this.instance.qualityData;
+        if (data && !isNaN(data.value)) {
+            this.handler = 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) {
+                this.finalize(output, callback);
+            }
+            else if (callback) {
+                callback(err, '');
+            }
+        });
+    }
+    writeAsync(output, callback) {
+        if (this.aborted) {
+            if (callback) {
+                callback((0, types_1.createAbortError)(), '');
+            }
+            return Promise.resolve();
+        }
+        return this.handler.writeAsync(output)
+            .then(() => this.finalize(output, callback))
+            .catch(err => {
+            if (callback) {
+                callback(err, '');
+            }
+            else {
+                this.instance.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(output)], err, 2048 /* LOG_TYPE.IMAGE */);
+            }
+        });
+    }
+    get host() {
+        return this._host || this.instance.host;
+    }
+    get aborted() {
+        return this.instance.aborted;
+    }
+    get rotateCount() {
+        return this.instance.rotateData?.values.length || 0;
+    }
+}
+// @ts-ignore
+class Jimp extends Image {
+    constructor() {
+        super(...arguments);
+        this._moduleName = "jimp" /* STRINGS.MODULE_NAME */;
+        this._threadable = true;
+    }
+    static async transform(file, command, options = {}) {
+        const [outputType, saveAs, finalAs] = (0, util_1.parseFormat)(command = command.trim(), options.mimeType);
+        const empty = () => options.tempFile ? '' : null;
+        if (outputType) {
+            const instance = new Jimp(options.module);
+            let buffer = null;
+            if (Buffer.isBuffer(file)) {
+                const tempDir = TEMP_DIR || instance.getTempDir();
+                if (!this.createDir(tempDir)) {
+                    return empty();
+                }
+                try {
+                    const { ext } = await this.resolveMime(file) || { ext: 'unknown' };
+                    buffer = file;
+                    fs.writeFileSync(file = path.join(tempDir, (0, types_1.generateUUID)() + '.' + ext), buffer);
+                }
+                catch {
+                    return empty();
+                }
+                options.cache = false;
+            }
+            const filename = path.basename(file);
+            const broadcastId = options.broadcastId;
+            if (broadcastId) {
+                if ((0, types_1.isPlainObject)(broadcastId)) {
+                    instance.broadcastId = broadcastId.value;
+                    if (broadcastId.stripAnsi === false) {
+                        instance.supports('stripAnsi', false);
+                    }
+                }
+                else {
+                    instance.broadcastId = broadcastId;
+                }
+            }
+            const writeMessage = (failed, cTimeMs) => {
+                if (cTimeMs || options.startTime) {
+                    formatMessage.call(instance, filename + (0, util_1.showOutputType)(options.mimeType, outputType, finalAs), options.startTime, failed, cTimeMs);
+                }
+            };
+            let tempKey, tempFile;
+            if (options.cache) {
+                let ctimeMs;
+                [buffer, tempFile, ctimeMs] = getImageCache.call(instance, tempKey = file + command + (options.mimeType || ''));
+                if (buffer) {
+                    writeMessage(false, ctimeMs);
+                    return Promise.resolve(buffer);
+                }
+            }
+            instance.formatMessage(Image.LOG_TYPE.IMAGE, "jimp" /* STRINGS.MODULE_NAME */, ["Transforming image..." /* STRINGS.TRANSFORM */, filename], command);
+            Image.initCpuUsage(instance);
+            return performCommand(null, instance, file, command, outputType, finalAs)
+                .then(async (handler) => {
+                const result = await handler.getBuffer(options.tempFile, saveAs);
+                instance.flushLog();
+                writeMessage(!result || instance.errors.length > 0);
+                if (result && tempKey && tempFile) {
+                    setImageCache.call(instance, tempKey, tempFile, result, file);
+                }
+                return result;
+            })
+                .catch(() => empty())
+                .finally(() => buffer && !options.cache && removeFile(file));
+        }
+        return empty();
+    }
+    parseRotate(value) {
+        const data = super.parseRotate(value);
+        if (data && this.settings.jimp?.rotate_clockwise) {
+            const values = data.values;
+            for (let i = 0; i < values.length; ++i) {
+                values[i] *= -1;
+            }
+        }
+        return data;
+    }
+    async using(data, command) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            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" /* ERR_MESSAGE.UNKNOWN */, !localUri ? 'URI' : 'MIME'));
+                return;
+            }
+            if (!this.canRead(localUri, { ownPermissionOnly: true })) {
+                reject((0, types_1.errorValue)("Not permitted to read file" /* ERR_MESSAGE.UNSUPPORTED_READ */, localUri));
+                return;
+            }
+            const [outputType, saveAs, finalAs] = (0, util_1.parseFormat)(command = command.trim(), mimeType, true);
+            if (!outputType) {
+                reject((0, types_1.errorValue)("Invalid format" /* ERR_MESSAGE.FORMAT */, /^\w+/.exec(command)?.[0] || "Unknown" /* ERR_MESSAGE.UNKNOWN */));
+                return;
+            }
+            const replace = command.indexOf('@') !== -1;
+            const output = host.addCopy(data.getObject({ command, outputType }), saveAs, replace);
+            if (!output) {
+                reject((0, types_1.errorValue)("Not able to copy file" /* ERR_MESSAGE.NOT_COPYABLE */, outputType));
+                return;
+            }
+            if (!this.canWrite(output, { ownPermissionOnly: true })) {
+                reject((0, types_1.errorValue)("Not permitted to write file" /* ERR_MESSAGE.UNSUPPORTED_WRITE */, output));
+                return;
+            }
+            const startTime = process.hrtime();
+            const success = (result, ctimeMs) => {
+                const filename = path.basename(result);
+                if (file.document) {
+                    host.writeImage(file.document, data.getObject({ command, output: result }));
+                }
+                if (host.getLocalUri(data) !== result) {
+                    if (command.indexOf('%') !== -1) {
+                        const files = host.filesToCompare.get(file);
+                        if (files) {
+                            files.push(result);
+                        }
+                        else {
+                            host.filesToCompare.set(file, [result]);
+                        }
+                    }
+                    else if (replace) {
+                        host.replace(file, result);
+                    }
+                    else {
+                        host.add(result, file);
+                    }
+                }
+                if (replace && file.localUri !== output && !host.assets.find(item => item.localUri === output && !item.invalid)) {
+                    host.filesToRemove.add(output);
+                }
+                formatMessage.call(this, (0, util_1.showInputType)(mimeType, outputType, finalAs) + filename, startTime, false, ctimeMs);
+                resolve();
+            };
+            let tempKey, tempFile;
+            if (this.settings.cache && (file.etag || file.buffer)) {
+                let buffer, ctimeMs;
+                [buffer, tempFile] = getImageCache.call(this, tempKey = (file.etag || Image.asHash(file.buffer)) + command + mimeType);
+                if (buffer) {
+                    const result = finalAs === 'webp' ? (0, util_1.renameExt)(output, 'webp', replace) : output;
+                    fs.writeFileSync(result, file.buffer = buffer);
+                    success(result, ctimeMs);
+                    return;
+                }
+            }
+            const finalize = (value) => {
+                if (tempFile && tempKey) {
+                    setImageCache.call(this, tempKey, tempFile, value);
+                }
+                if (replace) {
+                    delete file.buffer;
+                }
+                success(value);
+            };
+            const transformBuffer = (bmpFile) => {
+                startMessage();
+                performCommand(host, this, localUri, command, outputType, finalAs, bmpFile || file.buffer, file)
+                    .then((img) => {
+                    if (typeof bmpFile === 'string') {
+                        removeFile(bmpFile);
+                    }
+                    const errorResponse = (err) => {
+                        this.writeFail(["Unable to finalize image" /* ERR_IMAGE.FINALIZE */, "jimp" /* STRINGS.MODULE_NAME */], err, { type: 2048 /* LOG_TYPE.IMAGE */, startTime });
+                        resolve();
+                    };
+                    if (outputType === jimp.MIME_GIF) {
+                        try {
+                            const { GifUtil, GifFrame } = gifwrap;
+                            const frame = new GifFrame(img.handler.bitmap);
+                            GifUtil.quantizeSorokin(frame, 256);
+                            GifUtil.write(output, [frame])
+                                .then(() => finalize(output))
+                                .catch(err => errorResponse(err));
+                        }
+                        catch (err) {
+                            errorResponse(err);
+                        }
+                    }
+                    else {
+                        img.write(output, (err, result) => {
+                            if (!err && result) {
+                                finalize(result);
+                            }
+                            else {
+                                errorResponse(err || new Error("Unknown" /* ERR_MESSAGE.UNKNOWN */));
+                            }
+                        });
+                    }
+                })
+                    .catch(err => {
+                    this.writeFail(["Unable to read buffer" /* ERR_MESSAGE.READ_BUFFER */, path.basename(localUri)], err, { type: 2048 /* LOG_TYPE.IMAGE */, startTime });
+                    resolve();
+                });
+            };
+            const errorResponse = (err) => {
+                this.writeFail(["Unable to convert file" /* ERR_MESSAGE.CONVERT_FILE */, path.basename(localUri)], err, { type: 2048 /* LOG_TYPE.IMAGE */, startTime });
+                resolve();
+            };
+            const rotateAnim = (cmd) => {
+                const rotate = cmd.rotate;
+                if (rotate) {
+                    rotate.values = [rotate.values.pop()];
+                }
+            };
+            const hasTransform = (cmd) => !!(cmd.rotate || cmd.opacity >= 0 && cmd.opacity < 1 || cmd.resize || cmd.crop || cmd.method);
+            const startMessage = () => host.formatMessage(2048 /* LOG_TYPE.IMAGE */, "jimp" /* STRINGS.MODULE_NAME */, ["Transforming image..." /* STRINGS.TRANSFORM */, path.basename(localUri)], command);
+            if (mimeType === jimp.MIME_GIF) {
+                if (outputType === jimp.MIME_GIF || outputType === "image/webp" /* STRINGS.MIME_WEBP */) {
+                    const cmd = this.parseCommand(command);
+                    const transformWebP = (target, modified) => {
+                        var _a;
+                        if (finalAs === 'webp') {
+                            if (!modified) {
+                                startMessage();
+                            }
+                            const { path: webp_path, gif2webp } = (_a = this.settings).webp || (_a.webp = {});
+                            const webp = (0, util_1.renameExt)(output, 'webp', replace);
+                            const args = [(0, util_1.normalizePath)(target)];
+                            const quality = cmd.quality;
+                            if (quality) {
+                                if (!isNaN(quality.value)) {
+                                    args.push('-q', quality.value.toString());
+                                }
+                                if (!isNaN(quality.method)) {
+                                    args.push('-m', quality.method.toString());
+                                }
+                            }
+                            if (Array.isArray(gif2webp)) {
+                                for (let i = 0, length = gif2webp.length; i < length; ++i) {
+                                    const arg = gif2webp[i];
+                                    switch (arg) {
+                                        case '-h':
+                                        case '-version':
+                                            continue;
+                                        case '-o':
+                                            ++i;
+                                            continue;
+                                        case '-q':
+                                        case '-m':
+                                            if (args.includes(arg)) {
+                                                ++i;
+                                                continue;
+                                            }
+                                            break;
+                                        case '--':
+                                            i = length;
+                                            continue;
+                                    }
+                                    args.push(arg);
+                                }
+                            }
+                            args.push('-o', (0, util_1.normalizePath)(webp));
+                            try {
+                                child_process.execFile((0, util_1.getWebP_bin)('gif2webp', webp_path), args, { shell: true, signal: this.signal }, (err, stdout) => {
+                                    if (!err) {
+                                        this.addLog(types_1.STATUS_TYPE.INFO, stdout);
+                                        finalize(webp);
+                                    }
+                                    else {
+                                        errorResponse(err);
+                                    }
+                                });
+                            }
+                            catch (err) {
+                                if (this.checkPackage(err, 'gif2webp-bin@3', 2048 /* LOG_TYPE.IMAGE */)) {
+                                    resolve();
+                                }
+                                else {
+                                    errorResponse(err);
+                                }
+                            }
+                        }
+                        else if (modified) {
+                            finalize(output);
+                        }
+                        else {
+                            resolve();
+                        }
+                    };
+                    if (hasTransform(cmd)) {
+                        try {
+                            startMessage();
+                            const { GifUtil, BitmapImage } = gifwrap;
+                            GifUtil.read(file.buffer || localUri)
+                                .then(gif => {
+                                rotateAnim(cmd);
+                                Promise.all(gif.frames.map(frame => {
+                                    const handler = new JimpHandler(GifUtil.shareAsJimp(jimp, frame), this);
+                                    return transformCommand(localUri, handler, cmd, jimp.MIME_GIF);
+                                }))
+                                    .then(items => {
+                                    const frames = gif.frames;
+                                    for (let i = 0, length = items.length; i < length; ++i) {
+                                        const img = new BitmapImage(items[i].handler.bitmap);
+                                        GifUtil.quantizeSorokin(img, 256);
+                                        frames[i].bitmap = img.bitmap;
+                                    }
+                                    GifUtil.write(output, frames, gif)
+                                        .then(() => transformWebP(output, true))
+                                        .catch(err => errorResponse(err));
+                                })
+                                    .catch(err => errorResponse(err));
+                            })
+                                .catch(err => errorResponse(err));
+                        }
+                        catch (err) {
+                            errorResponse(err);
+                        }
+                    }
+                    else {
+                        transformWebP(localUri, false);
+                    }
+                }
+                else {
+                    transformBuffer();
+                }
+            }
+            else if (mimeType === "image/webp" /* STRINGS.MIME_WEBP */) {
+                const tryWebpMux = async () => {
+                    let loaded;
+                    try {
+                        const webp = new (require('node-webpmux').Image)();
+                        loaded = true;
+                        if (Image.supported(18, 1)) {
+                            this.formatMessage(2048 /* LOG_TYPE.IMAGE */, 'WARN', 'node-webpmux is not compatible with global fetch', 'NodeJS: --no-experimental-fetch', { ...Image.LOG_STYLE_WARN });
+                        }
+                        await webp.initLib();
+                        await webp.load(host.getBuffer(file));
+                        if (!(webp.hasAnim && (outputType === "image/webp" /* STRINGS.MIME_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);
+                            return true;
+                        }
+                        const cmd = this.parseCommand(command);
+                        if (hasTransform(cmd)) {
+                            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);
+                                handler.background(webp.anim.bgColor);
+                                return transformCommand(localUri, handler, cmd, jimp.MIME_BMP);
+                            }))
+                                .then(items => {
+                                const length = items.length;
+                                if (outputType === jimp.MIME_GIF) {
+                                    try {
+                                        const { GifFrame, GifUtil, BitmapImage } = gifwrap;
+                                        const frames = new Array(length);
+                                        for (let i = 0; i < length; ++i) {
+                                            const { x, y, delay } = webp.frames[i];
+                                            const img = new BitmapImage(items[i].handler.bitmap);
+                                            GifUtil.quantizeSorokin(img, 256);
+                                            frames[i] = new GifFrame(new BitmapImage(img), { xOffset: x, yOffset: y, delayCentisecs: delay / 10 });
+                                        }
+                                        GifUtil.write(output, frames, { loops: webp.anim.loops })
+                                            .then(() => finalize(output))
+                                            .catch(err => errorResponse(err));
+                                    }
+                                    catch (err) {
+                                        errorResponse(err);
+                                    }
+                                }
+                                else {
+                                    const { value: q = NaN, method: m = NaN, preset } = cmd.quality || {};
+                                    const quality = !isNaN(q) ? q : undefined;
+                                    const method = !isNaN(m) ? m : undefined;
+                                    rotateAnim(cmd);
+                                    const frames = new Array(length);
+                                    let w = 0, h = 0;
+                                    for (let i = 0; i < length; ++i) {
+                                        const { width, height, data: buffer } = items[i].handler.bitmap;
+                                        frames[i] = webp.setFrameData(i, buffer, { width, height, quality, method, preset });
+                                        w = Math.max(w, width);
+                                        h = Math.max(h, height);
+                                    }
+                                    Promise.all(frames)
+                                        .then(() => {
+                                        webp.save(output, { width: w, height: h, bgColor: cmd.rotate ? [0, 0, 0, 0] : undefined })
+                                            .then(() => finalize(output))
+                                            .catch(err => errorResponse(err));
+                                    })
+                                        .catch(err => errorResponse(err));
+                                }
+                            })
+                                .catch(err => errorResponse(err));
+                        }
+                        else {
+                            resolve();
+                        }
+                        return true;
+                    }
+                    catch (err) {
+                        if (loaded) {
+                            this.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, 'node-webpmux'], err, { type: 2048 /* LOG_TYPE.IMAGE */, startTime });
+                        }
+                        else if (this.checkPackage(err, 'node-webpmux@3', 2048 /* LOG_TYPE.IMAGE */)) {
+                            resolve();
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+                const { path: webp_path } = (_a = this.settings).webp || (_a.webp = {});
+                const bmpFile = getTempPath.call(this, 'bmp');
+                try {
+                    child_process.execFile((0, util_1.getWebP_bin)('dwebp', webp_path), [(0, util_1.normalizePath)(localUri), '-bmp', '-o', (0, util_1.normalizePath)(bmpFile)], { shell: true, signal: this.signal }, err => {
+                        if (!err) {
+                            transformBuffer(bmpFile);
+                        }
+                        else {
+                            removeFile(bmpFile);
+                            tryWebpMux().then(valid => !valid && errorResponse(err));
+                        }
+                    });
+                }
+                catch (err) {
+                    if (!await tryWebpMux()) {
+                        if (this.checkPackage(err, 'dwebp-bin@1', 2048 /* LOG_TYPE.IMAGE */)) {
+                            resolve();
+                        }
+                        else {
+                            errorResponse(err);
+                        }
+                    }
+                }
+            }
+            else {
+                transformBuffer();
+            }
+        });
+    }
+    get settings() {
+        var _a;
+        return (_a = this.module).settings || (_a.settings = {});
+    }
+}
+
+module.exports = Jimp;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@pi-r/jimp",
+  "version": "0.0.1",
+  "description": "Jimp image constructor for E-mc.",
+  "main": "index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/pi-r.git",
+    "directory": "src/module/jimp"
+  },
+  "keywords": [
+    "squared",
+    "e-mc",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/anpham6/pi-r#readme",
+  "dependencies": {
+    "@e-mc/image": "^0.4.0",
+    "@e-mc/types": "^0.4.0",
+    "bmp-js": "^0.1.0",
+    "gifwrap": "^0.9.4",
+    "jimp": "^0.22.7"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,19 @@
+import type { IHost, IImage, ImageConstructor } from '@e-mc/types/lib';
+import type { ImageModule } from '@e-mc/types/lib/settings';
+
+import type { ImageHandler } from '@e-mc/image/types';
+
+import type * as jimp from 'jimp';
+
+export interface IJimpHandler<T extends IHost = IHost, U extends ImageModule = ImageModule> extends ImageHandler<jimp, T, IImage<T, U>> {
+    method(): Promise<void>;
+    rotate(localFile?: string, callback?: ResultCallback<string>): Promise<this>;
+    background(value: number | [number, number, number, number]): void;
+    writeAsync(output: string, callback?: ResultCallback): Promise<void>;
+}
+
+export interface JimpImageConstructor extends ImageConstructor {
+    new(handler: jimp, instance: IImage, host?: Null<IHost>): IJimpHandler;
+}
+
+export type ResultCallback<T = unknown, U = void, V = unknown> = (err: V, result: T) => U;

package/util.d.ts

@@ -0,0 +1,10 @@
+declare namespace util {
+    function parseFormat(command: string, mimeType?: string, gif?: boolean): [string, string, string];
+    function renameExt(output: string, ext: string, replace?: boolean): string;
+    function normalizePath(value: string): string;
+    function getWebP_bin(name: string, pathname: string | undefined): string;
+    function showInputType(value: string | undefined, outputType: string, finalAs: string): string;
+    function showOutputType(value: string | undefined, outputType: string, finalAs: string): string;
+}
+
+export = util;

package/util.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showOutputType = exports.showInputType = exports.getWebP_bin = exports.normalizePath = exports.renameExt = exports.parseFormat = exports.MIME_OUTPUT = exports.MIME_INPUT = void 0;
+const path = require("path");
+const fs = require("fs");
+const jimp = require("jimp");
+const types_1 = require("@e-mc/types");
+const Image = require("@e-mc/image");
+exports.MIME_INPUT = new Set([jimp.MIME_PNG, jimp.MIME_JPEG, jimp.MIME_BMP, jimp.MIME_GIF, jimp.MIME_TIFF, "image/webp" /* STRINGS.MIME_WEBP */]);
+exports.MIME_OUTPUT = new Set([jimp.MIME_PNG, jimp.MIME_JPEG, jimp.MIME_BMP, jimp.MIME_GIF, "image/webp" /* STRINGS.MIME_WEBP */]);
+function parseFormat(command, mimeType, gif) {
+    command = command.toLowerCase();
+    for (let mime of exports.MIME_OUTPUT) {
+        let saveAs = mime.split('/')[1];
+        if (command.startsWith(saveAs)) {
+            let finalAs = '';
+            if (saveAs !== 'gif') {
+                switch (saveAs) {
+                    case 'jpeg':
+                        saveAs = 'jpg';
+                        break;
+                    case 'webp':
+                        if (mimeType === "image/webp" /* STRINGS.MIME_WEBP */) {
+                            try {
+                                require('node-webpmux');
+                                mime = "image/webp" /* STRINGS.MIME_WEBP */;
+                                break;
+                            }
+                            catch {
+                            }
+                        }
+                        if (mimeType === jimp.MIME_JPEG) {
+                            mime = jimp.MIME_JPEG;
+                            saveAs = 'jpg';
+                        }
+                        else if (gif && mimeType === jimp.MIME_GIF) {
+                            mime = jimp.MIME_GIF;
+                            saveAs = 'gif';
+                        }
+                        else {
+                            mime = jimp.MIME_PNG;
+                            saveAs = 'png';
+                        }
+                        finalAs = 'webp';
+                        break;
+                }
+            }
+            else if (!gif) {
+                break;
+            }
+            return [mime, saveAs, finalAs];
+        }
+    }
+    return ['', '', ''];
+}
+exports.parseFormat = parseFormat;
+function renameExt(output, ext, replace) {
+    let result = (0, types_1.renameExt)(output.replace('.__copy__.', '.'), ext);
+    if (!replace) {
+        const pathname = result;
+        let i = 0;
+        while (Image.isPath(result)) {
+            result = pathname.substring(0, pathname.lastIndexOf('.') + 1) + `(${++i}).` + ext;
+        }
+    }
+    return result;
+}
+exports.renameExt = renameExt;
+function normalizePath(value) {
+    return '"' + value.replace(/"/g, '\\"') + '"';
+}
+exports.normalizePath = normalizePath;
+function getWebP_bin(name, pathname) {
+    if (pathname && fs.existsSync(pathname)) {
+        name += process.platform === 'win32' ? '.exe' : '';
+        const bin = path.join(pathname, name);
+        return Image.sanitizeCmd(fs.existsSync(bin) ? bin : path.join(pathname, 'bin', name));
+    }
+    return require(name + '-bin');
+}
+exports.getWebP_bin = getWebP_bin;
+function showInputType(value, outputType, finalAs) {
+    if (finalAs) {
+        outputType = 'image/' + finalAs;
+    }
+    return value && outputType !== value ? value.split('/').pop() + ' -> ' : '';
+}
+exports.showInputType = showInputType;
+function showOutputType(value, outputType, finalAs) {
+    if (finalAs) {
+        outputType = 'image/' + finalAs;
+    }
+    return value !== outputType ? ' -> ' + outputType.split('/').pop() : '';
+}
+exports.showOutputType = showOutputType;