@wdio/image-comparison-core 1.0.0

package/dist/resemble/resemble.jimp.cjs

@@ -0,0 +1,981 @@
+"use strict";
+/*
+James Cryer / Huddle
+URL: https://github.com/Huddle/Resemble.js
+Modified by: @wswebcreation
+Reason: The node-canvas library was producing a lot of issues due to system dependency errors.
+        The Jimp library is a pure JavaScript image processing library that can be used in a Node.js environment.
+        The browser is not needed anymore, so the API is deliberately broken to only work in a Node.js environment.
+        The old code is still in the file, but commented out. This way, the code can easily be compared when needed with
+        the original resemble.js file.
+*/
+const { Jimp, JimpMime } = require('jimp');
+const naiveFallback = function () {
+    // ISC (c) 2011-2019 https://github.com/medikoo/es5-ext/blob/master/global.js
+    if (typeof self === 'object' && self) {
+        return self;
+    }
+    if (typeof window === 'object' && window) {
+        return window;
+    }
+    throw new Error('Unable to resolve global `this`');
+};
+const getGlobalThis = function () {
+    // ISC (c) 2011-2019 https://github.com/medikoo/es5-ext/blob/master/global.js
+    // Fallback to standard globalThis if available
+    if (typeof globalThis === 'object' && globalThis) {
+        return globalThis;
+    }
+    try {
+        Object.defineProperty(Object.prototype, '__global__', {
+            get: function () {
+                return this;
+            },
+            configurable: true,
+        });
+    }
+    catch (error) {
+        return naiveFallback();
+    }
+    try {
+        // eslint-disable-next-line no-undef
+        if (!__global__) {
+            return naiveFallback();
+        }
+        return __global__; // eslint-disable-line no-undef
+    }
+    finally {
+        delete Object.prototype.__global__;
+    }
+};
+const isNode = function () {
+    const globalPolyfill = getGlobalThis();
+    return (typeof globalPolyfill.process !== 'undefined' &&
+        globalPolyfill.process.versions &&
+        globalPolyfill.process.versions.node);
+};
+(function (root, factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        define([], factory);
+    }
+    else if (typeof module === 'object' && module.exports) {
+        module.exports = factory();
+    }
+    else {
+        root.resemble = factory();
+    }
+})(this /* eslint-disable-line no-invalid-this*/, function () {
+    'use strict';
+    let Img;
+    // var Canvas;
+    // var loadNodeCanvasImage;
+    // if (isNode()) {
+    //   Canvas = require("canvas"); // eslint-disable-line global-require
+    //   Img = Canvas.Image;
+    //   loadNodeCanvasImage = Canvas.loadImage;
+    // } else {
+    //   Img = Image;
+    // }
+    function createCanvas(width, height) {
+        // if (isNode()) {
+        //   return Canvas.createCanvas(width, height);
+        // }
+        // var cnvs = document.createElement("canvas");
+        // cnvs.width = width;
+        // cnvs.height = height;
+        // return cnvs;
+        return new Jimp({ width, height });
+    }
+    const oldGlobalSettings = {};
+    let globalOutputSettings = oldGlobalSettings;
+    const resemble = function (fileData) {
+        let pixelTransparency = 1;
+        const errorPixelColor = {
+            // Color for Error Pixels. Between 0 and 255.
+            red: 255,
+            green: 0,
+            blue: 255,
+            alpha: 255,
+        };
+        const targetPix = { r: 0, g: 0, b: 0, a: 0 }; // isAntialiased
+        const errorPixelTransform = {
+            flat: function (px, offset) {
+                px[offset] = errorPixelColor.red;
+                px[offset + 1] = errorPixelColor.green;
+                px[offset + 2] = errorPixelColor.blue;
+                px[offset + 3] = errorPixelColor.alpha;
+            },
+            movement: function (px, offset, d1, d2) {
+                px[offset] = (d2.r * (errorPixelColor.red / 255) + errorPixelColor.red) / 2;
+                px[offset + 1] = (d2.g * (errorPixelColor.green / 255) + errorPixelColor.green) / 2;
+                px[offset + 2] = (d2.b * (errorPixelColor.blue / 255) + errorPixelColor.blue) / 2;
+                px[offset + 3] = d2.a;
+            },
+            flatDifferenceIntensity: function (px, offset, d1, d2) {
+                px[offset] = errorPixelColor.red;
+                px[offset + 1] = errorPixelColor.green;
+                px[offset + 2] = errorPixelColor.blue;
+                px[offset + 3] = colorsDistance(d1, d2);
+            },
+            movementDifferenceIntensity: function (px, offset, d1, d2) {
+                const ratio = (colorsDistance(d1, d2) / 255) * 0.8;
+                px[offset] =
+                    (1 - ratio) * (d2.r * (errorPixelColor.red / 255)) +
+                        ratio * errorPixelColor.red;
+                px[offset + 1] =
+                    (1 - ratio) * (d2.g * (errorPixelColor.green / 255)) +
+                        ratio * errorPixelColor.green;
+                px[offset + 2] =
+                    (1 - ratio) * (d2.b * (errorPixelColor.blue / 255)) +
+                        ratio * errorPixelColor.blue;
+                px[offset + 3] = d2.a;
+            },
+            diffOnly: function (px, offset, d1, d2) {
+                px[offset] = d2.r;
+                px[offset + 1] = d2.g;
+                px[offset + 2] = d2.b;
+                px[offset + 3] = d2.a;
+            },
+        };
+        let errorPixel = errorPixelTransform.flat;
+        let errorType;
+        let boundingBoxes;
+        let ignoredBoxes;
+        let ignoreAreasColoredWith;
+        let largeImageThreshold = 1200;
+        let useCrossOrigin = true;
+        let data = {};
+        let images = [];
+        const updateCallbackArray = [];
+        const tolerance = {
+            // between 0 and 255
+            red: 16,
+            green: 16,
+            blue: 16,
+            alpha: 16,
+            minBrightness: 16,
+            maxBrightness: 240,
+        };
+        let ignoreAntialiasing = false;
+        let ignoreColors = false;
+        let scaleToSameSize = false;
+        let compareOnly = false;
+        let returnEarlyThreshold;
+        function colorsDistance(c1, c2) {
+            return ((Math.abs(c1.r - c2.r) + Math.abs(c1.g - c2.g) + Math.abs(c1.b - c2.b)) / 3);
+        }
+        function withinBoundingBox(x, y, width, height, box) {
+            return (x >= (box.left || 0) &&
+                x <= (box.right || width) &&
+                y >= (box.top || 0) &&
+                y <= (box.bottom || height));
+        }
+        function withinComparedArea(x, y, width, height, pixel2) {
+            let isIncluded = true;
+            let i;
+            let boundingBox;
+            let ignoredBox;
+            let selected;
+            let ignored;
+            if (boundingBoxes instanceof Array) {
+                selected = false;
+                for (i = 0; i < boundingBoxes.length; i++) {
+                    boundingBox = boundingBoxes[i];
+                    if (withinBoundingBox(x, y, width, height, boundingBox)) {
+                        selected = true;
+                        break;
+                    }
+                }
+            }
+            if (ignoredBoxes instanceof Array) {
+                ignored = true;
+                for (i = 0; i < ignoredBoxes.length; i++) {
+                    ignoredBox = ignoredBoxes[i];
+                    if (withinBoundingBox(x, y, width, height, ignoredBox)) {
+                        ignored = false;
+                        break;
+                    }
+                }
+            }
+            if (ignoreAreasColoredWith) {
+                return colorsDistance(pixel2, ignoreAreasColoredWith) !== 0;
+            }
+            if (selected === undefined && ignored === undefined) {
+                return true;
+            }
+            if (selected === false && ignored === true) {
+                return false;
+            }
+            if (selected === true || ignored === true) {
+                isIncluded = true;
+            }
+            if (selected === false || ignored === false) {
+                isIncluded = false;
+            }
+            return isIncluded;
+        }
+        function triggerDataUpdate() {
+            const len = updateCallbackArray.length;
+            let i;
+            for (i = 0; i < len; i++) {
+                if (typeof updateCallbackArray[i] === 'function') {
+                    updateCallbackArray[i](data);
+                }
+            }
+        }
+        function loop(w, h, callback) {
+            let x;
+            let y;
+            for (x = 0; x < w; x++) {
+                for (y = 0; y < h; y++) {
+                    callback(x, y);
+                }
+            }
+        }
+        function parseImage(sourceImageData, width, height) {
+            let pixelCount = 0;
+            let redTotal = 0;
+            let greenTotal = 0;
+            let blueTotal = 0;
+            let alphaTotal = 0;
+            let brightnessTotal = 0;
+            let whiteTotal = 0;
+            let blackTotal = 0;
+            loop(width, height, function (horizontalPos, verticalPos) {
+                const offset = (verticalPos * width + horizontalPos) * 4;
+                const red = sourceImageData[offset];
+                const green = sourceImageData[offset + 1];
+                const blue = sourceImageData[offset + 2];
+                const alpha = sourceImageData[offset + 3];
+                const brightness = getBrightness(red, green, blue);
+                if (red === green && red === blue && alpha) {
+                    if (red === 0) {
+                        blackTotal++;
+                    }
+                    else if (red === 255) {
+                        whiteTotal++;
+                    }
+                }
+                pixelCount++;
+                redTotal += (red / 255) * 100;
+                greenTotal += (green / 255) * 100;
+                blueTotal += (blue / 255) * 100;
+                alphaTotal += ((255 - alpha) / 255) * 100;
+                brightnessTotal += (brightness / 255) * 100;
+            });
+            data.red = Math.floor(redTotal / pixelCount);
+            data.green = Math.floor(greenTotal / pixelCount);
+            data.blue = Math.floor(blueTotal / pixelCount);
+            data.alpha = Math.floor(alphaTotal / pixelCount);
+            data.brightness = Math.floor(brightnessTotal / pixelCount);
+            data.white = Math.floor((whiteTotal / pixelCount) * 100);
+            data.black = Math.floor((blackTotal / pixelCount) * 100);
+            triggerDataUpdate();
+        }
+        function onLoadImage(hiddenImage, callback) {
+            // don't assign to hiddenImage, see https://github.com/Huddle/Resemble.js/pull/87/commits/300d43352a2845aad289b254bfbdc7cd6a37e2d7
+            let width = hiddenImage.bitmap.width;
+            let height = hiddenImage.bitmap.height;
+            if (scaleToSameSize && images.length === 1) {
+                width = images[0].bitmap.width;
+                height = images[0].bitmap.height;
+            }
+            // var hiddenCanvas = createCanvas(width, height);
+            // var imageData;
+            // hiddenCanvas.getContext("2d").drawImage(hiddenImage, 0, 0, width, height);
+            // imageData = hiddenCanvas
+            //   .getContext("2d")
+            //   .getImageData(0, 0, width, height);
+            // images.push(imageData);
+            images.push(hiddenImage);
+            callback(hiddenImage, width, height);
+        }
+        function loadImageData(fileDataForImage, callback) {
+            // var fileReader;
+            // var hiddenImage = new Img();
+            // if (!hiddenImage.setAttribute) {
+            //   hiddenImage.setAttribute = function setAttribute() {};
+            // }
+            // if (useCrossOrigin) {
+            //   hiddenImage.setAttribute("crossorigin", "anonymous");
+            // }
+            // hiddenImage.onerror = function (event) {
+            //   hiddenImage.onload = null;
+            //   hiddenImage.onerror = null; // fixes pollution between calls
+            //   const error = event ? event + "" : "Unknown error";
+            //   images.push({
+            //     error: `Failed to load image '${fileDataForImage}'. ${error}`,
+            //   });
+            //   callback();
+            // };
+            // hiddenImage.onload = function () {
+            //   hiddenImage.onload = null; // fixes pollution between calls
+            //   hiddenImage.onerror = null;
+            //   onLoadImage(hiddenImage, callback);
+            // };
+            // if (typeof fileDataForImage === "string") {
+            //   hiddenImage.src = fileDataForImage;
+            //   if (!isNode() && hiddenImage.complete && hiddenImage.naturalWidth > 0) {
+            //     hiddenImage.onload();
+            //   }
+            // } else if (
+            //   typeof fileDataForImage.data !== "undefined" &&
+            //   typeof fileDataForImage.width === "number" &&
+            //   typeof fileDataForImage.height === "number"
+            // ) {
+            //   images.push(fileDataForImage);
+            //   callback(
+            //     fileDataForImage,
+            //     fileDataForImage.width,
+            //     fileDataForImage.height
+            //   );
+            // } else if (
+            //   typeof Buffer !== "undefined" &&
+            //   fileDataForImage instanceof Buffer
+            // ) {
+            //   // If we have Buffer, assume we're on Node+Canvas and its supported
+            //   // hiddenImage.src = fileDataForImage;
+            //   loadNodeCanvasImage(fileDataForImage)
+            //     .then(function (image) {
+            //       hiddenImage.onload = null; // fixes pollution between calls
+            //       hiddenImage.onerror = null;
+            //       onLoadImage(image, callback);
+            //     })
+            //     .catch(function (err) {
+            //       images.push({
+            //         error: err ? err + "" : "Image load error.",
+            //       });
+            //       callback();
+            //     });
+            // } else {
+            //   fileReader = new FileReader();
+            //   fileReader.onload = function (event) {
+            //     hiddenImage.src = event.target.result;
+            //   };
+            //   fileReader.readAsDataURL(fileDataForImage);
+            // }
+            Jimp.read(fileDataForImage)
+                .then((image) => {
+                onLoadImage(image, callback);
+            })
+                .catch((err) => {
+                images.push({
+                    error: `Failed to load image '${fileDataForImage}'. ${err}`,
+                });
+                callback();
+            });
+        }
+        function isColorSimilar(a, b, color) {
+            const absDiff = Math.abs(a - b);
+            if (typeof a === 'undefined') {
+                return false;
+            }
+            if (typeof b === 'undefined') {
+                return false;
+            }
+            if (a === b) {
+                return true;
+            }
+            else if (absDiff < tolerance[color]) {
+                return true;
+            }
+            return false;
+        }
+        function isPixelBrightnessSimilar(d1, d2) {
+            const alpha = isColorSimilar(d1.a, d2.a, 'alpha');
+            const brightness = isColorSimilar(d1.brightness, d2.brightness, 'minBrightness');
+            return brightness && alpha;
+        }
+        function getBrightness(r, g, b) {
+            return 0.3 * r + 0.59 * g + 0.11 * b;
+        }
+        function isRGBSame(d1, d2) {
+            const red = d1.r === d2.r;
+            const green = d1.g === d2.g;
+            const blue = d1.b === d2.b;
+            return red && green && blue;
+        }
+        function isRGBSimilar(d1, d2) {
+            const red = isColorSimilar(d1.r, d2.r, 'red');
+            const green = isColorSimilar(d1.g, d2.g, 'green');
+            const blue = isColorSimilar(d1.b, d2.b, 'blue');
+            const alpha = isColorSimilar(d1.a, d2.a, 'alpha');
+            return red && green && blue && alpha;
+        }
+        function isContrasting(d1, d2) {
+            return Math.abs(d1.brightness - d2.brightness) > tolerance.maxBrightness;
+        }
+        function getHue(red, green, blue) {
+            const r = red / 255;
+            const g = green / 255;
+            const b = blue / 255;
+            const max = Math.max(r, g, b);
+            const min = Math.min(r, g, b);
+            let h;
+            let d;
+            if (max === min) {
+                h = 0; // achromatic
+            }
+            else {
+                d = max - min;
+                switch (max) {
+                    case r:
+                        h = (g - b) / d + (g < b ? 6 : 0);
+                        break;
+                    case g:
+                        h = (b - r) / d + 2;
+                        break;
+                    case b:
+                        h = (r - g) / d + 4;
+                        break;
+                    default:
+                        h /= 6;
+                }
+            }
+            return h;
+        }
+        function isAntialiased(sourcePix, pix, cacheSet, verticalPos, horizontalPos, width) {
+            let offset;
+            const distance = 1;
+            let i;
+            let j;
+            let hasHighContrastSibling = 0;
+            let hasSiblingWithDifferentHue = 0;
+            let hasEquivalentSibling = 0;
+            addHueInfo(sourcePix);
+            for (i = distance * -1; i <= distance; i++) {
+                for (j = distance * -1; j <= distance; j++) {
+                    if (i === 0 && j === 0) {
+                        // ignore source pixel
+                        continue;
+                    }
+                    else {
+                        offset = ((verticalPos + j) * width + (horizontalPos + i)) * 4;
+                        if (!getPixelInfo(targetPix, pix, offset, cacheSet)) {
+                            continue;
+                        }
+                        addBrightnessInfo(targetPix);
+                        addHueInfo(targetPix);
+                        if (isContrasting(sourcePix, targetPix)) {
+                            hasHighContrastSibling++;
+                        }
+                        if (isRGBSame(sourcePix, targetPix)) {
+                            hasEquivalentSibling++;
+                        }
+                        if (Math.abs(targetPix.h - sourcePix.h) > 0.3) {
+                            hasSiblingWithDifferentHue++;
+                        }
+                        if (hasSiblingWithDifferentHue > 1 || hasHighContrastSibling > 1) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            if (hasEquivalentSibling < 2) {
+                return true;
+            }
+            return false;
+        }
+        function copyPixel(px, offset, pix) {
+            if (errorType === 'diffOnly') {
+                return;
+            }
+            px[offset] = pix.r; // r
+            px[offset + 1] = pix.g; // g
+            px[offset + 2] = pix.b; // b
+            px[offset + 3] = pix.a * pixelTransparency; // a
+        }
+        function copyGrayScalePixel(px, offset, pix) {
+            if (errorType === 'diffOnly') {
+                return;
+            }
+            px[offset] = pix.brightness; // r
+            px[offset + 1] = pix.brightness; // g
+            px[offset + 2] = pix.brightness; // b
+            px[offset + 3] = pix.a * pixelTransparency; // a
+        }
+        function getPixelInfo(dst, pix, offset) {
+            if (pix.length > offset) {
+                dst.r = pix[offset];
+                dst.g = pix[offset + 1];
+                dst.b = pix[offset + 2];
+                dst.a = pix[offset + 3];
+                return true;
+            }
+            return false;
+        }
+        function addBrightnessInfo(pix) {
+            pix.brightness = getBrightness(pix.r, pix.g, pix.b); // 'corrected' lightness
+        }
+        function addHueInfo(pix) {
+            pix.h = getHue(pix.r, pix.g, pix.b);
+        }
+        function analyseImages(img1, img2, width, height) {
+            const data1 = img1.bitmap.data;
+            const data2 = img2.bitmap.data;
+            let hiddenCanvas;
+            // var context;
+            // var imgd;
+            let pix;
+            if (!compareOnly) {
+                hiddenCanvas = createCanvas(width, height);
+                // context = hiddenCanvas.getContext("2d");
+                // imgd = context.createImageData(width, height);
+                pix = hiddenCanvas.bitmap.data;
+            }
+            let mismatchCount = 0;
+            const diffBounds = {
+                top: height,
+                left: width,
+                bottom: 0,
+                right: 0,
+            };
+            const diffPixels = [];
+            const updateBounds = function (x, y) {
+                // Update the big box
+                diffBounds.left = Math.min(x, diffBounds.left);
+                diffBounds.right = Math.max(x, diffBounds.right);
+                diffBounds.top = Math.min(y, diffBounds.top);
+                diffBounds.bottom = Math.max(y, diffBounds.bottom);
+                // Update the diffPixels array
+                diffPixels.push({ x, y });
+            };
+            const time = Date.now();
+            let skip;
+            if (!!largeImageThreshold &&
+                ignoreAntialiasing &&
+                (width > largeImageThreshold || height > largeImageThreshold)) {
+                skip = 6;
+            }
+            const pixel1 = { r: 0, g: 0, b: 0, a: 0 };
+            const pixel2 = { r: 0, g: 0, b: 0, a: 0 };
+            let skipTheRest = false;
+            loop(width, height, function (horizontalPos, verticalPos) {
+                if (skipTheRest) {
+                    return;
+                }
+                if (skip) {
+                    // only skip if the image isn't small
+                    if (verticalPos % skip === 0 || horizontalPos % skip === 0) {
+                        return;
+                    }
+                }
+                const offset = (verticalPos * width + horizontalPos) * 4;
+                if (!getPixelInfo(pixel1, data1, offset, 1) ||
+                    !getPixelInfo(pixel2, data2, offset, 2)) {
+                    return;
+                }
+                const isWithinComparedArea = withinComparedArea(horizontalPos, verticalPos, width, height, pixel2);
+                if (ignoreColors) {
+                    addBrightnessInfo(pixel1);
+                    addBrightnessInfo(pixel2);
+                    if (isPixelBrightnessSimilar(pixel1, pixel2) || !isWithinComparedArea) {
+                        if (!compareOnly) {
+                            copyGrayScalePixel(pix, offset, pixel2);
+                        }
+                    }
+                    else {
+                        if (!compareOnly) {
+                            errorPixel(pix, offset, pixel1, pixel2);
+                        }
+                        mismatchCount++;
+                        updateBounds(horizontalPos, verticalPos);
+                    }
+                    return;
+                }
+                if (isRGBSimilar(pixel1, pixel2) || !isWithinComparedArea) {
+                    if (!compareOnly) {
+                        copyPixel(pix, offset, pixel1);
+                    }
+                }
+                else if (ignoreAntialiasing &&
+                    (addBrightnessInfo(pixel1), // jit pixel info augmentation looks a little weird, sorry.
+                        addBrightnessInfo(pixel2),
+                        isAntialiased(pixel1, data1, 1, verticalPos, horizontalPos, width) ||
+                            isAntialiased(pixel2, data2, 2, verticalPos, horizontalPos, width))) {
+                    if (isPixelBrightnessSimilar(pixel1, pixel2) || !isWithinComparedArea) {
+                        if (!compareOnly) {
+                            copyGrayScalePixel(pix, offset, pixel2);
+                        }
+                    }
+                    else {
+                        if (!compareOnly) {
+                            errorPixel(pix, offset, pixel1, pixel2);
+                        }
+                        mismatchCount++;
+                        updateBounds(horizontalPos, verticalPos);
+                    }
+                }
+                else {
+                    if (!compareOnly) {
+                        errorPixel(pix, offset, pixel1, pixel2);
+                    }
+                    mismatchCount++;
+                    updateBounds(horizontalPos, verticalPos);
+                }
+                if (compareOnly) {
+                    const currentMisMatchPercent = (mismatchCount / (height * width)) * 100;
+                    if (currentMisMatchPercent > returnEarlyThreshold) {
+                        skipTheRest = true;
+                    }
+                }
+            });
+            data.rawMisMatchPercentage = (mismatchCount / (height * width)) * 100;
+            data.misMatchPercentage = data.rawMisMatchPercentage.toFixed(2);
+            data.diffBounds = diffBounds;
+            data.analysisTime = Date.now() - time;
+            // Add diffPixels array to the data object
+            data.diffPixels = diffPixels;
+            data.getImageDataUrl = function (text) {
+                if (compareOnly) {
+                    throw Error('No diff image available - ran in compareOnly mode');
+                }
+                let barHeight = 0;
+                if (text) {
+                    barHeight = addLabel(text, hiddenCanvas);
+                }
+                // context.putImageData(imgd, 0, barHeight);
+                return hiddenCanvas.getBase64(JimpMime.png);
+            };
+            if (!compareOnly) {
+                data.getBuffer = function (includeOriginal) {
+                    if (includeOriginal) {
+                        const imageWidth = hiddenCanvas.bitmap.width + 2;
+                        hiddenCanvas.resize(imageWidth * 3, hiddenCanvas.bitmap.height);
+                        hiddenCanvas.composite(img1, 0, 0);
+                        hiddenCanvas.composite(img2, imageWidth, 0);
+                        hiddenCanvas.composite(hiddenCanvas, imageWidth * 2, 0);
+                    }
+                    return hiddenCanvas.getBuffer(JimpMime.png);
+                };
+            }
+        }
+        function addLabel(text, hiddenCanvas) {
+            const textPadding = 2;
+            // context.font = "12px sans-serif";
+            // var textWidth = context.measureText(text).width + textPadding * 2;
+            // var barHeight = 22;
+            // if (textWidth > hiddenCanvas.width) {
+            //   hiddenCanvas.width = textWidth;
+            // }
+            // hiddenCanvas.height += barHeight;
+            // context.fillStyle = "#666";
+            // context.fillRect(0, 0, hiddenCanvas.width, barHeight - 4);
+            // context.fillStyle = "#fff";
+            // context.fillRect(0, barHeight - 4, hiddenCanvas.width, 4);
+            // context.fillStyle = "#fff";
+            // context.textBaseline = "top";
+            // context.font = "12px sans-serif";
+            // context.fillText(text, textPadding, 1);
+            // return barHeight;
+            return Jimp.loadFont(Jimp.FONT_SANS_12_WHITE).then((font) => {
+                const textWidth = Jimp.measureText(font, text) + textPadding * 2;
+                const barHeight = 22;
+                if (textWidth > hiddenCanvas.bitmap.width) {
+                    hiddenCanvas.resize(textWidth, hiddenCanvas.bitmap.height);
+                }
+                const context = hiddenCanvas.clone();
+                context.print(font, textPadding, 1, text);
+                return barHeight;
+            });
+        }
+        function normalise(img, w, h) {
+            // var c;
+            // var context;
+            if (img.bitmap.height < h || img.bitmap.width < w) {
+                // c = createCanvas(w, h);
+                // context = c.getContext("2d");
+                // context.putImageData(img, 0, 0);
+                return img.contain({ w, h });
+            }
+            return img;
+        }
+        function outputSettings(options) {
+            let key;
+            if (options.errorColor) {
+                for (key in options.errorColor) {
+                    if (options.errorColor.hasOwnProperty(key)) {
+                        errorPixelColor[key] = options.errorColor[key] === void 0
+                            ? errorPixelColor[key]
+                            : options.errorColor[key];
+                    }
+                }
+            }
+            if (options.errorType && errorPixelTransform[options.errorType]) {
+                errorPixel = errorPixelTransform[options.errorType];
+                errorType = options.errorType;
+            }
+            if (options.errorPixel && typeof options.errorPixel === 'function') {
+                errorPixel = options.errorPixel;
+            }
+            pixelTransparency = isNaN(Number(options.transparency))
+                ? pixelTransparency
+                : options.transparency;
+            if (options.largeImageThreshold !== undefined) {
+                largeImageThreshold = options.largeImageThreshold;
+            }
+            if (options.useCrossOrigin !== undefined) {
+                useCrossOrigin = options.useCrossOrigin;
+            }
+            if (options.boundingBox !== undefined) {
+                boundingBoxes = [options.boundingBox];
+            }
+            if (options.ignoredBox !== undefined) {
+                ignoredBoxes = [options.ignoredBox];
+            }
+            if (options.boundingBoxes !== undefined) {
+                boundingBoxes = options.boundingBoxes;
+            }
+            if (options.ignoredBoxes !== undefined) {
+                ignoredBoxes = options.ignoredBoxes;
+            }
+            if (options.ignoreAreasColoredWith !== undefined) {
+                ignoreAreasColoredWith = options.ignoreAreasColoredWith;
+            }
+        }
+        function compare(one, two) {
+            if (globalOutputSettings !== oldGlobalSettings) {
+                outputSettings(globalOutputSettings);
+            }
+            function onceWeHaveBoth() {
+                let width;
+                let height;
+                if (images.length === 2) {
+                    if (images[0].error || images[1].error) {
+                        data = {};
+                        data.error = images[0].error ? images[0].error : images[1].error;
+                        triggerDataUpdate();
+                        return;
+                    }
+                    width = images[0].bitmap.width > images[1].bitmap.width
+                        ? images[0].bitmap.width
+                        : images[1].bitmap.width;
+                    height = images[0].bitmap.height > images[1].bitmap.height
+                        ? images[0].bitmap.height
+                        : images[1].bitmap.height;
+                    data.isSameDimensions = images[0].bitmap.width === images[1].bitmap.width &&
+                        images[0].bitmap.height === images[1].bitmap.height ? true : false;
+                    data.dimensionDifference = {
+                        width: images[0].bitmap.width - images[1].bitmap.width,
+                        height: images[0].bitmap.height - images[1].bitmap.height,
+                    };
+                    analyseImages(normalise(images[0], width, height), normalise(images[1], width, height), width, height);
+                    triggerDataUpdate();
+                }
+            }
+            images = [];
+            loadImageData(one, onceWeHaveBoth);
+            loadImageData(two, onceWeHaveBoth);
+        }
+        function getCompareApi(param) {
+            let secondFileData;
+            const hasMethod = typeof param === 'function';
+            if (!hasMethod) {
+                // assume it's file data
+                secondFileData = param;
+            }
+            var self = {
+                setReturnEarlyThreshold: function (threshold) {
+                    if (threshold) {
+                        compareOnly = true;
+                        returnEarlyThreshold = threshold;
+                    }
+                    return self;
+                },
+                scaleToSameSize: function () {
+                    scaleToSameSize = true;
+                    if (hasMethod) {
+                        param();
+                    }
+                    return self;
+                },
+                useOriginalSize: function () {
+                    scaleToSameSize = false;
+                    if (hasMethod) {
+                        param();
+                    }
+                    return self;
+                },
+                ignoreNothing: function () {
+                    tolerance.red = 0;
+                    tolerance.green = 0;
+                    tolerance.blue = 0;
+                    tolerance.alpha = 0;
+                    tolerance.minBrightness = 0;
+                    tolerance.maxBrightness = 255;
+                    ignoreAntialiasing = false;
+                    ignoreColors = false;
+                    if (hasMethod) {
+                        param();
+                    }
+                    return self;
+                },
+                ignoreLess: function () {
+                    tolerance.red = 16;
+                    tolerance.green = 16;
+                    tolerance.blue = 16;
+                    tolerance.alpha = 16;
+                    tolerance.minBrightness = 16;
+                    tolerance.maxBrightness = 240;
+                    ignoreAntialiasing = false;
+                    ignoreColors = false;
+                    if (hasMethod) {
+                        param();
+                    }
+                    return self;
+                },
+                ignoreAntialiasing: function () {
+                    tolerance.red = 32;
+                    tolerance.green = 32;
+                    tolerance.blue = 32;
+                    tolerance.alpha = 32;
+                    tolerance.minBrightness = 64;
+                    tolerance.maxBrightness = 96;
+                    ignoreAntialiasing = true;
+                    ignoreColors = false;
+                    if (hasMethod) {
+                        param();
+                    }
+                    return self;
+                },
+                ignoreColors: function () {
+                    tolerance.alpha = 16;
+                    tolerance.minBrightness = 16;
+                    tolerance.maxBrightness = 240;
+                    ignoreAntialiasing = false;
+                    ignoreColors = true;
+                    if (hasMethod) {
+                        param();
+                    }
+                    return self;
+                },
+                ignoreAlpha: function () {
+                    tolerance.red = 16;
+                    tolerance.green = 16;
+                    tolerance.blue = 16;
+                    tolerance.alpha = 255;
+                    tolerance.minBrightness = 16;
+                    tolerance.maxBrightness = 240;
+                    ignoreAntialiasing = false;
+                    ignoreColors = false;
+                    if (hasMethod) {
+                        param();
+                    }
+                    return self;
+                },
+                repaint: function () {
+                    if (hasMethod) {
+                        param();
+                    }
+                    return self;
+                },
+                outputSettings: function (options) {
+                    outputSettings(options);
+                    return self;
+                },
+                onComplete: function (callback) {
+                    updateCallbackArray.push(callback);
+                    const wrapper = function () {
+                        compare(fileData, secondFileData);
+                    };
+                    wrapper();
+                    return getCompareApi(wrapper);
+                },
+                setupCustomTolerance: function (customSettings) {
+                    for (const property in tolerance) {
+                        if (!customSettings.hasOwnProperty(property)) {
+                            continue;
+                        }
+                        tolerance[property] = customSettings[property];
+                    }
+                },
+            };
+            return self;
+        }
+        var rootSelf = {
+            onComplete: function (callback) {
+                updateCallbackArray.push(callback);
+                loadImageData(fileData, function (imageData, width, height) {
+                    parseImage(imageData, width, height);
+                });
+            },
+            compareTo: function (secondFileData) {
+                return getCompareApi(secondFileData);
+            },
+            outputSettings: function (options) {
+                outputSettings(options);
+                return rootSelf;
+            },
+        };
+        return rootSelf;
+    };
+    function setGlobalOutputSettings(settings) {
+        globalOutputSettings = settings;
+        return resemble;
+    }
+    function applyIgnore(api, ignore, customTolerance) {
+        switch (ignore) {
+            case 'nothing':
+                api.ignoreNothing();
+                break;
+            case 'less':
+                api.ignoreLess();
+                break;
+            case 'antialiasing':
+                api.ignoreAntialiasing();
+                break;
+            case 'colors':
+                api.ignoreColors();
+                break;
+            case 'alpha':
+                api.ignoreAlpha();
+                break;
+            default:
+                throw new Error('Invalid ignore: ' + ignore);
+        }
+        api.setupCustomTolerance(customTolerance);
+    }
+    resemble.compare = function (image1, image2, options) {
+        return new Promise((resolve, reject) => {
+            let opt;
+            if (typeof options !== 'object') {
+                opt = {};
+            }
+            else {
+                opt = options;
+            }
+            const res = resemble(image1);
+            let compare;
+            if (opt.output) {
+                res.outputSettings(opt.output);
+            }
+            compare = res.compareTo(image2);
+            if (opt.returnEarlyThreshold) {
+                compare.setReturnEarlyThreshold(opt.returnEarlyThreshold);
+            }
+            if (opt.scaleToSameSize) {
+                compare.scaleToSameSize();
+            }
+            const toleranceSettings = opt.tolerance || {};
+            if (typeof opt.ignore === 'string') {
+                applyIgnore(compare, opt.ignore, toleranceSettings);
+            }
+            else if (opt.ignore && opt.ignore.forEach) {
+                opt.ignore.forEach(function (v) {
+                    applyIgnore(compare, v, toleranceSettings);
+                });
+            }
+            compare.onComplete(function (data) {
+                if (data.error) {
+                    reject(data.error);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    };
+    resemble.outputSettings = setGlobalOutputSettings;
+    return resemble;
+});