@appium/images-plugin 1.1.4 → 1.1.9

package/build/lib/finder.js

@@ -1,384 +1,342 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_FIX_IMAGE_TEMPLATE_SCALE = exports.DEFAULT_SETTINGS = exports.MJSONWP_ELEMENT_KEY = exports.W3C_ELEMENT_KEY = void 0;
-const lru_cache_1 = __importDefault(require("lru-cache"));
-const appium_support_1 = require("appium-support");
-const appium_base_driver_1 = require("appium-base-driver");
-const image_element_1 = require("./image-element");
-const compare_1 = require("./compare");
-const logger_1 = __importDefault(require("./logger"));
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.W3C_ELEMENT_KEY = exports.MJSONWP_ELEMENT_KEY = exports.DEFAULT_SETTINGS = exports.DEFAULT_FIX_IMAGE_TEMPLATE_SCALE = void 0;
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _lruCache = _interopRequireDefault(require("lru-cache"));
+
+var _support = require("@appium/support");
+
+var _baseDriver = require("@appium/base-driver");
+
+var _imageElement = require("./image-element");
+
+var _compare = require("./compare");
+
+var _logger = _interopRequireDefault(require("./logger"));
+
 const MJSONWP_ELEMENT_KEY = 'ELEMENT';
 exports.MJSONWP_ELEMENT_KEY = MJSONWP_ELEMENT_KEY;
-const W3C_ELEMENT_KEY = appium_support_1.util.W3C_WEB_ELEMENT_IDENTIFIER;
+const W3C_ELEMENT_KEY = _support.util.W3C_WEB_ELEMENT_IDENTIFIER;
 exports.W3C_ELEMENT_KEY = W3C_ELEMENT_KEY;
 const DEFAULT_FIX_IMAGE_TEMPLATE_SCALE = 1;
 exports.DEFAULT_FIX_IMAGE_TEMPLATE_SCALE = DEFAULT_FIX_IMAGE_TEMPLATE_SCALE;
-// Used to compare ratio and screen width
-// Pixel is basically under 1080 for example. 100K is probably enough fo a while.
 const FLOAT_PRECISION = 100000;
-const MAX_CACHE_SIZE = 1024 * 1024 * 40; // 40mb
+const MAX_CACHE_SIZE = 1024 * 1024 * 40;
 const DEFAULT_SETTINGS = {
-    // value between 0 and 1 representing match strength, below which an image
-    // element will not be found
-    imageMatchThreshold: compare_1.DEFAULT_MATCH_THRESHOLD,
-    // if the image returned by getScreenshot differs in size or aspect ratio
-    // from the screen, attempt to fix it automatically
-    fixImageFindScreenshotDims: true,
-    // whether Appium should ensure that an image template sent in during image
-    // element find should have its size adjusted so the match algorithm will not
-    // complain
-    fixImageTemplateSize: false,
-    // whether Appium should ensure that an image template sent in during image
-    // element find should have its scale adjusted to display size so the match
-    // algorithm will not complain.
-    // e.g. iOS has `width=375, height=667` window rect, but its screenshot is
-    //      `width=750 × height=1334` pixels. This setting help to adjust the scale
-    //      if a user use `width=750 × height=1334` pixels's base template image.
-    fixImageTemplateScale: false,
-    // Users might have scaled template image to reduce their storage size.
-    // This setting allows users to scale a template image they send to Appium server
-    // so that the Appium server compares the actual scale users originally had.
-    // e.g. If a user has an image of 270 x 32 pixels which was originally 1080 x 126 pixels,
-    //      the user can set {defaultImageTemplateScale: 4.0} to scale the small image
-    //      to the original one so that Appium can compare it as the original one.
-    defaultImageTemplateScale: image_element_1.DEFAULT_TEMPLATE_IMAGE_SCALE,
-    // whether Appium should re-check that an image element can be matched
-    // against the current screenshot before clicking it
-    checkForImageElementStaleness: true,
-    // whether before clicking on an image element Appium should re-determine the
-    // position of the element on screen
-    autoUpdateImageElementPosition: false,
-    // which method to use for tapping by coordinate for image elements. the
-    // options are 'w3c' or 'mjsonwp'
-    imageElementTapStrategy: image_element_1.IMAGE_EL_TAP_STRATEGY_W3C,
-    // which method to use to save the matched image area in ImageElement class.
-    // It is used for debugging purpose.
-    getMatchedImageResult: false,
+  imageMatchThreshold: _compare.DEFAULT_MATCH_THRESHOLD,
+  imageMatchMethod: '',
+  fixImageFindScreenshotDims: true,
+  fixImageTemplateSize: false,
+  fixImageTemplateScale: false,
+  defaultImageTemplateScale: _imageElement.DEFAULT_TEMPLATE_IMAGE_SCALE,
+  checkForImageElementStaleness: true,
+  autoUpdateImageElementPosition: false,
+  imageElementTapStrategy: _imageElement.IMAGE_EL_TAP_STRATEGY_W3C,
+  getMatchedImageResult: false
 };
 exports.DEFAULT_SETTINGS = DEFAULT_SETTINGS;
