@pi-r/jimp 0.7.3 → 0.8.1

package/index.js

@@ -5,12 +5,13 @@ const child_process = require("child_process");
 const jimp = require("jimp");
 const gifwrap = require("gifwrap");
 const bmp = require("bmp-js");
+const crypto_1 = require("crypto");
 const types_1 = require("@e-mc/types");
 const Image = require('@e-mc/image');
 let WEBPMUX = null, WEBPMUX_INIT = false;
 try {
     WEBPMUX = require('node-webpmux');
-    new WEBPMUX.Image().initLib().then(() => WEBPMUX_INIT = true);
+    void new WEBPMUX.Image().initLib().then(() => WEBPMUX_INIT = true);
 }
 catch {
 }
@@ -80,9 +81,9 @@ function getMethodName(value) {
     }
 }
 async function performCommand(host, instance, localUri, command, outputType, finalAs, buffer, parent) {
-    return jimp.read((buffer || localUri))
+    return await jimp.read((buffer || localUri))
         .then(async (img) => {
-        return transformCommand(localUri, new JimpHandler(img, instance, host), command, outputType, finalAs, parent);
+        return await transformCommand(localUri, new JimpHandler(img, instance, host), command, outputType, finalAs, parent);
     });
 }
 function execOptions(settings) {
@@ -117,19 +118,18 @@ async function transformCommand(localFile, handler, command, outputType, outputA
             return handler;
         case 1:
             return handler.rotate();
-        default:
-            return handler.rotate(localFile, (err, result) => {
-                if (!err && handler.host?.moduleName === 'filemanager') {
-                    try {
-                        handler.host.add(result, parent);
-                    }
-                    catch {
-                    }
-                }
-            });
     }
+    return handler.rotate(localFile, (err, result) => {
+        if (!err && handler.host?.moduleName === 'filemanager') {
+            try {
+                handler.host.add(result, parent);
+            }
+            catch {
+            }
+        }
+    });
 }
