easytouch-linux 1.0.6 → 1.0.7

package/.playwright/package/lib/server/webkit/wkProvisionalPage.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WKProvisionalPage = void 0;
+var _eventsHelper = require("../../utils/eventsHelper");
+var _utils = require("../../utils");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class WKProvisionalPage {
+  constructor(session, page) {
+    var _page$_page$mainFrame;
+    this._session = void 0;
+    this._wkPage = void 0;
+    this._coopNavigationRequest = void 0;
+    this._sessionListeners = [];
+    this._mainFrameId = null;
+    this.initializationPromise = void 0;
+    this._session = session;
+    this._wkPage = page;
+    // Cross-Origin-Opener-Policy (COOP) request starts in one process and once response headers
+    // have been received, continues in another.
+    //
+    // Network.requestWillBeSent and requestIntercepted (if intercepting) from the original web process
+    // will always come before a provisional page is created based on the response COOP headers.
+    // Thereafter we'll receive targetCreated (provisional) and later on in some order loadingFailed from the
+    // original process and requestWillBeSent from the provisional one. We should ignore loadingFailed
+    // as the original request continues in the provisional process. But if the provisional load is later
+    // canceled we should dispatch loadingFailed to the client.
+    this._coopNavigationRequest = (_page$_page$mainFrame = page._page.mainFrame().pendingDocument()) === null || _page$_page$mainFrame === void 0 ? void 0 : _page$_page$mainFrame.request;
+    const overrideFrameId = handler => {
+      return payload => {
+        // Pretend that the events happened in the same process.
+        if (payload.frameId) payload.frameId = this._wkPage._page._frameManager.mainFrame()._id;
+        handler(payload);
+      };
+    };
+    const wkPage = this._wkPage;
+    this._sessionListeners = [_eventsHelper.eventsHelper.addEventListener(session, 'Network.requestWillBeSent', overrideFrameId(e => this._onRequestWillBeSent(e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.requestIntercepted', overrideFrameId(e => wkPage._onRequestIntercepted(session, e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.responseReceived', overrideFrameId(e => wkPage._onResponseReceived(session, e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.loadingFinished', overrideFrameId(e => this._onLoadingFinished(e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.loadingFailed', overrideFrameId(e => this._onLoadingFailed(e)))];
+    this.initializationPromise = this._wkPage._initializeSession(session, true, ({
+      frameTree
+    }) => this._handleFrameTree(frameTree));
+  }
+  coopNavigationRequest() {
+    return this._coopNavigationRequest;
+  }
+  dispose() {
+    _eventsHelper.eventsHelper.removeEventListeners(this._sessionListeners);
+  }
+  commit() {
+    (0, _utils.assert)(this._mainFrameId);
+    this._wkPage._onFrameAttached(this._mainFrameId, null);
+  }
+  _onRequestWillBeSent(event) {
+    if (this._coopNavigationRequest && this._coopNavigationRequest.url() === event.request.url) {
+      // If it's a continuation of the main frame navigation request after COOP headers were received,
+      // take over original request, and replace its request id with the new one.
+      this._wkPage._adoptRequestFromNewProcess(this._coopNavigationRequest, this._session, event.requestId);
+      // Simply ignore this event as it has already been dispatched from the original process
+      // and there will ne no requestIntercepted event from the provisional process as it resumes
+      // existing network load (that has already received reponse headers).
+      return;
+    }
+    this._wkPage._onRequestWillBeSent(this._session, event);
+  }
+  _onLoadingFinished(event) {
+    this._coopNavigationRequest = undefined;
+    this._wkPage._onLoadingFinished(event);
+  }
+  _onLoadingFailed(event) {
+    this._coopNavigationRequest = undefined;
+    this._wkPage._onLoadingFailed(this._session, event);
+  }
+  _handleFrameTree(frameTree) {
+    (0, _utils.assert)(!frameTree.frame.parentId);
+    this._mainFrameId = frameTree.frame.id;
+  }
+}
+exports.WKProvisionalPage = WKProvisionalPage;

package/.playwright/package/lib/server/webkit/wkWorkers.js

@@ -0,0 +1,104 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WKWorkers = void 0;
+var _eventsHelper = require("../../utils/eventsHelper");
+var _page = require("../page");
+var _wkConnection = require("./wkConnection");
+var _wkExecutionContext = require("./wkExecutionContext");
+/**
+ * Copyright 2019 Microsoft Corporation All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class WKWorkers {
+  constructor(page) {
+    this._sessionListeners = [];
+    this._page = void 0;
+    this._workerSessions = new Map();
+    this._page = page;
+  }
+  setSession(session) {
+    _eventsHelper.eventsHelper.removeEventListeners(this._sessionListeners);
+    this.clear();
+    this._sessionListeners = [_eventsHelper.eventsHelper.addEventListener(session, 'Worker.workerCreated', event => {
+      const worker = new _page.Worker(this._page, event.url);
+      const workerSession = new _wkConnection.WKSession(session.connection, event.workerId, message => {
+        session.send('Worker.sendMessageToWorker', {
+          workerId: event.workerId,
+          message: JSON.stringify(message)
+        }).catch(e => {
+          workerSession.dispatchMessage({
+            id: message.id,
+            error: {
+              message: e.message
+            }
+          });
+        });
+      });
+      this._workerSessions.set(event.workerId, workerSession);
+      worker._createExecutionContext(new _wkExecutionContext.WKExecutionContext(workerSession, undefined));
+      this._page._addWorker(event.workerId, worker);
+      workerSession.on('Console.messageAdded', event => this._onConsoleMessage(worker, event));
+      Promise.all([workerSession.send('Runtime.enable'), workerSession.send('Console.enable'), session.send('Worker.initialized', {
+        workerId: event.workerId
+      })]).catch(e => {
+        // Worker can go as we are initializing it.
+        this._page._removeWorker(event.workerId);
+      });
+    }), _eventsHelper.eventsHelper.addEventListener(session, 'Worker.dispatchMessageFromWorker', event => {
+      const workerSession = this._workerSessions.get(event.workerId);
+      if (!workerSession) return;
+      workerSession.dispatchMessage(JSON.parse(event.message));
+    }), _eventsHelper.eventsHelper.addEventListener(session, 'Worker.workerTerminated', event => {
+      const workerSession = this._workerSessions.get(event.workerId);
+      if (!workerSession) return;
+      workerSession.dispose();
+      this._workerSessions.delete(event.workerId);
+      this._page._removeWorker(event.workerId);
+    })];
+  }
+  clear() {
+    this._page._clearWorkers();
+    this._workerSessions.clear();
+  }
+  async initializeSession(session) {
+    await session.send('Worker.enable');
+  }
+  async _onConsoleMessage(worker, event) {
+    const {
+      type,
+      level,
+      text,
+      parameters,
+      url,
+      line: lineNumber,
+      column: columnNumber
+    } = event.message;
+    let derivedType = type || '';
+    if (type === 'log') derivedType = level;else if (type === 'timing') derivedType = 'timeEnd';
+    const handles = (parameters || []).map(p => {
+      return worker._existingExecutionContext.createHandle(p);
+    });
+    const location = {
+      url: url || '',
+      lineNumber: (lineNumber || 1) - 1,
+      columnNumber: (columnNumber || 1) - 1
+    };
+    this._page._addConsoleMessage(derivedType, handles, location, handles.length ? undefined : text);
+  }
+}
+exports.WKWorkers = WKWorkers;

package/.playwright/package/lib/third_party/pixelmatch.js

@@ -0,0 +1,255 @@
+/**
+ * 
+ * ISC License
+ *
+ * Copyright (c) 2019, Mapbox
+
+ * Permission to use, copy, modify, and/or distribute this software for any purpose
+ * with or without fee is hereby granted, provided that the above copyright notice
+ * and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ */
+
+'use strict';
+
+module.exports = pixelmatch;
+
+const defaultOptions = {
+    threshold: 0.1,         // matching threshold (0 to 1); smaller is more sensitive
+    includeAA: false,       // whether to skip anti-aliasing detection
+    alpha: 0.1,             // opacity of original image in diff output
+    aaColor: [255, 255, 0], // color of anti-aliased pixels in diff output
+    diffColor: [255, 0, 0], // color of different pixels in diff output
+    diffColorAlt: null,     // whether to detect dark on light differences between img1 and img2 and set an alternative color to differentiate between the two
+    diffMask: false         // draw the diff over a transparent background (a mask)
+};
+
+function pixelmatch(img1, img2, output, width, height, options) {
+
+    if (!isPixelData(img1) || !isPixelData(img2) || (output && !isPixelData(output)))
+        throw new Error('Image data: Uint8Array, Uint8ClampedArray or Buffer expected.');
+
+    if (img1.length !== img2.length || (output && output.length !== img1.length))
+        throw new Error('Image sizes do not match.');
+
+    if (img1.length !== width * height * 4) throw new Error('Image data size does not match width/height.');
+
+    options = Object.assign({}, defaultOptions, options);
+
+    // check if images are identical
+    const len = width * height;
+    const a32 = new Uint32Array(img1.buffer, img1.byteOffset, len);
+    const b32 = new Uint32Array(img2.buffer, img2.byteOffset, len);
+    let identical = true;
+
+    for (let i = 0; i < len; i++) {
+        if (a32[i] !== b32[i]) { identical = false; break; }
+    }
+    if (identical) { // fast path if identical
+        if (output && !options.diffMask) {
+            for (let i = 0; i < len; i++) drawGrayPixel(img1, 4 * i, options.alpha, output);
+        }
+        return 0;
+    }
+
+    // maximum acceptable square distance between two colors;
+    // 35215 is the maximum possible value for the YIQ difference metric
+    const maxDelta = 35215 * options.threshold * options.threshold;
+    let diff = 0;
+
+    // compare each pixel of one image against the other one
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+
+            const pos = (y * width + x) * 4;
+
+            // squared YUV distance between colors at this pixel position, negative if the img2 pixel is darker
+            const delta = colorDelta(img1, img2, pos, pos);
+
+            // the color difference is above the threshold
+            if (Math.abs(delta) > maxDelta) {
+                // check it's a real rendering difference or just anti-aliasing
+                if (!options.includeAA && (antialiased(img1, x, y, width, height, img2) ||
+                                           antialiased(img2, x, y, width, height, img1))) {
+                    // one of the pixels is anti-aliasing; draw as yellow and do not count as difference
+                    // note that we do not include such pixels in a mask
+                    if (output && !options.diffMask) drawPixel(output, pos, ...options.aaColor);
+
+                } else {
+                    // found substantial difference not caused by anti-aliasing; draw it as such
+                    if (output) {
+                        drawPixel(output, pos, ...(delta < 0 && options.diffColorAlt || options.diffColor));
+                    }
+                    diff++;
+                }
+
+            } else if (output) {
+                // pixels are similar; draw background as grayscale image blended with white
+                if (!options.diffMask) drawGrayPixel(img1, pos, options.alpha, output);
+            }
+        }
+    }
+
+    // return the number of different pixels
+    return diff;
+}
+
+function isPixelData(arr) {
+    // work around instanceof Uint8Array not working properly in some Jest environments
+    return ArrayBuffer.isView(arr) && arr.constructor.BYTES_PER_ELEMENT === 1;
+}
+
+// check if a pixel is likely a part of anti-aliasing;
+// based on "Anti-aliased Pixel and Intensity Slope Detector" paper by V. Vysniauskas, 2009
+
+function antialiased(img, x1, y1, width, height, img2) {
+    const x0 = Math.max(x1 - 1, 0);
+    const y0 = Math.max(y1 - 1, 0);
+    const x2 = Math.min(x1 + 1, width - 1);
+    const y2 = Math.min(y1 + 1, height - 1);
+    const pos = (y1 * width + x1) * 4;
+    let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+    let min = 0;
+    let max = 0;
+    let minX, minY, maxX, maxY;
+
+    // go through 8 adjacent pixels
+    for (let x = x0; x <= x2; x++) {
+        for (let y = y0; y <= y2; y++) {
+            if (x === x1 && y === y1) continue;
+
+            // brightness delta between the center pixel and adjacent one
+            const delta = colorDelta(img, img, pos, (y * width + x) * 4, true);
+
+            // count the number of equal, darker and brighter adjacent pixels
+            if (delta === 0) {
+                zeroes++;
+                // if found more than 2 equal siblings, it's definitely not anti-aliasing
+                if (zeroes > 2) return false;
+
+            // remember the darkest pixel
+            } else if (delta < min) {
+                min = delta;
+                minX = x;
+                minY = y;
+
+            // remember the brightest pixel
+            } else if (delta > max) {
+                max = delta;
+                maxX = x;
+                maxY = y;
+            }
+        }
+    }
+
+    // if there are no both darker and brighter pixels among siblings, it's not anti-aliasing
+    if (min === 0 || max === 0) return false;
+
+    // if either the darkest or the brightest pixel has 3+ equal siblings in both images
+    // (definitely not anti-aliased), this pixel is anti-aliased
+    return (hasManySiblings(img, minX, minY, width, height) && hasManySiblings(img2, minX, minY, width, height)) ||
+           (hasManySiblings(img, maxX, maxY, width, height) && hasManySiblings(img2, maxX, maxY, width, height));
+}
+
+// check if a pixel has 3+ adjacent pixels of the same color.
+function hasManySiblings(img, x1, y1, width, height) {
+    const x0 = Math.max(x1 - 1, 0);
+    const y0 = Math.max(y1 - 1, 0);
+    const x2 = Math.min(x1 + 1, width - 1);
+    const y2 = Math.min(y1 + 1, height - 1);
+    const pos = (y1 * width + x1) * 4;
+    let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+
+    // go through 8 adjacent pixels
+    for (let x = x0; x <= x2; x++) {
+        for (let y = y0; y <= y2; y++) {
+            if (x === x1 && y === y1) continue;
+
+            const pos2 = (y * width + x) * 4;
+            if (img[pos] === img[pos2] &&
+                img[pos + 1] === img[pos2 + 1] &&
+                img[pos + 2] === img[pos2 + 2] &&
+                img[pos + 3] === img[pos2 + 3]) zeroes++;
+
+            if (zeroes > 2) return true;
+        }
+    }
+
+    return false;
+}
+
+// calculate color difference according to the paper "Measuring perceived color difference
+// using YIQ NTSC transmission color space in mobile applications" by Y. Kotsarenko and F. Ramos
+
+function colorDelta(img1, img2, k, m, yOnly) {
+    let r1 = img1[k + 0];
+    let g1 = img1[k + 1];
+    let b1 = img1[k + 2];
+    let a1 = img1[k + 3];
+
+    let r2 = img2[m + 0];
+    let g2 = img2[m + 1];
+    let b2 = img2[m + 2];
+    let a2 = img2[m + 3];
+
+    if (a1 === a2 && r1 === r2 && g1 === g2 && b1 === b2) return 0;
+
+    if (a1 < 255) {
+        a1 /= 255;
+        r1 = blend(r1, a1);
+        g1 = blend(g1, a1);
+        b1 = blend(b1, a1);
+    }
+
+    if (a2 < 255) {
+        a2 /= 255;
+        r2 = blend(r2, a2);
+        g2 = blend(g2, a2);
+        b2 = blend(b2, a2);
+    }
+
+    const y1 = rgb2y(r1, g1, b1);
+    const y2 = rgb2y(r2, g2, b2);
+    const y = y1 - y2;
+
+    if (yOnly) return y; // brightness difference only
+
+    const i = rgb2i(r1, g1, b1) - rgb2i(r2, g2, b2);
+    const q = rgb2q(r1, g1, b1) - rgb2q(r2, g2, b2);
+
+    const delta = 0.5053 * y * y + 0.299 * i * i + 0.1957 * q * q;
+
+    // encode whether the pixel lightens or darkens in the sign
+    return y1 > y2 ? -delta : delta;
+}
+
+function rgb2y(r, g, b) { return r * 0.29889531 + g * 0.58662247 + b * 0.11448223; }
+function rgb2i(r, g, b) { return r * 0.59597799 - g * 0.27417610 - b * 0.32180189; }
+function rgb2q(r, g, b) { return r * 0.21147017 - g * 0.52261711 + b * 0.31114694; }
+
+// blend semi-transparent color with white
+function blend(c, a) {
+    return 255 + (c - 255) * a;
+}
+
+function drawPixel(output, pos, r, g, b) {
+    output[pos + 0] = r;
+    output[pos + 1] = g;
+    output[pos + 2] = b;
+    output[pos + 3] = 255;
+}
+
+function drawGrayPixel(img, i, alpha, output) {
+    const r = img[i + 0];
+    const g = img[i + 1];
+    const b = img[i + 2];
+    const val = blend(rgb2y(r, g, b), alpha * img[i + 3] / 255);
+    drawPixel(output, i, val, val, val);
+}

package/.playwright/package/lib/utils/ascii.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonStringifyForceASCII = jsonStringifyForceASCII;
+exports.wrapInASCIIBox = wrapInASCIIBox;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function wrapInASCIIBox(text, padding = 0) {
+  const lines = text.split('\n');
+  const maxLength = Math.max(...lines.map(line => line.length));
+  return ['╔' + '═'.repeat(maxLength + padding * 2) + '╗', ...lines.map(line => '║' + ' '.repeat(padding) + line + ' '.repeat(maxLength - line.length + padding) + '║'), '╚' + '═'.repeat(maxLength + padding * 2) + '╝'].join('\n');
+}
+function jsonStringifyForceASCII(object) {
+  return JSON.stringify(object).replace(/[\u007f-\uffff]/g, c => '\\u' + ('0000' + c.charCodeAt(0).toString(16)).slice(-4));
+}

package/.playwright/package/lib/utils/comparators.js

@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compareBuffersOrStrings = compareBuffersOrStrings;
+exports.getComparator = getComparator;
+var _utilsBundle = require("../utilsBundle");
+var _pixelmatch = _interopRequireDefault(require("../third_party/pixelmatch"));
+var _compare = require("../image_tools/compare");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// @ts-ignore
+
+function getComparator(mimeType) {
+  if (mimeType === 'image/png') return compareImages.bind(null, 'image/png');
+  if (mimeType === 'image/jpeg') return compareImages.bind(null, 'image/jpeg');
+  if (mimeType === 'text/plain') return compareText;
+  return compareBuffersOrStrings;
+}
+const JPEG_JS_MAX_BUFFER_SIZE_IN_MB = 5 * 1024; // ~5 GB
+
+function compareBuffersOrStrings(actualBuffer, expectedBuffer) {
+  if (typeof actualBuffer === 'string') return compareText(actualBuffer, expectedBuffer);
+  if (!actualBuffer || !(actualBuffer instanceof Buffer)) return {
+    errorMessage: 'Actual result should be a Buffer or a string.'
+  };
+  if (Buffer.compare(actualBuffer, expectedBuffer)) return {
+    errorMessage: 'Buffers differ'
+  };
+  return null;
+}
+function compareImages(mimeType, actualBuffer, expectedBuffer, options = {}) {
+  var _options$comparator, _ref;
+  if (!actualBuffer || !(actualBuffer instanceof Buffer)) return {
+    errorMessage: 'Actual result should be a Buffer.'
+  };
+  validateBuffer(expectedBuffer, mimeType);
+  let actual = mimeType === 'image/png' ? _utilsBundle.PNG.sync.read(actualBuffer) : _utilsBundle.jpegjs.decode(actualBuffer, {
+    maxMemoryUsageInMB: JPEG_JS_MAX_BUFFER_SIZE_IN_MB
+  });
+  let expected = mimeType === 'image/png' ? _utilsBundle.PNG.sync.read(expectedBuffer) : _utilsBundle.jpegjs.decode(expectedBuffer, {
+    maxMemoryUsageInMB: JPEG_JS_MAX_BUFFER_SIZE_IN_MB
+  });
+  const size = {
+    width: Math.max(expected.width, actual.width),
+    height: Math.max(expected.height, actual.height)
+  };
+  let sizesMismatchError = '';
+  if (expected.width !== actual.width || expected.height !== actual.height) {
+    sizesMismatchError = `Expected an image ${expected.width}px by ${expected.height}px, received ${actual.width}px by ${actual.height}px. `;
+    actual = resizeImage(actual, size);
+    expected = resizeImage(expected, size);
+  }
+  const diff = new _utilsBundle.PNG({
+    width: size.width,
+    height: size.height
+  });
+  let count;
+  if (options.comparator === 'ssim-cie94') {
+    count = (0, _compare.compare)(expected.data, actual.data, diff.data, size.width, size.height, {
+      // All ΔE* formulae are originally designed to have the difference of 1.0 stand for a "just noticeable difference" (JND).
+      // See https://en.wikipedia.org/wiki/Color_difference#CIELAB_%CE%94E*
+      maxColorDeltaE94: 1.0
+    });
+  } else if (((_options$comparator = options.comparator) !== null && _options$comparator !== void 0 ? _options$comparator : 'pixelmatch') === 'pixelmatch') {
+    var _options$threshold;
+    count = (0, _pixelmatch.default)(expected.data, actual.data, diff.data, size.width, size.height, {
+      threshold: (_options$threshold = options.threshold) !== null && _options$threshold !== void 0 ? _options$threshold : 0.2
+    });
+  } else {
+    throw new Error(`Configuration specifies unknown comparator "${options.comparator}"`);
+  }
+  const maxDiffPixels1 = options.maxDiffPixels;
+  const maxDiffPixels2 = options.maxDiffPixelRatio !== undefined ? expected.width * expected.height * options.maxDiffPixelRatio : undefined;
+  let maxDiffPixels;
+  if (maxDiffPixels1 !== undefined && maxDiffPixels2 !== undefined) maxDiffPixels = Math.min(maxDiffPixels1, maxDiffPixels2);else maxDiffPixels = (_ref = maxDiffPixels1 !== null && maxDiffPixels1 !== void 0 ? maxDiffPixels1 : maxDiffPixels2) !== null && _ref !== void 0 ? _ref : 0;
+  const ratio = Math.ceil(count / (expected.width * expected.height) * 100) / 100;
+  const pixelsMismatchError = count > maxDiffPixels ? `${count} pixels (ratio ${ratio.toFixed(2)} of all image pixels) are different.` : '';
+  if (pixelsMismatchError || sizesMismatchError) return {
+    errorMessage: sizesMismatchError + pixelsMismatchError,
+    diff: _utilsBundle.PNG.sync.write(diff)
+  };
+  return null;
+}
+function validateBuffer(buffer, mimeType) {
+  if (mimeType === 'image/png') {
+    const pngMagicNumber = [137, 80, 78, 71, 13, 10, 26, 10];
+    if (buffer.length < pngMagicNumber.length || !pngMagicNumber.every((byte, index) => buffer[index] === byte)) throw new Error('could not decode image as PNG.');
+  } else if (mimeType === 'image/jpeg') {
+    const jpegMagicNumber = [255, 216];
+    if (buffer.length < jpegMagicNumber.length || !jpegMagicNumber.every((byte, index) => buffer[index] === byte)) throw new Error('could not decode image as JPEG.');
+  }
+}
+function compareText(actual, expectedBuffer) {
+  if (typeof actual !== 'string') return {
+    errorMessage: 'Actual result should be a string'
+  };
+  let expected = expectedBuffer.toString('utf-8');
+  if (expected === actual) return null;
+  // Eliminate '\'
+  if (!actual.endsWith('\n')) actual += '\n';
+  if (!expected.endsWith('\n')) expected += '\n';
+  const lines = _utilsBundle.diff.createPatch('file', expected, actual, undefined, undefined, {
+    context: 5
+  }).split('\n');
+  const coloredLines = lines.slice(4).map(line => {
+    if (line.startsWith('-')) return _utilsBundle.colors.red(line);
+    if (line.startsWith('+')) return _utilsBundle.colors.green(line);
+    if (line.startsWith('@@')) return _utilsBundle.colors.dim(line);
+    return line;
+  });
+  const errorMessage = coloredLines.join('\n');
+  return {
+    errorMessage
+  };
+}
+function resizeImage(image, size) {
+  if (image.width === size.width && image.height === size.height) return image;
+  const buffer = new Uint8Array(size.width * size.height * 4);
+  for (let y = 0; y < size.height; y++) {
+    for (let x = 0; x < size.width; x++) {
+      const to = (y * size.width + x) * 4;
+      if (y < image.height && x < image.width) {
+        const from = (y * image.width + x) * 4;
+        buffer[to] = image.data[from];
+        buffer[to + 1] = image.data[from + 1];
+        buffer[to + 2] = image.data[from + 2];
+        buffer[to + 3] = image.data[from + 3];
+      } else {
+        buffer[to] = 0;
+        buffer[to + 1] = 0;
+        buffer[to + 2] = 0;
+        buffer[to + 3] = 0;
+      }
+    }
+  }
+  return {
+    data: Buffer.from(buffer),
+    width: size.width,
+    height: size.height
+  };
+}