+
 class ImageElementFinder {
-    constructor(driver, max = MAX_CACHE_SIZE) {
-        this.driver = driver;
-        this.imgElCache = new lru_cache_1.default({
-            max,
-            length: (el) => el.template.length,
-        });
+  constructor(driver, max = MAX_CACHE_SIZE) {
+    this.driver = driver;
+    this.imgElCache = new _lruCache.default({
+      max,
+      length: el => el.template.length
+    });
+  }
+
+  setDriver(driver) {
+    this.driver = driver;
+  }
+
+  registerImageElement(imgEl) {
+    this.imgElCache.set(imgEl.id, imgEl);
+    const protoKey = this.driver.isW3CProtocol() ? W3C_ELEMENT_KEY : MJSONWP_ELEMENT_KEY;
+    return imgEl.asElement(protoKey);
+  }
+
+  async findByImage(b64Template, {
+    shouldCheckStaleness = false,
+    multiple = false,
+    ignoreDefaultImageTemplateScale = false
+  }) {
+    if (!this.driver) {
+      throw new Error(`Can't find without a driver!`);
     }
-    setDriver(driver) {
-        this.driver = driver;
+
+    const settings = { ...DEFAULT_SETTINGS,
+      ...this.driver.settings.getSettings()
+    };
+    const {
+      imageMatchThreshold: threshold,
+      imageMatchMethod,
+      fixImageTemplateSize,
+      fixImageTemplateScale,
+      defaultImageTemplateScale,
+      getMatchedImageResult: visualize
+    } = settings;
+
+    _logger.default.info(`Finding image element with match threshold ${threshold}`);
+
+    if (!this.driver.getWindowSize) {
+      throw new Error("This driver does not support the required 'getWindowSize' command");
     }
-    registerImageElement(imgEl) {
-        this.imgElCache.set(imgEl.id, imgEl);
-        const protoKey = this.driver.isW3CProtocol() ? W3C_ELEMENT_KEY : MJSONWP_ELEMENT_KEY;
-        return imgEl.asElement(protoKey);
+
+    const {
+      width: screenWidth,
+      height: screenHeight
+    } = await this.driver.getWindowSize();
+
+    if (fixImageTemplateSize) {
+      b64Template = await this.ensureTemplateSize(b64Template, screenWidth, screenHeight);
     }
-    /**
-     * @typedef {Object} FindByImageOptions
-     * @property {boolean} [shouldCheckStaleness=false] - whether this call to find an
-     * image is merely to check staleness. If so we can bypass a lot of logic
-     * @property {boolean} [multiple=false] - Whether we are finding one element or
-     * multiple
-     * @property {boolean} [ignoreDefaultImageTemplateScale=false] - Whether we
-     * ignore defaultImageTemplateScale. It can be used when you would like to
-     * scale b64Template with defaultImageTemplateScale setting.
-     */
-    /**
-     * Find a screen rect represented by an ImageElement corresponding to an image
-     * template sent in by the client
-     *
-     * @param {string} b64Template - base64-encoded image used as a template to be
-     * matched in the screenshot
-     * @param {FindByImageOptions} - additional options
-     *
-     * @returns {WebElement} - WebDriver element with a special id prefix
-     */
-    findByImage(b64Template, { shouldCheckStaleness = false, multiple = false, ignoreDefaultImageTemplateScale = false, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.driver) {
-                throw new Error(`Can't find without a driver!`);
-            }
-            const settings = Object.assign({}, DEFAULT_SETTINGS, this.driver.settings.getSettings());
-            const { imageMatchThreshold: threshold, fixImageTemplateSize, fixImageTemplateScale, defaultImageTemplateScale, getMatchedImageResult: visualize, } = settings;
-            logger_1.default.info(`Finding image element with match threshold ${threshold}`);
-            if (!this.driver.getWindowSize) {
-                throw new Error("This driver does not support the required 'getWindowSize' command");
-            }
-            const { width: screenWidth, height: screenHeight } = yield this.driver.getWindowSize();
-            // someone might have sent in a template that's larger than the screen
-            // dimensions. If so let's check and cut it down to size since the algorithm
-            // will not work unless we do. But because it requires some potentially
-            // expensive commands, only do this if the user has requested it in settings.
-            if (fixImageTemplateSize) {
-                b64Template = yield this.ensureTemplateSize(b64Template, screenWidth, screenHeight);
-            }
-            let rect = null;
-            let b64Matched = null;
-            let score = 0;
-            const condition = () => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const { b64Screenshot, scale } = yield this.getScreenshotForImageFind(screenWidth, screenHeight);
-                    b64Template = yield this.fixImageTemplateScale(b64Template, Object.assign({ defaultImageTemplateScale, ignoreDefaultImageTemplateScale,
-                        fixImageTemplateScale }, scale));
-                    const comparedImage = yield compare_1.compareImages(compare_1.MATCH_TEMPLATE_MODE, b64Screenshot, b64Template, { threshold, visualize });
-                    rect = comparedImage.rect;
-                    b64Matched = comparedImage.visualization;
-                    score = comparedImage.score;
-                    return true;
-                }
-                catch (err) {
-                    // if compareImages fails, we'll get a specific error, but we should
-                    // retry, so trap that and just return false to trigger the next round of
-                    // implicitly waiting. For other errors, throw them to get out of the
-                    // implicit wait loop
-                    if (err.message.match(/Cannot find any occurrences/)) {
-                        return false;
-                    }
-                    throw err;
-                }
-            });
-            try {
-                yield this.driver.implicitWaitForCondition(condition);
-            }
-            catch (err) {
-                // this `implicitWaitForCondition` method will throw a 'Condition unmet'
-                // error if an element is not found eventually. In that case, we will
-                // handle the element not found response below. In the case where get some
-                // _other_ kind of error, it means something blew up totally apart from the
-                // implicit wait timeout. We should not mask that error and instead throw
-                // it straightaway
-                if (!err.message.match(/Condition unmet/)) {
-                    throw err;
-                }
-            }
-            if (!rect) {
-                if (multiple) {
-                    return [];
-                }
-                throw new appium_base_driver_1.errors.NoSuchElementError();
-            }
-            logger_1.default.info(`Image template matched: ${JSON.stringify(rect)}`);
-            if (b64Matched) {
-                logger_1.default.info(`Matched base64 data: ${b64Matched.substring(0, 200)}...`);
-            }
-            const imgEl = new image_element_1.ImageElement(b64Template, rect, score, b64Matched, this);
-            // if we're just checking staleness, return straightaway so we don't add
-            // a new element to the cache. shouldCheckStaleness does not support multiple
-            // elements, since it is a purely internal mechanism
-            if (shouldCheckStaleness) {
-                return imgEl;
-            }
-            const protocolEl = this.registerImageElement(imgEl);
-            return multiple ? [protocolEl] : protocolEl;
+
+    const results = [];
+
+    const condition = async () => {
+      try {
+        const {
+          b64Screenshot,
+          scale
+        } = await this.getScreenshotForImageFind(screenWidth, screenHeight);
+        b64Template = await this.fixImageTemplateScale(b64Template, {
+          defaultImageTemplateScale,
+          ignoreDefaultImageTemplateScale,
+          fixImageTemplateScale,
+          ...scale
         });
+        const comparisonOpts = {
+          threshold,
+          visualize,
+          multiple
+        };
+
+        if (imageMatchMethod) {
+          comparisonOpts.method = imageMatchMethod;
+        }
+
+        if (multiple) {
+          results.push(...(await (0, _compare.compareImages)(_compare.MATCH_TEMPLATE_MODE, b64Screenshot, b64Template, comparisonOpts)));
+        } else {
+          results.push(await (0, _compare.compareImages)(_compare.MATCH_TEMPLATE_MODE, b64Screenshot, b64Template, comparisonOpts));
+        }
+
+        return true;
+      } catch (err) {
+        if (err.message.match(/Cannot find any occurrences/)) {
+          return false;
+        }
+
+        throw err;
+      }
+    };
+
+    try {
+      await this.driver.implicitWaitForCondition(condition);
+    } catch (err) {
+      if (!err.message.match(/Condition unmet/)) {
+        throw err;
+      }
     }
-    /**
-     * Ensure that the image template sent in for a find is of a suitable size
-     *
-     * @param {string} b64Template - base64-encoded image
-     * @param {int} screenWidth - width of screen
-     * @param {int} screenHeight - height of screen
-     *
-     * @returns {string} base64-encoded image, potentially resized
-     */
-    ensureTemplateSize(b64Template, screenWidth, screenHeight) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let imgObj = yield appium_support_1.imageUtil.getJimpImage(b64Template);
-            let { width: tplWidth, height: tplHeight } = imgObj.bitmap;
-            logger_1.default.info(`Template image is ${tplWidth}x${tplHeight}. Screen size is ${screenWidth}x${screenHeight}`);
-            // if the template fits inside the screen dimensions, we're good
-            if (tplWidth <= screenWidth && tplHeight <= screenHeight) {
-                return b64Template;
-            }
-            logger_1.default.info(`Scaling template image from ${tplWidth}x${tplHeight} to match ` +
-                `screen at ${screenWidth}x${screenHeight}`);
-            // otherwise, scale it to fit inside the screen dimensions
-            imgObj = imgObj.scaleToFit(screenWidth, screenHeight);
-            return (yield imgObj.getBuffer(appium_support_1.imageUtil.MIME_PNG)).toString('base64');
-        });
+
+    if (_lodash.default.isEmpty(results)) {
+      if (multiple) {
+        return [];
+      }
+
+      throw new _baseDriver.errors.NoSuchElementError();
     }
-    /**
-     * @typedef {Object} Screenshot
-     * @property {string} b64Screenshot - base64 based screenshot string
-     */
-    /**
-     * @typedef {Object} ScreenshotScale
-     * @property {float} xScale - Scale ratio for width
-     * @property {float} yScale - Scale ratio for height
-     */
-    /**
-     * Get the screenshot image that will be used for find by element, potentially
-     * altering it in various ways based on user-requested settings
-     *
-     * @param {int} screenWidth - width of screen
-     * @param {int} screenHeight - height of screen
-     *
-     * @returns {Screenshot, ?ScreenshotScale} base64-encoded screenshot and ScreenshotScale
-     */
-    getScreenshotForImageFind(screenWidth, screenHeight) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.driver.getScreenshot) {
-                throw new Error("This driver does not support the required 'getScreenshot' command");
-            }
-            const settings = Object.assign({}, DEFAULT_SETTINGS, this.driver.settings.getSettings());
-            const { fixImageFindScreenshotDims } = settings;
-            let b64Screenshot = yield this.driver.getScreenshot();
-            // if the user has requested not to correct for aspect or size differences
-            // between the screenshot and the screen, just return the screenshot now
-            if (!fixImageFindScreenshotDims) {
-                logger_1.default.info(`Not verifying screenshot dimensions match screen`);
-                return { b64Screenshot };
-            }
-            if (screenWidth < 1 || screenHeight < 1) {
-                logger_1.default.warn(`The retrieved screen size ${screenWidth}x${screenHeight} does ` +
-                    `not seem to be valid. No changes will be applied to the screenshot`);
-                return { b64Screenshot };
-            }
-            // otherwise, do some verification on the screenshot to make sure it matches
-            // the screen size and aspect ratio
-            logger_1.default.info('Verifying screenshot size and aspect ratio');
-            let imgObj = yield appium_support_1.imageUtil.getJimpImage(b64Screenshot);
-            let { width: shotWidth, height: shotHeight } = imgObj.bitmap;
-            if (shotWidth < 1 || shotHeight < 1) {
-                logger_1.default.warn(`The retrieved screenshot size ${shotWidth}x${shotHeight} does ` +
-                    `not seem to be valid. No changes will be applied to the screenshot`);
-                return { b64Screenshot };
-            }
-            if (screenWidth === shotWidth && screenHeight === shotHeight) {
-                // the height and width of the screenshot and the device screen match, which
-                // means we should be safe when doing template matches
-                logger_1.default.info('Screenshot size matched screen size');
-                return { b64Screenshot };
-            }
-            // otherwise, if they don't match, it could spell problems for the accuracy
-            // of coordinates returned by the image match algorithm, since we match based
-            // on the screenshot coordinates not the device coordinates themselves. There
-            // are two potential types of mismatch: aspect ratio mismatch and scale
-            // mismatch. We need to detect and fix both
-            const scale = { xScale: 1.0, yScale: 1.0 };
-            const screenAR = screenWidth / screenHeight;
-            const shotAR = shotWidth / shotHeight;
-            if (Math.round(screenAR * FLOAT_PRECISION) === Math.round(shotAR * FLOAT_PRECISION)) {
-                logger_1.default.info(`Screenshot aspect ratio '${shotAR}' (${shotWidth}x${shotHeight}) matched ` +
-                    `screen aspect ratio '${screenAR}' (${screenWidth}x${screenHeight})`);
-            }
-            else {
-                logger_1.default.warn(`When trying to find an element, determined that the screen ` +
-                    `aspect ratio and screenshot aspect ratio are different. Screen ` +
-                    `is ${screenWidth}x${screenHeight} whereas screenshot is ` +
-                    `${shotWidth}x${shotHeight}.`);
-                // In the case where the x-scale and y-scale are different, we need to decide
-                // which one to respect, otherwise the screenshot and template will end up
-                // being resized in a way that changes its aspect ratio (distorts it). For example, let's say:
-                // this.getScreenshot(shotWidth, shotHeight) is 540x397,
-                // this.getDeviceSize(screenWidth, screenHeight) is 1080x1920.
-                // The ratio would then be {xScale: 0.5, yScale: 0.2}.
-                // In this case, we must should `yScale: 0.2` as scaleFactor, because
-                // if we select the xScale, the height will be bigger than real screenshot size
-                // which is used to image comparison by OpenCV as a base image.
-                // All of this is primarily useful when the screenshot is a horizontal slice taken out of the
-                // screen (for example not including top/bottom nav bars)
-                const xScale = (1.0 * shotWidth) / screenWidth;
-                const yScale = (1.0 * shotHeight) / screenHeight;
-                const scaleFactor = xScale >= yScale ? yScale : xScale;
-                logger_1.default.warn(`Resizing screenshot to ${shotWidth * scaleFactor}x${shotHeight * scaleFactor} to match ` +
-                    `screen aspect ratio so that image element coordinates have a ` +
-                    `greater chance of being correct.`);
-                imgObj = imgObj.resize(shotWidth * scaleFactor, shotHeight * scaleFactor);
-                scale.xScale *= scaleFactor;
-                scale.yScale *= scaleFactor;
-                shotWidth = imgObj.bitmap.width;
-                shotHeight = imgObj.bitmap.height;
-            }
-            // Resize based on the screen dimensions only if both width and height are mismatched
-            // since except for that, it might be a situation which is different window rect and
-            // screenshot size like `@driver.window_rect #=>x=0, y=0, width=1080, height=1794` and
-            // `"deviceScreenSize"=>"1080x1920"`
-            if (screenWidth !== shotWidth && screenHeight !== shotHeight) {
-                logger_1.default.info(`Scaling screenshot from ${shotWidth}x${shotHeight} to match ` +
-                    `screen at ${screenWidth}x${screenHeight}`);
-                imgObj = imgObj.resize(screenWidth, screenHeight);
-                scale.xScale *= (1.0 * screenWidth) / shotWidth;
-                scale.yScale *= (1.0 * screenHeight) / shotHeight;
-            }
-            b64Screenshot = (yield imgObj.getBuffer(appium_support_1.imageUtil.MIME_PNG)).toString('base64');
-            return { b64Screenshot, scale };
-        });
+
+    const elements = results.map(({
+      rect,
+      score,
+      visualization
+    }) => {
+      _logger.default.info(`Image template matched: ${JSON.stringify(rect)}`);
+
+      return new _imageElement.ImageElement(b64Template, rect, score, visualization, this);
+    });
+
+    if (shouldCheckStaleness) {
+      return elements[0];
     }