-function setImageCache(tempKey, tempFile, output, localFile) {
+function setImageCache(instance, tempKey, tempFile, output, localFile) {
     try {
         if (typeof output === 'string') {
             fs.copyFileSync(output, tempFile);
@@ -137,7 +137,7 @@ function setImageCache(tempKey, tempFile, output, localFile) {
         else {
             fs.writeFileSync(tempFile, output);
         }
-        const stored = getCacheData.call(this);
+        const stored = getCacheData(instance);
         if (localFile) {
             const { ctimeMs, mtimeMs, size } = fs.statSync(localFile);
             stored[tempKey] = { tempKey, tempFile, ctimeMs, localFile, mtimeMs, size };
@@ -145,7 +145,7 @@ function setImageCache(tempKey, tempFile, output, localFile) {
         else {
             stored[tempKey] = { tempKey, tempFile, ctimeMs: Date.now() };
         }
-        if (this.settings.jimp.cache_expires) {
+        if (instance.settings.jimp.cache_expires) {
             fs.writeFile(tempFile + '.json', JSON.stringify(stored[tempKey]), 'utf-8', () => { });
         }
     }
@@ -153,8 +153,8 @@ function setImageCache(tempKey, tempFile, output, localFile) {
         TEMP_DIR = '';
     }
 }
-function getImageCache(tempKey) {
-    const stored = getCacheData.call(this);
+function getImageCache(instance, tempKey) {
+    const stored = getCacheData(instance);
     const data = stored[tempKey];
     if (data) {
         const { tempFile, localFile, ctimeMs, mtimeMs, size } = data;
@@ -173,13 +173,13 @@ function getImageCache(tempKey) {
         removeFile(tempFile);
         delete stored[tempKey];
     }
-    TEMP_DIR ||= this.getTempDir({ moduleDir: true, increment: 5 });
-    return [null, TEMP_DIR ? path.join(TEMP_DIR, (0, types_1.generateUUID)()) : ''];
+    TEMP_DIR ||= instance.getTempDir({ moduleDir: true, increment: 5 });
+    return [null, TEMP_DIR ? path.join(TEMP_DIR, (0, crypto_1.randomUUID)()) : ''];
 }
-function getCacheData() {
+function getCacheData(instance) {
     if (!CACHE_INIT) {
-        TEMP_DIR = this.getTempDir({ moduleDir: true, increment: 5 });
-        const settings = this.settings.jimp ||= {};
+        TEMP_DIR = instance.getTempDir({ moduleDir: true, increment: 5 });
+        const settings = instance.settings.jimp ||= {};
         const expires = (0, types_1.parseExpires)(settings.cache_expires || 0);
         if (expires === 0) {
             settings.cache_expires = 0;
@@ -189,10 +189,10 @@ function getCacheData() {
                 Image.removeDir(TEMP_DIR, true);
             }
             else {
-                const current = Date.now();
                 try {
+                    const current = Date.now();
                     fs.readdirSync(TEMP_DIR, { withFileTypes: true }).forEach(item => {
-                        if (item.isFile() && item.name.endsWith('.json')) {
+                        if (item.isFile() && path.extname(item.name) === '.json') {
                             const pathname = path.join(TEMP_DIR, item.name);
                             try {
                                 const data = JSON.parse(fs.readFileSync(pathname, 'utf-8'));
@@ -218,19 +218,29 @@ function getCacheData() {
     }
     return CACHE_TRANSFORM;
 }
-function formatMessage(value, startTime, failed, cTimeMs) {
+function formatMessage(instance, value, startTime, failed, cTimeMs) {
     if (cTimeMs) {
-        this.formatMessage(2048, "jimp", [value, 'cache'], new Date(cTimeMs).toLocaleString(), { ...Image.LOG_STYLE_NOTICE, hintBold: true });
+        instance.formatMessage(2048, "jimp", [value, 'cache'], new Date(cTimeMs).toLocaleString(), { ...Image.LOG_STYLE_NOTICE, hintBold: true });
     }
     else if (startTime) {
-        this.writeTimeProcess("jimp", value, startTime, { type: 2048, failed });
+        instance.writeTimeProcess("jimp", value, startTime, { type: 2048, 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);
+function getTempPath(instance, ext) {
+    const tempDir = TEMP_DIR || instance.getTempDir({ moduleDir: true, createDir: true }) || instance.getTempDir();
+    return path.join(tempDir, (0, crypto_1.randomUUID)() + '.' + ext);
 }
-const removeFile = (pathname) => fs.unlink(pathname, () => { });
+function rotateAnim(cmd) {
+    const rotate = cmd.rotate;
+    if (rotate) {
+        rotate.values = [rotate.values.pop()];
+    }
+}
+function removeFile(pathname) {
+    fs.unlink(pathname, () => { });
+}
+const hasTransform = (cmd) => !!(cmd.rotate || cmd.opacity >= 0 && cmd.opacity < 1 || cmd.resize || cmd.crop || cmd.method);
+const emptyResult = (options) => (options.tempFile ? '' : null);
 class JimpHandler {
     handler;
     instance;
@@ -264,14 +274,18 @@ class JimpHandler {
                     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", "jimp"], err, 2048)));
+                        .then(() => {
+                        this.finalize(output, callback);
+                    })
+                        .catch((err) => {
+                        this.instance.writeFail(["Unable to rotate image", "jimp"], err, 2048);
+                    }));
                 }
             }
             if (deg) {
                 handler.rotate(deg);
             }
-            if (tasks.length) {
+            if (tasks.length > 0) {
                 return Promise.all(tasks).then(() => this);
             }
         }
@@ -440,7 +454,11 @@ class JimpHandler {
                     else if (webp !== output) {
                         const tempFile = output;
                         queueMicrotask(() => {
-                            fs.unlink(tempFile, error => !error && fs.rmdir(path.dirname(tempFile), () => { }));
+                            fs.unlink(tempFile, error => {
+                                if (!error) {
+                                    fs.rmdir(path.dirname(tempFile), () => { });
+                                }
+                            });
                         });
                         output = filename;
                     }
@@ -462,7 +480,7 @@ class JimpHandler {
     }
     async 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()));
+        const output = getTempPath(this.instance, this.instance.outputAs || (saveAs && util_1.MIME_OUTPUT.has('image/' + (saveAs === 'jpg' ? 'jpeg' : saveAs)) ? saveAs : this.handler.getMIME().split('/').pop()));
         return !output ? empty() : new Promise(resolve => {
             this.handler.write(output, error => {
                 if (error) {
@@ -484,7 +502,13 @@ class JimpHandler {
                             this.instance.writeFail(["Unable to read file", path.basename(result)], err, 32);
                             resolve(null);
                         }
-                        queueMicrotask(() => fs.unlink(result, err => !err && this.instance.emit('file:delete', result)));
+                        finally {
+                            fs.unlink(result, err => {
+                                if (!err) {
+                                    this.instance.emit('file:delete', result);
+                                }
+                            });
+                        }
                     }
                 });
             });
@@ -541,7 +565,9 @@ class JimpHandler {
             return;
         }
         return this.handler.writeAsync(output)
-            .then(() => this.finalize(output, callback))
+            .then(() => {
+            this.finalize(output, callback);
+        })
             .catch((err) => {
             if (callback) {
                 callback(err, '');
@@ -564,24 +590,23 @@ class JimpHandler {
 class Jimp extends Image {
     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) {
-            return empty();
+            return emptyResult(options);
         }
         const instance = new Jimp(options.module);
         let buffer = null;
         if (Buffer.isBuffer(file)) {
             const tempDir = TEMP_DIR || instance.getTempDir();
             if (!this.createDir(tempDir)) {
-                return empty();
+                return emptyResult(options);
             }
             try {
                 const { ext } = await this.resolveMime(file) || { ext: 'unknown' };
                 buffer = file;
-                fs.writeFileSync(file = path.join(tempDir, (0, types_1.generateUUID)() + '.' + ext), buffer);
+                fs.writeFileSync(file = path.join(tempDir, (0, crypto_1.randomUUID)() + '.' + ext), buffer);
             }
             catch {
-                return empty();
+                return emptyResult(options);
             }
             options.cache = false;
         }
@@ -600,13 +625,13 @@ class Jimp extends Image {
         }
         const writeMessage = (failed, cTimeMs) => {
             if (cTimeMs || options.startTime) {
-                formatMessage.call(instance, filename + (0, util_1.showOutputType)(options.mimeType, outputType, finalAs), options.startTime, failed, cTimeMs);
+                formatMessage(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 || ''));
+            [buffer, tempFile, ctimeMs] = getImageCache(instance, tempKey = file + command + (options.mimeType || ''));
             if (buffer) {
                 writeMessage(false, ctimeMs);
                 return buffer;
@@ -620,12 +645,18 @@ class Jimp extends Image {
             instance.flushLog();
             writeMessage(!result || instance.errors.length > 0);
             if (result && tempKey && tempFile) {
-                setImageCache.call(instance, tempKey, tempFile, result, file);
+                setImageCache(instance, tempKey, tempFile, result, file);
             }
             return result;
         })
-            .catch(() => empty())
-            .finally(() => buffer && !options.cache && removeFile(file));
+            .catch(() => {
+            return emptyResult(options);
+        })
+            .finally(() => {
+            if (buffer && !options.cache) {
+                removeFile(file);
+            }
+        });
     }
     _moduleName = "jimp";
     _threadable = true;
@@ -697,13 +728,13 @@ class Jimp extends Image {
                 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);
+                formatMessage(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);
+                [buffer, tempFile] = getImageCache(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);
@@ -713,7 +744,7 @@ class Jimp extends Image {
             }
             const finalize = (value) => {
                 if (tempFile && tempKey) {
-                    setImageCache.call(this, tempKey, tempFile, value);
+                    setImageCache(this, tempKey, tempFile, value);
                 }
                 if (replace) {
                     delete file.buffer;
@@ -737,8 +768,10 @@ class Jimp extends Image {
                             const frame = new GifFrame(img.handler.bitmap);
                             GifUtil.quantizeSorokin(frame, 256);
                             GifUtil.write(output, [frame])
-                                .then(() => finalize(output))
-                                .catch((err) => errorResponse(err));
+                                .then(() => {
+                                finalize(output);
+                            })
+                                .catch(errorResponse);
                         }
                         catch (err) {
                             errorResponse(err);
@@ -764,14 +797,9 @@ class Jimp extends Image {
                 this.writeFail(["Unable to convert file", path.basename(localUri)], err, { type: 2048, startTime });
                 resolve();
             };
-            const rotateAnim = (cmd) => {
-                const rotate = cmd.rotate;
-                if (rotate) {
-                    rotate.values = [rotate.values.pop()];
-                }
+            const startMessage = () => {
+                host.formatMessage(2048, "jimp", ["Transforming image...", path.basename(localUri)], command);
             };
-            const hasTransform = (cmd) => !!(cmd.rotate || cmd.opacity >= 0 && cmd.opacity < 1 || cmd.resize || cmd.crop || cmd.method);
-            const startMessage = () => host.formatMessage(2048, "jimp", ["Transforming image...", path.basename(localUri)], command);
             if (mimeType === jimp.MIME_GIF) {
                 if (outputType === jimp.MIME_GIF || outputType === "image/webp") {
                     const cmd = this.parseCommand(command);
@@ -857,19 +885,34 @@ class Jimp extends Image {
                                     return transformCommand(localUri, handler, cmd, jimp.MIME_GIF);
                                 }))
                                     .then(items => {
+                                    const quantize = this.settings.jimp?.gifwrap_quantize || '';
                                     const frames = gif.frames;
                                     for (let i = 0, length = items.length; i < length; ++i) {
                                         const img = new BitmapImage(items[i].handler.bitmap);
-                                        GifUtil.quantizeSorokin(img, 256);
+                                        switch (quantize) {
+                                            case 'none':
+                                                break;
+                                            case 'dekker':
+                                                GifUtil.quantizeDekker(img, 256);
+                                                break;
+                                            case 'wu':
+                                                GifUtil.quantizeWu(img, 256);
+                                                break;
+                                            default:
+                                                GifUtil.quantizeSorokin(img, 256);
+                                                break;
+                                        }
                                         frames[i].bitmap = img.bitmap;
                                     }
                                     GifUtil.write(output, frames, gif)
-                                        .then(() => transformWebP(output, true))
-                                        .catch((err) => errorResponse(err));
+                                        .then(() => {
+                                        transformWebP(output, true);
+                                    })
+                                        .catch(errorResponse);
                                 })
-                                    .catch((err) => errorResponse(err));
+                                    .catch(errorResponse);
                             })
-                                .catch((err) => errorResponse(err));
+                                .catch(errorResponse);
                         }
                         catch (err) {
                             errorResponse(err);
@@ -909,16 +952,31 @@ class Jimp extends Image {
                                 if (outputType === jimp.MIME_GIF) {
                                     try {
                                         const { GifFrame, GifUtil, BitmapImage } = gifwrap;
+                                        const quantize = this.settings.jimp?.gifwrap_quantize || '';
                                         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);
+                                            switch (quantize) {
+                                                case 'none':
+                                                    break;
+                                                case 'dekker':
+                                                    GifUtil.quantizeDekker(img, 256);
+                                                    break;
+                                                case 'wu':
+                                                    GifUtil.quantizeWu(img, 256);
+                                                    break;
+                                                default:
+                                                    GifUtil.quantizeSorokin(img, 256);
+                                                    break;
+                                            }
                                             frames[i] = 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));
+                                            .then(() => {
+                                            finalize(output);
+                                        })
+                                            .catch(errorResponse);
                                     }
                                     catch (err) {
                                         errorResponse(err);
@@ -940,13 +998,15 @@ class Jimp extends Image {
                                     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));
+                                            .then(() => {
+                                            finalize(output);
+                                        })
+                                            .catch(errorResponse);
                                     })
-                                        .catch((err) => errorResponse(err));
+                                        .catch(errorResponse);
                                 }
                             })
-                                .catch((err) => errorResponse(err));
+                                .catch(errorResponse);
                         }
                         else {
                             resolve();
@@ -966,7 +1026,7 @@ class Jimp extends Image {
                 };
                 const settings = this.settings;
                 const { path: webp_path } = settings.webp ||= {};
-                const bmpFile = getTempPath.call(this, 'bmp');
+                const bmpFile = getTempPath(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, ...execOptions(settings) }, err => {
                         if (!err) {
@@ -974,7 +1034,11 @@ class Jimp extends Image {
                         }
                         else {
                             removeFile(bmpFile);
-                            tryWebpMux().then(valid => !valid && errorResponse(err));
+                            void tryWebpMux().then(valid => {
+                                if (!valid) {
+                                    errorResponse(err);
+                                }
+                            });
                         }
                     });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/jimp",
-  "version": "0.7.3",
+  "version": "0.8.1",
   "description": "Jimp image constructor for E-mc.",
   "main": "index.js",
   "publishConfig": {
@@ -20,8 +20,8 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/image": "^0.9.6",
-    "@e-mc/types": "^0.9.6",
+    "@e-mc/image": "^0.10.0",
+    "@e-mc/types": "^0.10.0",
     "bmp-js": "^0.1.0",
     "gifwrap": "^0.10.1",
     "jimp": "^0.22.12"

package/types/index.d.ts

@@ -1,10 +1,24 @@
-import type { IHost, IImage, ImageConstructor } from '@e-mc/types/lib';
-import type { ImageModule } from '@e-mc/types/lib/settings';
+import type { IFileManager, IHost, IImage, ImageConstructor } from '@e-mc/types/lib';
+import type { ExternalAsset } from '@e-mc/types/lib/asset';
+import type { TransformOptions } from '@e-mc/types/lib/image';
+import type { ImageModule, ImageSettings } from '@e-mc/types/lib/settings';
+import type { ExecAction } from '@e-mc/types/lib/module';
 
 import type { ImageHandler } from '@e-mc/image/types';
 
 import type * as jimp from 'jimp';
 
+export interface JimpSettings extends ImageSettings {
+    jimp?: {
+        exec?: ExecAction;
+        cache_expires?: number | string;
+        rotate_clockwise?: boolean;
+        gifwrap_quantize?: "dekker" | "sorokin" | "wu" | "none";
+    };
+}
+
+export type ResultCallback<T = unknown, U = void, V = unknown> = (err: V, result: T) => U;
+
 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>;
@@ -12,8 +26,8 @@ export interface IJimpHandler<T extends IHost = IHost, U extends ImageModule = I
     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;
+export interface JimpImageConstructor<T extends IFileManager<U>, U extends ExternalAsset = ExternalAsset, V extends ImageModule = ImageModule<JimpSettings>> extends ConstructorDerived<ImageConstructor<T, V>> {
+    transform<W extends TransformOptions>(file: string, command: string, options?: W): Promise<W extends { tempFile: true } ? string : Null<Buffer>>;
+    readonly prototype: IImage<T, V>;
+    new(module?: V, ...args: unknown[]): IImage<T, V>;
+}

package/util.js

@@ -1,5 +1,11 @@
 "use strict";
-exports.showOutputType = exports.showInputType = exports.getWebP_bin = exports.normalizePath = exports.renameExt = exports.parseFormat = exports.MIME_OUTPUT = exports.MIME_INPUT = void 0;
+exports.MIME_OUTPUT = exports.MIME_INPUT = void 0;
+exports.parseFormat = parseFormat;
+exports.renameExt = renameExt;
+exports.normalizePath = normalizePath;
+exports.getWebP_bin = getWebP_bin;
+exports.showInputType = showInputType;
+exports.showOutputType = showOutputType;
 const path = require("path");
 const fs = require("fs");
 const jimp = require("jimp");
@@ -52,7 +58,6 @@ function parseFormat(command, mimeType, gif) {
     }
     return ['', '', ''];
 }
-exports.parseFormat = parseFormat;
 function renameExt(output, ext, replace) {
     let result = (0, types_1.renameExt)(output.replace('.__copy__.', '.'), ext);
     if (!replace) {
@@ -64,31 +69,26 @@ function renameExt(output, ext, replace) {
     }
     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' : '';
+        name += Image.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;