@e-mc/image 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e-mc/image",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Image constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,9 +20,7 @@
   "license": "BSD 3-Clause",
   "homepage": "https://github.com/anpham6/e-mc#readme",
   "dependencies": {
-    "@e-mc/core": "0.1.0",
-    "@e-mc/types": "0.1.0",
-    "bmp-js": "^0.1.0",
-    "jimp": "^0.22.7"
+    "@e-mc/core": "0.2.0",
+    "@e-mc/types": "0.2.0"
   }
 }

package/types/index.d.ts

@@ -1,3 +1,5 @@
+/// <reference path="../../types/index.d.ts" />
+
 export interface ImageHandler<T, U, V> {
     readonly handler: T;
     host: U | null;

package/jimp/image.d.ts

@@ -1,19 +0,0 @@
-import type { IHost, IImage, ImageConstructor } from '../../types/lib';
-
-import type { ImageHandler } from '../types';
-
-// @ts-ignore
-import type * as jimp from 'jimp';
-
-export interface IJimpHandler<T extends IHost = IHost> extends ImageHandler<jimp, T, IImage<T>> {
-    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/jimp/index.d.ts

@@ -1,5 +0,0 @@
-import type { JimpImageConstructor } from './image';
-
-declare const Jimp: JimpImageConstructor;
-
-export = Jimp;

package/jimp/index.js

@@ -1,998 +0,0 @@
-"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 bmp = require("bmp-js");
-const types_1 = require("../../types");
-const index_1 = require("../index");
-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);
-        const lastAccessed = Date.now();
-        if (localFile) {
-            const { mtimeMs, size } = fs.statSync(localFile);
-            stored[tempKey] = { tempKey, tempFile, lastAccessed, localFile, mtimeMs, size };
-        }
-        else {
-            stored[tempKey] = { tempKey, tempFile, lastAccessed };
-        }
-        writeImageData.call(this, tempFile, stored[tempKey]);
-    }
-    catch {
-        TEMP_DIR = '';
-    }
-}
-function getImageCache(tempKey) {
-    const stored = getCacheData.call(this);
-    const data = stored[tempKey];
-    if (data) {
-        const { tempFile, localFile, mtimeMs, size } = data;
-        try {
-            data.lastAccessed = Date.now();
-            writeImageData.call(this, tempFile, data);
-            if (!localFile) {
-                return [fs.readFileSync(tempFile)];
-            }
-            const stat = fs.statSync(localFile);
-            if (stat.mtimeMs === mtimeMs && stat.size === size) {
-                return [fs.readFileSync(tempFile)];
-            }
-        }
-        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 writeImageData(tempFile, data) {
-    if (this.settings.jimp.cache_expires) {
-        queueMicrotask(() => {
-            fs.writeFile(tempFile + '.json', JSON.stringify(data), 'utf-8', () => { });
-        });
-    }
-}
-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) {
-                index_1.default.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.lastAccessed + expires > current) {
-                                        CACHE_TRANSFORM[data.tempKey] = data;
-                                        return;
-                                    }
-                                    removeFile(data.tempFile);
-                                }
-                            }
-                            catch {
-                            }
-                            removeFile(pathname);
-                        }
-                    });
-                }
-                catch {
-                }
-            }
-        }
-        CACHE_INIT = true;
-    }
-    return CACHE_TRANSFORM;
-}
-function formatMessage(value, cacheFile, startTime, failed) {
-    if (cacheFile) {
-        this.formatMessage(2048 /* LOG_TYPE.IMAGE */, "jimp" /* STRINGS.MODULE_NAME */, [value, 'cache'], cacheFile, { ...index_1.default.LOG_STYLE_NOTICE, hintBold: true });
-    }
-    else {
-        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;
-    }
-}
-class Jimp extends index_1.default {
-    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 = (cache, failed) => {
-                if (options.startTime) {
-                    formatMessage.call(instance, filename + (0, util_1.showOutputType)(options.mimeType, outputType, finalAs), cache ? file : '', options.startTime, failed);
-                }
-            };
-            let tempKey, tempFile;
-            if (options.cache) {
-                [buffer, tempFile] = getImageCache.call(instance, tempKey = file + command + (options.mimeType || ''));
-                if (buffer) {
-                    writeMessage(true, false);
-                    return Promise.resolve(buffer);
-                }
-            }
-            instance.formatMessage(index_1.default.LOG_TYPE.IMAGE, "jimp" /* STRINGS.MODULE_NAME */, ["Transforming image..." /* STRINGS.TRANSFORM */, filename], command);
-            index_1.default.initCpuUsage(instance);
-            return performCommand(null, instance, file, command, outputType, finalAs)
-                .then(async (handler) => {
-                const result = await handler.getBuffer(options.tempFile, saveAs);
-                instance.flushLog();
-                writeMessage(false, !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, cache) => {
-                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, cache ? result : '', startTime, false);
-                resolve();
-            };
-            let tempKey, tempFile;
-            if (this.settings.cache && (file.etag || file.buffer)) {
-                let buffer;
-                [buffer, tempFile] = getImageCache.call(this, tempKey = (file.etag || index_1.default.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, true);
-                    return;
-                }
-            }
-            const finalize = (value) => {
-                if (tempFile && tempKey) {
-                    setImageCache.call(this, tempKey, tempFile, value);
-                }
-                if (replace) {
-                    delete file.buffer;
-                }
-                success(value, false);
-            };
-            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 } = require('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) {
-                            if (this.checkPackage(err, 'gifwrap', 2048 /* LOG_TYPE.IMAGE */)) {
-                                resolve();
-                            }
-                            else {
-                                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 } = require('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) {
-                            if (this.checkPackage(err, 'gifwrap', 2048 /* LOG_TYPE.IMAGE */)) {
-                                resolve();
-                            }
-                            else {
-                                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 (index_1.default.supported(18, 1)) {
-                            this.formatMessage(2048 /* LOG_TYPE.IMAGE */, 'WARN', 'node-webpmux is not compatible with global fetch', 'NodeJS: --no-experimental-fetch', { ...index_1.default.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: index_1.default.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: index_1.default.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 } = require('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) {
-                                        if (this.checkPackage(err, 'gifwrap', 2048 /* LOG_TYPE.IMAGE */)) {
-                                            resolve();
-                                        }
-                                        else {
-                                            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 = {});
-    }
-}
-exports.default = Jimp;
-
-if (exports.default) {
-    module.exports = exports.default;
-    module.exports.default = exports.default;
-}

package/jimp/util.d.ts

@@ -1,10 +0,0 @@
-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/jimp/util.js

@@ -1,95 +0,0 @@
-"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("../../types");
-const index_1 = require("../index");
-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 (index_1.default.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 index_1.default.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;