-    /**
-     * @typedef {Object} ImageTemplateSettings
-     * @property {boolean} fixImageTemplateScale - fixImageTemplateScale in device-settings
-     * @property {float} defaultImageTemplateScale - defaultImageTemplateScale in device-settings
-     * @property {boolean} ignoreDefaultImageTemplateScale - Ignore defaultImageTemplateScale if it has true.
-     * If b64Template has been scaled to defaultImageTemplateScale or should ignore the scale,
-     * this parameter should be true. e.g. click in image-element module
-     * @property {float} xScale - Scale ratio for width
-     * @property {float} yScale - Scale ratio for height
-  
-     */
-    /**
-     * Get a image that will be used for template maching.
-     * Returns scaled image if scale ratio is provided.
-     *
-     *
-     * @param {string} b64Template - base64-encoded image used as a template to be
-     * matched in the screenshot
-     * @param {ImageTemplateSettings} opts - Image template scale related options
-     *
-     * @returns {string} base64-encoded scaled template screenshot
-     */
-    fixImageTemplateScale(b64Template, opts = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!opts) {
-                return b64Template;
-            }
-            let { fixImageTemplateScale = false, defaultImageTemplateScale = image_element_1.DEFAULT_TEMPLATE_IMAGE_SCALE, ignoreDefaultImageTemplateScale = false, xScale = DEFAULT_FIX_IMAGE_TEMPLATE_SCALE, yScale = DEFAULT_FIX_IMAGE_TEMPLATE_SCALE } = opts;
-            if (ignoreDefaultImageTemplateScale) {
-                defaultImageTemplateScale = image_element_1.DEFAULT_TEMPLATE_IMAGE_SCALE;
-            }
-            // Default
-            if (defaultImageTemplateScale === image_element_1.DEFAULT_TEMPLATE_IMAGE_SCALE && !fixImageTemplateScale) {
-                return b64Template;
-            }
-            // Calculate xScale and yScale Appium should scale
-            if (fixImageTemplateScale) {
-                xScale *= defaultImageTemplateScale;
-                yScale *= defaultImageTemplateScale;
-            }
-            else {
-                xScale = yScale = 1 * defaultImageTemplateScale;
-            }
-            // xScale and yScale can be NaN if defaultImageTemplateScale is string, for example
-            if (!parseFloat(xScale) || !parseFloat(yScale)) {
-                return b64Template;
-            }
-            // Return if the scale is default, 1, value
-            if (Math.round(xScale * FLOAT_PRECISION) === Math.round(DEFAULT_FIX_IMAGE_TEMPLATE_SCALE * FLOAT_PRECISION)
-                && Math.round(yScale * FLOAT_PRECISION === Math.round(DEFAULT_FIX_IMAGE_TEMPLATE_SCALE * FLOAT_PRECISION))) {
-                return b64Template;
-            }
-            let imgTempObj = yield appium_support_1.imageUtil.getJimpImage(b64Template);
-            let { width: baseTempWidth, height: baseTempHeigh } = imgTempObj.bitmap;
-            const scaledWidth = baseTempWidth * xScale;
-            const scaledHeight = baseTempHeigh * yScale;
-            logger_1.default.info(`Scaling template image from ${baseTempWidth}x${baseTempHeigh}` +
-                ` to ${scaledWidth}x${scaledHeight}`);
-            logger_1.default.info(`The ratio is ${xScale} and ${yScale}`);
-            imgTempObj = yield imgTempObj.resize(scaledWidth, scaledHeight);
-            return (yield imgTempObj.getBuffer(appium_support_1.imageUtil.MIME_PNG)).toString('base64');
-        });
+
+    const registeredElements = elements.map(imgEl => this.registerImageElement(imgEl));
+    return multiple ? registeredElements : registeredElements[0];
+  }
+
+  async ensureTemplateSize(b64Template, screenWidth, screenHeight) {
+    let imgObj = await _support.imageUtil.getJimpImage(b64Template);
+    let {
+      width: tplWidth,
+      height: tplHeight
+    } = imgObj.bitmap;
+
+    _logger.default.info(`Template image is ${tplWidth}x${tplHeight}. Screen size is ${screenWidth}x${screenHeight}`);
+
+    if (tplWidth <= screenWidth && tplHeight <= screenHeight) {
+      return b64Template;
+    }
+
+    _logger.default.info(`Scaling template image from ${tplWidth}x${tplHeight} to match ` + `screen at ${screenWidth}x${screenHeight}`);
+
+    imgObj = imgObj.scaleToFit(screenWidth, screenHeight);
+    return (await imgObj.getBuffer(_support.imageUtil.MIME_PNG)).toString('base64');
+  }
+
+  async getScreenshotForImageFind(screenWidth, screenHeight) {
+    if (!this.driver.getScreenshot) {
+      throw new Error("This driver does not support the required 'getScreenshot' command");
+    }
+
+    const settings = Object.assign({}, DEFAULT_SETTINGS, this.driver.settings.getSettings());
+    const {
+      fixImageFindScreenshotDims
+    } = settings;
+    let b64Screenshot = await this.driver.getScreenshot();
+
+    if (!fixImageFindScreenshotDims) {
+      _logger.default.info(`Not verifying screenshot dimensions match screen`);
+
+      return {
+        b64Screenshot
+      };
+    }
+
+    if (screenWidth < 1 || screenHeight < 1) {
+      _logger.default.warn(`The retrieved screen size ${screenWidth}x${screenHeight} does ` + `not seem to be valid. No changes will be applied to the screenshot`);
+
+      return {
+        b64Screenshot
+      };
+    }
+
+    _logger.default.info('Verifying screenshot size and aspect ratio');
+
+    let imgObj = await _support.imageUtil.getJimpImage(b64Screenshot);
+    let {
+      width: shotWidth,
+      height: shotHeight
+    } = imgObj.bitmap;
+
+    if (shotWidth < 1 || shotHeight < 1) {
+      _logger.default.warn(`The retrieved screenshot size ${shotWidth}x${shotHeight} does ` + `not seem to be valid. No changes will be applied to the screenshot`);
+
+      return {
+        b64Screenshot
+      };
+    }
+
+    if (screenWidth === shotWidth && screenHeight === shotHeight) {
+      _logger.default.info('Screenshot size matched screen size');
+
+      return {
+        b64Screenshot
+      };
+    }
+
+    const scale = {
+      xScale: 1.0,
+      yScale: 1.0
+    };
+    const screenAR = screenWidth / screenHeight;
+    const shotAR = shotWidth / shotHeight;
+
+    if (Math.round(screenAR * FLOAT_PRECISION) === Math.round(shotAR * FLOAT_PRECISION)) {
+      _logger.default.info(`Screenshot aspect ratio '${shotAR}' (${shotWidth}x${shotHeight}) matched ` + `screen aspect ratio '${screenAR}' (${screenWidth}x${screenHeight})`);
+    } else {
+      _logger.default.warn(`When trying to find an element, determined that the screen ` + `aspect ratio and screenshot aspect ratio are different. Screen ` + `is ${screenWidth}x${screenHeight} whereas screenshot is ` + `${shotWidth}x${shotHeight}.`);
+
+      const xScale = 1.0 * shotWidth / screenWidth;
+      const yScale = 1.0 * shotHeight / screenHeight;
+      const scaleFactor = xScale >= yScale ? yScale : xScale;
+
+      _logger.default.warn(`Resizing screenshot to ${shotWidth * scaleFactor}x${shotHeight * scaleFactor} to match ` + `screen aspect ratio so that image element coordinates have a ` + `greater chance of being correct.`);
+
+      imgObj = imgObj.resize(shotWidth * scaleFactor, shotHeight * scaleFactor);
+      scale.xScale *= scaleFactor;
+      scale.yScale *= scaleFactor;
+      shotWidth = imgObj.bitmap.width;
+      shotHeight = imgObj.bitmap.height;
+    }
+
+    if (screenWidth !== shotWidth && screenHeight !== shotHeight) {
+      _logger.default.info(`Scaling screenshot from ${shotWidth}x${shotHeight} to match ` + `screen at ${screenWidth}x${screenHeight}`);
+
+      imgObj = imgObj.resize(screenWidth, screenHeight);
+      scale.xScale *= 1.0 * screenWidth / shotWidth;
+      scale.yScale *= 1.0 * screenHeight / shotHeight;
+    }
+
+    b64Screenshot = (await imgObj.getBuffer(_support.imageUtil.MIME_PNG)).toString('base64');
+    return {
+      b64Screenshot,
+      scale
+    };
+  }
+
+  async fixImageTemplateScale(b64Template, opts = {}) {
+    if (!opts) {
+      return b64Template;
+    }
+
+    let {
+      fixImageTemplateScale = false,
+      defaultImageTemplateScale = _imageElement.DEFAULT_TEMPLATE_IMAGE_SCALE,
+      ignoreDefaultImageTemplateScale = false,
+      xScale = DEFAULT_FIX_IMAGE_TEMPLATE_SCALE,
+      yScale = DEFAULT_FIX_IMAGE_TEMPLATE_SCALE
+    } = opts;
+
+    if (ignoreDefaultImageTemplateScale) {
+      defaultImageTemplateScale = _imageElement.DEFAULT_TEMPLATE_IMAGE_SCALE;
+    }
+
+    if (defaultImageTemplateScale === _imageElement.DEFAULT_TEMPLATE_IMAGE_SCALE && !fixImageTemplateScale) {
+      return b64Template;
+    }
+
+    if (fixImageTemplateScale) {
+      xScale *= defaultImageTemplateScale;
+      yScale *= defaultImageTemplateScale;
+    } else {
+      xScale = yScale = 1 * defaultImageTemplateScale;
+    }
+
+    if (!parseFloat(xScale) || !parseFloat(yScale)) {
+      return b64Template;
+    }
+
+    if (Math.round(xScale * FLOAT_PRECISION) === Math.round(DEFAULT_FIX_IMAGE_TEMPLATE_SCALE * FLOAT_PRECISION) && Math.round(yScale * FLOAT_PRECISION === Math.round(DEFAULT_FIX_IMAGE_TEMPLATE_SCALE * FLOAT_PRECISION))) {
+      return b64Template;
     }
+
+    let imgTempObj = await _support.imageUtil.getJimpImage(b64Template);
+    let {
+      width: baseTempWidth,
+      height: baseTempHeigh
+    } = imgTempObj.bitmap;
+    const scaledWidth = baseTempWidth * xScale;
+    const scaledHeight = baseTempHeigh * yScale;
+
+    _logger.default.info(`Scaling template image from ${baseTempWidth}x${baseTempHeigh}` + ` to ${scaledWidth}x${scaledHeight}`);
+
+    _logger.default.info(`The ratio is ${xScale} and ${yScale}`);
+
+    imgTempObj = await imgTempObj.resize(scaledWidth, scaledHeight);
+    return (await imgTempObj.getBuffer(_support.imageUtil.MIME_PNG)).toString('base64');
+  }
+
 }
