@digipair/skill-pdf2pic 0.94.0-0 → 0.94.0-1

package/dist/index.cjs.js

@@ -1,6 +1,4550 @@
 'use strict';
 
-var pdf2pic = require('pdf2pic');
+var require$$4 = require('stream');
+var require$$1$1 = require('events');
+var require$$1 = require('util');
+var require$$0 = require('fs');
+var require$$0$2 = require('child_process');
+var require$$0$1 = require('path');
+var require$$0$3 = require('tty');
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+function getDefaultExportFromCjs(x) {
+    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var gm = {
+    exports: {}
+};
+
+var options = {
+    exports: {}
+};
+
+var hasRequiredOptions;
+
+function requireOptions () {
+	if (hasRequiredOptions) return options.exports;
+	hasRequiredOptions = 1;
+	(function (module, exports) {
+		module.exports = function exports1(proto) {
+		    proto._options = {};
+		    proto.options = function setOptions(options) {
+		        var keys = Object.keys(options), i = keys.length, key;
+		        while(i--){
+		            key = keys[i];
+		            this._options[key] = options[key];
+		        }
+		        return this;
+		    };
+		}; 
+	} (options));
+	return options.exports;
+}
+
+/**
+ * Extend proto.
+ */
+
+var getters;
+var hasRequiredGetters;
+
+function requireGetters () {
+	if (hasRequiredGetters) return getters;
+	hasRequiredGetters = 1;
+	getters = function(gm) {
+	    var proto = gm.prototype;
+	    /**
+	   * `identify` states
+	   */ var IDENTIFYING = 1;
+	    var IDENTIFIED = 2;
+	    /**
+	   * Map getter functions to output names.
+	   *
+	   * - format: specifying the -format argument (see man gm)
+	   * - verbose: use -verbose instead of -format (only if necessary b/c its slow)
+	   * - helper: use the conversion helper
+	   */ var map = {
+	        'format': {
+	            key: 'format',
+	            format: '%m ',
+	            helper: 'Format'
+	        },
+	        'depth': {
+	            key: 'depth',
+	            format: '%q'
+	        },
+	        'filesize': {
+	            key: 'Filesize',
+	            format: '%b'
+	        },
+	        'size': {
+	            key: 'size',
+	            format: '%wx%h ',
+	            helper: 'Geometry'
+	        },
+	        'color': {
+	            key: 'color',
+	            format: '%k',
+	            helper: 'Colors'
+	        },
+	        'orientation': {
+	            key: 'Orientation',
+	            format: '%[EXIF:Orientation]',
+	            helper: 'Orientation'
+	        },
+	        'res': {
+	            key: 'Resolution',
+	            verbose: true
+	        }
+	    };
+	    /**
+	   * Getter functions
+	   */ Object.keys(map).forEach(function(getter) {
+	        proto[getter] = function(opts, callback) {
+	            if (!callback) callback = opts, opts = {};
+	            if (!callback) return this;
+	            var val = map[getter], key = val.key, self = this;
+	            if (self.data[key]) {
+	                callback.call(self, null, self.data[key]);
+	                return self;
+	            }
+	            self.on(getter, callback);
+	            self.bufferStream = !!opts.bufferStream;
+	            if (val.verbose) {
+	                self.identify(opts, function(err, stdout, stderr, cmd) {
+	                    if (err) {
+	                        self.emit(getter, err, self.data[key], stdout, stderr, cmd);
+	                    } else {
+	                        self.emit(getter, err, self.data[key]);
+	                    }
+	                });
+	                return self;
+	            }
+	            var args = makeArgs(self, val);
+	            self._exec(args, function(err, stdout, stderr, cmd) {
+	                if (err) {
+	                    self.emit(getter, err, self.data[key], stdout, stderr, cmd);
+	                    return;
+	                }
+	                var result = (stdout || '').trim();
+	                if (val.helper in helper) {
+	                    helper[val.helper](self.data, result);
+	                } else {
+	                    self.data[key] = result;
+	                }
+	                self.emit(getter, err, self.data[key]);
+	            });
+	            return self;
+	        };
+	    });
+	    /**
+	   * identify command
+	   *
+	   * Overwrites all internal data with the parsed output
+	   * which is more accurate than the fast shortcut
+	   * getters.
+	   */ proto.identify = function identify(opts, callback) {
+	        // identify with pattern
+	        if (typeof opts === 'string') {
+	            opts = {
+	                format: opts
+	            };
+	        }
+	        if (!callback) callback = opts, opts = {};
+	        if (!callback) return this;
+	        if (opts && opts.format) return identifyPattern.call(this, opts, callback);
+	        var self = this;
+	        if (IDENTIFIED === self._identifyState) {
+	            callback.call(self, null, self.data);
+	            return self;
+	        }
+	        self.on('identify', callback);
+	        if (IDENTIFYING === self._identifyState) {
+	            return self;
+	        }
+	        self._identifyState = IDENTIFYING;
+	        self.bufferStream = !!opts.bufferStream;
+	        var args = makeArgs(self, {
+	            verbose: true
+	        });
+	        self._exec(args, function(err, stdout, stderr, cmd) {
+	            if (err) {
+	                self.emit('identify', err, self.data, stdout, stderr, cmd);
+	                return;
+	            }
+	            err = parse(stdout, self);
+	            if (err) {
+	                self.emit('identify', err, self.data, stdout, stderr, cmd);
+	                return;
+	            }
+	            self.data.path = self.source;
+	            self.emit('identify', null, self.data);
+	            self._identifyState = IDENTIFIED;
+	        });
+	        return self;
+	    };
+	    /**
+	   * identify with pattern
+	   *
+	   * Execute `identify -format` with custom pattern
+	   */ function identifyPattern(opts, callback) {
+	        var self = this;
+	        self.bufferStream = !!opts.bufferStream;
+	        var args = makeArgs(self, opts);
+	        self._exec(args, function(err, stdout, stderr, cmd) {
+	            if (err) {
+	                return callback.call(self, err, undefined, stdout, stderr, cmd);
+	            }
+	            callback.call(self, err, (stdout || '').trim());
+	        });
+	        return self;
+	    }
+	    /**
+	   * Parses `identify` responses.
+	   *
+	   * @param {String} stdout
+	   * @param {Gm} self
+	   * @return {Error} [optionally]
+	   */ function parse(stdout, self) {
+	        // normalize
+	        var parts = (stdout || "").trim().replace(/\r\n|\r/g, "\n").split("\n");
+	        // skip the first line (its just the filename)
+	        parts.shift();
+	        try {
+	            var len = parts.length, rgx1 = /^( *)(.+?): (.*)$/ // key: val
+	            , rgx2 = /^( *)(.+?):$/ // key: begin nested object
+	            , out = {
+	                indent: {}
+	            }, level = null, lastkey, i = 0, res, o;
+	            for(; i < len; ++i){
+	                res = rgx1.exec(parts[i]) || rgx2.exec(parts[i]);
+	                if (!res) continue;
+	                var indent = res[1].length, key = res[2] ? res[2].trim() : '';
+	                if ('Image' == key || 'Warning' == key) continue;
+	                var val = res[3] ? res[3].trim() : null;
+	                // first iteration?
+	                if (null === level) {
+	                    level = indent;
+	                    o = out.root = out.indent[level] = self.data;
+	                } else if (indent < level) {
+	                    // outdent
+	                    if (!(indent in out.indent)) {
+	                        continue;
+	                    }
+	                    o = out.indent[indent];
+	                } else if (indent > level) {
+	                    // dropping into a nested object
+	                    out.indent[level] = o;
+	                    // weird format, key/val pair with nested children. discard the val
+	                    o = o[lastkey] = {};
+	                }
+	                level = indent;
+	                if (val) {
+	                    // if previous key was exist and we got the same key
+	                    // cast it to an array.
+	                    if (o.hasOwnProperty(key)) {
+	                        // cast it to an array and dont forget the previous value
+	                        if (!Array.isArray(o[key])) {
+	                            var tmp = o[key];
+	                            o[key] = [
+	                                tmp
+	                            ];
+	                        }
+	                        // set value
+	                        o[key].push(val);
+	                    } else {
+	                        o[key] = val;
+	                    }
+	                    if (key in helper) {
+	                        helper[key](o, val);
+	                    }
+	                }
+	                lastkey = key;
+	            }
+	        } catch (err) {
+	            err.message = err.message + "\n\n  Identify stdout:\n  " + stdout;
+	            return err;
+	        }
+	    }
+	    /**
+	   * Create an argument array for the identify command.
+	   *
+	   * @param {gm} self
+	   * @param {Object} val
+	   * @return {Array}
+	   */ function makeArgs(self, val) {
+	        var args = [
+	            'identify',
+	            '-ping'
+	        ];
+	        if (val.format) {
+	            args.push('-format', val.format);
+	        }
+	        if (val.verbose) {
+	            args.push('-verbose');
+	        }
+	        args = args.concat(self.src());
+	        return args;
+	    }
+	    /**
+	   * Map exif orientation codes to orientation names.
+	   */ var orientations = {
+	        '1': 'TopLeft',
+	        '2': 'TopRight',
+	        '3': 'BottomRight',
+	        '4': 'BottomLeft',
+	        '5': 'LeftTop',
+	        '6': 'RightTop',
+	        '7': 'RightBottom',
+	        '8': 'LeftBottom'
+	    };
+	    /**
+	   * identify -verbose helpers
+	   */ var helper = gm.identifyHelpers = {};
+	    helper.Geometry = function Geometry(o, val) {
+	        // We only want the size of the first frame.
+	        // Each frame is separated by a space.
+	        var split = val.split(" ").shift().split("x");
+	        var width = parseInt(split[0], 10);
+	        var height = parseInt(split[1], 10);
+	        if (o.size && o.size.width && o.size.height) {
+	            if (width > o.size.width) o.size.width = width;
+	            if (height > o.size.height) o.size.height = height;
+	        } else {
+	            o.size = {
+	                width: width,
+	                height: height
+	            };
+	        }
+	    };
+	    helper.Format = function Format(o, val) {
+	        o.format = val.split(" ")[0];
+	    };
+	    helper.Depth = function Depth(o, val) {
+	        o.depth = parseInt(val, 10);
+	    };
+	    helper.Colors = function Colors(o, val) {
+	        o.color = parseInt(val, 10);
+	    };
+	    helper.Orientation = function Orientation(o, val) {
+	        if (val in orientations) {
+	            o['Profile-EXIF'] || (o['Profile-EXIF'] = {});
+	            o['Profile-EXIF'].Orientation = val;
+	            o.Orientation = orientations[val];
+	        } else {
+	            o.Orientation = val || 'Unknown';
+	        }
+	    };
+	};
+	return getters;
+}
+
+var utils$7 = {};
+
+/**
+ * Escape the given shell `arg`.
+ *
+ * @param {String} arg
+ * @return {String}
+ * @api public
+ */
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils$7;
+	hasRequiredUtils = 1;
+	utils$7.escape = function escape(arg) {
+	    return '"' + String(arg).trim().replace(/"/g, '\\"') + '"';
+	};
+	utils$7.unescape = function escape(arg) {
+	    return String(arg).trim().replace(/"/g, "");
+	};
+	utils$7.argsToArray = function(args) {
+	    var arr = [];
+	    for(var i = 0; i <= arguments.length; i++){
+	        if ('undefined' != typeof arguments[i]) arr.push(arguments[i]);
+	    }
+	    return arr;
+	};
+	utils$7.isUtil = function(v) {
+	    var ty = 'object';
+	    switch(Object.prototype.toString.call(v)){
+	        case '[object String]':
+	            ty = 'String';
+	            break;
+	        case '[object Array]':
+	            ty = 'Array';
+	            break;
+	        case '[object Boolean]':
+	            ty = 'Boolean';
+	            break;
+	    }
+	    return ty;
+	};
+	return utils$7;
+}
+
+/**
+ * Dependencies
+ */
+
+var args;
+var hasRequiredArgs;
+
+function requireArgs () {
+	if (hasRequiredArgs) return args;
+	hasRequiredArgs = 1;
+	var argsToArray = requireUtils().argsToArray;
+	var isUtil = requireUtils().isUtil;
+	/**
+	 * Extend proto
+	 */ args = function(proto) {
+	    // change the specified frame.
+	    // See #202.
+	    proto.selectFrame = function(frame) {
+	        if (typeof frame === 'number') this.sourceFrames = '[' + frame + ']';
+	        return this;
+	    };
+	    // define the sub-command to use, http://www.graphicsmagick.org/utilities.html
+	    proto.command = proto.subCommand = function subCommand(name) {
+	        this._subCommand = name;
+	        return this;
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-adjoin
+	    proto.adjoin = function adjoin() {
+	        return this.out("-adjoin");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-affine
+	    proto.affine = function affine(matrix) {
+	        return this.out("-affine", matrix);
+	    };
+	    proto.alpha = function alpha(type) {
+	        if (!this._options.imageMagick) return new Error('Method -alpha is not supported by GraphicsMagick');
+	        return this.out('-alpha', type);
+	    };
+	    /**
+	   * Appends images to the list of "source" images.
+	   *
+	   * We may also specify either top-to-bottom or left-to-right
+	   * behavior of the appending by passing a boolean argument.
+	   *
+	   * Examples:
+	   *
+	   *    img = gm(src);
+	   *
+	   *    // +append means left-to-right
+	   *    img.append(img1, img2)       gm convert src img1 img2 -append
+	   *    img.append(img, true)        gm convert src img +append
+	   *    img.append(img, false)       gm convert src img -append
+	   *    img.append(img)              gm convert src img -append
+	   *    img.append(img).append()     gm convert src img -append
+	   *    img.append(img).append(true) gm convert src img +append
+	   *    img.append(img).append(true) gm convert src img +append
+	   *    img.append(img).background('#222) gm convert src img -background #222 +append
+	   *    img.append([img1,img2...],true)
+
+	   * @param {String} or {Array} [img]
+	   * @param {Boolean} [ltr]
+	   * @see http://www.graphicsmagick.org/GraphicsMagick.html#details-append
+	   */ proto.append = function append(img, ltr) {
+	        if (!this._append) {
+	            this._append = [];
+	            this.addSrcFormatter(function(src) {
+	                this.out(this._append.ltr ? '+append' : '-append');
+	                src.push.apply(src, this._append);
+	            });
+	        }
+	        if (0 === arguments.length) {
+	            this._append.ltr = false;
+	            return this;
+	        }
+	        for(var i = 0; i < arguments.length; ++i){
+	            var arg = arguments[i];
+	            switch(isUtil(arg)){
+	                case 'Boolean':
+	                    this._append.ltr = arg;
+	                    break;
+	                case 'String':
+	                    this._append.push(arg);
+	                    break;
+	                case 'Array':
+	                    for(var j = 0, len = arg.length; j < len; j++){
+	                        if (isUtil(arg[j]) == 'String') {
+	                            this._append.push(arg[j]);
+	                        }
+	                    }
+	                    break;
+	            }
+	        }
+	        return this;
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-authenticate
+	    proto.authenticate = function authenticate(string) {
+	        return this.out("-authenticate", string);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-average
+	    proto.average = function average() {
+	        return this.out("-average");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-backdrop
+	    proto.backdrop = function backdrop() {
+	        return this.out("-backdrop");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-black-threshold
+	    proto.blackThreshold = function blackThreshold(red, green, blue, opacity) {
+	        return this.out("-black-threshold", argsToArray(red, green, blue, opacity).join(','));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-blue-primary
+	    proto.bluePrimary = function bluePrimary(x, y) {
+	        return this.out("-blue-primary", argsToArray(x, y).join(','));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-border
+	    proto.border = function border(width, height) {
+	        return this.out("-border", width + "x" + height);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-bordercolor
+	    proto.borderColor = function borderColor(color) {
+	        return this.out("-bordercolor", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-box
+	    proto.box = function box(color) {
+	        return this.out("-box", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-channel
+	    proto.channel = function channel(type) {
+	        return this.out("-channel", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-chop
+	    proto.chop = function chop(w, h, x, y) {
+	        return this.in("-chop", w + "x" + h + "+" + (x || 0) + "+" + (y || 0));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-clip
+	    proto.clip = function clip() {
+	        return this.out("-clip");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-coalesce
+	    proto.coalesce = function coalesce() {
+	        return this.out("-coalesce");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-colorize
+	    proto.colorize = function colorize(r, g, b) {
+	        return this.out("-colorize", [
+	            r,
+	            g,
+	            b
+	        ].join(","));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-colormap
+	    proto.colorMap = function colorMap(type) {
+	        return this.out("-colormap", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-compose
+	    proto.compose = function compose(operator) {
+	        return this.out("-compose", operator);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-compress
+	    proto.compress = function compress(type) {
+	        return this.out("-compress", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-kernel
+	    proto.convolve = function convolve(kernel) {
+	        return this.out("-convolve", kernel);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-create-directories
+	    proto.createDirectories = function createDirectories() {
+	        return this.out("-create-directories");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-deconstruct
+	    proto.deconstruct = function deconstruct() {
+	        return this.out("-deconstruct");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-define
+	    proto.define = function define(value) {
+	        return this.out("-define", value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-delay
+	    proto.delay = function delay(value) {
+	        return this.out("-delay", value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-displace
+	    proto.displace = function displace(horizontalScale, verticalScale) {
+	        return this.out("-displace", horizontalScale + 'x' + verticalScale);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-display
+	    proto.display = function display(value) {
+	        return this.out("-display", value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-dispose
+	    proto.dispose = function dispose(method) {
+	        return this.out("-dispose", method);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-dissolve
+	    proto.dissolve = function dissolve(percent) {
+	        return this.out("-dissolve", percent + '%');
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-encoding
+	    proto.encoding = function encoding(type) {
+	        return this.out("-encoding", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-endian
+	    proto.endian = function endian(type) {
+	        return this.out("-endian", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-file
+	    proto.file = function file(filename) {
+	        return this.out("-file", filename);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-flatten
+	    proto.flatten = function flatten() {
+	        return this.out("-flatten");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-foreground
+	    proto.foreground = function foreground(color) {
+	        return this.out("-foreground", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-frame
+	    proto.frame = function frame(width, height, outerBevelWidth, innerBevelWidth) {
+	        if (arguments.length == 0) return this.out("-frame");
+	        return this.out("-frame", width + 'x' + height + '+' + outerBevelWidth + '+' + innerBevelWidth);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-fuzz
+	    proto.fuzz = function fuzz(distance, percent) {
+	        return this.out("-fuzz", distance + (percent ? '%' : ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-gaussian
+	    proto.gaussian = function gaussian(radius, sigma) {
+	        return this.out("-gaussian", argsToArray(radius, sigma).join('x'));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-geometry
+	    proto.geometry = function geometry(width, height, arg) {
+	        // If the first argument is a string, and there is only one argument, this is a custom geometry command.
+	        if (arguments.length == 1 && typeof arguments[0] === "string") return this.out("-geometry", arguments[0]);
+	        // Otherwise, return a resizing geometry command with an option alrgument.
+	        return this.out("-geometry", width + 'x' + height + (arg || ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-green-primary
+	    proto.greenPrimary = function greenPrimary(x, y) {
+	        return this.out("-green-primary", x + ',' + y);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-highlight-color
+	    proto.highlightColor = function highlightColor(color) {
+	        return this.out("-highlight-color", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-highlight-style
+	    proto.highlightStyle = function highlightStyle(style) {
+	        return this.out("-highlight-style", style);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-iconGeometry
+	    proto.iconGeometry = function iconGeometry(geometry) {
+	        return this.out("-iconGeometry", geometry);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-intent
+	    proto.intent = function intent(type) {
+	        return this.out("-intent", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-lat
+	    proto.lat = function lat(width, height, offset, percent) {
+	        return this.out("-lat", width + 'x' + height + offset + (percent ? '%' : ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-level
+	    proto.level = function level(blackPoint, gamma, whitePoint, percent) {
+	        return this.out("-level", argsToArray(blackPoint, gamma, whitePoint).join(',') + (percent ? '%' : ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-list
+	    proto.list = function list(type) {
+	        return this.out("-list", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-log
+	    proto.log = function log(string) {
+	        return this.out("-log", string);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-loop
+	    proto.loop = function loop(iterations) {
+	        return this.out("-loop", iterations);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-map
+	    proto.map = function map(filename) {
+	        return this.out("-map", filename);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-mask
+	    proto.mask = function mask(filename) {
+	        return this.out("-mask", filename);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-matte
+	    proto.matte = function matte() {
+	        return this.out("-matte");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-mattecolor
+	    proto.matteColor = function matteColor(color) {
+	        return this.out("-mattecolor", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-maximum-error
+	    proto.maximumError = function maximumError(limit) {
+	        return this.out("-maximum-error", limit);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-mode
+	    proto.mode = function mode(value) {
+	        return this.out("-mode", value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-monitor
+	    proto.monitor = function monitor() {
+	        return this.out("-monitor");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-mosaic
+	    proto.mosaic = function mosaic() {
+	        return this.out("-mosaic");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-motion-blur
+	    proto.motionBlur = function motionBlur(radius, sigma, angle) {
+	        var arg = radius;
+	        if (typeof sigma != 'undefined') arg += 'x' + sigma;
+	        if (typeof angle != 'undefined') arg += '+' + angle;
+	        return this.out("-motion-blur", arg);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-name
+	    proto.name = function name() {
+	        return this.out("-name");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-noop
+	    proto.noop = function noop() {
+	        return this.out("-noop");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-normalize
+	    proto.normalize = function normalize() {
+	        return this.out("-normalize");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-opaque
+	    proto.opaque = function opaque(color) {
+	        return this.out("-opaque", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-operator
+	    proto.operator = function operator(channel, operator, rvalue, percent) {
+	        return this.out("-operator", channel, operator, rvalue + (percent ? '%' : ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-ordered-dither
+	    proto.orderedDither = function orderedDither(channeltype, NxN) {
+	        return this.out("-ordered-dither", channeltype, NxN);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-output-directory
+	    proto.outputDirectory = function outputDirectory(directory) {
+	        return this.out("-output-directory", directory);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-page
+	    proto.page = function page(width, height, arg) {
+	        return this.out("-page", width + 'x' + height + (arg || ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-pause
+	    proto.pause = function pause(seconds) {
+	        return this.out("-pause", seconds);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-pen
+	    proto.pen = function pen(color) {
+	        return this.out("-pen", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-ping
+	    proto.ping = function ping() {
+	        return this.out("-ping");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-pointsize
+	    proto.pointSize = function pointSize(value) {
+	        return this.out("-pointsize", value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-preview
+	    proto.preview = function preview(type) {
+	        return this.out("-preview", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-process
+	    proto.process = function process(command) {
+	        return this.out("-process", command);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-profile
+	    proto.profile = function profile(filename) {
+	        return this.out("-profile", filename);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-progress
+	    proto.progress = function progress() {
+	        return this.out("+progress");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-random-threshold
+	    proto.randomThreshold = function randomThreshold(channeltype, LOWxHIGH) {
+	        return this.out("-random-threshold", channeltype, LOWxHIGH);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-recolor
+	    proto.recolor = function recolor(matrix) {
+	        return this.out("-recolor", matrix);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-red-primary
+	    proto.redPrimary = function redPrimary(x, y) {
+	        return this.out("-red-primary", x, y);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-remote
+	    proto.remote = function remote() {
+	        return this.out("-remote");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-render
+	    proto.render = function render() {
+	        return this.out("-render");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-repage
+	    proto.repage = function repage(width, height, xoff, yoff, arg) {
+	        if (arguments[0] === "+") return this.out("+repage");
+	        return this.out("-repage", width + 'x' + height + '+' + xoff + '+' + yoff + (arg || ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-sample
+	    proto.sample = function sample(geometry) {
+	        return this.out("-sample", geometry);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-sampling-factor
+	    proto.samplingFactor = function samplingFactor(horizontalFactor, verticalFactor) {
+	        return this.out("-sampling-factor", horizontalFactor + 'x' + verticalFactor);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-scene
+	    proto.scene = function scene(value) {
+	        return this.out("-scene", value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-scenes
+	    proto.scenes = function scenes(start, end) {
+	        return this.out("-scenes", start + '-' + end);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-screen
+	    proto.screen = function screen() {
+	        return this.out("-screen");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-set
+	    proto.set = function set(attribute, value) {
+	        return this.out("-set", attribute, value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-segment
+	    proto.segment = function segment(clusterThreshold, smoothingThreshold) {
+	        return this.out("-segment", clusterThreshold + 'x' + smoothingThreshold);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-shade
+	    proto.shade = function shade(azimuth, elevation) {
+	        return this.out("-shade", azimuth + 'x' + elevation);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-shadow
+	    proto.shadow = function shadow(radius, sigma) {
+	        return this.out("-shadow", argsToArray(radius, sigma).join('x'));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-shared-memory
+	    proto.sharedMemory = function sharedMemory() {
+	        return this.out("-shared-memory");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-shave
+	    proto.shave = function shave(width, height, percent) {
+	        return this.out("-shave", width + 'x' + height + (percent ? '%' : ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-shear
+	    proto.shear = function shear(xDegrees, yDegreees) {
+	        return this.out("-shear", xDegrees + 'x' + yDegreees);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-silent
+	    proto.silent = function silent(color) {
+	        return this.out("-silent");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-size
+	    proto.rawSize = function rawSize(width, height, offset) {
+	        var off = 'undefined' != typeof offset ? '+' + offset : '';
+	        return this.out("-size", width + 'x' + height + off);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-snaps
+	    proto.snaps = function snaps(value) {
+	        return this.out("-snaps", value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-stegano
+	    proto.stegano = function stegano(offset) {
+	        return this.out("-stegano", offset);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-stereo
+	    proto.stereo = function stereo() {
+	        return this.out("-stereo");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-text-font
+	    proto.textFont = function textFont(name) {
+	        return this.out("-text-font", name);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-texture
+	    proto.texture = function texture(filename) {
+	        return this.out("-texture", filename);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-threshold
+	    proto.threshold = function threshold(value, percent) {
+	        return this.out("-threshold", value + (percent ? '%' : ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-thumbnail
+	    proto.thumbnail = function thumbnail(w, h, options) {
+	        options = options || "";
+	        var geometry, wIsValid = Boolean(w || w === 0), hIsValid = Boolean(h || h === 0);
+	        if (wIsValid && hIsValid) {
+	            geometry = w + "x" + h + options;
+	        } else if (wIsValid) {
+	            // GraphicsMagick requires <width>x<options>, ImageMagick requires <width><options>
+	            geometry = this._options.imageMagick ? w + options : w + 'x' + options;
+	        } else if (hIsValid) {
+	            geometry = 'x' + h + options;
+	        } else {
+	            return this;
+	        }
+	        return this.out("-thumbnail", geometry);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-tile
+	    proto.tile = function tile(filename) {
+	        return this.out("-tile", filename);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-title
+	    proto.title = function title(string) {
+	        return this.out("-title", string);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-transform
+	    proto.transform = function transform(color) {
+	        return this.out("-transform", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-transparent
+	    proto.transparent = function transparent(color) {
+	        return this.out("-transparent", color);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-treedepth
+	    proto.treeDepth = function treeDepth(value) {
+	        return this.out("-treedepth", value);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-update
+	    proto.update = function update(seconds) {
+	        return this.out("-update", seconds);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-units
+	    proto.units = function units(type) {
+	        return this.out("-units", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-unsharp
+	    proto.unsharp = function unsharp(radius, sigma, amount, threshold) {
+	        var arg = radius;
+	        if (typeof sigma != 'undefined') arg += 'x' + sigma;
+	        if (typeof amount != 'undefined') arg += '+' + amount;
+	        if (typeof threshold != 'undefined') arg += '+' + threshold;
+	        return this.out("-unsharp", arg);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-use-pixmap
+	    proto.usePixmap = function usePixmap() {
+	        return this.out("-use-pixmap");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-view
+	    proto.view = function view(string) {
+	        return this.out("-view", string);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-virtual-pixel
+	    proto.virtualPixel = function virtualPixel(method) {
+	        return this.out("-virtual-pixel", method);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-visual
+	    proto.visual = function visual(type) {
+	        return this.out("-visual", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-watermark
+	    proto.watermark = function watermark(brightness, saturation) {
+	        return this.out("-watermark", brightness + 'x' + saturation);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-wave
+	    proto.wave = function wave(amplitude, wavelength) {
+	        return this.out("-wave", amplitude + 'x' + wavelength);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-white-point
+	    proto.whitePoint = function whitePoint(x, y) {
+	        return this.out("-white-point", x + 'x' + y);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-white-threshold
+	    proto.whiteThreshold = function whiteThreshold(red, green, blue, opacity) {
+	        return this.out("-white-threshold", argsToArray(red, green, blue, opacity).join(','));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-window
+	    proto.window = function window(id) {
+	        return this.out("-window", id);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-window-group
+	    proto.windowGroup = function windowGroup() {
+	        return this.out("-window-group");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-strip (graphicsMagick >= 1.3.15)
+	    proto.strip = function strip() {
+	        if (this._options.imageMagick) return this.out("-strip");
+	        return this.noProfile().out("+comment"); //Equivalent to "-strip" for all versions of graphicsMagick
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-interlace
+	    proto.interlace = function interlace(type) {
+	        return this.out("-interlace", type || "None");
+	    };
+	    // force output format
+	    proto.setFormat = function setFormat(format) {
+	        if (format) this._outputFormat = format;
+	        return this;
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-resize
+	    proto.resize = function resize(w, h, options) {
+	        options = options || "";
+	        var geometry, wIsValid = Boolean(w || w === 0), hIsValid = Boolean(h || h === 0);
+	        if (wIsValid && hIsValid) {
+	            geometry = w + "x" + h + options;
+	        } else if (wIsValid) {
+	            // GraphicsMagick requires <width>x<options>, ImageMagick requires <width><options>
+	            geometry = this._options.imageMagick ? w + options : w + 'x' + options;
+	        } else if (hIsValid) {
+	            geometry = 'x' + h + options;
+	        } else {
+	            return this;
+	        }
+	        return this.out("-resize", geometry);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-resize with '!' option
+	    proto.resizeExact = function resize(w, h) {
+	        var options = "!";
+	        return proto.resize.apply(this, [
+	            w,
+	            h,
+	            options
+	        ]);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-scale
+	    proto.scale = function scale(w, h, options) {
+	        options = options || "";
+	        var geometry;
+	        if (w && h) {
+	            geometry = w + "x" + h + options;
+	        } else if (w && !h) {
+	            geometry = this._options.imageMagick ? w + options : w + 'x' + options;
+	        } else if (!w && h) {
+	            geometry = 'x' + h + options;
+	        }
+	        return this.out("-scale", geometry);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-filter
+	    proto.filter = function filter(val) {
+	        return this.out("-filter", val);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-density
+	    proto.density = function density(w, h) {
+	        if (w && !h && this._options.imageMagick) {
+	            // GraphicsMagick requires <width>x<height>y, ImageMagick may take dpi<resolution>
+	            // recommended 300dpi for higher quality
+	            return this.in("-density", w);
+	        }
+	        return this.in("-density", w + "x" + h);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-profile
+	    proto.noProfile = function noProfile() {
+	        this.out('+profile', '"*"');
+	        return this;
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-resample
+	    proto.resample = function resample(w, h) {
+	        return this.out("-resample", w + "x" + h);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-rotate
+	    proto.rotate = function rotate(color, deg) {
+	        return this.out("-background", color, "-rotate", String(deg || 0));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-flip
+	    proto.flip = function flip() {
+	        return this.out("-flip");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-flop
+	    proto.flop = function flop() {
+	        return this.out("-flop");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-crop
+	    proto.crop = function crop(w, h, x, y, percent) {
+	        if (this.inputIs('jpg')) {
+	            // avoid error "geometry does not contain image (unable to crop image)" - gh-17
+	            var index = this._in.indexOf('-size');
+	            if (~index) {
+	                this._in.splice(index, 2);
+	            }
+	        }
+	        return this.out("-crop", w + "x" + h + "+" + (x || 0) + "+" + (y || 0) + (percent ? '%' : ''));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-magnify
+	    proto.magnify = function magnify(factor) {
+	        return this.in("-magnify");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.minify = function minify() {
+	        return this.in("-minify");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-quality
+	    proto.quality = function quality(val) {
+	        return this.in("-quality", val || 75);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-blur
+	    proto.blur = function blur(radius, sigma) {
+	        return this.out("-blur", radius + (sigma ? "x" + sigma : ""));
+	    };
+	    // http://www.graphicsmagick.org/convert.html
+	    proto.charcoal = function charcoal(factor) {
+	        return this.out("-charcoal", factor || 2);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-modulate
+	    proto.modulate = function modulate(b, s, h) {
+	        return this.out("-modulate", [
+	            b,
+	            s,
+	            h
+	        ].join(","));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-antialias
+	    // note: antialiasing is enabled by default
+	    proto.antialias = function antialias(disable) {
+	        return false === disable ? this.out("+antialias") : this;
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-depth
+	    proto.bitdepth = function bitdepth(val) {
+	        return this.out("-depth", val);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-colors
+	    proto.colors = function colors(val) {
+	        return this.out("-colors", val || 128);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-colorspace
+	    proto.colorspace = function colorspace(val) {
+	        return this.out("-colorspace", val);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-comment
+	    proto.comment = comment("-comment");
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-contrast
+	    proto.contrast = function contrast(mult) {
+	        var arg = (parseInt(mult, 10) || 0) > 0 ? "+contrast" : "-contrast";
+	        mult = Math.abs(mult) || 1;
+	        while(mult--){
+	            this.out(arg);
+	        }
+	        return this;
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-cycle
+	    proto.cycle = function cycle(amount) {
+	        return this.out("-cycle", amount || 2);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.despeckle = function despeckle() {
+	        return this.out("-despeckle");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-dither
+	    // note: either colors() or monochrome() must be used for this
+	    // to take effect.
+	    proto.dither = function dither(on) {
+	        var sign = false === on ? "+" : "-";
+	        return this.out(sign + "dither");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.monochrome = function monochrome() {
+	        return this.out("-monochrome");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.edge = function edge(radius) {
+	        return this.out("-edge", radius || 1);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.emboss = function emboss(radius) {
+	        return this.out("-emboss", radius || 1);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.enhance = function enhance() {
+	        return this.out("-enhance");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.equalize = function equalize() {
+	        return this.out("-equalize");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-gamma
+	    proto.gamma = function gamma(r, g, b) {
+	        return this.out("-gamma", [
+	            r,
+	            g,
+	            b
+	        ].join());
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.implode = function implode(factor) {
+	        return this.out("-implode", factor || 1);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-comment
+	    proto.label = comment("-label");
+	    var limits = [
+	        "disk",
+	        "file",
+	        "map",
+	        "memory",
+	        "pixels",
+	        "threads"
+	    ];
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-limit
+	    proto.limit = function limit(type, val) {
+	        type = type.toLowerCase();
+	        if (!~limits.indexOf(type)) {
+	            return this;
+	        }
+	        return this.out("-limit", type, val);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.median = function median(radius) {
+	        return this.out("-median", radius || 1);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-negate
+	    proto.negative = function negative(grayscale) {
+	        var sign = grayscale ? "+" : "-";
+	        return this.out(sign + "negate");
+	    };
+	    var noises = [
+	        "uniform",
+	        "gaussian",
+	        "multiplicative",
+	        "impulse",
+	        "laplacian",
+	        "poisson"
+	    ];
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-noise
+	    proto.noise = function noise(radius) {
+	        radius = String(radius).toLowerCase();
+	        var sign = ~noises.indexOf(radius) ? "+" : "-";
+	        return this.out(sign + "noise", radius);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-paint
+	    proto.paint = function paint(radius) {
+	        return this.out("-paint", radius);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-raise
+	    proto.raise = function raise(w, h) {
+	        return this.out("-raise", (w || 0) + "x" + (h || 0));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-raise
+	    proto.lower = function lower(w, h) {
+	        return this.out("+raise", (w || 0) + "x" + (h || 0));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-region
+	    proto.region = function region(w, h, x, y) {
+	        w = w || 0;
+	        h = h || 0;
+	        x = x || 0;
+	        y = y || 0;
+	        return this.out("-region", w + "x" + h + "+" + x + "+" + y);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-roll
+	    proto.roll = function roll(x, y) {
+	        x = ((x = parseInt(x, 10) || 0) >= 0 ? "+" : "") + x;
+	        y = ((y = parseInt(y, 10) || 0) >= 0 ? "+" : "") + y;
+	        return this.out("-roll", x + y);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-sharpen
+	    proto.sharpen = function sharpen(radius, sigma) {
+	        sigma = sigma ? "x" + sigma : "";
+	        return this.out("-sharpen", radius + sigma);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-solarize
+	    proto.solarize = function solarize(factor) {
+	        return this.out("-solarize", (factor || 1) + "%");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-spread
+	    proto.spread = function spread(amount) {
+	        return this.out("-spread", amount || 5);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-swirl
+	    proto.swirl = function swirl(degrees) {
+	        return this.out("-swirl", degrees || 180);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-type
+	    proto.type = function type(type) {
+	        return this.in("-type", type);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-trim
+	    proto.trim = function trim() {
+	        return this.out("-trim");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-extent
+	    proto.extent = function extent(w, h, options) {
+	        options = options || "";
+	        var geometry;
+	        if (w && h) {
+	            geometry = w + "x" + h + options;
+	        } else if (w && !h) {
+	            geometry = this._options.imageMagick ? w + options : w + 'x' + options;
+	        } else if (!w && h) {
+	            geometry = 'x' + h + options;
+	        }
+	        return this.out("-extent", geometry);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-gravity
+	    // Be sure to use gravity BEFORE extent
+	    proto.gravity = function gravity(type) {
+	        if (!type || !~gravity.types.indexOf(type)) {
+	            type = "NorthWest"; // Documented default.
+	        }
+	        return this.out("-gravity", type);
+	    };
+	    proto.gravity.types = [
+	        "NorthWest",
+	        "North",
+	        "NorthEast",
+	        "West",
+	        "Center",
+	        "East",
+	        "SouthWest",
+	        "South",
+	        "SouthEast"
+	    ];
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-flatten
+	    proto.flatten = function flatten() {
+	        return this.out("-flatten");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-background
+	    proto.background = function background(color) {
+	        return this.in("-background", color);
+	    };
+	};
+	/**
+	 * Generates a handler for comments/labels.
+	 */ function comment(arg) {
+	    return function(format) {
+	        format = String(format);
+	        format = "@" == format.charAt(0) ? format.substring(1) : format;
+	        return this.out(arg, '"' + format + '"');
+	    };
+	}
+	return args;
+}
+
+/**
+ * Module dependencies.
+ */
+
+var drawing;
+var hasRequiredDrawing;
+
+function requireDrawing () {
+	if (hasRequiredDrawing) return drawing;
+	hasRequiredDrawing = 1;
+	var escape = requireUtils().escape;
+	/**
+	 * Extend proto.
+	 */ drawing = function(proto) {
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-fill
+	    proto.fill = function fill(color) {
+	        return this.out("-fill", color || "none");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-stroke
+	    proto.stroke = function stroke(color, width) {
+	        if (width) {
+	            this.strokeWidth(width);
+	        }
+	        return this.out("-stroke", color || "none");
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-strokewidth
+	    proto.strokeWidth = function strokeWidth(width) {
+	        return this.out("-strokewidth", width);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-font
+	    proto.font = function font(font, size) {
+	        if (size) {
+	            this.fontSize(size);
+	        }
+	        return this.out("-font", font);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html
+	    proto.fontSize = function fontSize(size) {
+	        return this.out("-pointsize", size);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.draw = function draw(args) {
+	        return this.out("-draw", [].slice.call(arguments).join(" "));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawPoint = function drawPoint(x, y) {
+	        return this.draw("point", x + "," + y);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawLine = function drawLine(x0, y0, x1, y1) {
+	        return this.draw("line", x0 + "," + y0, x1 + "," + y1);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawRectangle = function drawRectangle(x0, y0, x1, y1, wc, hc) {
+	        var shape = "rectangle", lastarg;
+	        if ("undefined" !== typeof wc) {
+	            shape = "roundRectangle";
+	            if ("undefined" === typeof hc) {
+	                hc = wc;
+	            }
+	            lastarg = wc + "," + hc;
+	        }
+	        return this.draw(shape, x0 + "," + y0, x1 + "," + y1, lastarg);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawArc = function drawArc(x0, y0, x1, y1, a0, a1) {
+	        return this.draw("arc", x0 + "," + y0, x1 + "," + y1, a0 + "," + a1);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawEllipse = function drawEllipse(x0, y0, rx, ry, a0, a1) {
+	        if (a0 == undefined) a0 = 0;
+	        if (a1 == undefined) a1 = 360;
+	        return this.draw("ellipse", x0 + "," + y0, rx + "," + ry, a0 + "," + a1);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawCircle = function drawCircle(x0, y0, x1, y1) {
+	        return this.draw("circle", x0 + "," + y0, x1 + "," + y1);
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawPolyline = function drawPolyline() {
+	        return this.draw("polyline", formatPoints(arguments));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawPolygon = function drawPolygon() {
+	        return this.draw("polygon", formatPoints(arguments));
+	    };
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawBezier = function drawBezier() {
+	        return this.draw("bezier", formatPoints(arguments));
+	    };
+	    proto._gravities = [
+	        "northwest",
+	        "north",
+	        "northeast",
+	        "west",
+	        "center",
+	        "east",
+	        "southwest",
+	        "south",
+	        "southeast"
+	    ];
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.drawText = function drawText(x0, y0, text, gravity) {
+	        var gravity = String(gravity || "").toLowerCase(), arg = [
+	            "text " + x0 + "," + y0 + " " + escape(text)
+	        ];
+	        if (~this._gravities.indexOf(gravity)) {
+	            arg.unshift("gravity", gravity);
+	        }
+	        return this.draw.apply(this, arg);
+	    };
+	    proto._drawProps = [
+	        "color",
+	        "matte"
+	    ];
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-draw
+	    proto.setDraw = function setDraw(prop, x, y, method) {
+	        prop = String(prop || "").toLowerCase();
+	        if (!~this._drawProps.indexOf(prop)) {
+	            return this;
+	        }
+	        return this.draw(prop, x + "," + y, method);
+	    };
+	};
+	function formatPoints(points) {
+	    var len = points.length, result = [], i = 0;
+	    for(; i < len; ++i){
+	        result.push(points[i].join(","));
+	    }
+	    return result;
+	}
+	return drawing;
+}
+
+/**
+ * Extend proto.
+ */
+
+var thumb;
+var hasRequiredThumb;
+
+function requireThumb () {
+	if (hasRequiredThumb) return thumb;
+	hasRequiredThumb = 1;
+	thumb = function(proto) {
+	    proto.thumb = function thumb(w, h, name, quality, align, progressive, callback, opts) {
+	        var self = this, args = Array.prototype.slice.call(arguments);
+	        opts = args.pop();
+	        if (typeof opts === 'function') {
+	            callback = opts;
+	            opts = '';
+	        } else {
+	            callback = args.pop();
+	        }
+	        w = args.shift();
+	        h = args.shift();
+	        name = args.shift();
+	        quality = args.shift() || 63;
+	        align = args.shift() || 'topleft';
+	        var interlace = args.shift() ? 'Line' : 'None';
+	        self.size(function(err, size) {
+	            if (err) {
+	                return callback.apply(self, arguments);
+	            }
+	            w = parseInt(w, 10);
+	            h = parseInt(h, 10);
+	            var w1, h1;
+	            var xoffset = 0;
+	            var yoffset = 0;
+	            if (size.width < size.height) {
+	                w1 = w;
+	                h1 = Math.floor(size.height * (w / size.width));
+	                if (h1 < h) {
+	                    w1 = Math.floor(w1 * ((h - h1) / h + 1));
+	                    h1 = h;
+	                }
+	            } else if (size.width > size.height) {
+	                h1 = h;
+	                w1 = Math.floor(size.width * (h / size.height));
+	                if (w1 < w) {
+	                    h1 = Math.floor(h1 * ((w - w1) / w + 1));
+	                    w1 = w;
+	                }
+	            } else if (size.width == size.height) {
+	                var bigger = w > h ? w : h;
+	                w1 = bigger;
+	                h1 = bigger;
+	            }
+	            if (align == 'center') {
+	                if (w < w1) {
+	                    xoffset = (w1 - w) / 2;
+	                }
+	                if (h < h1) {
+	                    yoffset = (h1 - h) / 2;
+	                }
+	            }
+	            self.quality(quality).in("-size", w1 + "x" + h1).scale(w1, h1, opts).crop(w, h, xoffset, yoffset).interlace(interlace).noProfile().write(name, function() {
+	                callback.apply(self, arguments);
+	            });
+	        });
+	        return self;
+	    };
+	    proto.thumbExact = function() {
+	        var self = this, args = Array.prototype.slice.call(arguments);
+	        args.push('!');
+	        self.thumb.apply(self, args);
+	    };
+	};
+	return thumb;
+}
+
+var arrayParallel;
+var hasRequiredArrayParallel;
+
+function requireArrayParallel () {
+	if (hasRequiredArrayParallel) return arrayParallel;
+	hasRequiredArrayParallel = 1;
+	arrayParallel = function parallel(fns, context, callback) {
+	    if (!callback) {
+	        if (typeof context === 'function') {
+	            callback = context;
+	            context = null;
+	        } else {
+	            callback = noop;
+	        }
+	    }
+	    var pending = fns && fns.length;
+	    if (!pending) return callback(null, []);
+	    var finished = false;
+	    var results = new Array(pending);
+	    fns.forEach(context ? function(fn, i) {
+	        fn.call(context, maybeDone(i));
+	    } : function(fn, i) {
+	        fn(maybeDone(i));
+	    });
+	    function maybeDone(i) {
+	        return function(err, result) {
+	            if (finished) return;
+	            if (err) {
+	                callback(err, results);
+	                finished = true;
+	                return;
+	            }
+	            results[i] = result;
+	            if (!--pending) callback(null, results);
+	        };
+	    }
+	};
+	function noop() {}
+	return arrayParallel;
+}
+
+/**
+ * Module dependencies.
+ */
+
+var morph;
+var hasRequiredMorph;
+
+function requireMorph () {
+	if (hasRequiredMorph) return morph;
+	hasRequiredMorph = 1;
+	var fs = require$$0;
+	var parallel = requireArrayParallel();
+	/**
+	 * Extend proto.
+	 */ morph = function(proto) {
+	    /**
+	   * Do nothing.
+	   */ function noop() {}
+	    // http://www.graphicsmagick.org/GraphicsMagick.html#details-morph
+	    proto.morph = function morph(other, outname, callback) {
+	        if (!outname) {
+	            throw new Error("an output filename is required");
+	        }
+	        callback = (callback || noop).bind(this);
+	        var self = this;
+	        if (Array.isArray(other)) {
+	            other.forEach(function(img) {
+	                self.out(img);
+	            });
+	            self.out("-morph", other.length);
+	        } else {
+	            self.out(other, "-morph", 1);
+	        }
+	        self.write(outname, function(err, stdout, stderr, cmd) {
+	            if (err) return callback(err, stdout, stderr, cmd);
+	            // Apparently some platforms create the following temporary files.
+	            // Check if the output file exists, if it doesn't, then
+	            // work with temporary files.
+	            fs.exists(outname, function(exists) {
+	                if (exists) return callback(null, stdout, stderr, cmd);
+	                parallel([
+	                    fs.unlink.bind(fs, outname + '.0'),
+	                    fs.unlink.bind(fs, outname + '.2'),
+	                    fs.rename.bind(fs, outname + '.1', outname)
+	                ], function(err) {
+	                    callback(err, stdout, stderr, cmd);
+	                });
+	            });
+	        });
+	        return self;
+	    };
+	};
+	return morph;
+}
+
+/**
+ * Extend proto.
+ */
+
+var sepia;
+var hasRequiredSepia;
+
+function requireSepia () {
+	if (hasRequiredSepia) return sepia;
+	hasRequiredSepia = 1;
+	sepia = function(proto) {
+	    proto.sepia = function sepia() {
+	        return this.modulate(115, 0, 100).colorize(7, 21, 50);
+	    };
+	};
+	return sepia;
+}
+
+/**
+ * Extend proto.
+ */
+
+var autoOrient;
+var hasRequiredAutoOrient;
+
+function requireAutoOrient () {
+	if (hasRequiredAutoOrient) return autoOrient;
+	hasRequiredAutoOrient = 1;
+	autoOrient = function(proto) {
+	    var exifTransforms = {
+	        topleft: '',
+	        topright: [
+	            '-flop'
+	        ],
+	        bottomright: [
+	            '-rotate',
+	            180
+	        ],
+	        bottomleft: [
+	            '-flip'
+	        ],
+	        lefttop: [
+	            '-flip',
+	            '-rotate',
+	            90
+	        ],
+	        righttop: [
+	            '-rotate',
+	            90
+	        ],
+	        rightbottom: [
+	            '-flop',
+	            '-rotate',
+	            90
+	        ],
+	        leftbottom: [
+	            '-rotate',
+	            270
+	        ]
+	    };
+	    proto.autoOrient = function autoOrient() {
+	        // Always strip EXIF data since we can't
+	        // change/edit it.
+	        // imagemagick has a native -auto-orient option
+	        // so does graphicsmagick, but in 1.3.18.
+	        // nativeAutoOrient option enables this if you know you have >= 1.3.18
+	        if (this._options.nativeAutoOrient || this._options.imageMagick) {
+	            this.out('-auto-orient');
+	            return this;
+	        }
+	        this.preprocessor(function(callback) {
+	            this.orientation({
+	                bufferStream: true
+	            }, function(err, orientation) {
+	                if (err) return callback(err);
+	                var transforms = exifTransforms[orientation.toLowerCase()];
+	                if (transforms) {
+	                    // remove any existing transforms that might conflict
+	                    var index = this._out.indexOf(transforms[0]);
+	                    if (~index) {
+	                        this._out.splice(index, transforms.length);
+	                    }
+	                    // repage to fix coordinates
+	                    this._out.unshift.apply(this._out, transforms.concat('-page', '+0+0'));
+	                }
+	                callback();
+	            });
+	        });
+	        return this;
+	    };
+	};
+	return autoOrient;
+}
+
+/**
+ * Extend proto
+ */
+
+var convenience;
+var hasRequiredConvenience;
+
+function requireConvenience () {
+	if (hasRequiredConvenience) return convenience;
+	hasRequiredConvenience = 1;
+	convenience = function(proto) {
+	    requireThumb()(proto);
+	    requireMorph()(proto);
+	    requireSepia()(proto);
+	    requireAutoOrient()(proto);
+	};
+	return convenience;
+}
+
+var crossSpawn = {
+    exports: {}
+};
+
+var windows;
+var hasRequiredWindows;
+
+function requireWindows () {
+	if (hasRequiredWindows) return windows;
+	hasRequiredWindows = 1;
+	windows = isexe;
+	isexe.sync = sync;
+	var fs = require$$0;
+	function checkPathExt(path, options) {
+	    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+	    if (!pathext) {
+	        return true;
+	    }
+	    pathext = pathext.split(';');
+	    if (pathext.indexOf('') !== -1) {
+	        return true;
+	    }
+	    for(var i = 0; i < pathext.length; i++){
+	        var p = pathext[i].toLowerCase();
+	        if (p && path.substr(-p.length).toLowerCase() === p) {
+	            return true;
+	        }
+	    }
+	    return false;
+	}
+	function checkStat(stat, path, options) {
+	    if (!stat.isSymbolicLink() && !stat.isFile()) {
+	        return false;
+	    }
+	    return checkPathExt(path, options);
+	}
+	function isexe(path, options, cb) {
+	    fs.stat(path, function(er, stat) {
+	        cb(er, er ? false : checkStat(stat, path, options));
+	    });
+	}
+	function sync(path, options) {
+	    return checkStat(fs.statSync(path), path, options);
+	}
+	return windows;
+}
+
+var mode;
+var hasRequiredMode;
+
+function requireMode () {
+	if (hasRequiredMode) return mode;
+	hasRequiredMode = 1;
+	mode = isexe;
+	isexe.sync = sync;
+	var fs = require$$0;
+	function isexe(path, options, cb) {
+	    fs.stat(path, function(er, stat) {
+	        cb(er, er ? false : checkStat(stat, options));
+	    });
+	}
+	function sync(path, options) {
+	    return checkStat(fs.statSync(path), options);
+	}
+	function checkStat(stat, options) {
+	    return stat.isFile() && checkMode(stat, options);
+	}
+	function checkMode(stat, options) {
+	    var mod = stat.mode;
+	    var uid = stat.uid;
+	    var gid = stat.gid;
+	    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+	    var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
+	    var u = parseInt('100', 8);
+	    var g = parseInt('010', 8);
+	    var o = parseInt('001', 8);
+	    var ug = u | g;
+	    var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+	    return ret;
+	}
+	return mode;
+}
+
+var isexe_1;
+var hasRequiredIsexe;
+
+function requireIsexe () {
+	if (hasRequiredIsexe) return isexe_1;
+	hasRequiredIsexe = 1;
+	var core;
+	if (process.platform === 'win32' || commonjsGlobal.TESTING_WINDOWS) {
+	    core = requireWindows();
+	} else {
+	    core = requireMode();
+	}
+	isexe_1 = isexe;
+	isexe.sync = sync;
+	function isexe(path, options, cb) {
+	    if (typeof options === 'function') {
+	        cb = options;
+	        options = {};
+	    }
+	    if (!cb) {
+	        if (typeof Promise !== 'function') {
+	            throw new TypeError('callback not provided');
+	        }
+	        return new Promise(function(resolve, reject) {
+	            isexe(path, options || {}, function(er, is) {
+	                if (er) {
+	                    reject(er);
+	                } else {
+	                    resolve(is);
+	                }
+	            });
+	        });
+	    }
+	    core(path, options || {}, function(er, is) {
+	        // ignore EACCES because that just means we aren't allowed to run it
+	        if (er) {
+	            if (er.code === 'EACCES' || options && options.ignoreErrors) {
+	                er = null;
+	                is = false;
+	            }
+	        }
+	        cb(er, is);
+	    });
+	}
+	function sync(path, options) {
+	    // my kingdom for a filtered catch
+	    try {
+	        return core.sync(path, options || {});
+	    } catch (er) {
+	        if (options && options.ignoreErrors || er.code === 'EACCES') {
+	            return false;
+	        } else {
+	            throw er;
+	        }
+	    }
+	}
+	return isexe_1;
+}
+
+var which_1;
+var hasRequiredWhich;
+
+function requireWhich () {
+	if (hasRequiredWhich) return which_1;
+	hasRequiredWhich = 1;
+	function _array_like_to_array(arr, len) {
+	    if (len == null || len > arr.length) len = arr.length;
+	    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+	    return arr2;
+	}
+	function _array_without_holes(arr) {
+	    if (Array.isArray(arr)) return _array_like_to_array(arr);
+	}
+	function _iterable_to_array(iter) {
+	    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+	}
+	function _non_iterable_spread() {
+	    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	function _to_consumable_array(arr) {
+	    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+	}
+	function _unsupported_iterable_to_array(o, minLen) {
+	    if (!o) return;
+	    if (typeof o === "string") return _array_like_to_array(o, minLen);
+	    var n = Object.prototype.toString.call(o).slice(8, -1);
+	    if (n === "Object" && o.constructor) n = o.constructor.name;
+	    if (n === "Map" || n === "Set") return Array.from(n);
+	    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+	}
+	var isWindows = process.platform === 'win32' || process.env.OSTYPE === 'cygwin' || process.env.OSTYPE === 'msys';
+	var path = require$$0$1;
+	var COLON = isWindows ? ';' : ':';
+	var isexe = requireIsexe();
+	var getNotFoundError = function(cmd) {
+	    return Object.assign(new Error("not found: ".concat(cmd)), {
+	        code: 'ENOENT'
+	    });
+	};
+	var getPathInfo = function(cmd, opt) {
+	    var colon = opt.colon || COLON;
+	    // If it has a slash, then we don't bother searching the pathenv.
+	    // just check the file itself, and that's it.
+	    var pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [
+	        ''
+	    ] : // windows always checks the cwd first
+	    _to_consumable_array(isWindows ? [
+	        process.cwd()
+	    ] : []).concat(_to_consumable_array((opt.path || process.env.PATH || /* istanbul ignore next: very unusual */ '').split(colon)));
+	    var pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM' : '';
+	    var pathExt = isWindows ? pathExtExe.split(colon) : [
+	        ''
+	    ];
+	    if (isWindows) {
+	        if (cmd.indexOf('.') !== -1 && pathExt[0] !== '') pathExt.unshift('');
+	    }
+	    return {
+	        pathEnv: pathEnv,
+	        pathExt: pathExt,
+	        pathExtExe: pathExtExe
+	    };
+	};
+	var which = function(cmd, opt, cb) {
+	    if (typeof opt === 'function') {
+	        cb = opt;
+	        opt = {};
+	    }
+	    if (!opt) opt = {};
+	    var _getPathInfo = getPathInfo(cmd, opt), pathEnv = _getPathInfo.pathEnv, pathExt = _getPathInfo.pathExt, pathExtExe = _getPathInfo.pathExtExe;
+	    var found = [];
+	    var step = function(i) {
+	        return new Promise(function(resolve, reject) {
+	            if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+	            var ppRaw = pathEnv[i];
+	            var pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+	            var pCmd = path.join(pathPart, cmd);
+	            var p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+	            resolve(subStep(p, i, 0));
+	        });
+	    };
+	    var subStep = function(p, i, ii) {
+	        return new Promise(function(resolve, reject) {
+	            if (ii === pathExt.length) return resolve(step(i + 1));
+	            var ext = pathExt[ii];
+	            isexe(p + ext, {
+	                pathExt: pathExtExe
+	            }, function(er, is) {
+	                if (!er && is) {
+	                    if (opt.all) found.push(p + ext);
+	                    else return resolve(p + ext);
+	                }
+	                return resolve(subStep(p, i, ii + 1));
+	            });
+	        });
+	    };
+	    return cb ? step(0).then(function(res) {
+	        return cb(null, res);
+	    }, cb) : step(0);
+	};
+	var whichSync = function(cmd, opt) {
+	    opt = opt || {};
+	    var _getPathInfo = getPathInfo(cmd, opt), pathEnv = _getPathInfo.pathEnv, pathExt = _getPathInfo.pathExt, pathExtExe = _getPathInfo.pathExtExe;
+	    var found = [];
+	    for(var i = 0; i < pathEnv.length; i++){
+	        var ppRaw = pathEnv[i];
+	        var pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+	        var pCmd = path.join(pathPart, cmd);
+	        var p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+	        for(var j = 0; j < pathExt.length; j++){
+	            var cur = p + pathExt[j];
+	            try {
+	                var is = isexe.sync(cur, {
+	                    pathExt: pathExtExe
+	                });
+	                if (is) {
+	                    if (opt.all) found.push(cur);
+	                    else return cur;
+	                }
+	            } catch (ex) {}
+	        }
+	    }
+	    if (opt.all && found.length) return found;
+	    if (opt.nothrow) return null;
+	    throw getNotFoundError(cmd);
+	};
+	which_1 = which;
+	which.sync = whichSync;
+	return which_1;
+}
+
+var pathKey = {
+    exports: {}
+};
+
+var hasRequiredPathKey;
+
+function requirePathKey () {
+	if (hasRequiredPathKey) return pathKey.exports;
+	hasRequiredPathKey = 1;
+	var pathKey$1 = function() {
+	    var options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+	    var environment = options.env || process.env;
+	    var platform = options.platform || process.platform;
+	    if (platform !== 'win32') {
+	        return 'PATH';
+	    }
+	    return Object.keys(environment).reverse().find(function(key) {
+	        return key.toUpperCase() === 'PATH';
+	    }) || 'Path';
+	};
+	pathKey.exports = pathKey$1;
+	// TODO: Remove this for the next major release
+	pathKey.exports.default = pathKey$1;
+	return pathKey.exports;
+}
+
+var resolveCommand_1;
+var hasRequiredResolveCommand;
+
+function requireResolveCommand () {
+	if (hasRequiredResolveCommand) return resolveCommand_1;
+	hasRequiredResolveCommand = 1;
+	var path = require$$0$1;
+	var which = requireWhich();
+	var getPathKey = requirePathKey();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+	    var env = parsed.options.env || process.env;
+	    var cwd = process.cwd();
+	    var hasCustomCwd = parsed.options.cwd != null;
+	    // Worker threads do not have process.chdir()
+	    var shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+	    // If a custom `cwd` was specified, we need to change the process cwd
+	    // because `which` will do stat calls but does not support a custom cwd
+	    if (shouldSwitchCwd) {
+	        try {
+	            process.chdir(parsed.options.cwd);
+	        } catch (err) {
+	        /* Empty */ }
+	    }
+	    var resolved;
+	    try {
+	        resolved = which.sync(parsed.command, {
+	            path: env[getPathKey({
+	                env: env
+	            })],
+	            pathExt: withoutPathExt ? path.delimiter : undefined
+	        });
+	    } catch (e) {
+	    /* Empty */ } finally{
+	        if (shouldSwitchCwd) {
+	            process.chdir(cwd);
+	        }
+	    }
+	    // If we successfully resolved, ensure that an absolute path is returned
+	    // Note that when a custom `cwd` was used, we need to resolve to an absolute path based on it
+	    if (resolved) {
+	        resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : '', resolved);
+	    }
+	    return resolved;
+	}
+	function resolveCommand(parsed) {
+	    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	resolveCommand_1 = resolveCommand;
+	return resolveCommand_1;
+}
+
+var _escape = {};
+
+var hasRequired_escape;
+
+function require_escape () {
+	if (hasRequired_escape) return _escape;
+	hasRequired_escape = 1;
+	// See http://www.robvanderwoude.com/escapechars.php
+	var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+	    // Escape meta chars
+	    arg = arg.replace(metaCharsRegExp, '^$1');
+	    return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+	    // Convert to string
+	    arg = "".concat(arg);
+	    // Algorithm below is based on https://qntm.org/cmd
+	    // It's slightly altered to disable JS backtracking to avoid hanging on specially crafted input
+	    // Please see https://github.com/moxystudio/node-cross-spawn/pull/160 for more information
+	    // Sequence of backslashes followed by a double quote:
+	    // double up all the backslashes and escape the double quote
+	    arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+	    // Sequence of backslashes followed by the end of the string
+	    // (which will become a double quote later):
+	    // double up all the backslashes
+	    arg = arg.replace(/(?=(\\+?)?)\1$/, '$1$1');
+	    // All other backslashes occur literally
+	    // Quote the whole thing:
+	    arg = '"'.concat(arg, '"');
+	    // Escape meta chars
+	    arg = arg.replace(metaCharsRegExp, '^$1');
+	    // Double escape meta chars if necessary
+	    if (doubleEscapeMetaChars) {
+	        arg = arg.replace(metaCharsRegExp, '^$1');
+	    }
+	    return arg;
+	}
+	_escape.command = escapeCommand;
+	_escape.argument = escapeArgument;
+	return _escape;
+}
+
+var shebangRegex;
+var hasRequiredShebangRegex;
+
+function requireShebangRegex () {
+	if (hasRequiredShebangRegex) return shebangRegex;
+	hasRequiredShebangRegex = 1;
+	shebangRegex = /^#!(.*)/;
+	return shebangRegex;
+}
+
+var shebangCommand;
+var hasRequiredShebangCommand;
+
+function requireShebangCommand () {
+	if (hasRequiredShebangCommand) return shebangCommand;
+	hasRequiredShebangCommand = 1;
+	function _array_like_to_array(arr, len) {
+	    if (len == null || len > arr.length) len = arr.length;
+	    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+	    return arr2;
+	}
+	function _array_with_holes(arr) {
+	    if (Array.isArray(arr)) return arr;
+	}
+	function _iterable_to_array_limit(arr, i) {
+	    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+	    if (_i == null) return;
+	    var _arr = [];
+	    var _n = true;
+	    var _d = false;
+	    var _s, _e;
+	    try {
+	        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+	            _arr.push(_s.value);
+	            if (i && _arr.length === i) break;
+	        }
+	    } catch (err) {
+	        _d = true;
+	        _e = err;
+	    } finally{
+	        try {
+	            if (!_n && _i["return"] != null) _i["return"]();
+	        } finally{
+	            if (_d) throw _e;
+	        }
+	    }
+	    return _arr;
+	}
+	function _non_iterable_rest() {
+	    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+	}
+	function _sliced_to_array(arr, i) {
+	    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+	}
+	function _unsupported_iterable_to_array(o, minLen) {
+	    if (!o) return;
+	    if (typeof o === "string") return _array_like_to_array(o, minLen);
+	    var n = Object.prototype.toString.call(o).slice(8, -1);
+	    if (n === "Object" && o.constructor) n = o.constructor.name;
+	    if (n === "Map" || n === "Set") return Array.from(n);
+	    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+	}
+	var shebangRegex = requireShebangRegex();
+	shebangCommand = function() {
+	    var string = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : '';
+	    var match = string.match(shebangRegex);
+	    if (!match) {
+	        return null;
+	    }
+	    var _match__replace_split = _sliced_to_array(match[0].replace(/#! ?/, '').split(' '), 2), path = _match__replace_split[0], argument = _match__replace_split[1];
+	    var binary = path.split('/').pop();
+	    if (binary === 'env') {
+	        return argument;
+	    }
+	    return argument ? "".concat(binary, " ").concat(argument) : binary;
+	};
+	return shebangCommand;
+}
+
+var readShebang_1;
+var hasRequiredReadShebang;
+
+function requireReadShebang () {
+	if (hasRequiredReadShebang) return readShebang_1;
+	hasRequiredReadShebang = 1;
+	var fs = require$$0;
+	var shebangCommand = requireShebangCommand();
+	function readShebang(command) {
+	    // Read the first 150 bytes from the file
+	    var size = 150;
+	    var buffer = Buffer.alloc(size);
+	    var fd;
+	    try {
+	        fd = fs.openSync(command, 'r');
+	        fs.readSync(fd, buffer, 0, size, 0);
+	        fs.closeSync(fd);
+	    } catch (e) {}
+	    // Attempt to extract shebang (null is returned if not a shebang)
+	    return shebangCommand(buffer.toString());
+	}
+	readShebang_1 = readShebang;
+	return readShebang_1;
+}
+
+var parse_1;
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse_1;
+	hasRequiredParse = 1;
+	var path = require$$0$1;
+	var resolveCommand = requireResolveCommand();
+	var escape = require_escape();
+	var readShebang = requireReadShebang();
+	var isWin = process.platform === 'win32';
+	var isExecutableRegExp = /\.(?:com|exe)$/i;
+	var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+	    parsed.file = resolveCommand(parsed);
+	    var shebang = parsed.file && readShebang(parsed.file);
+	    if (shebang) {
+	        parsed.args.unshift(parsed.file);
+	        parsed.command = shebang;
+	        return resolveCommand(parsed);
+	    }
+	    return parsed.file;
+	}
+	function parseNonShell(parsed) {
+	    if (!isWin) {
+	        return parsed;
+	    }
+	    // Detect & add support for shebangs
+	    var commandFile = detectShebang(parsed);
+	    // We don't need a shell if the command filename is an executable
+	    var needsShell = !isExecutableRegExp.test(commandFile);
+	    // If a shell is required, use cmd.exe and take care of escaping everything correctly
+	    // Note that `forceShell` is an hidden option used only in tests
+	    if (parsed.options.forceShell || needsShell) {
+	        // Need to double escape meta chars if the command is a cmd-shim located in `node_modules/.bin/`
+	        // The cmd-shim simply calls execute the package bin file with NodeJS, proxying any argument
+	        // Because the escape of metachars with ^ gets interpreted when the cmd.exe is first called,
+	        // we need to double escape them
+	        var needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+	        // Normalize posix paths into OS compatible paths (e.g.: foo/bar -> foo\bar)
+	        // This is necessary otherwise it will always fail with ENOENT in those cases
+	        parsed.command = path.normalize(parsed.command);
+	        // Escape command & arguments
+	        parsed.command = escape.command(parsed.command);
+	        parsed.args = parsed.args.map(function(arg) {
+	            return escape.argument(arg, needsDoubleEscapeMetaChars);
+	        });
+	        var shellCommand = [
+	            parsed.command
+	        ].concat(parsed.args).join(' ');
+	        parsed.args = [
+	            '/d',
+	            '/s',
+	            '/c',
+	            '"'.concat(shellCommand, '"')
+	        ];
+	        parsed.command = process.env.comspec || 'cmd.exe';
+	        parsed.options.windowsVerbatimArguments = true; // Tell node's spawn that the arguments are already escaped
+	    }
+	    return parsed;
+	}
+	function parse(command, args, options) {
+	    // Normalize arguments, similar to nodejs
+	    if (args && !Array.isArray(args)) {
+	        options = args;
+	        args = null;
+	    }
+	    args = args ? args.slice(0) : []; // Clone array to avoid changing the original
+	    options = Object.assign({}, options); // Clone object to avoid changing the original
+	    // Build our parsed object
+	    var parsed = {
+	        command: command,
+	        args: args,
+	        options: options,
+	        file: undefined,
+	        original: {
+	            command: command,
+	            args: args
+	        }
+	    };
+	    // Delegate further parsing to shell or non-shell
+	    return options.shell ? parsed : parseNonShell(parsed);
+	}
+	parse_1 = parse;
+	return parse_1;
+}
+
+var enoent;
+var hasRequiredEnoent;
+
+function requireEnoent () {
+	if (hasRequiredEnoent) return enoent;
+	hasRequiredEnoent = 1;
+	var isWin = process.platform === 'win32';
+	function notFoundError(original, syscall) {
+	    return Object.assign(new Error("".concat(syscall, " ").concat(original.command, " ENOENT")), {
+	        code: 'ENOENT',
+	        errno: 'ENOENT',
+	        syscall: "".concat(syscall, " ").concat(original.command),
+	        path: original.command,
+	        spawnargs: original.args
+	    });
+	}
+	function hookChildProcess(cp, parsed) {
+	    if (!isWin) {
+	        return;
+	    }
+	    var originalEmit = cp.emit;
+	    cp.emit = function(name, arg1) {
+	        // If emitting "exit" event and exit code is 1, we need to check if
+	        // the command exists and emit an "error" instead
+	        // See https://github.com/IndigoUnited/node-cross-spawn/issues/16
+	        if (name === 'exit') {
+	            var err = verifyENOENT(arg1, parsed);
+	            if (err) {
+	                return originalEmit.call(cp, 'error', err);
+	            }
+	        }
+	        return originalEmit.apply(cp, arguments); // eslint-disable-line prefer-rest-params
+	    };
+	}
+	function verifyENOENT(status, parsed) {
+	    if (isWin && status === 1 && !parsed.file) {
+	        return notFoundError(parsed.original, 'spawn');
+	    }
+	    return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+	    if (isWin && status === 1 && !parsed.file) {
+	        return notFoundError(parsed.original, 'spawnSync');
+	    }
+	    return null;
+	}
+	enoent = {
+	    hookChildProcess: hookChildProcess,
+	    verifyENOENT: verifyENOENT,
+	    verifyENOENTSync: verifyENOENTSync,
+	    notFoundError: notFoundError
+	};
+	return enoent;
+}
+
+var hasRequiredCrossSpawn;
+
+function requireCrossSpawn () {
+	if (hasRequiredCrossSpawn) return crossSpawn.exports;
+	hasRequiredCrossSpawn = 1;
+	var cp = require$$0$2;
+	var parse = requireParse();
+	var enoent = requireEnoent();
+	function spawn(command, args, options) {
+	    // Parse the arguments
+	    var parsed = parse(command, args, options);
+	    // Spawn the child process
+	    var spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+	    // Hook into child process "exit" event to emit an error if the command
+	    // does not exists, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
+	    enoent.hookChildProcess(spawned, parsed);
+	    return spawned;
+	}
+	function spawnSync(command, args, options) {
+	    // Parse the arguments
+	    var parsed = parse(command, args, options);
+	    // Spawn the child process
+	    var result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+	    // Analyze if the command does not exist, see: https://github.com/IndigoUnited/node-cross-spawn/issues/16
+	    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+	    return result;
+	}
+	crossSpawn.exports = spawn;
+	crossSpawn.exports.spawn = spawn;
+	crossSpawn.exports.sync = spawnSync;
+	crossSpawn.exports._parse = parse;
+	crossSpawn.exports._enoent = enoent;
+	return crossSpawn.exports;
+}
+
+var src = {
+    exports: {}
+};
+
+var browser$1 = {
+    exports: {}
+};
+
+/**
+ * Helpers.
+ */
+
+var ms;
+var hasRequiredMs;
+
+function requireMs () {
+	if (hasRequiredMs) return ms;
+	hasRequiredMs = 1;
+	function _type_of(obj) {
+	    "@swc/helpers - typeof";
+	    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+	}
+	var s = 1000;
+	var m = s * 60;
+	var h = m * 60;
+	var d = h * 24;
+	var w = d * 7;
+	var y = d * 365.25;
+	/**
+	 * Parse or format the given `val`.
+	 *
+	 * Options:
+	 *
+	 *  - `long` verbose formatting [false]
+	 *
+	 * @param {String|Number} val
+	 * @param {Object} [options]
+	 * @throws {Error} throw an error if val is not a non-empty string or a number
+	 * @return {String|Number}
+	 * @api public
+	 */ ms = function(val, options) {
+	    options = options || {};
+	    var type = typeof val === "undefined" ? "undefined" : _type_of(val);
+	    if (type === 'string' && val.length > 0) {
+	        return parse(val);
+	    } else if (type === 'number' && isFinite(val)) {
+	        return options.long ? fmtLong(val) : fmtShort(val);
+	    }
+	    throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val));
+	};
+	/**
+	 * Parse the given `str` and return milliseconds.
+	 *
+	 * @param {String} str
+	 * @return {Number}
+	 * @api private
+	 */ function parse(str) {
+	    str = String(str);
+	    if (str.length > 100) {
+	        return;
+	    }
+	    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+	    if (!match) {
+	        return;
+	    }
+	    var n = parseFloat(match[1]);
+	    var type = (match[2] || 'ms').toLowerCase();
+	    switch(type){
+	        case 'years':
+	        case 'year':
+	        case 'yrs':
+	        case 'yr':
+	        case 'y':
+	            return n * y;
+	        case 'weeks':
+	        case 'week':
+	        case 'w':
+	            return n * w;
+	        case 'days':
+	        case 'day':
+	        case 'd':
+	            return n * d;
+	        case 'hours':
+	        case 'hour':
+	        case 'hrs':
+	        case 'hr':
+	        case 'h':
+	            return n * h;
+	        case 'minutes':
+	        case 'minute':
+	        case 'mins':
+	        case 'min':
+	        case 'm':
+	            return n * m;
+	        case 'seconds':
+	        case 'second':
+	        case 'secs':
+	        case 'sec':
+	        case 's':
+	            return n * s;
+	        case 'milliseconds':
+	        case 'millisecond':
+	        case 'msecs':
+	        case 'msec':
+	        case 'ms':
+	            return n;
+	        default:
+	            return undefined;
+	    }
+	}
+	/**
+	 * Short format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */ function fmtShort(ms) {
+	    var msAbs = Math.abs(ms);
+	    if (msAbs >= d) {
+	        return Math.round(ms / d) + 'd';
+	    }
+	    if (msAbs >= h) {
+	        return Math.round(ms / h) + 'h';
+	    }
+	    if (msAbs >= m) {
+	        return Math.round(ms / m) + 'm';
+	    }
+	    if (msAbs >= s) {
+	        return Math.round(ms / s) + 's';
+	    }
+	    return ms + 'ms';
+	}
+	/**
+	 * Long format for `ms`.
+	 *
+	 * @param {Number} ms
+	 * @return {String}
+	 * @api private
+	 */ function fmtLong(ms) {
+	    var msAbs = Math.abs(ms);
+	    if (msAbs >= d) {
+	        return plural(ms, msAbs, d, 'day');
+	    }
+	    if (msAbs >= h) {
+	        return plural(ms, msAbs, h, 'hour');
+	    }
+	    if (msAbs >= m) {
+	        return plural(ms, msAbs, m, 'minute');
+	    }
+	    if (msAbs >= s) {
+	        return plural(ms, msAbs, s, 'second');
+	    }
+	    return ms + ' ms';
+	}
+	/**
+	 * Pluralization helper.
+	 */ function plural(ms, msAbs, n, name) {
+	    var isPlural = msAbs >= n * 1.5;
+	    return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
+	}
+	return ms;
+}
+
+var common$1;
+var hasRequiredCommon;
+
+function requireCommon () {
+	if (hasRequiredCommon) return common$1;
+	hasRequiredCommon = 1;
+	function _instanceof(left, right) {
+	    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+	        return !!right[Symbol.hasInstance](left);
+	    } else {
+	        return left instanceof right;
+	    }
+	}
+	/**
+	 * This is the common logic for both the Node.js and web browser
+	 * implementations of `debug()`.
+	 */ function setup(env) {
+	    createDebug.debug = createDebug;
+	    createDebug.default = createDebug;
+	    createDebug.coerce = coerce;
+	    createDebug.disable = disable;
+	    createDebug.enable = enable;
+	    createDebug.enabled = enabled;
+	    createDebug.humanize = requireMs();
+	    Object.keys(env).forEach(function(key) {
+	        createDebug[key] = env[key];
+	    });
+	    /**
+	  * Active `debug` instances.
+	  */ createDebug.instances = [];
+	    /**
+	  * The currently active debug mode names, and names to skip.
+	  */ createDebug.names = [];
+	    createDebug.skips = [];
+	    /**
+	  * Map of special "%n" handling functions, for the debug "format" argument.
+	  *
+	  * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
+	  */ createDebug.formatters = {};
+	    /**
+	  * Selects a color for a debug namespace
+	  * @param {String} namespace The namespace string for the for the debug instance to be colored
+	  * @return {Number|String} An ANSI color code for the given namespace
+	  * @api private
+	  */ function selectColor(namespace) {
+	        var hash = 0;
+	        for(var i = 0; i < namespace.length; i++){
+	            hash = (hash << 5) - hash + namespace.charCodeAt(i);
+	            hash |= 0; // Convert to 32bit integer
+	        }
+	        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+	    }
+	    createDebug.selectColor = selectColor;
+	    /**
+	  * Create a debugger with the given `namespace`.
+	  *
+	  * @param {String} namespace
+	  * @return {Function}
+	  * @api public
+	  */ function createDebug(namespace) {
+	        var prevTime;
+	        function debug() {
+	            // Disabled?
+	            if (!debug.enabled) {
+	                return;
+	            }
+	            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+	                args[_key] = arguments[_key];
+	            }
+	            var self = debug; // Set `diff` timestamp
+	            var curr = Number(new Date());
+	            var ms = curr - (prevTime || curr);
+	            self.diff = ms;
+	            self.prev = prevTime;
+	            self.curr = curr;
+	            prevTime = curr;
+	            args[0] = createDebug.coerce(args[0]);
+	            if (typeof args[0] !== 'string') {
+	                // Anything else let's inspect with %O
+	                args.unshift('%O');
+	            } // Apply any `formatters` transformations
+	            var index = 0;
+	            args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {
+	                // If we encounter an escaped % then don't increase the array index
+	                if (match === '%%') {
+	                    return match;
+	                }
+	                index++;
+	                var formatter = createDebug.formatters[format];
+	                if (typeof formatter === 'function') {
+	                    var val = args[index];
+	                    match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
+	                    args.splice(index, 1);
+	                    index--;
+	                }
+	                return match;
+	            }); // Apply env-specific formatting (colors, etc.)
+	            createDebug.formatArgs.call(self, args);
+	            var logFn = self.log || createDebug.log;
+	            logFn.apply(self, args);
+	        }
+	        debug.namespace = namespace;
+	        debug.enabled = createDebug.enabled(namespace);
+	        debug.useColors = createDebug.useColors();
+	        debug.color = selectColor(namespace);
+	        debug.destroy = destroy;
+	        debug.extend = extend; // Debug.formatArgs = formatArgs;
+	        // debug.rawLog = rawLog;
+	        // env-specific initialization logic for debug instances
+	        if (typeof createDebug.init === 'function') {
+	            createDebug.init(debug);
+	        }
+	        createDebug.instances.push(debug);
+	        return debug;
+	    }
+	    function destroy() {
+	        var index = createDebug.instances.indexOf(this);
+	        if (index !== -1) {
+	            createDebug.instances.splice(index, 1);
+	            return true;
+	        }
+	        return false;
+	    }
+	    function extend(namespace, delimiter) {
+	        return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
+	    }
+	    /**
+	  * Enables a debug mode by namespaces. This can include modes
+	  * separated by a colon and wildcards.
+	  *
+	  * @param {String} namespaces
+	  * @api public
+	  */ function enable(namespaces) {
+	        createDebug.save(namespaces);
+	        createDebug.names = [];
+	        createDebug.skips = [];
+	        var i;
+	        var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
+	        var len = split.length;
+	        for(i = 0; i < len; i++){
+	            if (!split[i]) {
+	                continue;
+	            }
+	            namespaces = split[i].replace(/\*/g, '.*?');
+	            if (namespaces[0] === '-') {
+	                createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
+	            } else {
+	                createDebug.names.push(new RegExp('^' + namespaces + '$'));
+	            }
+	        }
+	        for(i = 0; i < createDebug.instances.length; i++){
+	            var instance = createDebug.instances[i];
+	            instance.enabled = createDebug.enabled(instance.namespace);
+	        }
+	    }
+	    /**
+	  * Disable debug output.
+	  *
+	  * @api public
+	  */ function disable() {
+	        createDebug.enable('');
+	    }
+	    /**
+	  * Returns true if the given mode name is enabled, false otherwise.
+	  *
+	  * @param {String} name
+	  * @return {Boolean}
+	  * @api public
+	  */ function enabled(name) {
+	        if (name[name.length - 1] === '*') {
+	            return true;
+	        }
+	        var i;
+	        var len;
+	        for(i = 0, len = createDebug.skips.length; i < len; i++){
+	            if (createDebug.skips[i].test(name)) {
+	                return false;
+	            }
+	        }
+	        for(i = 0, len = createDebug.names.length; i < len; i++){
+	            if (createDebug.names[i].test(name)) {
+	                return true;
+	            }
+	        }
+	        return false;
+	    }
+	    /**
+	  * Coerce `val`.
+	  *
+	  * @param {Mixed} val
+	  * @return {Mixed}
+	  * @api private
+	  */ function coerce(val) {
+	        if (_instanceof(val, Error)) {
+	            return val.stack || val.message;
+	        }
+	        return val;
+	    }
+	    createDebug.enable(createDebug.load());
+	    return createDebug;
+	}
+	common$1 = setup;
+	return common$1;
+}
+
+var hasRequiredBrowser$1;
+
+function requireBrowser$1 () {
+	if (hasRequiredBrowser$1) return browser$1.exports;
+	hasRequiredBrowser$1 = 1;
+	(function (module, exports) {
+		function _type_of(obj) {
+		    "@swc/helpers - typeof";
+		    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+		}
+		function _typeof(obj) {
+		    if (typeof Symbol === "function" && _type_of(Symbol.iterator) === "symbol") {
+		        _typeof = function _typeof(obj) {
+		            return typeof obj === "undefined" ? "undefined" : _type_of(obj);
+		        };
+		    } else {
+		        _typeof = function _typeof(obj) {
+		            return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj === "undefined" ? "undefined" : _type_of(obj);
+		        };
+		    }
+		    return _typeof(obj);
+		}
+		/* eslint-env browser */ /**
+		 * This is the web browser implementation of `debug()`.
+		 */ exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		exports.storage = localstorage();
+		/**
+		 * Colors.
+		 */ exports.colors = [
+		    '#0000CC',
+		    '#0000FF',
+		    '#0033CC',
+		    '#0033FF',
+		    '#0066CC',
+		    '#0066FF',
+		    '#0099CC',
+		    '#0099FF',
+		    '#00CC00',
+		    '#00CC33',
+		    '#00CC66',
+		    '#00CC99',
+		    '#00CCCC',
+		    '#00CCFF',
+		    '#3300CC',
+		    '#3300FF',
+		    '#3333CC',
+		    '#3333FF',
+		    '#3366CC',
+		    '#3366FF',
+		    '#3399CC',
+		    '#3399FF',
+		    '#33CC00',
+		    '#33CC33',
+		    '#33CC66',
+		    '#33CC99',
+		    '#33CCCC',
+		    '#33CCFF',
+		    '#6600CC',
+		    '#6600FF',
+		    '#6633CC',
+		    '#6633FF',
+		    '#66CC00',
+		    '#66CC33',
+		    '#9900CC',
+		    '#9900FF',
+		    '#9933CC',
+		    '#9933FF',
+		    '#99CC00',
+		    '#99CC33',
+		    '#CC0000',
+		    '#CC0033',
+		    '#CC0066',
+		    '#CC0099',
+		    '#CC00CC',
+		    '#CC00FF',
+		    '#CC3300',
+		    '#CC3333',
+		    '#CC3366',
+		    '#CC3399',
+		    '#CC33CC',
+		    '#CC33FF',
+		    '#CC6600',
+		    '#CC6633',
+		    '#CC9900',
+		    '#CC9933',
+		    '#CCCC00',
+		    '#CCCC33',
+		    '#FF0000',
+		    '#FF0033',
+		    '#FF0066',
+		    '#FF0099',
+		    '#FF00CC',
+		    '#FF00FF',
+		    '#FF3300',
+		    '#FF3333',
+		    '#FF3366',
+		    '#FF3399',
+		    '#FF33CC',
+		    '#FF33FF',
+		    '#FF6600',
+		    '#FF6633',
+		    '#FF9900',
+		    '#FF9933',
+		    '#FFCC00',
+		    '#FFCC33'
+		];
+		/**
+		 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
+		 * and the Firebug extension (any Firefox version) are known
+		 * to support "%c" CSS customizations.
+		 *
+		 * TODO: add a `localStorage` variable to explicitly enable/disable colors
+		 */ // eslint-disable-next-line complexity
+		function useColors() {
+		    // NB: In an Electron preload script, document will be defined but not fully
+		    // initialized. Since we know we're in Chrome, we'll just detect this case
+		    // explicitly
+		    if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
+		        return true;
+		    } // Internet Explorer and Edge do not support colors.
+		    if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+		        return false;
+		    } // Is webkit? http://stackoverflow.com/a/16459606/376773
+		    // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
+		    return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+		    typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+		    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+		    typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+		    typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+		}
+		/**
+		 * Colorize log arguments if enabled.
+		 *
+		 * @api public
+		 */ function formatArgs(args) {
+		    args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
+		    if (!this.useColors) {
+		        return;
+		    }
+		    var c = 'color: ' + this.color;
+		    args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
+		    // arguments passed either before or after the %c, so we need to
+		    // figure out the correct index to insert the CSS into
+		    var index = 0;
+		    var lastC = 0;
+		    args[0].replace(/%[a-zA-Z%]/g, function(match) {
+		        if (match === '%%') {
+		            return;
+		        }
+		        index++;
+		        if (match === '%c') {
+		            // We only are interested in the *last* %c
+		            // (the user may have provided their own)
+		            lastC = index;
+		        }
+		    });
+		    args.splice(lastC, 0, c);
+		}
+		/**
+		 * Invokes `console.log()` when available.
+		 * No-op when `console.log` is not a "function".
+		 *
+		 * @api public
+		 */ function log() {
+		    var _console;
+		    // This hackery is required for IE8/9, where
+		    // the `console.log` function doesn't have 'apply'
+		    return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
+		}
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */ function save(namespaces) {
+		    try {
+		        if (namespaces) {
+		            exports.storage.setItem('debug', namespaces);
+		        } else {
+		            exports.storage.removeItem('debug');
+		        }
+		    } catch (error) {
+		    // XXX (@Qix-) should we be logging these?
+		    }
+		}
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */ function load() {
+		    var r;
+		    try {
+		        r = exports.storage.getItem('debug');
+		    } catch (error) {} // Swallow
+		    // XXX (@Qix-) should we be logging these?
+		    // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
+		    if (!r && typeof process !== 'undefined' && 'env' in process) {
+		        r = process.env.DEBUG;
+		    }
+		    return r;
+		}
+		/**
+		 * Localstorage attempts to return the localstorage.
+		 *
+		 * This is necessary because safari throws
+		 * when a user disables cookies/localstorage
+		 * and you attempt to access it.
+		 *
+		 * @return {LocalStorage}
+		 * @api private
+		 */ function localstorage() {
+		    try {
+		        // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
+		        // The Browser also has localStorage in the global context.
+		        return localStorage;
+		    } catch (error) {
+		    // XXX (@Qix-) should we be logging these?
+		    }
+		}
+		module.exports = requireCommon()(exports);
+		var formatters = module.exports.formatters;
+		/**
+		 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
+		 */ formatters.j = function(v) {
+		    try {
+		        return JSON.stringify(v);
+		    } catch (error) {
+		        return '[UnexpectedJSONParseError]: ' + error.message;
+		    }
+		}; 
+	} (browser$1, browser$1.exports));
+	return browser$1.exports;
+}
+
+var node = {
+    exports: {}
+};
+
+/* eslint-env browser */
+
+var browser;
+var hasRequiredBrowser;
+
+function requireBrowser () {
+	if (hasRequiredBrowser) return browser;
+	hasRequiredBrowser = 1;
+	function getChromeVersion() {
+	    var matches = RegExp("(Chrome|Chromium)\\/(?<chromeVersion>\\d+)\\.").exec(navigator.userAgent);
+	    if (!matches) {
+	        return;
+	    }
+	    return Number.parseInt(matches.groups.chromeVersion, 10);
+	}
+	var colorSupport = getChromeVersion() >= 69 ? {
+	    level: 1,
+	    hasBasic: true,
+	    has256: false,
+	    has16m: false
+	} : false;
+	browser = {
+	    stdout: colorSupport,
+	    stderr: colorSupport
+	};
+	return browser;
+}
+
+var hasRequiredNode;
+
+function requireNode () {
+	if (hasRequiredNode) return node.exports;
+	hasRequiredNode = 1;
+	(function (module, exports) {
+		/**
+		 * Module dependencies.
+		 */ var tty = require$$0$3;
+		var util = require$$1;
+		/**
+		 * This is the Node.js implementation of `debug()`.
+		 */ exports.init = init;
+		exports.log = log;
+		exports.formatArgs = formatArgs;
+		exports.save = save;
+		exports.load = load;
+		exports.useColors = useColors;
+		/**
+		 * Colors.
+		 */ exports.colors = [
+		    6,
+		    2,
+		    3,
+		    4,
+		    5,
+		    1
+		];
+		try {
+		    // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
+		    // eslint-disable-next-line import/no-extraneous-dependencies
+		    var supportsColor = requireBrowser();
+		    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+		        exports.colors = [
+		            20,
+		            21,
+		            26,
+		            27,
+		            32,
+		            33,
+		            38,
+		            39,
+		            40,
+		            41,
+		            42,
+		            43,
+		            44,
+		            45,
+		            56,
+		            57,
+		            62,
+		            63,
+		            68,
+		            69,
+		            74,
+		            75,
+		            76,
+		            77,
+		            78,
+		            79,
+		            80,
+		            81,
+		            92,
+		            93,
+		            98,
+		            99,
+		            112,
+		            113,
+		            128,
+		            129,
+		            134,
+		            135,
+		            148,
+		            149,
+		            160,
+		            161,
+		            162,
+		            163,
+		            164,
+		            165,
+		            166,
+		            167,
+		            168,
+		            169,
+		            170,
+		            171,
+		            172,
+		            173,
+		            178,
+		            179,
+		            184,
+		            185,
+		            196,
+		            197,
+		            198,
+		            199,
+		            200,
+		            201,
+		            202,
+		            203,
+		            204,
+		            205,
+		            206,
+		            207,
+		            208,
+		            209,
+		            214,
+		            215,
+		            220,
+		            221
+		        ];
+		    }
+		} catch (error) {} // Swallow - we only care if `supports-color` is available; it doesn't have to be.
+		/**
+		 * Build up the default `inspectOpts` object from the environment variables.
+		 *
+		 *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
+		 */ exports.inspectOpts = Object.keys(process.env).filter(function(key) {
+		    return /^debug_/i.test(key);
+		}).reduce(function(obj, key) {
+		    // Camel-case
+		    var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function(_, k) {
+		        return k.toUpperCase();
+		    }); // Coerce string value into JS value
+		    var val = process.env[key];
+		    if (/^(yes|on|true|enabled)$/i.test(val)) {
+		        val = true;
+		    } else if (/^(no|off|false|disabled)$/i.test(val)) {
+		        val = false;
+		    } else if (val === 'null') {
+		        val = null;
+		    } else {
+		        val = Number(val);
+		    }
+		    obj[prop] = val;
+		    return obj;
+		}, {});
+		/**
+		 * Is stdout a TTY? Colored output is enabled when `true`.
+		 */ function useColors() {
+		    return 'colors' in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+		}
+		/**
+		 * Adds ANSI color escape codes if enabled.
+		 *
+		 * @api public
+		 */ function formatArgs(args) {
+		    var name = this.namespace, _$useColors = this.useColors;
+		    if (_$useColors) {
+		        var c = this.color;
+		        var colorCode = "\x1B[3" + (c < 8 ? c : '8;5;' + c);
+		        var prefix = "  ".concat(colorCode, ";1m").concat(name, " \x1B[0m");
+		        args[0] = prefix + args[0].split('\n').join('\n' + prefix);
+		        args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + "\x1B[0m");
+		    } else {
+		        args[0] = getDate() + name + ' ' + args[0];
+		    }
+		}
+		function getDate() {
+		    if (exports.inspectOpts.hideDate) {
+		        return '';
+		    }
+		    return new Date().toISOString() + ' ';
+		}
+		/**
+		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 */ function log() {
+		    return process.stderr.write(util.format.apply(util, arguments) + '\n');
+		}
+		/**
+		 * Save `namespaces`.
+		 *
+		 * @param {String} namespaces
+		 * @api private
+		 */ function save(namespaces) {
+		    if (namespaces) {
+		        process.env.DEBUG = namespaces;
+		    } else {
+		        // If you set a process.env field to null or undefined, it gets cast to the
+		        // string 'null' or 'undefined'. Just delete instead.
+		        delete process.env.DEBUG;
+		    }
+		}
+		/**
+		 * Load `namespaces`.
+		 *
+		 * @return {String} returns the previously persisted debug modes
+		 * @api private
+		 */ function load() {
+		    return process.env.DEBUG;
+		}
+		/**
+		 * Init logic for `debug` instances.
+		 *
+		 * Create a new `inspectOpts` object in case `useColors` is set
+		 * differently for a particular `debug` instance.
+		 */ function init(debug) {
+		    debug.inspectOpts = {};
+		    var keys = Object.keys(exports.inspectOpts);
+		    for(var i = 0; i < keys.length; i++){
+		        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+		    }
+		}
+		module.exports = requireCommon()(exports);
+		var formatters = module.exports.formatters;
+		/**
+		 * Map %o to `util.inspect()`, all on a single line.
+		 */ formatters.o = function(v) {
+		    this.inspectOpts.colors = this.useColors;
+		    return util.inspect(v, this.inspectOpts).split('\n').map(function(str) {
+		        return str.trim();
+		    }).join(' ');
+		};
+		/**
+		 * Map %O to `util.inspect()`, allowing multiple lines if needed.
+		 */ formatters.O = function(v) {
+		    this.inspectOpts.colors = this.useColors;
+		    return util.inspect(v, this.inspectOpts);
+		}; 
+	} (node, node.exports));
+	return node.exports;
+}
+
+var hasRequiredSrc;
+
+function requireSrc () {
+	if (hasRequiredSrc) return src.exports;
+	hasRequiredSrc = 1;
+	/**
+	 * Detect Electron renderer / nwjs process, which is node, but we should
+	 * treat as a browser.
+	 */ if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
+	    src.exports = requireBrowser$1();
+	} else {
+	    src.exports = requireNode();
+	}
+	return src.exports;
+}
+
+var arraySeries;
+var hasRequiredArraySeries;
+
+function requireArraySeries () {
+	if (hasRequiredArraySeries) return arraySeries;
+	hasRequiredArraySeries = 1;
+	arraySeries = function series(fns, context, callback) {
+	    if (!callback) {
+	        if (typeof context === 'function') {
+	            callback = context;
+	            context = null;
+	        } else {
+	            callback = noop;
+	        }
+	    }
+	    if (!(fns && fns.length)) return callback();
+	    fns = fns.slice(0);
+	    var call = context ? function call() {
+	        fns.length ? fns.shift().call(context, next) : callback();
+	    } : function() {
+	        fns.length ? fns.shift()(next) : callback();
+	    };
+	    call();
+	    function next(err) {
+	        err ? callback(err) : call();
+	    }
+	};
+	function noop() {}
+	return arraySeries;
+}
+
+/**
+ * Module dependencies.
+ */
+
+var command;
+var hasRequiredCommand;
+
+function requireCommand () {
+	if (hasRequiredCommand) return command;
+	hasRequiredCommand = 1;
+	var spawn = requireCrossSpawn();
+	var utils = requireUtils();
+	var debug = requireSrc()('gm');
+	var series = requireArraySeries();
+	var PassThrough = require$$4.PassThrough;
+	/**
+	 * Error messaging.
+	 */ var noBufferConcat = 'gm v1.9.0+ required node v0.8+. Please update your version of node, downgrade gm < 1.9, or do not use `bufferStream`.';
+	/**
+	 * Extend proto
+	 */ command = function(proto) {
+	    function args(prop) {
+	        return function args() {
+	            var len = arguments.length;
+	            var a = [];
+	            var i = 0;
+	            for(; i < len; ++i){
+	                a.push(arguments[i]);
+	            }
+	            this[prop] = this[prop].concat(a);
+	            return this;
+	        };
+	    }
+	    function streamToUnemptyBuffer(stream, callback) {
+	        var done = false;
+	        var buffers = [];
+	        stream.on('data', function(data) {
+	            buffers.push(data);
+	        });
+	        stream.on('end', function() {
+	            if (done) return;
+	            done = true;
+	            var result = Buffer.concat(buffers);
+	            buffers = null;
+	            if (result.length === 0) {
+	                var err = new Error("Stream yields empty buffer");
+	                callback(err, null);
+	            } else {
+	                callback(null, result);
+	            }
+	        });
+	        stream.on('error', function(err) {
+	            done = true;
+	            buffers = null;
+	            callback(err);
+	        });
+	    }
+	    proto.in = args('_in');
+	    proto.out = args('_out');
+	    proto._preprocessor = [];
+	    proto.preprocessor = args('_preprocessor');
+	    /**
+	   * Execute the command and write the image to the specified file name.
+	   *
+	   * @param {String} name
+	   * @param {Function} callback
+	   * @return {Object} gm
+	   */ proto.write = function write(name, callback) {
+	        if (!callback) callback = name, name = null;
+	        if ("function" !== typeof callback) {
+	            throw new TypeError("gm().write() expects a callback function");
+	        }
+	        if (!name) {
+	            return callback(TypeError("gm().write() expects a filename when writing new files"));
+	        }
+	        this.outname = name;
+	        var self = this;
+	        this._preprocess(function(err) {
+	            if (err) return callback(err);
+	            self._spawn(self.args(), true, callback);
+	        });
+	    };
+	    /**
+	   * Execute the command and return stdin and stderr
+	   * ReadableStreams providing the image data.
+	   * If no callback is passed, a "through" stream will be returned,
+	   * and stdout will be piped through, otherwise the error will be passed.
+	   *
+	   * @param {String} format (optional)
+	   * @param {Function} callback (optional)
+	   * @return {Stream}
+	   */ proto.stream = function stream(format, callback) {
+	        if (!callback && typeof format === 'function') {
+	            callback = format;
+	            format = null;
+	        }
+	        var throughStream;
+	        if ("function" !== typeof callback) {
+	            throughStream = new PassThrough();
+	            callback = function callback(err, stdout, stderr) {
+	                if (err) throughStream.emit('error', err);
+	                else stdout.pipe(throughStream);
+	            };
+	        }
+	        if (format) {
+	            format = format.split('.').pop();
+	            this.outname = format + ":-";
+	        }
+	        var self = this;
+	        this._preprocess(function(err) {
+	            if (err) return callback(err);
+	            return self._spawn(self.args(), false, callback);
+	        });
+	        return throughStream || this;
+	    };
+	    /**
+	   * Convenience function for `proto.stream`.
+	   * Simply returns the buffer instead of the stream.
+	   *
+	   * @param {String} format (optional)
+	   * @param {Function} callback
+	   * @return {null}
+	   */ proto.toBuffer = function toBuffer(format, callback) {
+	        if (!callback) callback = format, format = null;
+	        if ("function" !== typeof callback) {
+	            throw new Error('gm().toBuffer() expects a callback.');
+	        }
+	        return this.stream(format, function(err, stdout) {
+	            if (err) return callback(err);
+	            streamToUnemptyBuffer(stdout, callback);
+	        });
+	    };
+	    /**
+	    * Run any preProcessor functions in series. Used by autoOrient.
+	    *
+	    * @param {Function} callback
+	    * @return {Object} gm
+	    */ proto._preprocess = function _preprocess(callback) {
+	        series(this._preprocessor, this, callback);
+	    };
+	    /**
+	    * Execute the command, buffer input and output, return stdout and stderr buffers.
+	    *
+	    * @param {String} bin
+	    * @param {Array} args
+	    * @param {Function} callback
+	    * @return {Object} gm
+	    */ proto._exec = function _exec(args, callback) {
+	        return this._spawn(args, true, callback);
+	    };
+	    /**
+	    * Execute the command with stdin, returning stdout and stderr streams or buffers.
+	    * @param {String} bin
+	    * @param {Array} args
+	    * @param {ReadableStream} stream
+	    * @param {Boolean} shouldBuffer
+	    * @param {Function} callback, signature (err, stdout, stderr) -> *
+	    * @return {Object} gm
+	    * @TODO refactor this mess
+	    */ proto._spawn = function _spawn(args, bufferOutput, callback) {
+	        var appPath = this._options.appPath || '';
+	        var bin;
+	        // Resolve executable
+	        switch(this._options.imageMagick){
+	            // legacy behavior
+	            case true:
+	                bin = args.shift();
+	                break;
+	            // ImgeMagick >= 7
+	            case '7+':
+	                bin = 'magick';
+	                break;
+	            // GraphicsMagick
+	            default:
+	                bin = 'gm';
+	                break;
+	        }
+	        // Prepend app path
+	        bin = appPath + bin;
+	        var cmd = bin + ' ' + args.map(utils.escape).join(' '), self = this, proc, timeout = parseInt(this._options.timeout), disposers = this._options.disposers, timeoutId;
+	        debug(cmd);
+	        //imageMagick does not support minify (https://github.com/aheckmann/gm/issues/385)
+	        if (args.indexOf("-minify") > -1 && this._options.imageMagick) {
+	            return cb(new Error("imageMagick does not support minify, use -scale or -sample. Alternatively, use graphicsMagick"));
+	        }
+	        try {
+	            proc = spawn(bin, args);
+	        } catch (e) {
+	            return cb(e);
+	        }
+	        proc.stdin.once('error', cb);
+	        proc.on('error', function(err) {
+	            if (err.code === 'ENOENT') {
+	                cb(new Error('Could not execute GraphicsMagick/ImageMagick: ' + cmd + " this most likely means the gm/convert binaries can't be found"));
+	            } else {
+	                cb(err);
+	            }
+	        });
+	        if (timeout) {
+	            timeoutId = setTimeout(function() {
+	                dispose('gm() resulted in a timeout.');
+	            }, timeout);
+	        }
+	        if (disposers) {
+	            disposers.forEach(function(disposer) {
+	                disposer.events.forEach(function(event) {
+	                    disposer.emitter.on(event, dispose);
+	                });
+	            });
+	        }
+	        if (self.sourceBuffer) {
+	            proc.stdin.write(this.sourceBuffer);
+	            proc.stdin.end();
+	        } else if (self.sourceStream) {
+	            if (!self.sourceStream.readable) {
+	                return cb(new Error("gm().stream() or gm().write() with a non-readable stream."));
+	            }
+	            self.sourceStream.pipe(proc.stdin);
+	            // bufferStream
+	            // We convert the input source from a stream to a buffer.
+	            if (self.bufferStream && !this._buffering) {
+	                if (!Buffer.concat) {
+	                    throw new Error(noBufferConcat);
+	                }
+	                // Incase there are multiple processes in parallel,
+	                // we only need one
+	                self._buffering = true;
+	                streamToUnemptyBuffer(self.sourceStream, function(err, buffer) {
+	                    self.sourceBuffer = buffer;
+	                    self.sourceStream = null; // The stream is now dead
+	                });
+	            }
+	        }
+	        // for _exec operations (identify() mostly), we also
+	        // need to buffer the output stream before returning
+	        if (bufferOutput) {
+	            var stdout = '', stderr = '';
+	            proc.stdout.on('data', function onOut(data) {
+	                stdout += data;
+	            });
+	            proc.stderr.on('data', function onErr(data) {
+	                stderr += data;
+	            });
+	            proc.on('close', function(code, signal) {
+	                var err;
+	                if (code !== 0 || signal !== null) {
+	                    err = new Error('Command failed: ' + stderr);
+	                    err.code = code;
+	                    err.signal = signal;
+	                }
+	                cb(err, stdout, stderr, cmd);
+	                stdout = stderr = null;
+	            });
+	        } else {
+	            cb(null, proc.stdout, proc.stderr, cmd);
+	        }
+	        return self;
+	        function cb(err, stdout, stderr, cmd) {
+	            if (cb.called) return;
+	            if (timeoutId) clearTimeout(timeoutId);
+	            cb.called = 1;
+	            if (args[0] !== 'identify' && bin !== 'identify') {
+	                self._in = [];
+	                self._out = [];
+	            }
+	            callback.call(self, err, stdout, stderr, cmd);
+	        }
+	        function dispose(msg) {
+	            var message = msg ? msg : 'gm() was disposed';
+	            var err = new Error(message);
+	            cb(err);
+	            if (proc.exitCode === null) {
+	                proc.stdin.pause();
+	                proc.kill();
+	            }
+	        }
+	    };
+	    /**
+	   * Returns arguments to be used in the command.
+	   *
+	   * @return {Array}
+	   */ proto.args = function args() {
+	        var outname = this.outname || "-";
+	        if (this._outputFormat) outname = this._outputFormat + ':' + outname;
+	        return [].concat(this._subCommand, this._in, this.src(), this._out, outname).filter(Boolean); // remove falsey
+	    };
+	    /**
+	   * Adds an img source formatter.
+	   *
+	   * `formatters` are passed an array of images which will be
+	   * used as 'input' images for the command. Useful for methods
+	   * like `.append()` where multiple source images may be used.
+	   *
+	   * @param {Function} formatter
+	   * @return {gm} this
+	   */ proto.addSrcFormatter = function addSrcFormatter(formatter) {
+	        if ('function' != typeof formatter) throw new TypeError('sourceFormatter must be a function');
+	        this._sourceFormatters || (this._sourceFormatters = []);
+	        this._sourceFormatters.push(formatter);
+	        return this;
+	    };
+	    /**
+	   * Applies all _sourceFormatters
+	   *
+	   * @return {Array}
+	   */ proto.src = function src() {
+	        var arr = [];
+	        for(var i = 0; i < this._sourceFormatters.length; ++i){
+	            this._sourceFormatters[i].call(this, arr);
+	        }
+	        return arr;
+	    };
+	    /**
+	   * Image types.
+	   */ var types = {
+	        'jpg': /\.jpe?g$/i,
+	        'png': /\.png$/i,
+	        'gif': /\.gif$/i,
+	        'tiff': /\.tif?f$/i,
+	        'bmp': /(?:\.bmp|\.dib)$/i,
+	        'webp': /\.webp$/i
+	    };
+	    types.jpeg = types.jpg;
+	    types.tif = types.tiff;
+	    types.dib = types.bmp;
+	    /**
+	   * Determine the type of source image.
+	   *
+	   * @param {String} type
+	   * @return {Boolean}
+	   * @example
+	   *   if (this.inputIs('png')) ...
+	   */ proto.inputIs = function inputIs(type) {
+	        if (!type) return false;
+	        var rgx = types[type];
+	        if (!rgx) {
+	            if ('.' !== type[0]) type = '.' + type;
+	            rgx = new RegExp('\\' + type + '$', 'i');
+	        }
+	        return rgx.test(this.source);
+	    };
+	    /**
+	   * add disposer (like 'close' of http.IncomingMessage) in order to dispose gm() with any event
+	   *
+	   * @param {EventEmitter} emitter
+	   * @param {Array} events
+	   * @return {Object} gm
+	   * @example
+	   *   command.addDisposer(req, ['close', 'end', 'finish']);
+	   */ proto.addDisposer = function addDisposer(emitter, events) {
+	        if (!this._options.disposers) {
+	            this._options.disposers = [];
+	        }
+	        this._options.disposers.push({
+	            emitter: emitter,
+	            events: events
+	        });
+	        return this;
+	    };
+	};
+	return command;
+}
+
+var compare = {
+    exports: {}
+};
+
+var hasRequiredCompare;
+
+function requireCompare () {
+	if (hasRequiredCompare) return compare.exports;
+	hasRequiredCompare = 1;
+	(function (module, exports) {
+		// compare
+		function _type_of(obj) {
+		    "@swc/helpers - typeof";
+		    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+		}
+		var spawn = requireCrossSpawn();
+		var debug = requireSrc()('gm');
+		var utils = requireUtils();
+		/**
+		 * Compare two images uses graphicsmagicks `compare` command.
+		 *
+		 * gm.compare(img1, img2, 0.4, function (err, equal, equality) {
+		 *   if (err) return handle(err);
+		 *   console.log('The images are equal: %s', equal);
+		 *   console.log('There equality was %d', equality);
+		 * });
+		 *
+		 * @param {String} orig Path to an image.
+		 * @param {String} compareTo Path to another image to compare to `orig`.
+		 * @param {Number|Object} [options] Options object or the amount of difference to tolerate before failing - defaults to 0.4
+		 * @param {Function} cb(err, Boolean, equality, rawOutput)
+		 */ module.exports = function exports1(proto) {
+		    function compare(orig, compareTo, options, cb) {
+		        var isImageMagick = this._options && this._options.imageMagick;
+		        var appPath = this._options && this._options.appPath || '';
+		        var args = [
+		            '-metric',
+		            'mse',
+		            orig,
+		            compareTo
+		        ];
+		        // Resove executable
+		        var bin;
+		        switch(isImageMagick){
+		            case true:
+		                bin = 'compare';
+		                break;
+		            case '7+':
+		                bin = 'magick';
+		                args.unshift('compare');
+		                break;
+		            default:
+		                bin = 'gm';
+		                args.unshift('compare');
+		                break;
+		        }
+		        // Prepend app path
+		        bin = appPath + bin;
+		        var tolerance = 0.4;
+		        // outputting the diff image
+		        if ((typeof options === "undefined" ? "undefined" : _type_of(options)) === 'object') {
+		            if (options.highlightColor && options.highlightColor.indexOf('"') < 0) {
+		                options.highlightColor = '"' + options.highlightColor + '"';
+		            }
+		            if (options.file) {
+		                if (typeof options.file !== 'string') {
+		                    throw new TypeError('The path for the diff output is invalid');
+		                }
+		                // graphicsmagick defaults to red
+		                if (options.highlightColor) {
+		                    args.push('-highlight-color');
+		                    args.push(options.highlightColor);
+		                }
+		                if (options.highlightStyle) {
+		                    args.push('-highlight-style');
+		                    args.push(options.highlightStyle);
+		                }
+		                // For IM, filename is the last argument. For GM it's `-file <filename>`
+		                if (!isImageMagick) {
+		                    args.push('-file');
+		                }
+		                args.push(options.file);
+		            }
+		            if (typeof options.tolerance != 'undefined') {
+		                if (typeof options.tolerance !== 'number') {
+		                    throw new TypeError('The tolerance value should be a number');
+		                }
+		                tolerance = options.tolerance;
+		            }
+		        } else {
+		            // For ImageMagick diff file is required but we don't care about it, so null it out
+		            if (isImageMagick) {
+		                args.push('null:');
+		            }
+		            if (typeof options == 'function') {
+		                cb = options; // tolerance value not provided, flip the cb place
+		            } else {
+		                tolerance = options;
+		            }
+		        }
+		        var cmd = bin + ' ' + args.map(utils.escape).join(' ');
+		        debug(cmd);
+		        var proc = spawn(bin, args);
+		        var stdout = '';
+		        var stderr = '';
+		        proc.stdout.on('data', function(data) {
+		            stdout += data;
+		        });
+		        proc.stderr.on('data', function(data) {
+		            stderr += data;
+		        });
+		        proc.on('close', function(code) {
+		            // ImageMagick returns err code 2 if err, 0 if similar, 1 if dissimilar
+		            if (isImageMagick) {
+		                if (code === 0) {
+		                    return cb(null, 0 <= tolerance, 0, stdout);
+		                } else if (code === 1) {
+		                    stdout = stderr;
+		                } else {
+		                    return cb(stderr);
+		                }
+		            } else {
+		                if (code !== 0) {
+		                    return cb(stderr);
+		                }
+		            }
+		            // Since ImageMagick similar gives err code 0 and no stdout, there's really no matching
+		            // Otherwise, output format for IM is `12.00 (0.123)` and for GM it's `Total: 0.123`
+		            var regex = isImageMagick ? /\((\d+\.?[\d\-\+e]*)\)/m : /Total: (\d+\.?\d*)/m;
+		            var match = regex.exec(stdout);
+		            if (!match) {
+		                return cb(new Error('Unable to parse output.\nGot ' + stdout));
+		            }
+		            var equality = parseFloat(match[1]);
+		            cb(null, equality <= tolerance, equality, stdout, orig, compareTo);
+		        });
+		    }
+		    if (proto) {
+		        proto.compare = compare;
+		    }
+		    return compare;
+		}; 
+	} (compare));
+	return compare.exports;
+}
+
+var composite = {
+    exports: {}
+};
+
+var hasRequiredComposite;
+
+function requireComposite () {
+	if (hasRequiredComposite) return composite.exports;
+	hasRequiredComposite = 1;
+	(function (module, exports) {
+		// composite
+		/**
+		 * Composite images together using the `composite` command in graphicsmagick.
+		 *
+		 * gm('/path/to/image.jpg')
+		 * .composite('/path/to/second_image.jpg')
+		 * .geometry('+100+150')
+		 * .write('/path/to/composite.png', function(err) {
+		 *   if(!err) console.log("Written composite image.");
+		 * });
+		 *
+		 * @param {String} other  Path to the image that contains the changes.
+		 * @param {String} [mask] Path to the image with opacity informtion. Grayscale.
+		 */ module.exports = function exports1(proto) {
+		    proto.composite = function(other, mask) {
+		        this.in(other);
+		        // If the mask is defined, add it to the output.
+		        if (typeof mask !== "undefined") this.out(mask);
+		        this.subCommand("composite");
+		        return this;
+		    };
+		}; 
+	} (composite));
+	return composite.exports;
+}
+
+var montage = {
+    exports: {}
+};
+
+var hasRequiredMontage;
+
+function requireMontage () {
+	if (hasRequiredMontage) return montage.exports;
+	hasRequiredMontage = 1;
+	(function (module, exports) {
+		// montage
+		/**
+		 * Montage images next to each other using the `montage` command in graphicsmagick.
+		 *
+		 * gm('/path/to/image.jpg')
+		 * .montage('/path/to/second_image.jpg')
+		 * .geometry('+100+150')
+		 * .write('/path/to/montage.png', function(err) {
+		 *   if(!err) console.log("Written montage image.");
+		 * });
+		 *
+		 * @param {String} other  Path to the image that contains the changes.
+		 */ module.exports = function exports1(proto) {
+		    proto.montage = function(other) {
+		        this.in(other);
+		        this.subCommand("montage");
+		        return this;
+		    };
+		}; 
+	} (montage));
+	return montage.exports;
+}
+
+var version = "1.25.1";
+var require$$13 = {
+    version: version};
+
+/**
+ * Module dependencies.
+ */
+
+(function (module, exports) {
+	function _instanceof(left, right) {
+	    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+	        return !!right[Symbol.hasInstance](left);
+	    } else {
+	        return left instanceof right;
+	    }
+	}
+	var Stream = require$$4.Stream;
+	var EventEmitter = require$$1$1.EventEmitter;
+	var util = require$$1;
+	util.inherits(gm, EventEmitter);
+	/**
+	 * Constructor.
+	 *
+	 * @param {String|Number} path - path to img source or ReadableStream or width of img to create
+	 * @param {Number} [height] - optional filename of ReadableStream or height of img to create
+	 * @param {String} [color] - optional hex background color of created img
+	 */ function gm(source, height, color) {
+	    var width;
+	    if (!_instanceof(this, gm)) {
+	        return new gm(source, height, color);
+	    }
+	    EventEmitter.call(this);
+	    this._options = {};
+	    this.options(this.__proto__._options);
+	    this.data = {};
+	    this._in = [];
+	    this._out = [];
+	    this._outputFormat = null;
+	    this._subCommand = 'convert';
+	    if (_instanceof(source, Stream)) {
+	        this.sourceStream = source;
+	        source = height || 'unknown.jpg';
+	    } else if (Buffer.isBuffer(source)) {
+	        this.sourceBuffer = source;
+	        source = height || 'unknown.jpg';
+	    } else if (height) {
+	        // new images
+	        width = source;
+	        source = "";
+	        this.in("-size", width + "x" + height);
+	        if (color) {
+	            this.in("xc:" + color);
+	        }
+	    }
+	    if (typeof source === "string") {
+	        // then source is a path
+	        // parse out gif frame brackets from filename
+	        // since stream doesn't use source path
+	        // eg. "filename.gif[0]"
+	        var frames = source.match(/(\[.+\])$/);
+	        if (frames) {
+	            this.sourceFrames = source.substr(frames.index, frames[0].length);
+	            source = source.substr(0, frames.index);
+	        }
+	    }
+	    this.source = source;
+	    this.addSrcFormatter(function(src) {
+	        // must be first source formatter
+	        var inputFromStdin = this.sourceStream || this.sourceBuffer;
+	        var ret = inputFromStdin ? '-' : this.source;
+	        var fileNameProvied = typeof height === 'string';
+	        if (inputFromStdin && fileNameProvied && /\.ico$/i.test(this.source)) {
+	            ret = "ico:-";
+	        }
+	        if (ret && this.sourceFrames) ret += this.sourceFrames;
+	        src.length = 0;
+	        src[0] = ret;
+	    });
+	}
+	/**
+	 * Subclasses the gm constructor with custom options.
+	 *
+	 * @param {options} options
+	 * @return {gm} the subclasses gm constructor
+	 */ var parent = gm;
+	gm.subClass = function subClass(options) {
+	    function gm(source, height, color) {
+	        if (!_instanceof(this, parent)) {
+	            return new gm(source, height, color);
+	        }
+	        parent.call(this, source, height, color);
+	    }
+	    gm.prototype.__proto__ = parent.prototype;
+	    gm.prototype._options = {};
+	    gm.prototype.options(options);
+	    return gm;
+	};
+	/**
+	 * Augment the prototype.
+	 */ requireOptions()(gm.prototype);
+	requireGetters()(gm);
+	requireArgs()(gm.prototype);
+	requireDrawing()(gm.prototype);
+	requireConvenience()(gm.prototype);
+	requireCommand()(gm.prototype);
+	requireCompare()(gm.prototype);
+	requireComposite()(gm.prototype);
+	requireMontage()(gm.prototype);
+	/**
+	 * Expose.
+	 */ module.exports = gm;
+	module.exports.utils = requireUtils();
+	module.exports.compare = requireCompare()();
+	module.exports.version = require$$13.version; 
+} (gm));
+
+var gmExports = gm.exports;
+
+var fromBuffer;
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _instanceof$G(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of$2(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var e = gmExports, t = require$$0$1, s = require$$0, i$2 = require$$4;
+var r = {
+    quality: 0,
+    format: "png",
+    width: 768,
+    height: 512,
+    density: 72,
+    preserveAspectRatio: false,
+    savePath: "./",
+    saveFilename: "untitled",
+    compression: "jpeg",
+    units: "PixelsPerInch"
+};
+function n(e, t, s, i) {
+    return new (s || (s = Promise))(function(r, n) {
+        function a(e) {
+            try {
+                h(i.next(e));
+            } catch (e) {
+                n(e);
+            }
+        }
+        function o(e) {
+            try {
+                h(i.throw(e));
+            } catch (e) {
+                n(e);
+            }
+        }
+        function h(e) {
+            var _$t;
+            e.done ? r(e.value) : (_$t = e.value, _instanceof$G(_$t, s) ? _$t : new s(function(e) {
+                e(_$t);
+            })).then(a, o);
+        }
+        h((i = i.apply(e, [])).next());
+    });
+}
+"function" == typeof SuppressedError && SuppressedError;
+var a = /*#__PURE__*/ function() {
+    function a() {
+        _class_call_check(this, a);
+        this.quality = 0, this.format = "png", this.width = 768, this.height = 512, this.preserveAspectRatio = false, this.density = 72, this.savePath = "./", this.saveFilename = "untitled", this.compression = "jpeg", this.units = "PixelsPerInch", this.gm = e.subClass({
+            imageMagick: false
+        });
+    }
+    _create_class(a, [
+        {
+            key: "generateValidFilename",
+            value: function generateValidFilename(e) {
+                var s = t.join(this.savePath, this.saveFilename);
+                return this.savePath.startsWith("./") && (s = "./".concat(s)), "number" == typeof e && (s = "".concat(s, ".").concat(e + 1)), "".concat(s, ".").concat(this.format);
+            }
+        },
+        {
+            key: "gmBaseCommand",
+            value: function gmBaseCommand(e, t) {
+                return this.gm(e, t).density(this.density, this.density).units(this.units).resize(this.width, this.height, this.preserveAspectRatio ? "^" : "!").quality(this.quality).compress(this.compression);
+            }
+        },
+        {
+            key: "toBase64",
+            value: function toBase64(e, t) {
+                return n(this, void 0, void 0, function() {
+                    var _ref, s, i, r;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.toBuffer(e, t)
+                                ];
+                            case 1:
+                                _ref = _state.sent(), s = _ref.buffer, i = _ref.size, r = _ref.page;
+                                return [
+                                    2,
+                                    {
+                                        base64: s.toString("base64"),
+                                        size: i,
+                                        page: r
+                                    }
+                                ];
+                        }
+                    });
+                });
+            }
+        },
+        {
+            key: "toBuffer",
+            value: function toBuffer(e, t) {
+                var _this = this;
+                var s = "".concat(e.path, "[").concat(t, "]");
+                return new Promise(function(i, r) {
+                    _this.gmBaseCommand(e, s).stream(_this.format, function(e, s) {
+                        var n = [];
+                        if (e) return r(e);
+                        s.on("data", function(e) {
+                            n.push(e);
+                        }).on("end", function() {
+                            return i({
+                                buffer: Buffer.concat(n),
+                                size: "".concat(_this.width, "x").concat(_this.height),
+                                page: t + 1
+                            });
+                        });
+                    });
+                });
+            }
+        },
+        {
+            key: "writeImage",
+            value: function writeImage(e, i) {
+                var _this = this;
+                var r = this.generateValidFilename(i), n = "".concat(e.path, "[").concat(i, "]");
+                return new Promise(function(a, o) {
+                    _this.gmBaseCommand(e, n).write(r, function(e) {
+                        return e ? o(e) : a({
+                            name: t.basename(r),
+                            size: "".concat(_this.width, "x").concat(_this.height),
+                            fileSize: s.statSync(r).size / 1e3,
+                            path: r,
+                            page: i + 1
+                        });
+                    });
+                });
+            }
+        },
+        {
+            key: "identify",
+            value: function identify(e, t) {
+                var s = this.gm(e);
+                return new Promise(function(e, i) {
+                    t ? s.identify(t, function(t, s) {
+                        return t ? i(t) : e(s.replace(/^[\w\W]*?1/, "1"));
+                    }) : s.identify(function(t, s) {
+                        return t ? i(t) : e(s);
+                    });
+                });
+            }
+        },
+        {
+            key: "setQuality",
+            value: function setQuality(e) {
+                return this.quality = e, this;
+            }
+        },
+        {
+            key: "setFormat",
+            value: function setFormat(e) {
+                return this.format = e, this;
+            }
+        },
+        {
+            key: "setSize",
+            value: function setSize(e, t) {
+                return this.width = e, this.height = this.preserveAspectRatio || t ? t : e, this;
+            }
+        },
+        {
+            key: "setPreserveAspectRatio",
+            value: function setPreserveAspectRatio(e) {
+                return this.preserveAspectRatio = e, this;
+            }
+        },
+        {
+            key: "setDensity",
+            value: function setDensity(e) {
+                return this.density = e, this;
+            }
+        },
+        {
+            key: "setSavePath",
+            value: function setSavePath(e) {
+                return this.savePath = e, this;
+            }
+        },
+        {
+            key: "setSaveFilename",
+            value: function setSaveFilename(e) {
+                return this.saveFilename = e, this;
+            }
+        },
+        {
+            key: "setUnits",
+            value: function setUnits(e) {
+                return this.units = e, this;
+            }
+        },
+        {
+            key: "setCompression",
+            value: function setCompression(e) {
+                return this.compression = e, this;
+            }
+        },
+        {
+            key: "setGMClass",
+            value: function setGMClass(t) {
+                return "boolean" == typeof t ? (this.gm = e.subClass({
+                    imageMagick: t
+                }), this) : "imagemagick" === t.toLocaleLowerCase() ? (this.gm = e.subClass({
+                    imageMagick: true
+                }), this) : (this.gm = e.subClass({
+                    appPath: t
+                }), this);
+            }
+        },
+        {
+            key: "getOptions",
+            value: function getOptions() {
+                return {
+                    quality: this.quality,
+                    format: this.format,
+                    width: this.width,
+                    height: this.height,
+                    preserveAspectRatio: this.preserveAspectRatio,
+                    density: this.density,
+                    savePath: this.savePath,
+                    saveFilename: this.saveFilename,
+                    compression: this.compression,
+                    units: this.units
+                };
+            }
+        }
+    ]);
+    return a;
+}();
+function o(e) {
+    return new i$2.Readable({
+        read: function read() {
+            this.push(e), this.push(null);
+        }
+    });
+}
+function h(e, t) {
+    return o(t);
+}
+function u(e, t) {
+    var _this = this;
+    var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : r;
+    var u = new a;
+    i = Object.assign(Object.assign({}, r), i);
+    var c = function(e, t, s) {
+        if (t < 1) throw new Error("Page number should be more than or equal 1");
+        var i = function(e) {
+            var _$t;
+            if (e && "object" != (typeof e === "undefined" ? "undefined" : _type_of$2(e))) throw new Error("Invalid convertOptions type: ".concat(e));
+            return null !== (_$t = null == e ? void 0 : e.responseType) && void 0 !== _$t ? _$t : "image";
+        }(s);
+        switch(i){
+            case "base64":
+                return u.toBase64(e, t - 1);
+            case "image":
+                return u.writeImage(e, t - 1);
+            case "buffer":
+                return u.toBuffer(e, t - 1);
+            default:
+                throw new Error("Invalid responseType: ".concat(i));
+        }
+    }, f = function(e, t, s) {
+        return Promise.all(t.map(function(t) {
+            return c(e, t, s);
+        }));
+    }, p = function() {
+        var s = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 1, i = arguments.length > 1 ? arguments[1] : void 0;
+        var r = h(e, t);
+        return c(r, s, i);
+    };
+    return p.bulk = function(i, r) {
+        return n(_this, void 0, void 0, function() {
+            var _c, a, h, c, _tmp, _$e, _, _1, _tmp1;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            function(e, t) {
+                                return n(this, void 0, void 0, function() {
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                return [
+                                                    2,
+                                                    t
+                                                ];
+                                            case 1:
+                                                return [
+                                                    2,
+                                                    _state.sent()
+                                                ];
+                                            case 2:
+                                                throw new Error("Cannot recognize specified source");
+                                        }
+                                    });
+                                });
+                            }(e, t)
+                        ];
+                    case 1:
+                        a = _state.sent();
+                        if (!(-1 === i)) return [
+                            3,
+                            3
+                        ];
+                        return [
+                            4,
+                            function(e, t) {
+                                return n(this, void 0, void 0, function() {
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                return [
+                                                    4,
+                                                    e.identify(t, "%p ")
+                                                ];
+                                            case 1:
+                                                return [
+                                                    2,
+                                                    _state.sent().split(" ").map(function(e) {
+                                                        return parseInt(e, 10);
+                                                    })
+                                                ];
+                                        }
+                                    });
+                                });
+                            }(u, o(a))
+                        ];
+                    case 2:
+                        _tmp = _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        _tmp = Array.isArray(i) ? i : [
+                            i
+                        ];
+                        _state.label = 4;
+                    case 4:
+                        h = _tmp, c = [];
+                        _$e = 0;
+                        _state.label = 5;
+                    case 5:
+                        if (!(_$e < h.length)) return [
+                            3,
+                            8
+                        ];
+                        _1 = (_ = (_c = c).push).apply;
+                        _tmp1 = [
+                            _c
+                        ];
+                        return [
+                            4,
+                            f(o(a), h.slice(_$e, _$e + 10), r)
+                        ];
+                    case 6:
+                        _1.apply(_, _tmp1.concat([
+                            _to_consumable_array.apply(void 0, [
+                                _state.sent()
+                            ])
+                        ]));
+                        _state.label = 7;
+                    case 7:
+                        _$e += 10;
+                        return [
+                            3,
+                            5
+                        ];
+                    case 8:
+                        return [
+                            2,
+                            c
+                        ];
+                }
+            });
+        });
+    }, p.setOptions = function() {
+        return function(e, t) {
+            return void e.setQuality(t.quality).setFormat(t.format).setPreserveAspectRatio(t.preserveAspectRatio).setSize(t.width, t.height).setDensity(t.density).setSavePath(t.savePath).setSaveFilename(t.saveFilename).setCompression(t.compression).setUnits(t.units);
+        }(u, i);
+    }, p.setGMClass = function(e) {
+        u.setGMClass(e);
+    }, p.setOptions(), p;
+}
+fromBuffer = function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : r;
+    return u("buffer", e, t);
+};
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -829,10 +5373,6 @@ var error = function error(msg) {
     throw new Error(msg);
 };
 
-function getDefaultExportFromCjs(x) {
-    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
 var common = {};
 
 (function (exports) {
@@ -27478,7 +32018,7 @@ let PDFService = class PDFService {
         const { width, height } = pdfPage.getSize();
         const widthPx = width / 72 * density;
         const heightPx = height / 72 * density;
-        const result = await pdf2pic.fromBuffer(buffer, {
+        const result = await fromBuffer(buffer, {
             density,
             format,
             preserveAspectRatio: true,