@wdio/image-comparison-core 1.3.0 → 2.0.0

package/dist/utils/imageUtils.js

@@ -0,0 +1,189 @@
+import { decode, encode } from 'fast-png';
+// Convert any channel count to RGBA 8-bit. fast-png may decode RGB, grayscale, or clamped PNGs.
+function toRGBA(data, channels, width, height) {
+    if (channels === 4 && (data instanceof Uint8Array || data instanceof Uint8ClampedArray)) {
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+    const pixels = width * height;
+    const out = new Uint8Array(pixels * 4);
+    for (let i = 0; i < pixels; i++) {
+        if (channels === 3) {
+            out[i * 4] = data[i * 3];
+            out[i * 4 + 1] = data[i * 3 + 1];
+            out[i * 4 + 2] = data[i * 3 + 2];
+            out[i * 4 + 3] = 255;
+        }
+        else if (channels === 1) {
+            const v = data[i];
+            out[i * 4] = v;
+            out[i * 4 + 1] = v;
+            out[i * 4 + 2] = v;
+            out[i * 4 + 3] = 255;
+        }
+        else if (channels === 2) {
+            const v = data[i * 2];
+            out[i * 4] = v;
+            out[i * 4 + 1] = v;
+            out[i * 4 + 2] = v;
+            out[i * 4 + 3] = data[i * 2 + 1];
+        }
+        else {
+            // 4-channel Uint16Array: downsample 16-bit → 8-bit
+            out[i * 4] = data[i * 4] >> 8;
+            out[i * 4 + 1] = data[i * 4 + 1] >> 8;
+            out[i * 4 + 2] = data[i * 4 + 2] >> 8;
+            out[i * 4 + 3] = data[i * 4 + 3] >> 8;
+        }
+    }
+    return out;
+}
+export function decodeImage(buffer) {
+    const png = decode(buffer);
+    return {
+        data: toRGBA(png.data, png.channels, png.width, png.height),
+        width: png.width,
+        height: png.height,
+    };
+}
+export function encodeImage(img) {
+    return Buffer.from(encode({ data: img.data, width: img.width, height: img.height, channels: 4, depth: 8 }));
+}
+export function toBase64Png(img) {
+    return encodeImage(img).toString('base64');
+}
+export function createCanvas(width, height, r = 0, g = 0, b = 0, a = 0) {
+    const data = new Uint8Array(width * height * 4);
+    if (r !== 0 || g !== 0 || b !== 0 || a !== 0) {
+        for (let i = 0; i < data.length; i += 4) {
+            data[i] = r;
+            data[i + 1] = g;
+            data[i + 2] = b;
+            data[i + 3] = a;
+        }
+    }
+    return { data, width, height };
+}
+export function cropImage(img, x, y, w, h) {
+    const data = new Uint8Array(w * h * 4);
+    const rowBytes = w * 4;
+    for (let row = 0; row < h; row++) {
+        const srcOffset = ((y + row) * img.width + x) * 4;
+        data.set(img.data.subarray(srcOffset, srcOffset + rowBytes), row * rowBytes);
+    }
+    return { data, width: w, height: h };
+}
+// Porter-Duff "over" compositing. Mutates base in place.
+export function compositeImage(base, overlay, offsetX, offsetY, opacity = 1) {
+    for (let oy = 0; oy < overlay.height; oy++) {
+        const by = oy + offsetY;
+        if (by < 0 || by >= base.height) {
+            continue;
+        }
+        for (let ox = 0; ox < overlay.width; ox++) {
+            const bx = ox + offsetX;
+            if (bx < 0 || bx >= base.width) {
+                continue;
+            }
+            const si = (oy * overlay.width + ox) * 4;
+            const di = (by * base.width + bx) * 4;
+            const srcA = (overlay.data[si + 3] / 255) * opacity;
+            const dstA = base.data[di + 3] / 255;
+            const outA = srcA + dstA * (1 - srcA);
+            if (outA === 0) {
+                continue;
+            }
+            base.data[di] = Math.round((overlay.data[si] * srcA + base.data[di] * dstA * (1 - srcA)) / outA);
+            base.data[di + 1] = Math.round((overlay.data[si + 1] * srcA + base.data[di + 1] * dstA * (1 - srcA)) / outA);
+            base.data[di + 2] = Math.round((overlay.data[si + 2] * srcA + base.data[di + 2] * dstA * (1 - srcA)) / outA);
+            base.data[di + 3] = Math.round(outA * 255);
+        }
+    }
+}
+export function resizeBilinear(img, newW, newH) {
+    const data = new Uint8Array(newW * newH * 4);
+    const xRatio = img.width / newW;
+    const yRatio = img.height / newH;
+    for (let dy = 0; dy < newH; dy++) {
+        const sy = dy * yRatio;
+        const y0 = Math.floor(sy);
+        const y1 = Math.min(y0 + 1, img.height - 1);
+        const yFrac = sy - y0;
+        for (let dx = 0; dx < newW; dx++) {
+            const sx = dx * xRatio;
+            const x0 = Math.floor(sx);
+            const x1 = Math.min(x0 + 1, img.width - 1);
+            const xFrac = sx - x0;
+            const i00 = (y0 * img.width + x0) * 4;
+            const i10 = (y0 * img.width + x1) * 4;
+            const i01 = (y1 * img.width + x0) * 4;
+            const i11 = (y1 * img.width + x1) * 4;
+            const di = (dy * newW + dx) * 4;
+            const w00 = (1 - xFrac) * (1 - yFrac);
+            const w10 = xFrac * (1 - yFrac);
+            const w01 = (1 - xFrac) * yFrac;
+            const w11 = xFrac * yFrac;
+            data[di] = Math.round(img.data[i00] * w00 + img.data[i10] * w10 + img.data[i01] * w01 + img.data[i11] * w11);
+            data[di + 1] = Math.round(img.data[i00 + 1] * w00 + img.data[i10 + 1] * w10 + img.data[i01 + 1] * w01 + img.data[i11 + 1] * w11);
+            data[di + 2] = Math.round(img.data[i00 + 2] * w00 + img.data[i10 + 2] * w10 + img.data[i01 + 2] * w01 + img.data[i11 + 2] * w11);
+            data[di + 3] = Math.round(img.data[i00 + 3] * w00 + img.data[i10 + 3] * w10 + img.data[i01 + 3] * w01 + img.data[i11 + 3] * w11);
+        }
+    }
+    return { data, width: newW, height: newH };
+}
+// 90° clockwise: new width = srcHeight, new height = srcWidth
+// dst(dx, dy) ← src(col=dy, row=srcH-1-dx)
+export function rotate90CW(img) {
+    const { width: srcW, height: srcH } = img;
+    const data = new Uint8Array(srcW * srcH * 4);
+    const newW = srcH;
+    const newH = srcW;
+    for (let dy = 0; dy < newH; dy++) {
+        for (let dx = 0; dx < newW; dx++) {
+            const si = ((srcH - 1 - dx) * srcW + dy) * 4;
+            const di = (dy * newW + dx) * 4;
+            data[di] = img.data[si];
+            data[di + 1] = img.data[si + 1];
+            data[di + 2] = img.data[si + 2];
+            data[di + 3] = img.data[si + 3];
+        }
+    }
+    return { data, width: newW, height: newH };
+}
+// 90° counter-clockwise: new width = srcHeight, new height = srcWidth
+// dst(dx, dy) ← src(col=srcW-1-dy, row=dx)
+export function rotate90CCW(img) {
+    const { width: srcW, height: srcH } = img;
+    const data = new Uint8Array(srcW * srcH * 4);
+    const newW = srcH;
+    const newH = srcW;
+    for (let dy = 0; dy < newH; dy++) {
+        for (let dx = 0; dx < newW; dx++) {
+            const si = (dx * srcW + (srcW - 1 - dy)) * 4;
+            const di = (dy * newW + dx) * 4;
+            data[di] = img.data[si];
+            data[di + 1] = img.data[si + 1];
+            data[di + 2] = img.data[si + 2];
+            data[di + 3] = img.data[si + 3];
+        }
+    }
+    return { data, width: newW, height: newH };
+}
+export function rotate180(img) {
+    const data = new Uint8Array(img.data.length);
+    const total = img.width * img.height;
+    for (let i = 0; i < total; i++) {
+        const si = i * 4;
+        const di = (total - 1 - i) * 4;
+        data[di] = img.data[si];
+        data[di + 1] = img.data[si + 1];
+        data[di + 2] = img.data[si + 2];
+        data[di + 3] = img.data[si + 3];
+    }
+    return { data, width: img.width, height: img.height };
+}
+// Multiply every pixel's alpha channel by opacity (0–1). Mutates in place.
+export function setOpacity(img, opacity) {
+    for (let i = 3; i < img.data.length; i += 4) {
+        img.data[i] = Math.round(img.data[i] * opacity);
+    }
+}

package/dist/utils/imageUtils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=imageUtils.test.d.ts.map

package/dist/utils/imageUtils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageUtils.test.d.ts","sourceRoot":"","sources":["../../src/utils/imageUtils.test.ts"],"names":[],"mappings":""}

package/dist/utils/imageUtils.test.js

@@ -0,0 +1,277 @@
+import { describe, it, expect } from 'vitest';
+import { encode } from 'fast-png';
+import { decodeImage, encodeImage, toBase64Png, createCanvas, cropImage, compositeImage, resizeBilinear, rotate90CW, rotate90CCW, rotate180, setOpacity, } from './imageUtils.js';
+// Build a minimal 2x2 RGBA PNG buffer for use as test input
+function makePng(pixels) {
+    // pixels: [[r,g,b,a], ...] in row-major order, width = sqrt(pixels.length)
+    const side = Math.sqrt(pixels.length);
+    const data = new Uint8Array(pixels.length * 4);
+    pixels.forEach(([r, g, b, a], i) => {
+        data[i * 4] = r;
+        data[i * 4 + 1] = g;
+        data[i * 4 + 2] = b;
+        data[i * 4 + 3] = a;
+    });
+    return Buffer.from(encode({ data, width: side, height: side, channels: 4, depth: 8 }));
+}
+describe('decodeImage', () => {
+    it('decodes an RGBA PNG buffer into a RawImage', () => {
+        const buf = makePng([[255, 0, 0, 255], [0, 255, 0, 255], [0, 0, 255, 255], [255, 255, 0, 255]]);
+        const img = decodeImage(buf);
+        expect(img.width).toBe(2);
+        expect(img.height).toBe(2);
+        expect(img.data[0]).toBe(255); // R
+        expect(img.data[1]).toBe(0); // G
+        expect(img.data[2]).toBe(0); // B
+        expect(img.data[3]).toBe(255); // A
+    });
+    it('converts an RGB (3-channel) PNG to RGBA by adding full alpha', () => {
+        const data = new Uint8Array([100, 150, 200, 50, 60, 70]);
+        const buf = Buffer.from(encode({ data, width: 2, height: 1, channels: 3, depth: 8 }));
+        const img = decodeImage(buf);
+        expect(img.width).toBe(2);
+        expect(img.height).toBe(1);
+        expect(img.data[0]).toBe(100); // R
+        expect(img.data[1]).toBe(150); // G
+        expect(img.data[2]).toBe(200); // B
+        expect(img.data[3]).toBe(255); // A added
+        expect(img.data[4]).toBe(50);
+        expect(img.data[7]).toBe(255); // A added for second pixel
+    });
+    it('converts a grayscale (1-channel) PNG to RGBA', () => {
+        const data = new Uint8Array([128]);
+        const buf = Buffer.from(encode({ data, width: 1, height: 1, channels: 1, depth: 8 }));
+        const img = decodeImage(buf);
+        expect(img.width).toBe(1);
+        expect(img.data[0]).toBe(128); // R = gray value
+        expect(img.data[1]).toBe(128); // G = gray value
+        expect(img.data[2]).toBe(128); // B = gray value
+        expect(img.data[3]).toBe(255); // A = full
+    });
+    it('converts a grayscale+alpha (2-channel) PNG to RGBA', () => {
+        const data = new Uint8Array([200, 128]); // gray=200, alpha=128
+        const buf = Buffer.from(encode({ data, width: 1, height: 1, channels: 2, depth: 8 }));
+        const img = decodeImage(buf);
+        expect(img.data[0]).toBe(200); // R = gray
+        expect(img.data[1]).toBe(200); // G = gray
+        expect(img.data[2]).toBe(200); // B = gray
+        expect(img.data[3]).toBe(128); // A preserved
+    });
+    it('converts a 16-bit RGBA PNG by downsampling to 8-bit', () => {
+        // 16-bit value 0xFF00 >> 8 = 255, 0x8000 >> 8 = 128
+        const data = new Uint16Array([0xFF00, 0x8000, 0x0000, 0xFF00]);
+        const buf = Buffer.from(encode({ data, width: 1, height: 1, channels: 4, depth: 16 }));
+        const img = decodeImage(buf);
+        expect(img.data[0]).toBe(255); // R: 0xFF00 >> 8
+        expect(img.data[1]).toBe(128); // G: 0x8000 >> 8
+        expect(img.data[2]).toBe(0); // B: 0x0000 >> 8
+        expect(img.data[3]).toBe(255); // A: 0xFF00 >> 8
+    });
+});
+describe('encodeImage / toBase64Png', () => {
+    it('round-trips a RawImage through encode → decode', () => {
+        const original = createCanvas(2, 2, 100, 150, 200, 255);
+        const buf = encodeImage(original);
+        const decoded = decodeImage(buf);
+        expect(decoded.width).toBe(2);
+        expect(decoded.height).toBe(2);
+        expect(decoded.data[0]).toBe(100);
+        expect(decoded.data[1]).toBe(150);
+        expect(decoded.data[2]).toBe(200);
+        expect(decoded.data[3]).toBe(255);
+    });
+    it('toBase64Png returns a valid base64 string that decodes back correctly', () => {
+        const img = createCanvas(1, 1, 10, 20, 30, 255);
+        const b64 = toBase64Png(img);
+        expect(typeof b64).toBe('string');
+        const decoded = decodeImage(Buffer.from(b64, 'base64'));
+        expect(decoded.data[0]).toBe(10);
+        expect(decoded.data[1]).toBe(20);
+        expect(decoded.data[2]).toBe(30);
+    });
+});
+describe('createCanvas', () => {
+    it('creates a zero-filled canvas by default', () => {
+        const img = createCanvas(3, 3);
+        expect(img.width).toBe(3);
+        expect(img.height).toBe(3);
+        expect(img.data.every(v => v === 0)).toBe(true);
+    });
+    it('fills all pixels with the provided RGBA color', () => {
+        const img = createCanvas(2, 2, 57, 170, 86, 255);
+        for (let i = 0; i < 4; i++) {
+            expect(img.data[i * 4]).toBe(57);
+            expect(img.data[i * 4 + 1]).toBe(170);
+            expect(img.data[i * 4 + 2]).toBe(86);
+            expect(img.data[i * 4 + 3]).toBe(255);
+        }
+    });
+});
+describe('cropImage', () => {
+    it('extracts the correct rectangular region', () => {
+        // 4x1 image: red, green, blue, yellow
+        const img = {
+            data: new Uint8Array([
+                255, 0, 0, 255, // red
+                0, 255, 0, 255, // green
+                0, 0, 255, 255, // blue
+                255, 255, 0, 255, // yellow
+            ]),
+            width: 4,
+            height: 1,
+        };
+        const cropped = cropImage(img, 1, 0, 2, 1);
+        expect(cropped.width).toBe(2);
+        expect(cropped.height).toBe(1);
+        // First pixel = green
+        expect(cropped.data[0]).toBe(0);
+        expect(cropped.data[1]).toBe(255);
+        expect(cropped.data[2]).toBe(0);
+        // Second pixel = blue
+        expect(cropped.data[4]).toBe(0);
+        expect(cropped.data[5]).toBe(0);
+        expect(cropped.data[6]).toBe(255);
+    });
+});
+describe('compositeImage', () => {
+    it('copies an opaque overlay exactly onto the base', () => {
+        const base = createCanvas(2, 2, 0, 0, 0, 255);
+        const overlay = createCanvas(1, 1, 255, 0, 0, 255);
+        compositeImage(base, overlay, 1, 1);
+        const di = (1 * 2 + 1) * 4;
+        expect(base.data[di]).toBe(255);
+        expect(base.data[di + 1]).toBe(0);
+        expect(base.data[di + 2]).toBe(0);
+        expect(base.data[di + 3]).toBe(255);
+        // Top-left should be untouched
+        expect(base.data[0]).toBe(0);
+    });
+    it('blends a semi-transparent overlay with opacity', () => {
+        const base = createCanvas(1, 1, 0, 0, 0, 255); // black opaque
+        const overlay = createCanvas(1, 1, 255, 0, 0, 255); // red opaque
+        compositeImage(base, overlay, 0, 0, 0.5);
+        // src_a = 0.5, dst_a = 1, out_a = 1
+        // R = round((255 * 0.5 + 0 * 1 * 0.5) / 1) = 128 (approximately)
+        expect(base.data[0]).toBeCloseTo(128, 0);
+        expect(base.data[3]).toBe(255);
+    });
+    it('skips blending when both src and dst alpha are zero', () => {
+        const base = createCanvas(1, 1, 255, 0, 0, 0); // red but fully transparent
+        const overlay = createCanvas(1, 1, 0, 255, 0, 0); // green but fully transparent
+        compositeImage(base, overlay, 0, 0);
+        // outA = 0 → pixel unchanged: base stays (255, 0, 0, 0)
+        expect(base.data[0]).toBe(255);
+        expect(base.data[3]).toBe(0);
+    });
+    it('skips pixels outside the base bounds', () => {
+        const base = createCanvas(2, 2, 0, 0, 0, 255);
+        const overlay = createCanvas(3, 3, 255, 0, 0, 255);
+        // Offset so overlay extends beyond base - should not throw
+        expect(() => compositeImage(base, overlay, 1, 1)).not.toThrow();
+    });
+});
+describe('resizeBilinear', () => {
+    it('doubles a 1x1 image to 2x2 with the same color', () => {
+        const img = createCanvas(1, 1, 100, 200, 50, 255);
+        const resized = resizeBilinear(img, 2, 2);
+        expect(resized.width).toBe(2);
+        expect(resized.height).toBe(2);
+        expect(resized.data[0]).toBe(100);
+        expect(resized.data[1]).toBe(200);
+        expect(resized.data[2]).toBe(50);
+    });
+    it('halves a 4x4 image to 2x2', () => {
+        const img = createCanvas(4, 4, 200, 100, 50, 255);
+        const resized = resizeBilinear(img, 2, 2);
+        expect(resized.width).toBe(2);
+        expect(resized.height).toBe(2);
+    });
+});
+describe('rotate90CW', () => {
+    it('swaps width and height', () => {
+        const img = createCanvas(4, 2, 0, 0, 0, 255);
+        const rotated = rotate90CW(img);
+        expect(rotated.width).toBe(2);
+        expect(rotated.height).toBe(4);
+    });
+    it('moves top-left pixel to top-right', () => {
+        // 2x1: [red | green]
+        const img = {
+            data: new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255]),
+            width: 2,
+            height: 1,
+        };
+        const rotated = rotate90CW(img);
+        // 90° CW: new 1x2 - top pixel comes from bottom-left of src (only 1 row, so left=red)
+        expect(rotated.width).toBe(1);
+        expect(rotated.height).toBe(2);
+        // top of rotated should be red (was left in src)
+        expect(rotated.data[0]).toBe(255); // R
+        expect(rotated.data[1]).toBe(0); // G
+    });
+});
+describe('rotate90CCW', () => {
+    it('swaps width and height', () => {
+        const img = createCanvas(4, 2, 0, 0, 0, 255);
+        const rotated = rotate90CCW(img);
+        expect(rotated.width).toBe(2);
+        expect(rotated.height).toBe(4);
+    });
+    it('is the inverse of rotate90CW', () => {
+        const img = createCanvas(3, 2, 0, 0, 0, 255);
+        img.data[0] = 42; // mark top-left
+        const cw = rotate90CW(img);
+        const back = rotate90CCW(cw);
+        expect(back.width).toBe(3);
+        expect(back.height).toBe(2);
+        expect(back.data[0]).toBe(42);
+    });
+});
+describe('rotate180', () => {
+    it('preserves dimensions', () => {
+        const img = createCanvas(3, 4, 0, 0, 0, 255);
+        const rotated = rotate180(img);
+        expect(rotated.width).toBe(3);
+        expect(rotated.height).toBe(4);
+    });
+    it('flips the pixel order', () => {
+        const img = {
+            data: new Uint8Array([255, 0, 0, 255, 0, 255, 0, 255]),
+            width: 2,
+            height: 1,
+        };
+        const rotated = rotate180(img);
+        // First pixel should now be green (was last)
+        expect(rotated.data[0]).toBe(0);
+        expect(rotated.data[1]).toBe(255);
+        expect(rotated.data[2]).toBe(0);
+        // Second pixel should be red
+        expect(rotated.data[4]).toBe(255);
+        expect(rotated.data[5]).toBe(0);
+    });
+    it('is its own inverse', () => {
+        const img = createCanvas(2, 2, 0, 0, 0, 255);
+        img.data[0] = 77;
+        const twice = rotate180(rotate180(img));
+        expect(twice.data[0]).toBe(77);
+    });
+});
+describe('setOpacity', () => {
+    it('halves the alpha channel of each pixel', () => {
+        const img = createCanvas(2, 2, 57, 170, 86, 255);
+        setOpacity(img, 0.5);
+        for (let i = 0; i < 4; i++) {
+            expect(img.data[i * 4 + 3]).toBe(128);
+        }
+    });
+    it('sets full opacity to 255', () => {
+        const img = createCanvas(1, 1, 0, 0, 0, 128);
+        setOpacity(img, 1);
+        expect(img.data[3]).toBe(128); // unchanged - 128 * 1 = 128
+    });
+    it('sets zero opacity to 0', () => {
+        const img = createCanvas(1, 1, 0, 0, 0, 200);
+        setOpacity(img, 0);
+        expect(img.data[3]).toBe(0);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wdio/image-comparison-core",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "author": "Wim Selles - wswebcreation",
   "description": "Image comparison core module for @wdio/visual-service - WebdriverIO visual testing framework",
   "keywords": [
@@ -26,7 +26,8 @@
     "url": "https://github.com/webdriverio/visual-testing/issues"
   },
   "dependencies": {
-    "jimp": "^1.6.1",
+    "fast-png": "^8.0.0",
+    "pixelmatch": "^7.2.0",
     "@wdio/logger": "^9.29.1",
     "@wdio/types": "^9.29.1"
   },

package/dist/resemble/compare.interfaces.d.ts

@@ -1,136 +0,0 @@
-import type { BaseBoundingBox, BaseCoordinates, BaseDimensions } from '../base.interfaces.js';
-export interface CompareData {
-    /** The mismatch percentage like 0.12345567 */
-    rawMisMatchPercentage: number;
-    /** The mismatch percentage like 0.12 */
-    misMatchPercentage: number;
-    /** The image buffer */
-    getBuffer: () => Buffer;
-    /** The bounds of the diff area */
-    diffBounds: BaseBoundingBox;
-    /** The analysis time in milliseconds */
-    analysisTime: number;
-    /** The diff pixels location(s) and color(s) */
-    diffPixels: BaseCoordinates[];
-}
-/**
- * Src: @types/resemblejs
- */
-type OutputSettings = {
-    /** Color to use for highlighting errors */
-    errorColor?: {
-        /** Red color component (0-255) */
-        red: number;
-        /** Green color component (0-255) */
-        green: number;
-        /** Blue color component (0-255) */
-        blue: number;
-    } | undefined;
-    /** Type of error highlighting to use */
-    errorType?: OutputErrorType | undefined;
-    /** Custom error pixel processing function */
-    errorPixel?: ((px: number[], offset: number, d1: Color, d2: Color) => void) | undefined;
-    /** Transparency level for the output image */
-    transparency?: number | undefined;
-    /** Threshold for large image processing */
-    largeImageThreshold?: number | undefined;
-    /** Whether to use cross-origin for image loading */
-    useCrossOrigin?: boolean | undefined;
-    /** Bounding box to focus comparison on */
-    boundingBox?: Box | undefined;
-    /** Box area to ignore during comparison */
-    ignoredBox?: Box | undefined;
-    /** Multiple bounding boxes to focus comparison on */
-    boundingBoxes?: Box[] | undefined;
-    /** Multiple box areas to ignore during comparison */
-    ignoredBoxes?: Box[] | undefined;
-    /** Color to ignore during comparison */
-    ignoreAreasColoredWith?: Color | undefined;
-};
-type Box = {
-    /** Left boundary of the box */
-    left: number;
-    /** Top boundary of the box */
-    top: number;
-    /** Right boundary of the box */
-    right: number;
-    /** Bottom boundary of the box */
-    bottom: number;
-};
-type Color = {
-    /** Red color component (0-255) */
-    r: number;
-    /** Green color component (0-255) */
-    g: number;
-    /** Blue color component (0-255) */
-    b: number;
-    /** Alpha transparency component (0-255) */
-    a: number;
-};
-type Tolerance = {
-    /** Tolerance for red color component */
-    red?: number;
-    /** Tolerance for green color component */
-    green?: number;
-    /** Tolerance for blue color component */
-    blue?: number;
-    /** Tolerance for alpha transparency component */
-    alpha?: number;
-    /** Minimum brightness tolerance */
-    minBrightness?: number;
-    /** Maximum brightness tolerance */
-    maxBrightness?: number;
-};
-type OutputErrorType = 'flat' | 'movement' | 'flatDifferenceIntensity' | 'movementDifferenceIntensity' | 'diffOnly';
-export type ComparisonIgnoreOption = 'nothing' | 'less' | 'antialiasing' | 'colors' | 'alpha';
-export interface ComparisonOptions {
-    /** Output settings for the comparison */
-    output?: OutputSettings | undefined;
-    /** Threshold to return early if mismatch exceeds this value */
-    returnEarlyThreshold?: number | undefined;
-    /** Whether to scale images to the same size before comparison */
-    scaleToSameSize?: boolean | undefined;
-    /** What aspects to ignore during comparison */
-    ignore?: ComparisonIgnoreOption | ComparisonIgnoreOption[] | undefined;
-    /** Tolerance settings for color differences */
-    tolerance?: Tolerance | undefined;
-}
-export interface ComparisonResult {
-    /**
-     * Error information if error encountered
-     *
-     * Note: If error encountered, other properties will be undefined
-     */
-    error?: unknown | undefined;
-    /**
-     * Time consumed by the comparison (in milliseconds)
-     */
-    analysisTime: number;
-    /**
-     * Do the two images have the same dimensions?
-     */
-    isSameDimensions: boolean;
-    /**
-     * The difference in width and height between the dimensions of the two compared images
-     */
-    dimensionDifference: BaseDimensions;
-    /**
-     * The percentage of pixels which do not match between the images
-     */
-    rawMisMatchPercentage: number;
-    /**
-     * Same as `rawMisMatchPercentage` but fixed to 2-digit after the decimal point
-     */
-    misMatchPercentage: number;
-    diffBounds: Box;
-    /**
-     * Get a data URL for the comparison image
-     */
-    getImageDataUrl(): string;
-    /**
-     * Get data buffer
-     */
-    getBuffer?: (includeOriginal: boolean) => Buffer;
-}
-export {};
-//# sourceMappingURL=compare.interfaces.d.ts.map

package/dist/resemble/compare.interfaces.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compare.interfaces.d.ts","sourceRoot":"","sources":["../../src/resemble/compare.interfaces.ts"],"names":[],"mappings":"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"}

package/dist/resemble/compareImages.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compareImages.d.ts","sourceRoot":"","sources":["../../src/resemble/compareImages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAE7E,wBAA8B,aAAa,CACvC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,iBAAiB,GAC3B,OAAO,CAAC,WAAW,CAAC,CAmBtB"}

package/dist/resemble/compareImages.js

@@ -1,21 +0,0 @@
-// @ts-ignore: Ignoring type checking for this module import
-import * as resembleJimp from './resemble.jimp.cjs';
-export default async function compareImages(image1, image2, options) {
-    /**
-     * Resemble.js implemented in the way that scales 2nd images to the size of 1st.
-     * Experimentally proven that downscaling images produces more accurate result than upscaling
-     */
-    const { imageToCompare1, imageToCompare2 } = options.scaleToSameSize && image1.length > image2.length
-        ? {
-            imageToCompare1: image2,
-            imageToCompare2: image1,
-        }
-        : { imageToCompare1: image1, imageToCompare2: image2 };
-    try {
-        const data = await resembleJimp.default.compare(imageToCompare1, imageToCompare2, options);
-        return data;
-    }
-    catch (err) {
-        throw err;
-    }
-}