+
 exports.default = ImageElementFinder;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"finder.js","sourceRoot":"","sources":["../../lib/finder.js"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../lib/finder.js"],"names":["MJSONWP_ELEMENT_KEY","W3C_ELEMENT_KEY","util","W3C_WEB_ELEMENT_IDENTIFIER","DEFAULT_FIX_IMAGE_TEMPLATE_SCALE","FLOAT_PRECISION","MAX_CACHE_SIZE","DEFAULT_SETTINGS","imageMatchThreshold","DEFAULT_MATCH_THRESHOLD","imageMatchMethod","fixImageFindScreenshotDims","fixImageTemplateSize","fixImageTemplateScale","defaultImageTemplateScale","DEFAULT_TEMPLATE_IMAGE_SCALE","checkForImageElementStaleness","autoUpdateImageElementPosition","imageElementTapStrategy","IMAGE_EL_TAP_STRATEGY_W3C","getMatchedImageResult","ImageElementFinder","constructor","driver","max","imgElCache","LRU","length","el","template","setDriver","registerImageElement","imgEl","set","id","protoKey","isW3CProtocol","asElement","findByImage","b64Template","shouldCheckStaleness","multiple","ignoreDefaultImageTemplateScale","Error","settings","getSettings","threshold","visualize","log","info","getWindowSize","width","screenWidth","height","screenHeight","ensureTemplateSize","results","condition","b64Screenshot","scale","getScreenshotForImageFind","comparisonOpts","method","push","MATCH_TEMPLATE_MODE","err","message","match","implicitWaitForCondition","_","isEmpty","errors","NoSuchElementError","elements","map","rect","score","visualization","JSON","stringify","ImageElement","registeredElements","imgObj","imageUtil","getJimpImage","tplWidth","tplHeight","bitmap","scaleToFit","getBuffer","MIME_PNG","toString","getScreenshot","Object","assign","warn","shotWidth","shotHeight","xScale","yScale","screenAR","shotAR","Math","round","scaleFactor","resize","opts","parseFloat","imgTempObj","baseTempWidth","baseTempHeigh","scaledWidth","scaledHeight"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AAEA;;AACA;;AAEA,MAAMA,mBAAmB,GAAG,SAA5B;;AACA,MAAMC,eAAe,GAAGC,cAAKC,0BAA7B;;AACA,MAAMC,gCAAgC,GAAG,CAAzC;;AAGA,MAAMC,eAAe,GAAG,MAAxB;AACA,MAAMC,cAAc,GAAG,OAAO,IAAP,GAAc,EAArC;AAEA,MAAMC,gBAAgB,GAAG;AAGvBC,EAAAA,mBAAmB,EAAEC,gCAHE;AASvBC,EAAAA,gBAAgB,EAAE,EATK;AAavBC,EAAAA,0BAA0B,EAAE,IAbL;AAkBvBC,EAAAA,oBAAoB,EAAE,KAlBC;AA0BvBC,EAAAA,qBAAqB,EAAE,KA1BA;AAkCvBC,EAAAA,yBAAyB,EAAEC,0CAlCJ;AAsCvBC,EAAAA,6BAA6B,EAAE,IAtCR;AA0CvBC,EAAAA,8BAA8B,EAAE,KA1CT;AA8CvBC,EAAAA,uBAAuB,EAAEC,uCA9CF;AAkDvBC,EAAAA,qBAAqB,EAAE;AAlDA,CAAzB;;;AAqDe,MAAMC,kBAAN,CAAyB;AACtCC,EAAAA,WAAW,CAAEC,MAAF,EAAUC,GAAG,GAAGlB,cAAhB,EAAgC;AACzC,SAAKiB,MAAL,GAAcA,MAAd;AACA,SAAKE,UAAL,GAAkB,IAAIC,iBAAJ,CAAQ;AACxBF,MAAAA,GADwB;AAExBG,MAAAA,MAAM,EAAGC,EAAD,IAAQA,EAAE,CAACC,QAAH,CAAYF;AAFJ,KAAR,CAAlB;AAID;;AAEDG,EAAAA,SAAS,CAAEP,MAAF,EAAU;AACjB,SAAKA,MAAL,GAAcA,MAAd;AACD;;AAEDQ,EAAAA,oBAAoB,CAAEC,KAAF,EAAS;AAC3B,SAAKP,UAAL,CAAgBQ,GAAhB,CAAoBD,KAAK,CAACE,EAA1B,EAA8BF,KAA9B;AACA,UAAMG,QAAQ,GAAG,KAAKZ,MAAL,CAAYa,aAAZ,KAA8BnC,eAA9B,GAAgDD,mBAAjE;AACA,WAAOgC,KAAK,CAACK,SAAN,CAAgBF,QAAhB,CAAP;AACD;;AAuBgB,QAAXG,WAAW,CAAEC,WAAF,EAAe;AAC9BC,IAAAA,oBAAoB,GAAG,KADO;AAE9BC,IAAAA,QAAQ,GAAG,KAFmB;AAG9BC,IAAAA,+BAA+B,GAAG;AAHJ,GAAf,EAId;AACD,QAAI,CAAC,KAAKnB,MAAV,EAAkB;AAChB,YAAM,IAAIoB,KAAJ,CAAW,8BAAX,CAAN;AACD;;AACD,UAAMC,QAAQ,GAAG,EAAC,GAAGrC,gBAAJ;AAAsB,SAAG,KAAKgB,MAAL,CAAYqB,QAAZ,CAAqBC,WAArB;AAAzB,KAAjB;AACA,UAAM;AACJrC,MAAAA,mBAAmB,EAAEsC,SADjB;AAEJpC,MAAAA,gBAFI;AAGJE,MAAAA,oBAHI;AAIJC,MAAAA,qBAJI;AAKJC,MAAAA,yBALI;AAMJM,MAAAA,qBAAqB,EAAE2B;AANnB,QAOFH,QAPJ;;AASAI,oBAAIC,IAAJ,CAAU,8CAA6CH,SAAU,EAAjE;;AACA,QAAI,CAAC,KAAKvB,MAAL,CAAY2B,aAAjB,EAAgC;AAC9B,YAAM,IAAIP,KAAJ,CAAU,mEAAV,CAAN;AACD;;AACD,UAAM;AAACQ,MAAAA,KAAK,EAAEC,WAAR;AAAqBC,MAAAA,MAAM,EAAEC;AAA7B,QAA6C,MAAM,KAAK/B,MAAL,CAAY2B,aAAZ,EAAzD;;AAMA,QAAItC,oBAAJ,EAA0B;AACxB2B,MAAAA,WAAW,GAAG,MAAM,KAAKgB,kBAAL,CAAwBhB,WAAxB,EAAqCa,WAArC,EAClBE,YADkB,CAApB;AAED;;AAED,UAAME,OAAO,GAAG,EAAhB;;AACA,UAAMC,SAAS,GAAG,YAAY;AAC5B,UAAI;AACF,cAAM;AAACC,UAAAA,aAAD;AAAgBC,UAAAA;AAAhB,YAAyB,MAAM,KAAKC,yBAAL,CAA+BR,WAA/B,EAA4CE,YAA5C,CAArC;AAEAf,QAAAA,WAAW,GAAG,MAAM,KAAK1B,qBAAL,CAA2B0B,WAA3B,EAAwC;AAC1DzB,UAAAA,yBAD0D;AAC/B4B,UAAAA,+BAD+B;AAE1D7B,UAAAA,qBAF0D;AAEnC,aAAG8C;AAFgC,SAAxC,CAApB;AAKA,cAAME,cAAc,GAAG;AACrBf,UAAAA,SADqB;AAErBC,UAAAA,SAFqB;AAGrBN,UAAAA;AAHqB,SAAvB;;AAKA,YAAI/B,gBAAJ,EAAsB;AACpBmD,UAAAA,cAAc,CAACC,MAAf,GAAwBpD,gBAAxB;AACD;;AACD,YAAI+B,QAAJ,EAAc;AACZe,UAAAA,OAAO,CAACO,IAAR,CAAa,IAAI,MAAM,4BAAcC,4BAAd,EACcN,aADd,EAEcnB,WAFd,EAGcsB,cAHd,CAAV,CAAb;AAID,SALD,MAKO;AACLL,UAAAA,OAAO,CAACO,IAAR,CAAa,MAAM,4BAAcC,4BAAd,EACcN,aADd,EAEcnB,WAFd,EAGcsB,cAHd,CAAnB;AAID;;AACD,eAAO,IAAP;AAED,OA7BD,CA6BE,OAAOI,GAAP,EAAY;AAKZ,YAAIA,GAAG,CAACC,OAAJ,CAAYC,KAAZ,CAAkB,6BAAlB,CAAJ,EAAsD;AACpD,iBAAO,KAAP;AACD;;AACD,cAAMF,GAAN;AACD;AACF,KAxCD;;AA0CA,QAAI;AACF,YAAM,KAAK1C,MAAL,CAAY6C,wBAAZ,CAAqCX,SAArC,CAAN;AACD,KAFD,CAEE,OAAOQ,GAAP,EAAY;AAOZ,UAAI,CAACA,GAAG,CAACC,OAAJ,CAAYC,KAAZ,CAAkB,iBAAlB,CAAL,EAA2C;AACzC,cAAMF,GAAN;AACD;AACF;;AAED,QAAII,gBAAEC,OAAF,CAAUd,OAAV,CAAJ,EAAwB;AACtB,UAAIf,QAAJ,EAAc;AACZ,eAAO,EAAP;AACD;;AACD,YAAM,IAAI8B,mBAAOC,kBAAX,EAAN;AACD;;AAED,UAAMC,QAAQ,GAAGjB,OAAO,CAACkB,GAAR,CAAY,CAAC;AAACC,MAAAA,IAAD;AAAOC,MAAAA,KAAP;AAAcC,MAAAA;AAAd,KAAD,KAAkC;AAC7D7B,sBAAIC,IAAJ,CAAU,2BAA0B6B,IAAI,CAACC,SAAL,CAAeJ,IAAf,CAAqB,EAAzD;;AACA,aAAO,IAAIK,0BAAJ,CAAiBzC,WAAjB,EAA8BoC,IAA9B,EAAoCC,KAApC,EAA2CC,aAA3C,EAA0D,IAA1D,CAAP;AACD,KAHgB,CAAjB;;AAQA,QAAIrC,oBAAJ,EAA0B;AACxB,aAAOiC,QAAQ,CAAC,CAAD,CAAf;AACD;;AAED,UAAMQ,kBAAkB,GAAGR,QAAQ,CAACC,GAAT,CAAc1C,KAAD,IAAW,KAAKD,oBAAL,CAA0BC,KAA1B,CAAxB,CAA3B;AAEA,WAAOS,QAAQ,GAAGwC,kBAAH,GAAwBA,kBAAkB,CAAC,CAAD,CAAzD;AACD;;AAWuB,QAAlB1B,kBAAkB,CAAEhB,WAAF,EAAea,WAAf,EAA4BE,YAA5B,EAA0C;AAChE,QAAI4B,MAAM,GAAG,MAAMC,mBAAUC,YAAV,CAAuB7C,WAAvB,CAAnB;AACA,QAAI;AAACY,MAAAA,KAAK,EAAEkC,QAAR;AAAkBhC,MAAAA,MAAM,EAAEiC;AAA1B,QAAuCJ,MAAM,CAACK,MAAlD;;AAEAvC,oBAAIC,IAAJ,CAAU,qBAAoBoC,QAAS,IAAGC,SAAU,oBAAmBlC,WAAY,IAAGE,YAAa,EAAnG;;AAEA,QAAI+B,QAAQ,IAAIjC,WAAZ,IAA2BkC,SAAS,IAAIhC,YAA5C,EAA0D;AACxD,aAAOf,WAAP;AACD;;AAEDS,oBAAIC,IAAJ,CAAU,+BAA8BoC,QAAS,IAAGC,SAAU,YAArD,GACC,aAAYlC,WAAY,IAAGE,YAAa,EADlD;;AAGA4B,IAAAA,MAAM,GAAGA,MAAM,CAACM,UAAP,CAAkBpC,WAAlB,EAA+BE,YAA/B,CAAT;AACA,WAAO,CAAC,MAAM4B,MAAM,CAACO,SAAP,CAAiBN,mBAAUO,QAA3B,CAAP,EAA6CC,QAA7C,CAAsD,QAAtD,CAAP;AACD;;AAoB8B,QAAzB/B,yBAAyB,CAAER,WAAF,EAAeE,YAAf,EAA6B;AAC1D,QAAI,CAAC,KAAK/B,MAAL,CAAYqE,aAAjB,EAAgC;AAC9B,YAAM,IAAIjD,KAAJ,CAAU,mEAAV,CAAN;AACD;;AACD,UAAMC,QAAQ,GAAGiD,MAAM,CAACC,MAAP,CAAc,EAAd,EAAkBvF,gBAAlB,EAAoC,KAAKgB,MAAL,CAAYqB,QAAZ,CAAqBC,WAArB,EAApC,CAAjB;AACA,UAAM;AAAClC,MAAAA;AAAD,QAA+BiC,QAArC;AAEA,QAAIc,aAAa,GAAG,MAAM,KAAKnC,MAAL,CAAYqE,aAAZ,EAA1B;;AAIA,QAAI,CAACjF,0BAAL,EAAiC;AAC/BqC,sBAAIC,IAAJ,CAAU,kDAAV;;AACA,aAAO;AAACS,QAAAA;AAAD,OAAP;AACD;;AAED,QAAIN,WAAW,GAAG,CAAd,IAAmBE,YAAY,GAAG,CAAtC,EAAyC;AACvCN,sBAAI+C,IAAJ,CAAU,6BAA4B3C,WAAY,IAAGE,YAAa,QAAzD,GACN,oEADH;;AAEA,aAAO;AAACI,QAAAA;AAAD,OAAP;AACD;;AAIDV,oBAAIC,IAAJ,CAAS,4CAAT;;AAEA,QAAIiC,MAAM,GAAG,MAAMC,mBAAUC,YAAV,CAAuB1B,aAAvB,CAAnB;AACA,QAAI;AAACP,MAAAA,KAAK,EAAE6C,SAAR;AAAmB3C,MAAAA,MAAM,EAAE4C;AAA3B,QAAyCf,MAAM,CAACK,MAApD;;AAEA,QAAIS,SAAS,GAAG,CAAZ,IAAiBC,UAAU,GAAG,CAAlC,EAAqC;AACnCjD,sBAAI+C,IAAJ,CAAU,iCAAgCC,SAAU,IAAGC,UAAW,QAAzD,GACN,oEADH;;AAEA,aAAO;AAACvC,QAAAA;AAAD,OAAP;AACD;;AAED,QAAIN,WAAW,KAAK4C,SAAhB,IAA6B1C,YAAY,KAAK2C,UAAlD,EAA8D;AAG5DjD,sBAAIC,IAAJ,CAAS,qCAAT;;AACA,aAAO;AAACS,QAAAA;AAAD,OAAP;AACD;;AAQD,UAAMC,KAAK,GAAG;AAACuC,MAAAA,MAAM,EAAE,GAAT;AAAcC,MAAAA,MAAM,EAAE;AAAtB,KAAd;AAEA,UAAMC,QAAQ,GAAGhD,WAAW,GAAGE,YAA/B;AACA,UAAM+C,MAAM,GAAGL,SAAS,GAAGC,UAA3B;;AACA,QAAIK,IAAI,CAACC,KAAL,CAAWH,QAAQ,GAAG/F,eAAtB,MAA2CiG,IAAI,CAACC,KAAL,CAAWF,MAAM,GAAGhG,eAApB,CAA/C,EAAqF;AACnF2C,sBAAIC,IAAJ,CAAU,4BAA2BoD,MAAO,MAAKL,SAAU,IAAGC,UAAW,YAAhE,GACN,wBAAuBG,QAAS,MAAKhD,WAAY,IAAGE,YAAa,GADpE;AAED,KAHD,MAGO;AACLN,sBAAI+C,IAAJ,CAAU,6DAAD,GACC,iEADD,GAEC,MAAK3C,WAAY,IAAGE,YAAa,yBAFlC,GAGC,GAAE0C,SAAU,IAAGC,UAAW,GAHpC;;AAgBA,YAAMC,MAAM,GAAI,MAAMF,SAAP,GAAoB5C,WAAnC;AACA,YAAM+C,MAAM,GAAI,MAAMF,UAAP,GAAqB3C,YAApC;AACA,YAAMkD,WAAW,GAAGN,MAAM,IAAIC,MAAV,GAAmBA,MAAnB,GAA4BD,MAAhD;;AAEAlD,sBAAI+C,IAAJ,CAAU,0BAAyBC,SAAS,GAAGQ,WAAY,IAAGP,UAAU,GAAGO,WAAY,YAA9E,GACC,+DADD,GAEC,kCAFV;;AAGAtB,MAAAA,MAAM,GAAGA,MAAM,CAACuB,MAAP,CAAcT,SAAS,GAAGQ,WAA1B,EAAuCP,UAAU,GAAGO,WAApD,CAAT;AAEA7C,MAAAA,KAAK,CAACuC,MAAN,IAAgBM,WAAhB;AACA7C,MAAAA,KAAK,CAACwC,MAAN,IAAgBK,WAAhB;AAEAR,MAAAA,SAAS,GAAGd,MAAM,CAACK,MAAP,CAAcpC,KAA1B;AACA8C,MAAAA,UAAU,GAAGf,MAAM,CAACK,MAAP,CAAclC,MAA3B;AACD;;AAMD,QAAID,WAAW,KAAK4C,SAAhB,IAA6B1C,YAAY,KAAK2C,UAAlD,EAA8D;AAC5DjD,sBAAIC,IAAJ,CAAU,2BAA0B+C,SAAU,IAAGC,UAAW,YAAnD,GACC,aAAY7C,WAAY,IAAGE,YAAa,EADlD;;AAEA4B,MAAAA,MAAM,GAAGA,MAAM,CAACuB,MAAP,CAAcrD,WAAd,EAA2BE,YAA3B,CAAT;AAEAK,MAAAA,KAAK,CAACuC,MAAN,IAAiB,MAAM9C,WAAP,GAAsB4C,SAAtC;AACArC,MAAAA,KAAK,CAACwC,MAAN,IAAiB,MAAM7C,YAAP,GAAuB2C,UAAvC;AACD;;AAEDvC,IAAAA,aAAa,GAAG,CAAC,MAAMwB,MAAM,CAACO,SAAP,CAAiBN,mBAAUO,QAA3B,CAAP,EAA6CC,QAA7C,CAAsD,QAAtD,CAAhB;AACA,WAAO;AAACjC,MAAAA,aAAD;AAAgBC,MAAAA;AAAhB,KAAP;AACD;;AAwB0B,QAArB9C,qBAAqB,CAAE0B,WAAF,EAAemE,IAAI,GAAG,EAAtB,EAA0B;AACnD,QAAI,CAACA,IAAL,EAAW;AACT,aAAOnE,WAAP;AACD;;AAED,QAAI;AACF1B,MAAAA,qBAAqB,GAAG,KADtB;AAEFC,MAAAA,yBAAyB,GAAGC,0CAF1B;AAGF2B,MAAAA,+BAA+B,GAAG,KAHhC;AAIFwD,MAAAA,MAAM,GAAG9F,gCAJP;AAKF+F,MAAAA,MAAM,GAAG/F;AALP,QAMAsG,IANJ;;AAQA,QAAIhE,+BAAJ,EAAqC;AACnC5B,MAAAA,yBAAyB,GAAGC,0CAA5B;AACD;;AAGD,QAAID,yBAAyB,KAAKC,0CAA9B,IAA8D,CAACF,qBAAnE,EAA0F;AACxF,aAAO0B,WAAP;AACD;;AAGD,QAAI1B,qBAAJ,EAA2B;AACzBqF,MAAAA,MAAM,IAAIpF,yBAAV;AACAqF,MAAAA,MAAM,IAAIrF,yBAAV;AACD,KAHD,MAGO;AACLoF,MAAAA,MAAM,GAAGC,MAAM,GAAG,IAAIrF,yBAAtB;AACD;;AAGD,QAAI,CAAC6F,UAAU,CAACT,MAAD,CAAX,IAAuB,CAACS,UAAU,CAACR,MAAD,CAAtC,EAAgD;AAC9C,aAAO5D,WAAP;AACD;;AAGD,QAAI+D,IAAI,CAACC,KAAL,CAAWL,MAAM,GAAG7F,eAApB,MAAyCiG,IAAI,CAACC,KAAL,CAAWnG,gCAAgC,GAAGC,eAA9C,CAAzC,IACGiG,IAAI,CAACC,KAAL,CAAWJ,MAAM,GAAG9F,eAAT,KAA6BiG,IAAI,CAACC,KAAL,CAAWnG,gCAAgC,GAAGC,eAA9C,CAAxC,CADP,EACgH;AAC9G,aAAOkC,WAAP;AACD;;AAED,QAAIqE,UAAU,GAAG,MAAMzB,mBAAUC,YAAV,CAAuB7C,WAAvB,CAAvB;AACA,QAAI;AAACY,MAAAA,KAAK,EAAE0D,aAAR;AAAuBxD,MAAAA,MAAM,EAAEyD;AAA/B,QAAgDF,UAAU,CAACrB,MAA/D;AAEA,UAAMwB,WAAW,GAAGF,aAAa,GAAGX,MAApC;AACA,UAAMc,YAAY,GAAGF,aAAa,GAAGX,MAArC;;AACAnD,oBAAIC,IAAJ,CAAU,+BAA8B4D,aAAc,IAAGC,aAAc,EAA9D,GACE,OAAMC,WAAY,IAAGC,YAAa,EAD7C;;AAEAhE,oBAAIC,IAAJ,CAAU,gBAAeiD,MAAO,QAAOC,MAAO,EAA9C;;AACAS,IAAAA,UAAU,GAAG,MAAMA,UAAU,CAACH,MAAX,CAAkBM,WAAlB,EAA+BC,YAA/B,CAAnB;AACA,WAAO,CAAC,MAAMJ,UAAU,CAACnB,SAAX,CAAqBN,mBAAUO,QAA/B,CAAP,EAAiDC,QAAjD,CAA0D,QAA1D,CAAP;AACD;;AAxXqC","sourcesContent":["import _ from 'lodash';\nimport LRU from 'lru-cache';\nimport { imageUtil, util } from '@appium/support';\nimport { errors } from '@appium/base-driver';\nimport { ImageElement, DEFAULT_TEMPLATE_IMAGE_SCALE,\n         IMAGE_EL_TAP_STRATEGY_W3C } from './image-element';\nimport { MATCH_TEMPLATE_MODE, compareImages, DEFAULT_MATCH_THRESHOLD } from './compare';\nimport log from './logger';\n\nconst MJSONWP_ELEMENT_KEY = 'ELEMENT';\nconst W3C_ELEMENT_KEY = util.W3C_WEB_ELEMENT_IDENTIFIER;\nconst DEFAULT_FIX_IMAGE_TEMPLATE_SCALE = 1;\n// Used to compare ratio and screen width\n// Pixel is basically under 1080 for example. 100K is probably enough fo a while.\nconst FLOAT_PRECISION = 100000;\nconst MAX_CACHE_SIZE = 1024 * 1024 * 40; // 40mb\n\nconst DEFAULT_SETTINGS = {\n  // value between 0 and 1 representing match strength, below which an image\n  // element will not be found\n  imageMatchThreshold: DEFAULT_MATCH_THRESHOLD,\n\n  // One of possible image matching methods.\n  // Read https://docs.opencv.org/3.0-beta/doc/py_tutorials/py_imgproc/py_template_matching/py_template_matching.html\n  // for more details.\n  // TM_CCOEFF_NORMED by default\n  imageMatchMethod: '',\n\n  // if the image returned by getScreenshot differs in size or aspect ratio\n  // from the screen, attempt to fix it automatically\n  fixImageFindScreenshotDims: true,\n\n  // whether Appium should ensure that an image template sent in during image\n  // element find should have its size adjusted so the match algorithm will not\n  // complain\n  fixImageTemplateSize: false,\n\n  // whether Appium should ensure that an image template sent in during image\n  // element find should have its scale adjusted to display size so the match\n  // algorithm will not complain.\n  // e.g. iOS has `width=375, height=667` window rect, but its screenshot is\n  //      `width=750 × height=1334` pixels. This setting help to adjust the scale\n  //      if a user use `width=750 × height=1334` pixels's base template image.\n  fixImageTemplateScale: false,\n\n  // Users might have scaled template image to reduce their storage size.\n  // This setting allows users to scale a template image they send to Appium server\n  // so that the Appium server compares the actual scale users originally had.\n  // e.g. If a user has an image of 270 x 32 pixels which was originally 1080 x 126 pixels,\n  //      the user can set {defaultImageTemplateScale: 4.0} to scale the small image\n  //      to the original one so that Appium can compare it as the original one.\n  defaultImageTemplateScale: DEFAULT_TEMPLATE_IMAGE_SCALE,\n\n  // whether Appium should re-check that an image element can be matched\n  // against the current screenshot before clicking it\n  checkForImageElementStaleness: true,\n\n  // whether before clicking on an image element Appium should re-determine the\n  // position of the element on screen\n  autoUpdateImageElementPosition: false,\n\n  // which method to use for tapping by coordinate for image elements. the\n  // options are 'w3c' or 'mjsonwp'\n  imageElementTapStrategy: IMAGE_EL_TAP_STRATEGY_W3C,\n\n  // which method to use to save the matched image area in ImageElement class.\n  // It is used for debugging purpose.\n  getMatchedImageResult: false,\n};\n\nexport default class ImageElementFinder {\n  constructor (driver, max = MAX_CACHE_SIZE) {\n    this.driver = driver;\n    this.imgElCache = new LRU({\n      max,\n      length: (el) => el.template.length,\n    });\n  }\n\n  setDriver (driver) {\n    this.driver = driver;\n  }\n\n  registerImageElement (imgEl) {\n    this.imgElCache.set(imgEl.id, imgEl);\n    const protoKey = this.driver.isW3CProtocol() ? W3C_ELEMENT_KEY : MJSONWP_ELEMENT_KEY;\n    return imgEl.asElement(protoKey);\n  }\n\n  /**\n   * @typedef FindByImageOptions\n   * @property {boolean} [shouldCheckStaleness=false] - whether this call to find an\n   * image is merely to check staleness. If so we can bypass a lot of logic\n   * @property {boolean} [multiple=false] - Whether we are finding one element or\n   * multiple\n   * @property {boolean} [ignoreDefaultImageTemplateScale=false] - Whether we\n   * ignore defaultImageTemplateScale. It can be used when you would like to\n   * scale b64Template with defaultImageTemplateScale setting.\n   */\n\n  /**\n   * Find a screen rect represented by an ImageElement corresponding to an image\n   * template sent in by the client\n   *\n   * @param {string} b64Template - base64-encoded image used as a template to be\n   * matched in the screenshot\n   * @param {FindByImageOptions} - additional options\n   *\n   * @returns {WebElement} - WebDriver element with a special id prefix\n   */\n  async findByImage (b64Template, {\n    shouldCheckStaleness = false,\n    multiple = false,\n    ignoreDefaultImageTemplateScale = false,\n  }) {\n    if (!this.driver) {\n      throw new Error(`Can't find without a driver!`);\n    }\n    const settings = {...DEFAULT_SETTINGS, ...this.driver.settings.getSettings()};\n    const {\n      imageMatchThreshold: threshold,\n      imageMatchMethod,\n      fixImageTemplateSize,\n      fixImageTemplateScale,\n      defaultImageTemplateScale,\n      getMatchedImageResult: visualize\n    } = settings;\n\n    log.info(`Finding image element with match threshold ${threshold}`);\n    if (!this.driver.getWindowSize) {\n      throw new Error(\"This driver does not support the required 'getWindowSize' command\");\n    }\n    const {width: screenWidth, height: screenHeight} = await this.driver.getWindowSize();\n\n    // someone might have sent in a template that's larger than the screen\n    // dimensions. If so let's check and cut it down to size since the algorithm\n    // will not work unless we do. But because it requires some potentially\n    // expensive commands, only do this if the user has requested it in settings.\n    if (fixImageTemplateSize) {\n      b64Template = await this.ensureTemplateSize(b64Template, screenWidth,\n        screenHeight);\n    }\n\n    const results = [];\n    const condition = async () => {\n      try {\n        const {b64Screenshot, scale} = await this.getScreenshotForImageFind(screenWidth, screenHeight);\n\n        b64Template = await this.fixImageTemplateScale(b64Template, {\n          defaultImageTemplateScale, ignoreDefaultImageTemplateScale,\n          fixImageTemplateScale, ...scale\n        });\n\n        const comparisonOpts = {\n          threshold,\n          visualize,\n          multiple,\n        };\n        if (imageMatchMethod) {\n          comparisonOpts.method = imageMatchMethod;\n        }\n        if (multiple) {\n          results.push(...(await compareImages(MATCH_TEMPLATE_MODE,\n                                               b64Screenshot,\n                                               b64Template,\n                                               comparisonOpts)));\n        } else {\n          results.push(await compareImages(MATCH_TEMPLATE_MODE,\n                                           b64Screenshot,\n                                           b64Template,\n                                           comparisonOpts));\n        }\n        return true;\n\n      } catch (err) {\n        // if compareImages fails, we'll get a specific error, but we should\n        // retry, so trap that and just return false to trigger the next round of\n        // implicitly waiting. For other errors, throw them to get out of the\n        // implicit wait loop\n        if (err.message.match(/Cannot find any occurrences/)) {\n          return false;\n        }\n        throw err;\n      }\n    };\n\n    try {\n      await this.driver.implicitWaitForCondition(condition);\n    } catch (err) {\n      // this `implicitWaitForCondition` method will throw a 'Condition unmet'\n      // error if an element is not found eventually. In that case, we will\n      // handle the element not found response below. In the case where get some\n      // _other_ kind of error, it means something blew up totally apart from the\n      // implicit wait timeout. We should not mask that error and instead throw\n      // it straightaway\n      if (!err.message.match(/Condition unmet/)) {\n        throw err;\n      }\n    }\n\n    if (_.isEmpty(results)) {\n      if (multiple) {\n        return [];\n      }\n      throw new errors.NoSuchElementError();\n    }\n\n    const elements = results.map(({rect, score, visualization}) => {\n      log.info(`Image template matched: ${JSON.stringify(rect)}`);\n      return new ImageElement(b64Template, rect, score, visualization, this);\n    });\n\n    // if we're just checking staleness, return straightaway so we don't add\n    // a new element to the cache. shouldCheckStaleness does not support multiple\n    // elements, since it is a purely internal mechanism\n    if (shouldCheckStaleness) {\n      return elements[0];\n    }\n\n    const registeredElements = elements.map((imgEl) => this.registerImageElement(imgEl));\n\n    return multiple ? registeredElements : registeredElements[0];\n  }\n\n  /**\n   * Ensure that the image template sent in for a find is of a suitable size\n   *\n   * @param {string} b64Template - base64-encoded image\n   * @param {int} screenWidth - width of screen\n   * @param {int} screenHeight - height of screen\n   *\n   * @returns {string} base64-encoded image, potentially resized\n   */\n  async ensureTemplateSize (b64Template, screenWidth, screenHeight) {\n    let imgObj = await imageUtil.getJimpImage(b64Template);\n    let {width: tplWidth, height: tplHeight} = imgObj.bitmap;\n\n    log.info(`Template image is ${tplWidth}x${tplHeight}. Screen size is ${screenWidth}x${screenHeight}`);\n    // if the template fits inside the screen dimensions, we're good\n    if (tplWidth <= screenWidth && tplHeight <= screenHeight) {\n      return b64Template;\n    }\n\n    log.info(`Scaling template image from ${tplWidth}x${tplHeight} to match ` +\n             `screen at ${screenWidth}x${screenHeight}`);\n    // otherwise, scale it to fit inside the screen dimensions\n    imgObj = imgObj.scaleToFit(screenWidth, screenHeight);\n    return (await imgObj.getBuffer(imageUtil.MIME_PNG)).toString('base64');\n  }\n\n  /**\n   * @typedef Screenshot\n   * @property {string} b64Screenshot - base64 based screenshot string\n   */\n  /**\n   * @typedef ScreenshotScale\n   * @property {float} xScale - Scale ratio for width\n   * @property {float} yScale - Scale ratio for height\n   */\n  /**\n   * Get the screenshot image that will be used for find by element, potentially\n   * altering it in various ways based on user-requested settings\n   *\n   * @param {int} screenWidth - width of screen\n   * @param {int} screenHeight - height of screen\n   *\n   * @returns { {b64Screenshot: Screenshot, scale: ScreenshotScale? } } base64-encoded screenshot and ScreenshotScale\n   */\n  async getScreenshotForImageFind (screenWidth, screenHeight) {\n    if (!this.driver.getScreenshot) {\n      throw new Error(\"This driver does not support the required 'getScreenshot' command\");\n    }\n    const settings = Object.assign({}, DEFAULT_SETTINGS, this.driver.settings.getSettings());\n    const {fixImageFindScreenshotDims} = settings;\n\n    let b64Screenshot = await this.driver.getScreenshot();\n\n    // if the user has requested not to correct for aspect or size differences\n    // between the screenshot and the screen, just return the screenshot now\n    if (!fixImageFindScreenshotDims) {\n      log.info(`Not verifying screenshot dimensions match screen`);\n      return {b64Screenshot};\n    }\n\n    if (screenWidth < 1 || screenHeight < 1) {\n      log.warn(`The retrieved screen size ${screenWidth}x${screenHeight} does ` +\n        `not seem to be valid. No changes will be applied to the screenshot`);\n      return {b64Screenshot};\n    }\n\n    // otherwise, do some verification on the screenshot to make sure it matches\n    // the screen size and aspect ratio\n    log.info('Verifying screenshot size and aspect ratio');\n\n    let imgObj = await imageUtil.getJimpImage(b64Screenshot);\n    let {width: shotWidth, height: shotHeight} = imgObj.bitmap;\n\n    if (shotWidth < 1 || shotHeight < 1) {\n      log.warn(`The retrieved screenshot size ${shotWidth}x${shotHeight} does ` +\n        `not seem to be valid. No changes will be applied to the screenshot`);\n      return {b64Screenshot};\n    }\n\n    if (screenWidth === shotWidth && screenHeight === shotHeight) {\n      // the height and width of the screenshot and the device screen match, which\n      // means we should be safe when doing template matches\n      log.info('Screenshot size matched screen size');\n      return {b64Screenshot};\n    }\n\n    // otherwise, if they don't match, it could spell problems for the accuracy\n    // of coordinates returned by the image match algorithm, since we match based\n    // on the screenshot coordinates not the device coordinates themselves. There\n    // are two potential types of mismatch: aspect ratio mismatch and scale\n    // mismatch. We need to detect and fix both\n\n    const scale = {xScale: 1.0, yScale: 1.0};\n\n    const screenAR = screenWidth / screenHeight;\n    const shotAR = shotWidth / shotHeight;\n    if (Math.round(screenAR * FLOAT_PRECISION) === Math.round(shotAR * FLOAT_PRECISION)) {\n      log.info(`Screenshot aspect ratio '${shotAR}' (${shotWidth}x${shotHeight}) matched ` +\n        `screen aspect ratio '${screenAR}' (${screenWidth}x${screenHeight})`);\n    } else {\n      log.warn(`When trying to find an element, determined that the screen ` +\n               `aspect ratio and screenshot aspect ratio are different. Screen ` +\n               `is ${screenWidth}x${screenHeight} whereas screenshot is ` +\n               `${shotWidth}x${shotHeight}.`);\n\n      // In the case where the x-scale and y-scale are different, we need to decide\n      // which one to respect, otherwise the screenshot and template will end up\n      // being resized in a way that changes its aspect ratio (distorts it). For example, let's say:\n      // this.getScreenshot(shotWidth, shotHeight) is 540x397,\n      // this.getDeviceSize(screenWidth, screenHeight) is 1080x1920.\n      // The ratio would then be {xScale: 0.5, yScale: 0.2}.\n      // In this case, we must should `yScale: 0.2` as scaleFactor, because\n      // if we select the xScale, the height will be bigger than real screenshot size\n      // which is used to image comparison by OpenCV as a base image.\n      // All of this is primarily useful when the screenshot is a horizontal slice taken out of the\n      // screen (for example not including top/bottom nav bars)\n      const xScale = (1.0 * shotWidth) / screenWidth;\n      const yScale = (1.0 * shotHeight) / screenHeight;\n      const scaleFactor = xScale >= yScale ? yScale : xScale;\n\n      log.warn(`Resizing screenshot to ${shotWidth * scaleFactor}x${shotHeight * scaleFactor} to match ` +\n               `screen aspect ratio so that image element coordinates have a ` +\n               `greater chance of being correct.`);\n      imgObj = imgObj.resize(shotWidth * scaleFactor, shotHeight * scaleFactor);\n\n      scale.xScale *= scaleFactor;\n      scale.yScale *= scaleFactor;\n\n      shotWidth = imgObj.bitmap.width;\n      shotHeight = imgObj.bitmap.height;\n    }\n\n    // Resize based on the screen dimensions only if both width and height are mismatched\n    // since except for that, it might be a situation which is different window rect and\n    // screenshot size like `@driver.window_rect #=>x=0, y=0, width=1080, height=1794` and\n    // `\"deviceScreenSize\"=>\"1080x1920\"`\n    if (screenWidth !== shotWidth && screenHeight !== shotHeight) {\n      log.info(`Scaling screenshot from ${shotWidth}x${shotHeight} to match ` +\n               `screen at ${screenWidth}x${screenHeight}`);\n      imgObj = imgObj.resize(screenWidth, screenHeight);\n\n      scale.xScale *= (1.0 * screenWidth) / shotWidth;\n      scale.yScale *= (1.0 * screenHeight) / shotHeight;\n    }\n\n    b64Screenshot = (await imgObj.getBuffer(imageUtil.MIME_PNG)).toString('base64');\n    return {b64Screenshot, scale};\n  }\n\n  /**\n   * @typedef ImageTemplateSettings\n   * @property {boolean} fixImageTemplateScale - fixImageTemplateScale in device-settings\n   * @property {float} defaultImageTemplateScale - defaultImageTemplateScale in device-settings\n   * @property {boolean} ignoreDefaultImageTemplateScale - Ignore defaultImageTemplateScale if it has true.\n   * If b64Template has been scaled to defaultImageTemplateScale or should ignore the scale,\n   * this parameter should be true. e.g. click in image-element module\n   * @property {float} xScale - Scale ratio for width\n   * @property {float} yScale - Scale ratio for height\n\n   */\n  /**\n   * Get a image that will be used for template maching.\n   * Returns scaled image if scale ratio is provided.\n   *\n   *\n   * @param {string} b64Template - base64-encoded image used as a template to be\n   * matched in the screenshot\n   * @param {ImageTemplateSettings} opts - Image template scale related options\n   *\n   * @returns {string} base64-encoded scaled template screenshot\n   */\n  async fixImageTemplateScale (b64Template, opts = {}) {\n    if (!opts) {\n      return b64Template;\n    }\n\n    let {\n      fixImageTemplateScale = false,\n      defaultImageTemplateScale = DEFAULT_TEMPLATE_IMAGE_SCALE,\n      ignoreDefaultImageTemplateScale = false,\n      xScale = DEFAULT_FIX_IMAGE_TEMPLATE_SCALE,\n      yScale = DEFAULT_FIX_IMAGE_TEMPLATE_SCALE\n    } = opts;\n\n    if (ignoreDefaultImageTemplateScale) {\n      defaultImageTemplateScale = DEFAULT_TEMPLATE_IMAGE_SCALE;\n    }\n\n    // Default\n    if (defaultImageTemplateScale === DEFAULT_TEMPLATE_IMAGE_SCALE && !fixImageTemplateScale) {\n      return b64Template;\n    }\n\n    // Calculate xScale and yScale Appium should scale\n    if (fixImageTemplateScale) {\n      xScale *= defaultImageTemplateScale;\n      yScale *= defaultImageTemplateScale;\n    } else {\n      xScale = yScale = 1 * defaultImageTemplateScale;\n    }\n\n    // xScale and yScale can be NaN if defaultImageTemplateScale is string, for example\n    if (!parseFloat(xScale) || !parseFloat(yScale)) {\n      return b64Template;\n    }\n\n    // Return if the scale is default, 1, value\n    if (Math.round(xScale * FLOAT_PRECISION) === Math.round(DEFAULT_FIX_IMAGE_TEMPLATE_SCALE * FLOAT_PRECISION)\n        && Math.round(yScale * FLOAT_PRECISION === Math.round(DEFAULT_FIX_IMAGE_TEMPLATE_SCALE * FLOAT_PRECISION))) {\n      return b64Template;\n    }\n\n    let imgTempObj = await imageUtil.getJimpImage(b64Template);\n    let {width: baseTempWidth, height: baseTempHeigh} = imgTempObj.bitmap;\n\n    const scaledWidth = baseTempWidth * xScale;\n    const scaledHeight = baseTempHeigh * yScale;\n    log.info(`Scaling template image from ${baseTempWidth}x${baseTempHeigh}` +\n              ` to ${scaledWidth}x${scaledHeight}`);\n    log.info(`The ratio is ${xScale} and ${yScale}`);\n    imgTempObj = await imgTempObj.resize(scaledWidth, scaledHeight);\n    return (await imgTempObj.getBuffer(imageUtil.MIME_PNG)).toString('base64');\n  }\n}\n\nexport { W3C_ELEMENT_KEY, MJSONWP_ELEMENT_KEY, DEFAULT_SETTINGS, DEFAULT_FIX_IMAGE_TEMPLATE_SCALE };\n"]}