testcafe 1.13.0 → 1.14.2

package/lib/client/driver/index.js

@@ -1,14 +1,17 @@
-// NOTE: We should have the capability to initialize scripts with different contexts.
-// This is required for iframes without the src attribute because Hammerhead does not
-// inject scripts into such iframes. So, we wrap all scripts in initialization functions.
-(function () {
-    function initTestCafeClientDrivers(window, isIFrameWithoutSrc) {
-        var document = window.document;
-
-        (function (hammerhead, Promise$3, testCafeCore, testcafeAutomation, testcafeUi) {
+window['%hammerhead%'].utils.removeInjectedScript();
+
+// NOTE: We should have the capability to initialize scripts with different contexts.
+// This is required for iframes without the src attribute because Hammerhead does not
+// inject scripts into such iframes. So, we wrap all scripts in initialization functions.
+(function () {
+    function initTestCafeClientDrivers(window, isIFrameWithoutSrc) {
+        var document = window.document;
+
+        (function (hammerhead, Promise$8, testCafeCore, testcafeAutomation, testCafeUI) {
     var hammerhead__default = 'default' in hammerhead ? hammerhead['default'] : hammerhead;
-    Promise$3 = Promise$3 && Object.prototype.hasOwnProperty.call(Promise$3, 'default') ? Promise$3['default'] : Promise$3;
+    Promise$8 = Promise$8 && Object.prototype.hasOwnProperty.call(Promise$8, 'default') ? Promise$8['default'] : Promise$8;
     var testCafeCore__default = 'default' in testCafeCore ? testCafeCore['default'] : testCafeCore;
+    var testCafeUI__default = 'default' in testCafeUI ? testCafeUI['default'] : testCafeUI;
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -41,7 +44,7 @@
 
     function __awaiter(thisArg, _arguments, P, generator) {
         function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise$3))(function (resolve, reject) {
+        return new (P || (P = Promise$8))(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); }
@@ -110,12 +113,16 @@
     // Do not use any browser or node-specific API!
     // -------------------------------------------------------------
     var COMMAND_TYPE = {
+        dispatchEvent: 'dispatch-event',
         click: 'click',
         rightClick: 'right-click',
         doubleClick: 'double-click',
         drag: 'drag',
         dragToElement: 'drag-to-element',
         hover: 'hover',
+        scroll: 'scroll',
+        scrollBy: 'scroll-by',
+        scrollIntoView: 'scroll-into-view',
         typeText: 'type-text',
         selectText: 'select-text',
         selectTextAreaContent: 'select-text-area-content',
@@ -150,6 +157,7 @@
         setNativeDialogHandler: 'set-native-dialog-handler',
         getNativeDialogHistory: 'get-native-dialog-history',
         getBrowserConsoleMessages: 'get-browser-console-messages',
+        getActiveElement: 'get-active-element',
         setTestSpeed: 'set-test-speed',
         setPageLoadTimeout: 'set-page-load-timeout',
         debug: 'debug',
@@ -2350,7 +2358,7 @@
         if (!testCafeCore.domUtils.isDomElement(el) && !testCafeCore.domUtils.isTextNode(el))
             return false;
         if (testCafeCore.domUtils.isOptionElement(el) || testCafeCore.domUtils.getTagName(el) === 'optgroup')
-            return testcafeUi.selectElement.isOptionElementVisible(el);
+            return testCafeUI.selectElement.isOptionElementVisible(el);
         return testCafeCore.positionUtils.isElementVisible(el);
     }
     function IsNodeCollection(obj) {
@@ -2587,331 +2595,482 @@
         };
     }
 
-    // Ensure command element properties
-    function ensureElementEditable(element) {
-        if (!testCafeCore.domUtils.isEditableElement(element))
-            throw new ActionElementNonEditableError();
+    var browserUtils = hammerhead__default.utils.browser;
+    function getAutomationPoint(element, offsetX, offsetY) {
+        var roundFn = browserUtils.isFirefox ? Math.ceil : Math.round;
+        var elementOffset = testCafeCore.positionUtils.getOffsetPosition(element, roundFn);
+        var left = element === document.documentElement ? 0 : elementOffset.left;
+        var top = element === document.documentElement ? 0 : elementOffset.top;
+        return {
+            x: left + offsetX,
+            y: top + offsetY
+        };
+    }
+
+    function convertToClient(element, point) {
+        var elementScroll = testCafeCore.styleUtils.getElementScroll(element);
+        if (!/html/i.test(element.tagName) && testCafeCore.styleUtils.hasScroll(element)) {
+            point.x -= elementScroll.left;
+            point.y -= elementScroll.top;
+        }
+        return testCafeCore.positionUtils.offsetToClientCoords(point);
+    }
+
+    function getDevicePoint(clientPoint) {
+        if (!clientPoint)
+            return null;
+        var screenLeft = window.screenLeft || window.screenX;
+        var screenTop = window.screenTop || window.screenY;
+        var x = screenLeft + clientPoint.x;
+        var y = screenTop + clientPoint.y;
+        return { x: x, y: y };
+    }
+
+    function calcOffset(size) {
+        var offset = size / 2;
+        return offset < 1 ? 0 : Math.round(offset);
     }
-    function ensureTextAreaElement(element) {
-        if (!testCafeCore.domUtils.isTextAreaElement(element))
-            throw new ActionElementNotTextAreaError();
+    function getDefaultAutomationOffsets(element) {
+        var rect = testCafeCore.positionUtils.getElementRectangle(element);
+        var offsetX = calcOffset(rect.width);
+        var offsetY = calcOffset(rect.height);
+        return { offsetX: offsetX, offsetY: offsetY };
     }
-    function ensureContentEditableElement(element, argumentTitle) {
-        if (!testCafeCore.domUtils.isContentEditableElement(element))
-            throw new ActionElementNonContentEditableError(argumentTitle);
+    function getOffsetOptions(element, offsetX, offsetY) {
+        var defaultOffsets = getDefaultAutomationOffsets(element);
+        offsetX = typeof offsetX === 'number' ? Math.round(offsetX) : defaultOffsets.offsetX;
+        offsetY = typeof offsetY === 'number' ? Math.round(offsetY) : defaultOffsets.offsetY;
+        if (offsetX > 0 && offsetY > 0)
+            return { offsetX: offsetX, offsetY: offsetY };
+        var dimensions = testCafeCore.positionUtils.getClientDimensions(element);
+        var width = Math.round(Math.max(element.scrollWidth, dimensions.width));
+        var height = Math.round(Math.max(element.scrollHeight, dimensions.height));
+        var maxX = dimensions.scrollbar.right + dimensions.border.left + dimensions.border.right + width;
+        var maxY = dimensions.scrollbar.bottom + dimensions.border.top + dimensions.border.bottom + height;
+        return {
+            offsetX: offsetX < 0 ? maxX + offsetX : offsetX,
+            offsetY: offsetY < 0 ? maxY + offsetY : offsetY
+        };
+    }
+
+    function isIframeWindow(window) {
+        return window.top !== window;
+    }
+
+    var domUtils = testCafeCore__default.domUtils;
+    var cursorUI = !isIframeWindow(window) ? testCafeUI__default.cursorUI : testCafeUI__default.iframeCursorUI;
+    // NOTE: the default position should be outside of the page (GH-794)
+    var cursor = {
+        x: -1,
+        y: -1,
+        currentActiveWindow: window.top,
+        _ensureActiveWindow: function () {
+            if (this.currentActiveWindow === window || this.currentActiveWindow === window.parent)
+                return;
+            var activeFrame = domUtils.findIframeByWindow(this.currentActiveWindow);
+            if (!activeFrame || !domUtils.isElementInDocument(activeFrame))
+                this.currentActiveWindow = window;
+        },
+        get active() {
+            this._ensureActiveWindow();
+            return this.currentActiveWindow === window;
+        },
+        set activeWindow(win) {
+            this.currentActiveWindow = win;
+        },
+        get activeWindow() {
+            this._ensureActiveWindow();
+            return this.currentActiveWindow;
+        },
+        get position() {
+            return { x: this.x, y: this.y };
+        },
+        get visible() {
+            return !isIframeWindow(window) && cursorUI.isVisible();
+        },
+        move: function (newX, newY) {
+            this.x = newX;
+            this.y = newY;
+            return cursorUI.move(this.x, this.y);
+        },
+        hide: function () {
+            if (this.visible)
+                cursorUI.hide();
+        },
+        show: function () {
+            if (!isIframeWindow(window))
+                cursorUI.show();
+        },
+        leftButtonDown: function () {
+            return cursorUI.leftButtonDown();
+        },
+        rightButtonDown: function () {
+            return cursorUI.rightButtonDown();
+        },
+        buttonUp: function () {
+            return cursorUI.buttonUp();
+        }
+    };
+
+    var browserUtils$1 = hammerhead__default.utils.browser;
+    var Promise$1 = hammerhead__default.Promise;
+    var nativeMethods$4 = hammerhead__default.nativeMethods;
+    var positionUtils = testCafeCore__default.positionUtils;
+    var domUtils$1 = testCafeCore__default.domUtils;
+    function getElementFromPoint(x, y, underTopShadowUIElement) {
+        var topElement = null;
+        return testCafeUI__default.hide(underTopShadowUIElement)
+            .then(function () {
+            topElement = positionUtils.getElementFromPoint(x, y);
+            return testCafeUI__default.show(underTopShadowUIElement);
+        })
+            .then(function () { return topElement; });
     }
-    function ensureRootContainer(elements) {
-        // NOTE: We should find a common element for the nodes to perform the select action
-        if (!testCafeCore.contentEditable.getNearestCommonAncestor(elements[0], elements[1]))
-            throw new ActionRootContainerNotFoundError();
-        return elements;
+    function ensureImageMap(imgElement, areaElement) {
+        var mapElement = domUtils$1.closest(areaElement, 'map');
+        return mapElement && mapElement.name === imgElement.useMap.substring(1) ? areaElement : imgElement;
     }
-    function ensureFileInput(element) {
-        if (!testCafeCore.domUtils.isFileInput(element))
-            throw new ActionElementIsNotFileInputError();
+    function findElementOrNonEmptyChildFromPoint(x, y, element) {
+        var topElement = positionUtils.getElementFromPoint(x, y);
+        var isNonEmptyChild = domUtils$1.containsElement(element, topElement) &&
+            nativeMethods$4.nodeTextContentGetter.call(topElement).length;
+        if (topElement && topElement === element || isNonEmptyChild)
+            return topElement;
+        return null;
     }
-    function ensureOffsetOptions(element, options) {
-        var _a = testcafeAutomation.getOffsetOptions(element, options.offsetX, options.offsetY), offsetX = _a.offsetX, offsetY = _a.offsetY;
-        options.offsetX = offsetX;
-        options.offsetY = offsetY;
+    function correctTopElementByExpectedElement(topElement, expectedElement) {
+        var expectedElementDefined = expectedElement && domUtils$1.isDomElement(expectedElement);
+        if (!expectedElementDefined || !topElement || topElement === expectedElement)
+            return topElement;
+        var isTREFElement = domUtils$1.getTagName(expectedElement) === 'tref';
+        // NOTE: 'document.elementFromPoint' can't find these types of elements
+        if (isTREFElement)
+            return expectedElement;
+        // NOTE: T299665 - Incorrect click automation for images with an associated map element in Firefox
+        // All browsers return the <area> element from document.getElementFromPoint, but
+        // Firefox returns the <img> element. We should accomplish this for Firefox as well.
+        var isImageMapArea = domUtils$1.getTagName(expectedElement) === 'area' && domUtils$1.isImgElement(topElement);
+        if (browserUtils$1.isFirefox && isImageMapArea)
+            return ensureImageMap(topElement, expectedElement);
+        // NOTE: try to find a multi-line link by its rectangle (T163678)
+        var isLinkOrChildExpected = domUtils$1.isAnchorElement(expectedElement) ||
+            domUtils$1.getParents(expectedElement, 'a').length;
+        var isTopElementChildOfLink = isLinkOrChildExpected &&
+            domUtils$1.containsElement(expectedElement, topElement) &&
+            nativeMethods$4.nodeTextContentGetter.call(topElement).length;
+        var shouldSearchForMultilineLink = isLinkOrChildExpected && !isTopElementChildOfLink &&
+            nativeMethods$4.nodeTextContentGetter.call(expectedElement).length;
+        if (!shouldSearchForMultilineLink)
+            return topElement;
+        var linkRect = expectedElement.getBoundingClientRect();
+        return findElementOrNonEmptyChildFromPoint(linkRect.right - 1, linkRect.top + 1, expectedElement) ||
+            findElementOrNonEmptyChildFromPoint(linkRect.left + 1, linkRect.bottom - 1, expectedElement) ||
+            topElement;
     }
-    var MAX_DELAY_AFTER_EXECUTION = 2000;
-    var CHECK_ELEMENT_IN_AUTOMATIONS_INTERVAL = 250;
-    var DateCtor$2 = hammerhead.nativeMethods.date;
-    var ActionExecutor = /** @class */ (function () {
-        function ActionExecutor(command, globalSelectorTimeout, statusBar, testSpeed) {
-            this.command = command;
-            this.globalSelectorTimeout = globalSelectorTimeout;
-            this.statusBar = statusBar;
-            this.testSpeed = testSpeed;
-            this.targetElement = null;
-            this.elements = [];
-            this.ensureElementsPromise = null;
-            this.ensureElementsStartTime = null;
-            this.executionStartTime = null;
-            this.executionStartedHandler = null;
-            this.commandSelectorTimeout = null;
-        }
-        ActionExecutor.prototype._getSpecificTimeout = function () {
-            var hasSpecificTimeout = this.command.selector && typeof this.command.selector.timeout === 'number';
-            return hasSpecificTimeout ? this.command.selector.timeout : this.globalSelectorTimeout;
-        };
-        ActionExecutor.prototype._delayAfterExecution = function () {
-            if (!this.command.options || this.command.options.speed === 1)
-                return hammerhead.Promise.resolve();
-            return testCafeCore.delay((1 - this.command.options.speed) * MAX_DELAY_AFTER_EXECUTION);
-        };
-        ActionExecutor.prototype._isExecutionTimeoutExpired = function () {
-            return hammerhead.nativeMethods.dateNow() - this.executionStartTime >= this.commandSelectorTimeout;
-        };
-        ActionExecutor.prototype._ensureCommandArguments = function () {
-            if (this.command.type === COMMAND_TYPE.pressKey) {
-                var parsedKeySequence = testCafeCore.parseKeySequence(this.command.keys);
-                if (parsedKeySequence.error)
-                    throw new ActionIncorrectKeysError('keys');
+    function fromPoint(x, y, expectedElement) {
+        var foundElement = null;
+        return getElementFromPoint(x, y)
+            .then(function (topElement) {
+            foundElement = topElement;
+            // NOTE: when trying to get an element by elementFromPoint in iframe and the target
+            // element is under any of shadow-ui elements, you will get null (only in IE).
+            // In this case, you should hide a top window's shadow-ui root to obtain an element.
+            var resChain = Promise$1.resolve(topElement);
+            if (!foundElement && isIframeWindow(window) && x > 0 && y > 0) {
+                resChain = resChain
+                    .then(function () { return getElementFromPoint(x, y, true); })
+                    .then(function (element) {
+                    foundElement = element;
+                    return element;
+                });
             }
+            return resChain
+                .then(function (element) { return correctTopElementByExpectedElement(element, expectedElement); })
+                .then(function (correctedElement) {
+                return { element: correctedElement, corrected: correctedElement !== foundElement };
+            });
+        });
+    }
+    function underCursor() {
+        var cursorPosition = cursor.position;
+        return fromPoint(cursorPosition.x, cursorPosition.y).then(function (_a) {
+            var element = _a.element;
+            return element;
+        });
+    }
+
+    var AUTOMATION_ERROR_TYPES = {
+        elementIsInvisibleError: 'elementIsInvisibleError',
+        foundElementIsNotTarget: 'foundElementIsNotTarget'
+    };
+
+    var ACTION_STEP_DELAY_DEFAULT = 10;
+    var MAX_MOUSE_ACTION_STEP_DELAY = 400;
+    var MAX_KEY_ACTION_STEP_DELAY = 200;
+    // We use an exponential function to calculate the cursor
+    // speed according to general test speed
+    // cursorSpeed = (maxSpeed * k) ^ speed / k
+    var MAX_CURSOR_SPEED = 100; // pixels/ms
+    var MAX_DRAGGING_SPEED = 4; // pixels/ms
+    var CURSOR_FACTOR = 4;
+    var AutomationSettings = /** @class */ (function () {
+        function AutomationSettings(speed) {
+            this.speedFactor = speed || 1;
+        }
+        Object.defineProperty(AutomationSettings.prototype, "mouseActionStepDelay", {
+            get: function () {
+                return this.speedFactor === 1 ? ACTION_STEP_DELAY_DEFAULT : (1 - this.speedFactor) * MAX_MOUSE_ACTION_STEP_DELAY;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(AutomationSettings.prototype, "keyActionStepDelay", {
+            get: function () {
+                return this.speedFactor === 1 ? ACTION_STEP_DELAY_DEFAULT : (1 - this.speedFactor) * MAX_KEY_ACTION_STEP_DELAY;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(AutomationSettings.prototype, "cursorSpeed", {
+            get: function () {
+                return Math.pow(MAX_CURSOR_SPEED * CURSOR_FACTOR, this.speedFactor) / CURSOR_FACTOR;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(AutomationSettings.prototype, "draggingSpeed", {
+            get: function () {
+                return Math.pow(MAX_DRAGGING_SPEED * CURSOR_FACTOR, this.speedFactor) / CURSOR_FACTOR;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return AutomationSettings;
+    }());
+
+    var Promise$2 = hammerhead__default.Promise;
+    var messageSandbox$1 = hammerhead__default.eventSandbox.message;
+    var DEFAULT_MAX_SCROLL_MARGIN = 50;
+    var SCROLL_MARGIN_INCREASE_STEP = 20;
+    var SCROLL_REQUEST_CMD = 'automation|scroll|request';
+    var SCROLL_RESPONSE_CMD = 'automation|scroll|response';
+    // Setup cross-iframe interaction
+    messageSandbox$1.on(messageSandbox$1.SERVICE_MSG_RECEIVED_EVENT, function (e) {
+        if (e.message.cmd === SCROLL_REQUEST_CMD) {
+            var _a = e.message, offsetX = _a.offsetX, offsetY = _a.offsetY, maxScrollMargin = _a.maxScrollMargin;
+            var element = testCafeCore.domUtils.findIframeByWindow(e.source);
+            var scroll_1 = new ScrollAutomation(element, { offsetX: offsetX, offsetY: offsetY });
+            scroll_1.maxScrollMargin = maxScrollMargin;
+            scroll_1
+                .run()
+                .then(function () { return messageSandbox$1.sendServiceMsg({ cmd: SCROLL_RESPONSE_CMD }, e.source); });
+        }
+    });
+    var ScrollAutomation = /** @class */ (function () {
+        function ScrollAutomation(element, scrollOptions) {
+            this.element = element;
+            this.offsetX = scrollOptions.offsetX;
+            this.offsetY = scrollOptions.offsetY;
+            this.scrollToCenter = scrollOptions.scrollToCenter;
+            this.skipParentFrames = scrollOptions.skipParentFrames;
+            this.raiseEvents = scrollOptions.raiseEvents;
+            this.maxScrollMargin = { left: DEFAULT_MAX_SCROLL_MARGIN, top: DEFAULT_MAX_SCROLL_MARGIN };
+            this.scrollWasPerformed = false;
+        }
+        ScrollAutomation.prototype._isScrollValuesChanged = function (scrollElement, originalScroll) {
+            return testCafeCore.styleUtils.getScrollLeft(scrollElement) !== originalScroll.left
+                || testCafeCore.styleUtils.getScrollTop(scrollElement) !== originalScroll.top;
         };
-        ActionExecutor.prototype._ensureCommandElements = function () {
+        ScrollAutomation.prototype._setScroll = function (element, _a) {
             var _this = this;
-            var elementDescriptors = [];
-            if (this.command.selector)
-                elementDescriptors.push(createElementDescriptor(this.command.selector));
-            if (this.command.type === COMMAND_TYPE.dragToElement)
-                elementDescriptors.push(createAdditionalElementDescriptor(this.command.destinationSelector, 'destinationSelector'));
-            else if (this.command.type === COMMAND_TYPE.selectEditableContent) {
-                elementDescriptors.push(createAdditionalElementDescriptor(this.command.startSelector, 'startSelector'));
-                elementDescriptors.push(createAdditionalElementDescriptor(this.command.endSelector || this.command.startSelector, 'endSelector'));
+            var left = _a.left, top = _a.top;
+            var scrollElement = testCafeCore.domUtils.isHtmlElement(element) ? testCafeCore.domUtils.findDocument(element) : element;
+            var originalScroll = {
+                left: testCafeCore.styleUtils.getScrollLeft(scrollElement),
+                top: testCafeCore.styleUtils.getScrollTop(scrollElement)
+            };
+            left = Math.max(left, 0);
+            top = Math.max(top, 0);
+            var scrollPromise = testCafeCore.scrollController.waitForScroll(scrollElement);
+            testCafeCore.styleUtils.setScrollLeft(scrollElement, left);
+            testCafeCore.styleUtils.setScrollTop(scrollElement, top);
+            if (!this._isScrollValuesChanged(scrollElement, originalScroll)) {
+                scrollPromise.cancel();
+                return Promise$2.resolve();
             }
-            return ensureElements(elementDescriptors, this.globalSelectorTimeout)
-                .then(function (elements) {
-                _this.elements = elements;
+            scrollPromise = scrollPromise.then(function () {
+                _this.scrollWasPerformed = _this.scrollWasPerformed || _this._isScrollValuesChanged(scrollElement, originalScroll);
             });
-        };
-        ActionExecutor.prototype._ensureCommandElementsProperties = function () {
-            if (this.command.type === COMMAND_TYPE.selectText)
-                ensureElementEditable(this.elements[0]);
-            else if (this.command.type === COMMAND_TYPE.selectTextAreaContent)
-                ensureTextAreaElement(this.elements[0]);
-            else if (this.command.type === COMMAND_TYPE.selectEditableContent) {
-                ensureContentEditableElement(this.elements[0], 'startSelector');
-                ensureContentEditableElement(this.elements[1], 'endSelector');
-                ensureRootContainer(this.elements);
+            return scrollPromise;
+        };
+        ScrollAutomation.prototype._getScrollToPoint = function (elementDimensions, _a, maxScrollMargin) {
+            var x = _a.x, y = _a.y;
+            var horizontalCenter = Math.floor(elementDimensions.width / 2);
+            var verticalCenter = Math.floor(Math.floor(elementDimensions.height / 2));
+            var leftScrollMargin = this.scrollToCenter ? horizontalCenter : Math.min(maxScrollMargin.left, horizontalCenter);
+            var topScrollMargin = this.scrollToCenter ? verticalCenter : Math.min(maxScrollMargin.top, verticalCenter);
+            var needForwardScrollLeft = x >= elementDimensions.scroll.left + elementDimensions.width - leftScrollMargin;
+            var needBackwardScrollLeft = x <= elementDimensions.scroll.left + leftScrollMargin;
+            var needForwardScrollTop = y >= elementDimensions.scroll.top + elementDimensions.height - topScrollMargin;
+            var needBackwardScrollTop = y <= elementDimensions.scroll.top + topScrollMargin;
+            var left = elementDimensions.scroll.left;
+            var top = elementDimensions.scroll.top;
+            if (needForwardScrollLeft)
+                left = x - elementDimensions.width + leftScrollMargin;
+            else if (needBackwardScrollLeft)
+                left = x - leftScrollMargin;
+            if (needForwardScrollTop)
+                top = y - elementDimensions.height + topScrollMargin;
+            else if (needBackwardScrollTop)
+                top = y - topScrollMargin;
+            return { left: left, top: top };
+        };
+        ScrollAutomation.prototype._getScrollToFullChildView = function (parentDimensions, childDimensions, maxScrollMargin) {
+            var fullViewScrollLeft = null;
+            var fullViewScrollTop = null;
+            var canShowFullElementWidth = parentDimensions.width >= childDimensions.width;
+            var canShowFullElementHeight = parentDimensions.height >= childDimensions.height;
+            var relativePosition = testCafeCore.positionUtils.calcRelativePosition(childDimensions, parentDimensions);
+            if (canShowFullElementWidth) {
+                var availableLeftScrollMargin = parentDimensions.width - childDimensions.width;
+                var leftScrollMargin = Math.min(maxScrollMargin.left, availableLeftScrollMargin);
+                if (this.scrollToCenter)
+                    leftScrollMargin = availableLeftScrollMargin / 2;
+                if (relativePosition.left < leftScrollMargin) {
+                    fullViewScrollLeft = Math.round(parentDimensions.scroll.left + relativePosition.left -
+                        leftScrollMargin);
+                }
+                else if (relativePosition.right < leftScrollMargin) {
+                    fullViewScrollLeft = Math.round(parentDimensions.scroll.left +
+                        Math.min(relativePosition.left, -relativePosition.right) +
+                        leftScrollMargin);
+                }
             }
-            else if (this.command.type === COMMAND_TYPE.setFilesToUpload || this.command.type === COMMAND_TYPE.clearUpload)
-                ensureFileInput(this.elements[0]);
+            if (canShowFullElementHeight) {
+                var availableTopScrollMargin = parentDimensions.height - childDimensions.height;
+                var topScrollMargin = Math.min(maxScrollMargin.top, availableTopScrollMargin);
+                if (this.scrollToCenter)
+                    topScrollMargin = availableTopScrollMargin / 2;
+                if (relativePosition.top < topScrollMargin)
+                    fullViewScrollTop = Math.round(parentDimensions.scroll.top + relativePosition.top - topScrollMargin);
+                else if (relativePosition.bottom < topScrollMargin) {
+                    fullViewScrollTop = Math.round(parentDimensions.scroll.top +
+                        Math.min(relativePosition.top, -relativePosition.bottom) +
+                        topScrollMargin);
+                }
+            }
+            return {
+                left: fullViewScrollLeft,
+                top: fullViewScrollTop
+            };
         };
-        ActionExecutor.prototype._ensureCommandOptions = function () {
-            if (this.elements.length && this.command.options && 'offsetX' in this.command.options && 'offsetY' in this.command.options)
-                ensureOffsetOptions(this.elements[0], this.command.options);
+        ScrollAutomation._getChildPoint = function (parentDimensions, childDimensions, offsets) {
+            return {
+                x: childDimensions.left - parentDimensions.left + parentDimensions.scroll.left +
+                    childDimensions.border.left + offsets.x,
+                y: childDimensions.top - parentDimensions.top + parentDimensions.scroll.top +
+                    childDimensions.border.top + offsets.y
+            };
         };
-        ActionExecutor.prototype._createAutomation = function () {
-            var selectArgs = null;
-            switch (this.command.type) {
-                case COMMAND_TYPE.click:
-                    if (/option|optgroup/.test(testCafeCore.domUtils.getTagName(this.elements[0])))
-                        return new testcafeAutomation.SelectChildClick(this.elements[0], this.command.options);
-                    return new testcafeAutomation.Click(this.elements[0], this.command.options);
-                case COMMAND_TYPE.rightClick:
-                    return new testcafeAutomation.RClick(this.elements[0], this.command.options);
-                case COMMAND_TYPE.doubleClick:
-                    return new testcafeAutomation.DblClick(this.elements[0], this.command.options);
-                case COMMAND_TYPE.hover:
-                    return new testcafeAutomation.Hover(this.elements[0], this.command.options);
-                case COMMAND_TYPE.drag:
-                    return new testcafeAutomation.DragToOffset(this.elements[0], this.command.dragOffsetX, this.command.dragOffsetY, this.command.options);
-                case COMMAND_TYPE.dragToElement:
-                    return new testcafeAutomation.DragToElement(this.elements[0], this.elements[1], this.command.options);
-                case COMMAND_TYPE.typeText:
-                    // eslint-disable-next-line no-restricted-properties
-                    return new testcafeAutomation.Type(this.elements[0], this.command.text, this.command.options);
-                case COMMAND_TYPE.selectText:
-                case COMMAND_TYPE.selectTextAreaContent:
-                    selectArgs = testcafeAutomation.calculateSelectTextArguments(this.elements[0], this.command);
-                    return new testcafeAutomation.SelectText(this.elements[0], selectArgs.startPos, selectArgs.endPos, this.command.options);
-                case COMMAND_TYPE.selectEditableContent:
-                    return new testcafeAutomation.SelectEditableContent(this.elements[0], this.elements[1], this.command.options);
-                case COMMAND_TYPE.pressKey:
-                    return new testcafeAutomation.Press(testCafeCore.parseKeySequence(this.command.keys).combinations, this.command.options);
-                case COMMAND_TYPE.setFilesToUpload:
-                    return new testcafeAutomation.Upload(this.elements[0], this.command.filePath, function (filePaths, scannedFilePaths) { return new ActionCannotFindFileToUploadError(filePaths, scannedFilePaths); });
-                case COMMAND_TYPE.clearUpload:
-                    return new testcafeAutomation.Upload(this.elements[0]);
+        ScrollAutomation.prototype._getScrollPosition = function (parentDimensions, childDimensions, offsets, maxScrollMargin) {
+            var childPoint = ScrollAutomation._getChildPoint(parentDimensions, childDimensions, offsets);
+            var scrollToPoint = this._getScrollToPoint(parentDimensions, childPoint, maxScrollMargin);
+            var scrollToFullView = this._getScrollToFullChildView(parentDimensions, childDimensions, maxScrollMargin);
+            var left = Math.max(scrollToFullView.left === null ? scrollToPoint.left : scrollToFullView.left, 0);
+            var top = Math.max(scrollToFullView.top === null ? scrollToPoint.top : scrollToFullView.top, 0);
+            return { left: left, top: top };
+        };
+        ScrollAutomation._getChildPointAfterScroll = function (parentDimensions, childDimensions, currentScroll, offsets) {
+            var x = Math.round(childDimensions.left + parentDimensions.scroll.left - currentScroll.left + offsets.x);
+            var y = Math.round(childDimensions.top + parentDimensions.scroll.top - currentScroll.top + offsets.y);
+            return { x: x, y: y };
+        };
+        ScrollAutomation.prototype._isChildFullyVisible = function (parentDimensions, childDimensions, offsets) {
+            var _a = ScrollAutomation._getChildPointAfterScroll(parentDimensions, childDimensions, parentDimensions.scroll, offsets), x = _a.x, y = _a.y;
+            var zeroMargin = { left: 0, top: 0 };
+            var _b = this._getScrollPosition(parentDimensions, childDimensions, offsets, zeroMargin), left = _b.left, top = _b.top;
+            return !this._isTargetElementObscuredInPoint(x, y) &&
+                left === parentDimensions.scroll.left && top === parentDimensions.scroll.top;
+        };
+        ScrollAutomation.prototype._scrollToChild = function (parent, child, offsets) {
+            var parentDimensions = testCafeCore.positionUtils.getClientDimensions(parent);
+            var childDimensions = testCafeCore.positionUtils.getClientDimensions(child);
+            var windowWidth = testCafeCore.styleUtils.getInnerWidth(window);
+            var windowHeight = testCafeCore.styleUtils.getInnerHeight(window);
+            var scrollPos = parentDimensions.scroll;
+            var needScroll = !this._isChildFullyVisible(parentDimensions, childDimensions, offsets);
+            while (needScroll) {
+                scrollPos = this._getScrollPosition(parentDimensions, childDimensions, offsets, this.maxScrollMargin);
+                var _a = ScrollAutomation._getChildPointAfterScroll(parentDimensions, childDimensions, scrollPos, offsets), x = _a.x, y = _a.y;
+                var isTargetObscured = this._isTargetElementObscuredInPoint(x, y);
+                this.maxScrollMargin.left += SCROLL_MARGIN_INCREASE_STEP;
+                if (this.maxScrollMargin.left >= windowWidth) {
+                    this.maxScrollMargin.left = DEFAULT_MAX_SCROLL_MARGIN;
+                    this.maxScrollMargin.top += SCROLL_MARGIN_INCREASE_STEP;
+                }
+                needScroll = isTargetObscured && this.maxScrollMargin.top < windowHeight;
             }
-            return null;
+            this.maxScrollMargin = { left: DEFAULT_MAX_SCROLL_MARGIN, top: DEFAULT_MAX_SCROLL_MARGIN };
+            return this._setScroll(parent, scrollPos);
         };
-        ActionExecutor.prototype._runAction = function (strictElementCheck) {
-            var _this = this;
-            return this
-                ._ensureCommandElements()
-                .then(function () { return _this._ensureCommandElementsProperties(); })
-                .then(function () {
-                _this._ensureCommandOptions();
-                var automation = _this._createAutomation();
-                if (automation.TARGET_ELEMENT_FOUND_EVENT) {
-                    automation.on(automation.TARGET_ELEMENT_FOUND_EVENT, function (e) {
-                        _this.targetElement = e.element;
-                        _this.statusBar.hideWaitingElementStatus(true);
-                        _this.executionStartedHandler();
-                    });
-                }
-                else {
-                    _this.statusBar.hideWaitingElementStatus(true);
-                    _this.executionStartedHandler();
-                }
-                return automation
-                    .run(strictElementCheck);
-            });
+        ScrollAutomation.prototype._scrollElement = function () {
+            if (!testCafeCore.styleUtils.hasScroll(this.element))
+                return Promise$2.resolve();
+            var elementDimensions = testCafeCore.positionUtils.getClientDimensions(this.element);
+            var scroll = this._getScrollToPoint(elementDimensions, { x: this.offsetX, y: this.offsetY }, this.maxScrollMargin);
+            return this._setScroll(this.element, scroll);
         };
-        ActionExecutor.prototype._runRecursively = function () {
+        ScrollAutomation.prototype._scrollParents = function () {
             var _this = this;
-            var actionFinished = false;
-            var strictElementCheck = true;
-            return testCafeCore.promiseUtils.whilst(function () { return !actionFinished; }, function () {
+            var parents = testCafeCore.styleUtils.getScrollableParents(this.element);
+            var currentChild = this.element;
+            var currentOffsetX = this.offsetX - Math.round(testCafeCore.styleUtils.getScrollLeft(currentChild));
+            var currentOffsetY = this.offsetY - Math.round(testCafeCore.styleUtils.getScrollTop(currentChild));
+            var childDimensions = null;
+            var parentDimensions = null;
+            var scrollParentsPromise = testCafeCore.promiseUtils.times(parents.length, function (i) {
                 return _this
-                    ._runAction(strictElementCheck)
+                    ._scrollToChild(parents[i], currentChild, { x: currentOffsetX, y: currentOffsetY })
                     .then(function () {
-                    actionFinished = true;
-                })
-                    .catch(function (err) {
-                    if (_this._isExecutionTimeoutExpired()) {
-                        if (err.message === testcafeAutomation.ERROR_TYPES.foundElementIsNotTarget) {
-                            // If we can't get a target element via elementFromPoint but it's
-                            // visible we click on the point where the element is located.
-                            strictElementCheck = false;
-                            return hammerhead.Promise.resolve();
-                        }
-                        throw err.message === testcafeAutomation.ERROR_TYPES.elementIsInvisibleError ?
-                            new ActionElementIsInvisibleError() : err;
-                    }
-                    return testCafeCore.delay(CHECK_ELEMENT_IN_AUTOMATIONS_INTERVAL);
+                    childDimensions = testCafeCore.positionUtils.getClientDimensions(currentChild);
+                    parentDimensions = testCafeCore.positionUtils.getClientDimensions(parents[i]);
+                    currentOffsetX += childDimensions.left - parentDimensions.left + parentDimensions.border.left;
+                    currentOffsetY += childDimensions.top - parentDimensions.top + parentDimensions.border.top;
+                    currentChild = parents[i];
                 });
             });
+            return scrollParentsPromise
+                .then(function () {
+                if (isIframeWindow(window) && !_this.skipParentFrames) {
+                    return testCafeCore.sendRequestToFrame({
+                        cmd: SCROLL_REQUEST_CMD,
+                        offsetX: currentOffsetX,
+                        offsetY: currentOffsetY,
+                        maxScrollMargin: _this.maxScrollMargin
+                    }, SCROLL_RESPONSE_CMD, window.parent);
+                }
+                return Promise$2.resolve();
+            });
         };
-        ActionExecutor.prototype.execute = function () {
+        ScrollAutomation._getFixedAncestorOrSelf = function (element) {
+            return testCafeCore.domUtils.findParent(element, true, testCafeCore.styleUtils.isFixedElement);
+        };
+        ScrollAutomation.prototype._isTargetElementObscuredInPoint = function (x, y) {
+            var elementInPoint = testCafeCore.positionUtils.getElementFromPoint(x, y);
+            if (!elementInPoint)
+                return false;
+            var fixedElement = ScrollAutomation._getFixedAncestorOrSelf(elementInPoint);
+            return fixedElement && !fixedElement.contains(this.element);
+        };
+        ScrollAutomation.prototype.run = function () {
             var _this = this;
-            if (this.command.options && !this.command.options.speed)
-                this.command.options.speed = this.testSpeed;
-            var startPromise = new hammerhead.Promise(function (resolve) {
-                _this.executionStartedHandler = resolve;
-            });
-            var completionPromise = new hammerhead.Promise(function (resolve) {
-                _this.executionStartTime = new DateCtor$2();
-                try {
-                    _this._ensureCommandArguments();
-                }
-                catch (err) {
-                    resolve(new DriverStatus({ isCommandResult: true, executionError: err }));
-                    return;
-                }
-                _this.commandSelectorTimeout = _this._getSpecificTimeout();
-                _this.statusBar.showWaitingElementStatus(_this.commandSelectorTimeout);
-                var _a = runWithBarriers(function () { return _this._runRecursively(); }), actionPromise = _a.actionPromise, barriersPromise = _a.barriersPromise;
-                actionPromise
-                    .then(function () { return hammerhead.Promise.all([
-                    _this._delayAfterExecution(),
-                    barriersPromise
-                ]); })
-                    .then(function () {
-                    var status = { isCommandResult: true };
-                    var elements = __spreadArrays(_this.elements);
-                    if (_this.targetElement)
-                        elements[0] = _this.targetElement;
-                    status.result = createReplicator(new SelectorElementActionTransform()).encode(elements);
-                    resolve(new DriverStatus(status));
-                })
-                    .catch(function (err) {
-                    return _this.statusBar.hideWaitingElementStatus(false)
-                        .then(function () { return resolve(new DriverStatus({ isCommandResult: true, executionError: err })); });
-                });
-            });
-            return { startPromise: startPromise, completionPromise: completionPromise };
-        };
-        return ActionExecutor;
-    }());
-    function executeAction(command, globalSelectorTimeout, statusBar, testSpeed) {
-        var actionExecutor = new ActionExecutor(command, globalSelectorTimeout, statusBar, testSpeed);
-        return actionExecutor.execute();
-    }
-
-    // -------------------------------------------------------------
-    // WARNING: this file is used by both the client and the server.
-    // Do not use any browser or node-specific API!
-    // -------------------------------------------------------------
-    function limitNumber (value, min, max) {
-        return Math.min(Math.max(min, value), max);
-    }
-
-    function determineDimensionBounds(bounds, maximum) {
-        var hasMin = typeof bounds.min === 'number';
-        var hasMax = typeof bounds.max === 'number';
-        var hasLength = typeof bounds.length === 'number';
-        if (hasLength)
-            bounds.length = limitNumber(bounds.length, 0, maximum);
-        if (hasMin && bounds.min < 0)
-            bounds.min += maximum;
-        if (hasMax && bounds.max < 0)
-            bounds.max += maximum;
-        if (!hasMin)
-            bounds.min = hasMax && hasLength ? bounds.max - bounds.length : 0;
-        if (!hasMax)
-            bounds.max = hasLength ? bounds.min + bounds.length : maximum;
-        bounds.min = limitNumber(bounds.min, 0, maximum);
-        bounds.max = limitNumber(bounds.max, 0, maximum);
-        bounds.length = bounds.max - bounds.min;
-        return bounds;
-    }
-    function determineScrollPoint(cropStart, cropEnd, viewportBound) {
-        return Math.round(cropStart + limitNumber(cropEnd - cropStart, 0, viewportBound) / 2);
-    }
-    function ensureCropOptions(element, options) {
-        var elementRectangle = element.getBoundingClientRect();
-        var elementBounds = {
-            left: elementRectangle.left,
-            right: elementRectangle.right,
-            top: elementRectangle.top,
-            bottom: elementRectangle.bottom
+            return this
+                ._scrollElement()
+                .then(function () { return _this._scrollParents(); })
+                .then(function () { return _this.scrollWasPerformed; });
         };
-        var elementMargin = testCafeCore.styleUtils.getElementMargin(element);
-        var elementPadding = testCafeCore.styleUtils.getElementPadding(element);
-        var elementBordersWidth = testCafeCore.styleUtils.getBordersWidth(element);
-        options.originOffset = { x: 0, y: 0 };
-        var scrollRight = elementBounds.left + element.scrollWidth + elementBordersWidth.left + elementBordersWidth.right;
-        var scrollBottom = elementBounds.top + element.scrollHeight + elementBordersWidth.top + elementBordersWidth.bottom;
-        elementBounds.right = Math.max(elementBounds.right, scrollRight);
-        elementBounds.bottom = Math.max(elementBounds.bottom, scrollBottom);
-        if (!options.includeBorders || !options.includePaddings) {
-            options.originOffset.x += elementBordersWidth.left;
-            options.originOffset.y += elementBordersWidth.top;
-            elementBounds.left += elementBordersWidth.left;
-            elementBounds.top += elementBordersWidth.top;
-            elementBounds.right -= elementBordersWidth.right;
-            elementBounds.bottom -= elementBordersWidth.bottom;
-            if (!options.includePaddings) {
-                options.originOffset.x += elementPadding.left;
-                options.originOffset.y += elementPadding.top;
-                elementBounds.left += elementPadding.left;
-                elementBounds.top += elementPadding.top;
-                elementBounds.right -= elementPadding.right;
-                elementBounds.bottom -= elementPadding.bottom;
-            }
-        }
-        else if (options.includeMargins) {
-            options.originOffset.x -= elementMargin.left;
-            options.originOffset.y -= elementMargin.top;
-            elementBounds.left -= elementMargin.left;
-            elementBounds.top -= elementMargin.top;
-            elementBounds.right += elementMargin.right;
-            elementBounds.bottom += elementMargin.bottom;
-        }
-        elementBounds.width = elementBounds.right - elementBounds.left;
-        elementBounds.height = elementBounds.bottom - elementBounds.top;
-        var horizontalCropBounds = determineDimensionBounds({ min: options.crop.left, max: options.crop.right, length: options.crop.width }, elementBounds.width);
-        var verticalCropBounds = determineDimensionBounds({ min: options.crop.top, max: options.crop.bottom, length: options.crop.height }, elementBounds.height);
-        options.crop.left = horizontalCropBounds.min;
-        options.crop.right = horizontalCropBounds.max;
-        options.crop.width = horizontalCropBounds.length;
-        options.crop.top = verticalCropBounds.min;
-        options.crop.bottom = verticalCropBounds.max;
-        options.crop.height = verticalCropBounds.length;
-        if (options.crop.width <= 0 || options.crop.height <= 0)
-            throw new InvalidElementScreenshotDimensionsError(options.crop.width, options.crop.height);
-        var viewportDimensions = testCafeCore.styleUtils.getViewportDimensions();
-        if (elementBounds.width > viewportDimensions.width || elementBounds.height > viewportDimensions.height)
-            options.scrollToCenter = true;
-        var hasScrollTargetX = typeof options.scrollTargetX === 'number';
-        var hasScrollTargetY = typeof options.scrollTargetY === 'number';
-        if (!hasScrollTargetX)
-            options.scrollTargetX = determineScrollPoint(options.crop.left, options.crop.right, viewportDimensions.width);
-        if (!hasScrollTargetY)
-            options.scrollTargetY = determineScrollPoint(options.crop.top, options.crop.bottom, viewportDimensions.height);
-        var _a = testcafeAutomation.getOffsetOptions(element, options.scrollTargetX, options.scrollTargetY), offsetX = _a.offsetX, offsetY = _a.offsetY;
-        options.scrollTargetX = offsetX;
-        options.scrollTargetY = offsetY;
-        var isScrollTargetXValid = !hasScrollTargetX || options.scrollTargetX >= options.crop.left && options.scrollTargetX <= options.crop.right;
-        var isScrollTargetYValid = !hasScrollTargetY || options.scrollTargetY >= options.crop.top && options.scrollTargetY <= options.crop.bottom;
-        if (!isScrollTargetXValid || !isScrollTargetYValid)
-            throw new ActionInvalidScrollTargetError(isScrollTargetXValid, isScrollTargetYValid);
-    }
+        return ScrollAutomation;
+    }());
 
     // -------------------------------------------------------------
     // WARNING: this file is used by both the client and the server.
@@ -3106,90 +3265,1276 @@
                 { name: 'skipDefaultDragBehavior', type: booleanOption }
             ]);
         };
-        return MoveOptions;
-    }(MouseOptions));
-    // Type
-    var TypeOptions = /** @class */ (function (_super) {
-        __extends(TypeOptions, _super);
-        function TypeOptions(obj, validate) {
-            var _this = _super.call(this) || this;
-            _this.replace = false;
-            _this.paste = false;
-            _this._assignFrom(obj, validate);
-            return _this;
-        }
-        TypeOptions.prototype._getAssignableProperties = function () {
-            return _super.prototype._getAssignableProperties.call(this).concat([
-                { name: 'replace', type: booleanOption },
-                { name: 'paste', type: booleanOption }
-            ]);
+        return MoveOptions;
+    }(MouseOptions));
+    // Type
+    var TypeOptions = /** @class */ (function (_super) {
+        __extends(TypeOptions, _super);
+        function TypeOptions(obj, validate) {
+            var _this = _super.call(this) || this;
+            _this.replace = false;
+            _this.paste = false;
+            _this.confidential = void 0;
+            _this._assignFrom(obj, validate);
+            return _this;
+        }
+        TypeOptions.prototype._getAssignableProperties = function () {
+            return _super.prototype._getAssignableProperties.call(this).concat([
+                { name: 'replace', type: booleanOption },
+                { name: 'paste', type: booleanOption },
+                { name: 'confidential', type: booleanOption }
+            ]);
+        };
+        return TypeOptions;
+    }(ClickOptions));
+    // DragToElement
+    var DragToElementOptions = /** @class */ (function (_super) {
+        __extends(DragToElementOptions, _super);
+        function DragToElementOptions(obj, validate) {
+            var _this = _super.call(this, obj, validate) || this;
+            _this.destinationOffsetX = null;
+            _this.destinationOffsetY = null;
+            _this._assignFrom(obj, validate);
+            return _this;
+        }
+        DragToElementOptions.prototype._getAssignableProperties = function () {
+            return _super.prototype._getAssignableProperties.call(this).concat([
+                { name: 'destinationOffsetX', type: integerOption },
+                { name: 'destinationOffsetY', type: integerOption }
+            ]);
+        };
+        return DragToElementOptions;
+    }(MouseOptions));
+    //ResizeToFitDevice
+    var ResizeToFitDeviceOptions = /** @class */ (function (_super) {
+        __extends(ResizeToFitDeviceOptions, _super);
+        function ResizeToFitDeviceOptions(obj, validate) {
+            var _this = _super.call(this) || this;
+            _this.portraitOrientation = false;
+            _this._assignFrom(obj, validate);
+            return _this;
+        }
+        ResizeToFitDeviceOptions.prototype._getAssignableProperties = function () {
+            return [
+                { name: 'portraitOrientation', type: booleanOption }
+            ];
+        };
+        return ResizeToFitDeviceOptions;
+    }(Assignable));
+    //Assertion
+    var AssertionOptions = /** @class */ (function (_super) {
+        __extends(AssertionOptions, _super);
+        function AssertionOptions(obj, validate) {
+            var _this = _super.call(this) || this;
+            _this.timeout = void 0;
+            _this.allowUnawaitedPromise = false;
+            _this._assignFrom(obj, validate);
+            return _this;
+        }
+        AssertionOptions.prototype._getAssignableProperties = function () {
+            return [
+                { name: 'timeout', type: positiveIntegerOption },
+                { name: 'allowUnawaitedPromise', type: booleanOption }
+            ];
+        };
+        return AssertionOptions;
+    }(Assignable));
+    // Press
+    var PressOptions = /** @class */ (function (_super) {
+        __extends(PressOptions, _super);
+        function PressOptions(obj, validate) {
+            var _this = _super.call(this) || this;
+            _this.confidential = void 0;
+            _this._assignFrom(obj, validate);
+            return _this;
+        }
+        PressOptions.prototype._getAssignableProperties = function () {
+            return _super.prototype._getAssignableProperties.call(this).concat([
+                { name: 'confidential', type: booleanOption }
+            ]);
+        };
+        return PressOptions;
+    }(ActionOptions));
+
+    function getPointsDistance(start, end) {
+        return Math.sqrt(Math.pow(end.x - start.x, 2) + Math.pow(end.y - start.y, 2));
+    }
+    function findLineAndRectSideIntersection(startLinePoint, endLinePoint, rectSide) {
+        var intersectionX = null;
+        var haveIntersectionInBounds = null;
+        if (rectSide.isHorizontal) {
+            intersectionX = testCafeCore.positionUtils.getLineXByYCoord(startLinePoint, endLinePoint, rectSide.y1);
+            haveIntersectionInBounds = intersectionX && intersectionX >= rectSide.x1 && intersectionX <= rectSide.x2;
+            return haveIntersectionInBounds ? { x: intersectionX, y: rectSide.y1 } : null;
+        }
+        var intersectionY = testCafeCore.positionUtils.getLineYByXCoord(startLinePoint, endLinePoint, rectSide.x1);
+        haveIntersectionInBounds = intersectionY && intersectionY >= rectSide.y1 && intersectionY <= rectSide.y2;
+        return haveIntersectionInBounds ? { x: rectSide.x1, y: intersectionY } : null;
+    }
+    function getLineRectIntersection (startLinePoint, endLinePoint, rect) {
+        var res = [];
+        var intersection = null;
+        var rectLines = [
+            { x1: rect.left, y1: rect.top, x2: rect.left, y2: rect.bottom, isHorizontal: false },
+            { x1: rect.right, y1: rect.top, x2: rect.right, y2: rect.bottom, isHorizontal: false },
+            { x1: rect.left, y1: rect.top, x2: rect.right, y2: rect.top, isHorizontal: true },
+            { x1: rect.left, y1: rect.bottom, x2: rect.right, y2: rect.bottom, isHorizontal: true } // bottom-side
+        ];
+        for (var i = 0; i < rectLines.length; i++) {
+            intersection = findLineAndRectSideIntersection(startLinePoint, endLinePoint, rectLines[i]);
+            if (intersection)
+                res.push(intersection);
+        }
+        if (!res.length)
+            return null;
+        if (res.length === 1)
+            return res[0];
+        // NOTE: if a line and rect have two intersection points, we return the nearest to startLinePoint
+        return getPointsDistance(startLinePoint, res[0]) < getPointsDistance(startLinePoint, res[1]) ? res[0] : res[1];
+    }
+
+    var Promise$3 = hammerhead__default.Promise;
+    var nativeMethods$5 = hammerhead__default.nativeMethods;
+    function nextTick () {
+        return new Promise$3(function (resolve) { return nativeMethods$5.setTimeout.call(window, resolve, 0); });
+    }
+
+    var DragAndDropState = /** @class */ (function () {
+        function DragAndDropState() {
+            this.enabled = false;
+            this.dropAllowed = false;
+            this.element = null;
+            this.dataTransfer = null;
+            this.dataStore = null;
+        }
+        return DragAndDropState;
+    }());
+
+    var browserUtils$2 = hammerhead__default.utils.browser;
+    var MoveEventSequenceBase = /** @class */ (function () {
+        function MoveEventSequenceBase(_a) {
+            var moveEvent = _a.moveEvent;
+            this.dragAndDropMode = false;
+            this.dropAllowed = false;
+            this.moveEvent = moveEvent;
+        }
+        MoveEventSequenceBase.prototype.setup = function () {
+            this.dragAndDropMode = false;
+            this.dropAllowed = false;
+        };
+        MoveEventSequenceBase.prototype.leaveElement = function ( /* currentElement, prevElement, commonAncestor, options */) {
+        };
+        MoveEventSequenceBase.prototype.move = function ( /* element, options */) {
+        };
+        MoveEventSequenceBase.prototype.enterElement = function ( /* currentElement, prevElement, commonAncestor, options */) {
+        };
+        MoveEventSequenceBase.prototype.dragAndDrop = function ( /* dragElement, currentElement, prevElement, options, dragDataStore */) {
+        };
+        MoveEventSequenceBase.prototype.teardown = function ( /* currentElement, eventOptions, prevElement */) {
+        };
+        MoveEventSequenceBase.prototype.run = function (currentElement, prevElement, options, dragElement, dragDataStore) {
+            // NOTE: if last hovered element was in an iframe that has been removed, IE
+            // raises an exception when we try to compare it with the current element
+            var prevElementInDocument = prevElement && testCafeCore.domUtils.isElementInDocument(prevElement);
+            var prevElementInRemovedIframe = prevElement && testCafeCore.domUtils.isElementInIframe(prevElement) &&
+                !testCafeCore.domUtils.getIframeByElement(prevElement);
+            if (!prevElementInDocument || prevElementInRemovedIframe)
+                prevElement = null;
+            var elementChanged = currentElement !== prevElement;
+            var commonAncestor = elementChanged ? testCafeCore.domUtils.getCommonAncestor(currentElement, prevElement) : null;
+            this.setup();
+            if (elementChanged && !!prevElement)
+                this.leaveElement(currentElement, prevElement, commonAncestor, options);
+            if (browserUtils$2.isIE)
+                this.move(currentElement, options);
+            if (elementChanged && testCafeCore.domUtils.isElementInDocument(currentElement))
+                this.enterElement(currentElement, prevElement, commonAncestor, options);
+            if (!browserUtils$2.isIE)
+                this.move(currentElement, options);
+            this.dragAndDrop(dragElement, currentElement, prevElement, options, dragDataStore);
+            this.teardown(currentElement, options, prevElement);
+            var dragAndDropMode = this.dragAndDropMode;
+            var dropAllowed = this.dropAllowed;
+            this.dragAndDropMode = false;
+            this.dropAllowed = false;
+            return { dragAndDropMode: dragAndDropMode, dropAllowed: dropAllowed };
+        };
+        return MoveEventSequenceBase;
+    }());
+
+    var eventSimulator = hammerhead__default.eventSandbox.eventSimulator;
+    var extend = hammerhead__default.utils.extend;
+    var nativeMethods$6 = hammerhead__default.nativeMethods;
+    var MoveBehaviour = /** @class */ (function () {
+        function MoveBehaviour() {
+        }
+        MoveBehaviour.leaveElement = function (currentElement, prevElement, commonAncestor, options) {
+            eventSimulator.mouseout(prevElement, extend({ relatedTarget: currentElement }, options));
+            var currentParent = prevElement;
+            while (currentParent && currentParent !== commonAncestor) {
+                eventSimulator.mouseleave(currentParent, extend({ relatedTarget: currentElement }, options));
+                currentParent = nativeMethods$6.nodeParentNodeGetter.call(currentParent);
+            }
+        };
+        MoveBehaviour.enterElement = function (currentElement, prevElement, commonAncestor, options) {
+            eventSimulator.mouseover(currentElement, extend({ relatedTarget: prevElement }, options));
+            var currentParent = currentElement;
+            var mouseenterElements = [];
+            while (currentParent && currentParent !== commonAncestor) {
+                mouseenterElements.push(currentParent);
+                currentParent = testCafeCore.domUtils.getParentExceptShadowRoot(currentParent);
+            }
+            for (var i = mouseenterElements.length - 1; i > -1; i--)
+                eventSimulator.mouseenter(mouseenterElements[i], extend({ relatedTarget: prevElement }, options));
+        };
+        MoveBehaviour.move = function (moveEvent, element, options) {
+            eventSimulator[moveEvent](element, options);
+        };
+        return MoveBehaviour;
+    }());
+    var DragAndDropBehavior = /** @class */ (function () {
+        function DragAndDropBehavior() {
+        }
+        DragAndDropBehavior.dragAndDrop = function (dragElement, currentElement, prevElement, options) {
+            eventSimulator.drag(dragElement, options);
+            var currentElementChanged = currentElement !== prevElement;
+            if (currentElementChanged) {
+                if (testCafeCore.domUtils.isElementInDocument(currentElement)) {
+                    options.relatedTarget = prevElement;
+                    eventSimulator.dragenter(currentElement, options);
+                }
+                if (prevElement) {
+                    options.relatedTarget = currentElement;
+                    eventSimulator.dragleave(prevElement, options);
+                }
+            }
+            return !eventSimulator.dragover(currentElement, options);
+        };
+        return DragAndDropBehavior;
+    }());
+
+    var eventSimulator$1 = hammerhead__default.eventSandbox.eventSimulator;
+    var TOUCH_MOVE_EVENT_NAME = 'touchmove';
+    var MoveEventSequence = /** @class */ (function (_super) {
+        __extends(MoveEventSequence, _super);
+        function MoveEventSequence(options) {
+            var _this = _super.call(this, options) || this;
+            _this.holdLeftButton = options.holdLeftButton;
+            return _this;
+        }
+        MoveEventSequence.prototype.leaveElement = function (currentElement, prevElement, commonAncestor, options) {
+            MoveBehaviour.leaveElement(currentElement, prevElement, commonAncestor, options);
+        };
+        MoveEventSequence.prototype.enterElement = function (currentElement, prevElement, commonAncestor, options) {
+            MoveBehaviour.enterElement(currentElement, prevElement, commonAncestor, options);
+        };
+        MoveEventSequence.prototype.move = function (element, options) {
+            if (this._needEmulateMoveEvent())
+                MoveBehaviour.move(this.moveEvent, element, options);
+        };
+        MoveEventSequence.prototype.teardown = function (currentElement, eventOptions, prevElement) {
+            // NOTE: we need to add an extra 'mousemove' if the element was changed because sometimes
+            // the client script requires several 'mousemove' events for an element (T246904)
+            if (this._needEmulateMoveEvent() && testCafeCore.domUtils.isElementInDocument(currentElement) && currentElement !== prevElement)
+                eventSimulator$1[this.moveEvent](currentElement, eventOptions);
+        };
+        MoveEventSequence.prototype._needEmulateMoveEvent = function () {
+            return this.moveEvent !== TOUCH_MOVE_EVENT_NAME || this.holdLeftButton;
+        };
+        return MoveEventSequence;
+    }(MoveEventSequenceBase));
+
+    var DragAndDropMoveEventSequence = /** @class */ (function (_super) {
+        __extends(DragAndDropMoveEventSequence, _super);
+        function DragAndDropMoveEventSequence() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        DragAndDropMoveEventSequence.prototype.setup = function () {
+            _super.prototype.setup.call(this);
+            this.dragAndDropMode = true;
+        };
+        DragAndDropMoveEventSequence.prototype.dragAndDrop = function (dragElement, currentElement, prevElement, options) {
+            this.dropAllowed = DragAndDropBehavior.dragAndDrop(dragElement, currentElement, prevElement, options);
+        };
+        return DragAndDropMoveEventSequence;
+    }(MoveEventSequenceBase));
+
+    var eventSimulator$2 = hammerhead__default.eventSandbox.eventSimulator;
+    var DragAndDropFirstMoveEventSequence = /** @class */ (function (_super) {
+        __extends(DragAndDropFirstMoveEventSequence, _super);
+        function DragAndDropFirstMoveEventSequence() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        DragAndDropFirstMoveEventSequence.prototype.setup = function () {
+            _super.prototype.setup.call(this);
+            this.dragAndDropMode = true;
+        };
+        DragAndDropFirstMoveEventSequence.prototype.leaveElement = function (currentElement, prevElement, commonAncestor, options) {
+            MoveBehaviour.leaveElement(currentElement, prevElement, commonAncestor, options);
+        };
+        DragAndDropFirstMoveEventSequence.prototype.move = function (element, option) {
+            MoveBehaviour.move(this.moveEvent, element, option);
+        };
+        DragAndDropFirstMoveEventSequence.prototype.enterElement = function (currentElement, prevElement, commonAncestor, options) {
+            MoveBehaviour.enterElement(currentElement, prevElement, commonAncestor, options);
+        };
+        DragAndDropFirstMoveEventSequence.prototype.dragAndDrop = function (dragElement, currentElement, prevElement, options, dragDataStore) {
+            var dragAllowed = eventSimulator$2.dragstart(dragElement, options);
+            dragDataStore.setReadOnlyMode();
+            if (!dragAllowed) {
+                this.dragAndDropMode = false;
+                return;
+            }
+            this.dropAllowed = DragAndDropBehavior.dragAndDrop(dragElement, currentElement, prevElement, options);
+        };
+        DragAndDropFirstMoveEventSequence.prototype.run = function (currentElement, prevElement, options, dragElement, dragDataStore) {
+            return _super.prototype.run.call(this, currentElement, null, options, dragElement, dragDataStore);
+        };
+        return DragAndDropFirstMoveEventSequence;
+    }(MoveEventSequenceBase));
+
+    function createEventSequence(dragAndDropEnabled, firstMovingStepOccured, options) {
+        if (!dragAndDropEnabled)
+            return new MoveEventSequence(options);
+        if (firstMovingStepOccured)
+            return new DragAndDropMoveEventSequence(options);
+        return new DragAndDropFirstMoveEventSequence(options);
+    }
+
+    var lastHoveredElement = null;
+    var lastHoveredElementHolder = {
+        get: function () {
+            return lastHoveredElement;
+        },
+        set: function (element) {
+            lastHoveredElement = element;
+        }
+    };
+
+    var Promise$4 = hammerhead__default.Promise;
+    var nativeMethods$7 = hammerhead__default.nativeMethods;
+    var featureDetection = hammerhead__default.utils.featureDetection;
+    var htmlUtils = hammerhead__default.utils.html;
+    var urlUtils = hammerhead__default.utils.url;
+    var eventSimulator$3 = hammerhead__default.eventSandbox.eventSimulator;
+    var messageSandbox$2 = hammerhead__default.eventSandbox.message;
+    var DataTransfer = hammerhead__default.eventSandbox.DataTransfer;
+    var DragDataStore = hammerhead__default.eventSandbox.DragDataStore;
+    var positionUtils$1 = testCafeCore__default.positionUtils;
+    var domUtils$2 = testCafeCore__default.domUtils;
+    var styleUtils = testCafeCore__default.styleUtils;
+    var eventUtils = testCafeCore__default.eventUtils;
+    var promiseUtils = testCafeCore__default.promiseUtils;
+    var sendRequestToFrame = testCafeCore__default.sendRequestToFrame;
+    var MOVE_REQUEST_CMD = 'automation|move|request';
+    var MOVE_RESPONSE_CMD = 'automation|move|response';
+    // Setup cross-iframe interaction
+    messageSandbox$2.on(messageSandbox$2.SERVICE_MSG_RECEIVED_EVENT, function (e) {
+        if (e.message.cmd === MOVE_REQUEST_CMD) {
+            if (e.source.parent === window)
+                MoveAutomation.onMoveToIframeRequest(e);
+            else {
+                hammerhead__default.on(hammerhead__default.EVENTS.beforeUnload, function () { return messageSandbox$2.sendServiceMsg({ cmd: MOVE_RESPONSE_CMD }, e.source); });
+                MoveAutomation.onMoveOutRequest(e);
+            }
+        }
+    });
+    // Utils
+    function findDraggableElement(element) {
+        var parentNode = element;
+        while (parentNode) {
+            if (parentNode.draggable)
+                return parentNode;
+            parentNode = nativeMethods$7.nodeParentNodeGetter.call(parentNode);
+        }
+        return null;
+    }
+    var MoveAutomation = /** @class */ (function () {
+        function MoveAutomation(element, moveOptions) {
+            this.touchMode = featureDetection.isTouchDevice;
+            this.moveEvent = this.touchMode ? 'touchmove' : 'mousemove';
+            this.holdLeftButton = moveOptions.holdLeftButton;
+            this.dragElement = null;
+            this.dragAndDropState = new DragAndDropState();
+            this.automationSettings = new AutomationSettings(moveOptions.speed);
+            var target = MoveAutomation.getTarget(element, moveOptions.offsetX, moveOptions.offsetY);
+            this.element = target.element;
+            this.offsetX = target.offsetX;
+            this.offsetY = target.offsetY;
+            this.speed = moveOptions.speed;
+            this.cursorSpeed = this.holdLeftButton ? this.automationSettings.draggingSpeed : this.automationSettings.cursorSpeed;
+            this.minMovingTime = moveOptions.minMovingTime || null;
+            this.modifiers = moveOptions.modifiers || {};
+            this.skipScrolling = moveOptions.skipScrolling;
+            this.skipDefaultDragBehavior = moveOptions.skipDefaultDragBehavior;
+            this.endPoint = null;
+            // moving state
+            this.movingTime = null;
+            this.x = null;
+            this.y = null;
+            this.startTime = null;
+            this.endTime = null;
+            this.distanceX = null;
+            this.distanceY = null;
+            this.firstMovingStepOccured = false;
+        }
+        MoveAutomation.getTarget = function (el, offsetX, offsetY) {
+            // NOTE: if the target point (considering offsets) is out of
+            // the element change the target element to the document element
+            var relateToDocument = !positionUtils$1.containsOffset(el, offsetX, offsetY);
+            var relatedPoint = relateToDocument ? getAutomationPoint(el, offsetX, offsetY) : { x: offsetX, y: offsetY };
+            return {
+                element: relateToDocument ? document.documentElement : el,
+                offsetX: relatedPoint.x,
+                offsetY: relatedPoint.y
+            };
+        };
+        MoveAutomation.onMoveToIframeRequest = function (e) {
+            var iframePoint = {
+                x: e.message.endX,
+                y: e.message.endY
+            };
+            var iframeWin = e.source;
+            var iframe = domUtils$2.findIframeByWindow(iframeWin);
+            var iframeBorders = styleUtils.getBordersWidth(iframe);
+            var iframePadding = styleUtils.getElementPadding(iframe);
+            var iframeRectangle = positionUtils$1.getIframeClientCoordinates(iframe);
+            var iframePointRelativeToParent = positionUtils$1.getIframePointRelativeToParentFrame(iframePoint, iframeWin);
+            var cursorPosition = cursor.position;
+            var intersectionPoint = positionUtils$1.isInRectangle(cursorPosition, iframeRectangle) ? cursorPosition :
+                getLineRectIntersection(cursorPosition, iframePointRelativeToParent, iframeRectangle);
+            var intersectionRelatedToIframe = {
+                x: intersectionPoint.x - iframeRectangle.left,
+                y: intersectionPoint.y - iframeRectangle.top
+            };
+            var moveOptions = new MoveOptions({
+                modifiers: e.message.modifiers,
+                offsetX: intersectionRelatedToIframe.x + iframeBorders.left + iframePadding.left,
+                offsetY: intersectionRelatedToIframe.y + iframeBorders.top + iframePadding.top,
+                speed: e.message.speed,
+                // NOTE: we should not perform scrolling because the active window was
+                // already scrolled to the target element before the request (GH-847)
+                skipScrolling: true
+            }, false);
+            var moveAutomation = new MoveAutomation(iframe, moveOptions);
+            var responseMsg = {
+                cmd: MOVE_RESPONSE_CMD,
+                x: intersectionRelatedToIframe.x,
+                y: intersectionRelatedToIframe.y
+            };
+            if (cursor.activeWindow !== iframeWin) {
+                moveAutomation
+                    .run()
+                    .then(function () {
+                    cursor.activeWindow = iframeWin;
+                    messageSandbox$2.sendServiceMsg(responseMsg, iframeWin);
+                });
+            }
+            else
+                messageSandbox$2.sendServiceMsg(responseMsg, iframeWin);
+        };
+        MoveAutomation.onMoveOutRequest = function (e) {
+            var parentWin = e.source;
+            var iframeRectangle = {
+                left: e.message.left,
+                right: e.message.right,
+                top: e.message.top,
+                bottom: e.message.bottom
+            };
+            if (!e.message.iframeUnderCursor) {
+                var _a = e.message, startX = _a.startX, startY = _a.startY;
+                var clientX = startX - iframeRectangle.left;
+                var clientY = startY - iframeRectangle.top;
+                // NOTE: We should not emulate mouseout and mouseleave if iframe was reloaded.
+                var element = lastHoveredElementHolder.get();
+                if (element) {
+                    eventSimulator$3.mouseout(element, { clientX: clientX, clientY: clientY, relatedTarget: null });
+                    eventSimulator$3.mouseleave(element, { clientX: clientX, clientY: clientY, relatedTarget: null });
+                }
+                messageSandbox$2.sendServiceMsg({ cmd: MOVE_RESPONSE_CMD }, parentWin);
+                return;
+            }
+            var cursorPosition = cursor.position;
+            var startPoint = {
+                x: iframeRectangle.left + cursorPosition.x,
+                y: iframeRectangle.top + cursorPosition.y
+            };
+            var endPoint = { x: e.message.endX, y: e.message.endY };
+            var intersectionPoint = getLineRectIntersection(startPoint, endPoint, iframeRectangle);
+            // NOTE: We should not move the cursor out of the iframe if
+            // the cursor path does not intersect with the iframe borders.
+            if (!intersectionPoint) {
+                messageSandbox$2.sendServiceMsg({
+                    cmd: MOVE_RESPONSE_CMD,
+                    x: iframeRectangle.left,
+                    y: iframeRectangle.top
+                }, parentWin);
+                return;
+            }
+            var moveOptions = new MoveOptions({
+                modifiers: e.message.modifiers,
+                offsetX: intersectionPoint.x - iframeRectangle.left,
+                offsetY: intersectionPoint.y - iframeRectangle.top,
+                speed: e.message.speed,
+                // NOTE: we should not perform scrolling because the active window was
+                // already scrolled to the target element before the request (GH-847)
+                skipScrolling: true
+            }, false);
+            var moveAutomation = new MoveAutomation(document.documentElement, moveOptions);
+            moveAutomation
+                .run()
+                .then(function () {
+                var responseMsg = {
+                    cmd: MOVE_RESPONSE_CMD,
+                    x: intersectionPoint.x,
+                    y: intersectionPoint.y
+                };
+                cursor.activeWindow = parentWin;
+                messageSandbox$2.sendServiceMsg(responseMsg, parentWin);
+            });
+        };
+        MoveAutomation.prototype._getTargetClientPoint = function () {
+            var scroll = styleUtils.getElementScroll(this.element);
+            if (domUtils$2.isHtmlElement(this.element)) {
+                return {
+                    x: Math.floor(this.offsetX - scroll.left),
+                    y: Math.floor(this.offsetY - scroll.top)
+                };
+            }
+            var clientPosition = positionUtils$1.getClientPosition(this.element);
+            var isDocumentBody = this.element.tagName && domUtils$2.isBodyElement(this.element);
+            return {
+                x: Math.floor(isDocumentBody ? clientPosition.x + this.offsetX : clientPosition.x + this.offsetX -
+                    scroll.left),
+                y: Math.floor(isDocumentBody ? clientPosition.y + this.offsetY : clientPosition.y + this.offsetY -
+                    scroll.top)
+            };
+        };
+        MoveAutomation.prototype._emulateEvents = function (currentElement) {
+            var button = this.holdLeftButton ? eventUtils.BUTTONS_PARAMETER.leftButton : eventUtils.BUTTONS_PARAMETER.noButton;
+            var devicePoint = getDevicePoint({ x: this.x, y: this.y });
+            var eventOptions = {
+                clientX: this.x,
+                clientY: this.y,
+                screenX: devicePoint.x,
+                screenY: devicePoint.y,
+                buttons: button,
+                ctrl: this.modifiers.ctrl,
+                alt: this.modifiers.alt,
+                shift: this.modifiers.shift,
+                meta: this.modifiers.meta,
+                dataTransfer: this.dragAndDropState.dataTransfer
+            };
+            var eventSequenceOptions = { moveEvent: this.moveEvent, holdLeftButton: this.holdLeftButton };
+            var eventSequence = createEventSequence(this.dragAndDropState.enabled, this.firstMovingStepOccured, eventSequenceOptions);
+            var _a = eventSequence.run(currentElement, lastHoveredElementHolder.get(), eventOptions, this.dragElement, this.dragAndDropState.dataStore), dragAndDropMode = _a.dragAndDropMode, dropAllowed = _a.dropAllowed;
+            this.firstMovingStepOccured = true;
+            this.dragAndDropState.enabled = dragAndDropMode;
+            this.dragAndDropState.dropAllowed = dropAllowed;
+            lastHoveredElementHolder.set(currentElement);
+        };
+        MoveAutomation.prototype._movingStep = function () {
+            var _this = this;
+            if (this.touchMode && !this.holdLeftButton) {
+                this.x = this.endPoint.x;
+                this.y = this.endPoint.y;
+            }
+            else if (!this.startTime) {
+                this.startTime = nativeMethods$7.dateNow();
+                this.endTime = this.startTime + this.movingTime;
+                // NOTE: the mousemove event can't be simulated at the point where the cursor
+                // was located at the start. Therefore, we add a minimal distance 1 px.
+                this.x += this.distanceX > 0 ? 1 : -1;
+                this.y += this.distanceY > 0 ? 1 : -1;
+            }
+            else {
+                var currentTime = Math.min(nativeMethods$7.dateNow(), this.endTime);
+                var progress = (currentTime - this.startTime) / (this.endTime - this.startTime);
+                this.x = Math.floor(this.startPoint.x + this.distanceX * progress);
+                this.y = Math.floor(this.startPoint.y + this.distanceY * progress);
+            }
+            return cursor
+                .move(this.x, this.y)
+                .then(underCursor)
+                // NOTE: in touch mode, events are simulated for the element for which mousedown was simulated (GH-372)
+                .then(function (topElement) {
+                var currentElement = _this.holdLeftButton && _this.touchMode ? _this.dragElement : topElement;
+                // NOTE: it can be null in IE
+                if (!currentElement)
+                    return null;
+                return _this._emulateEvents(currentElement);
+            })
+                .then(nextTick);
+        };
+        MoveAutomation.prototype._isMovingFinished = function () {
+            return this.x === this.endPoint.x && this.y === this.endPoint.y;
+        };
+        MoveAutomation.prototype._move = function () {
+            var _this = this;
+            this.startPoint = cursor.position;
+            this.x = this.startPoint.x;
+            this.y = this.startPoint.y;
+            this.distanceX = this.endPoint.x - this.startPoint.x;
+            this.distanceY = this.endPoint.y - this.startPoint.y;
+            this.movingTime = Math.max(Math.abs(this.distanceX), Math.abs(this.distanceY)) / this.cursorSpeed;
+            if (this.minMovingTime)
+                this.movingTime = Math.max(this.movingTime, this.minMovingTime);
+            return promiseUtils.whilst(function () { return !_this._isMovingFinished(); }, function () { return _this._movingStep(); });
+        };
+        MoveAutomation.prototype._scroll = function () {
+            if (this.skipScrolling)
+                return Promise$4.resolve();
+            var scrollOptions = new ScrollOptions({ offsetX: this.offsetX, offsetY: this.offsetY }, false);
+            var scrollAutomation = new ScrollAutomation(this.element, scrollOptions);
+            return scrollAutomation.run();
+        };
+        MoveAutomation.prototype._moveToCurrentFrame = function () {
+            if (cursor.active)
+                return Promise$4.resolve();
+            var _a = cursor.position, x = _a.x, y = _a.y;
+            var activeWindow = cursor.activeWindow;
+            var iframe = null;
+            var iframeUnderCursor = null;
+            var iframeRectangle = null;
+            var msg = {
+                cmd: MOVE_REQUEST_CMD,
+                startX: x,
+                startY: y,
+                endX: this.endPoint.x,
+                endY: this.endPoint.y,
+                modifiers: this.modifiers,
+                speed: this.speed
+            };
+            if (activeWindow.parent === window) {
+                iframe = domUtils$2.findIframeByWindow(activeWindow);
+                iframeRectangle = positionUtils$1.getIframeClientCoordinates(iframe);
+                msg.left = iframeRectangle.left;
+                msg.top = iframeRectangle.top;
+                msg.right = iframeRectangle.right;
+                msg.bottom = iframeRectangle.bottom;
+            }
+            return underCursor()
+                .then(function (topElement) {
+                iframeUnderCursor = topElement === iframe;
+                if (activeWindow.parent === window)
+                    msg.iframeUnderCursor = iframeUnderCursor;
+                return sendRequestToFrame(msg, MOVE_RESPONSE_CMD, activeWindow);
+            })
+                .then(function (message) {
+                cursor.activeWindow = window;
+                if (iframeUnderCursor || isIframeWindow(window))
+                    return cursor.move(message.x, message.y);
+                return null;
+            });
+        };
+        MoveAutomation.prototype.run = function () {
+            var _this = this;
+            return underCursor()
+                .then(function (topElement) {
+                _this.dragElement = _this.holdLeftButton ? topElement : null;
+                var draggable = findDraggableElement(_this.dragElement);
+                // NOTE: we should skip simulating drag&drop's native behavior if the mousedown event was prevented (GH - 2529)
+                if (draggable && featureDetection.hasDataTransfer && !_this.skipDefaultDragBehavior) {
+                    _this.dragAndDropState.enabled = true;
+                    _this.dragElement = draggable;
+                    _this.dragAndDropState.element = _this.dragElement;
+                    _this.dragAndDropState.dataStore = new DragDataStore();
+                    _this.dragAndDropState.dataTransfer = new DataTransfer(_this.dragAndDropState.dataStore);
+                    var isLink = domUtils$2.isAnchorElement(_this.dragElement);
+                    if (isLink || domUtils$2.isImgElement(_this.dragElement)) {
+                        var srcAttr = isLink ? 'href' : 'src';
+                        var parsedUrl = urlUtils.parseProxyUrl(_this.dragElement[srcAttr]);
+                        var src = parsedUrl ? parsedUrl.destUrl : _this.dragElement[srcAttr];
+                        var outerHTML = htmlUtils.cleanUpHtml(nativeMethods$7.elementOuterHTMLGetter.call(_this.dragElement));
+                        _this.dragAndDropState.dataTransfer.setData('text/plain', src);
+                        _this.dragAndDropState.dataTransfer.setData('text/uri-list', src);
+                        _this.dragAndDropState.dataTransfer.setData('text/html', outerHTML);
+                    }
+                }
+                return _this._scroll();
+            })
+                .then(function () {
+                var _a = _this._getTargetClientPoint(), x = _a.x, y = _a.y;
+                var windowWidth = styleUtils.getWidth(window);
+                var windowHeight = styleUtils.getHeight(window);
+                if (x >= 0 && x <= windowWidth && y >= 0 && y <= windowHeight) {
+                    _this.endPoint = { x: x, y: y };
+                    return _this
+                        ._moveToCurrentFrame()
+                        .then(function () { return _this._move(); });
+                }
+                return null;
+            })
+                .then(function () { return _this.dragAndDropState; });
+        };
+        return MoveAutomation;
+    }());
+
+    var extend$1 = hammerhead__default.utils.extend;
+    var ElementState = /** @class */ (function () {
+        function ElementState(_a) {
+            var _b = _a.element, element = _b === void 0 ? null : _b, _c = _a.clientPoint, clientPoint = _c === void 0 ? null : _c, _d = _a.screenPoint, screenPoint = _d === void 0 ? null : _d, _e = _a.isTarget, isTarget = _e === void 0 ? false : _e, _f = _a.inMoving, inMoving = _f === void 0 ? false : _f;
+            this.element = element;
+            this.clientPoint = clientPoint;
+            this.screenPoint = screenPoint;
+            this.isTarget = isTarget;
+            this.inMoving = inMoving;
+            this.devicePoint = getDevicePoint(clientPoint);
+        }
+        return ElementState;
+    }());
+    var VisibleElementAutomation = /** @class */ (function (_super) {
+        __extends(VisibleElementAutomation, _super);
+        function VisibleElementAutomation(element, offsetOptions) {
+            var _this = _super.call(this) || this;
+            _this.TARGET_ELEMENT_FOUND_EVENT = 'automation|target-element-found-event';
+            _this.element = element;
+            _this.options = offsetOptions;
+            _this.automationSettings = new AutomationSettings(offsetOptions.speed);
+            return _this;
+        }
+        VisibleElementAutomation.prototype._getElementForEvent = function (eventArgs) {
+            var _a = eventArgs.point, x = _a.x, y = _a.y;
+            var expectedElement = testCafeCore.positionUtils.containsOffset(this.element, this.options.offsetX, this.options.offsetY) ? this.element : null;
+            return fromPoint(x, y, expectedElement).then(function (_a) {
+                var element = _a.element;
+                return element;
+            });
+        };
+        VisibleElementAutomation.prototype._moveToElement = function () {
+            var _this = this;
+            var moveOptions = new MoveOptions(extend$1({ skipScrolling: true }, this.options), false);
+            var moveAutomation = new MoveAutomation(this.element, moveOptions);
+            return moveAutomation
+                .run()
+                .then(function () { return testCafeCore.delay(_this.automationSettings.mouseActionStepDelay); });
+        };
+        VisibleElementAutomation.prototype._scrollToElement = function () {
+            var _this = this;
+            var scrollOptions = new ScrollOptions(this.options);
+            var scrollAutomation = new ScrollAutomation(this.element, scrollOptions);
+            var wasScrolled = false;
+            return scrollAutomation
+                .run()
+                .then(function (scrollWasPerformed) {
+                wasScrolled = scrollWasPerformed;
+                return testCafeCore.delay(_this.automationSettings.mouseActionStepDelay);
+            })
+                .then(underCursor)
+                .then(function (currentElement) {
+                var elementUnderCursorContainsTarget = !!currentElement && testCafeCore.domUtils.contains(_this.element, currentElement);
+                if (!elementUnderCursorContainsTarget || !wasScrolled)
+                    return null;
+                var prevElement = lastHoveredElementHolder.get();
+                var commonAncestor = testCafeCore.domUtils.getCommonAncestor(currentElement, prevElement);
+                var clientPosition = testCafeCore.positionUtils.getClientPosition(currentElement);
+                var devicePoint = getDevicePoint({ x: clientPosition.x, y: clientPosition.y });
+                var options = {
+                    clientX: clientPosition.x,
+                    clientY: clientPosition.y,
+                    screenX: devicePoint.x,
+                    screenY: devicePoint.y,
+                    ctrl: false,
+                    alt: false,
+                    shift: false,
+                    meta: false,
+                    buttons: testCafeCore.eventUtils.BUTTONS_PARAMETER.leftButton
+                };
+                MoveBehaviour.leaveElement(currentElement, prevElement, commonAncestor, options);
+                MoveBehaviour.enterElement(currentElement, prevElement, commonAncestor, options);
+                lastHoveredElementHolder.set(currentElement);
+                return wasScrolled;
+            });
+        };
+        VisibleElementAutomation.prototype._getElementOffset = function () {
+            var defaultOffsets = getOffsetOptions(this.element);
+            var _a = this.options, offsetX = _a.offsetX, offsetY = _a.offsetY;
+            offsetX = offsetX || offsetX === 0 ? offsetX : defaultOffsets.offsetX;
+            offsetY = offsetY || offsetY === 0 ? offsetY : defaultOffsets.offsetY;
+            return { offsetX: offsetX, offsetY: offsetY };
+        };
+        VisibleElementAutomation.prototype._wrapAction = function (action) {
+            var _this = this;
+            var _a = this._getElementOffset(), offsetX = _a.offsetX, offsetY = _a.offsetY;
+            var screenPointBeforeAction = getAutomationPoint(this.element, offsetX, offsetY);
+            var clientPositionBeforeAction = testCafeCore.positionUtils.getClientPosition(this.element);
+            return action()
+                .then(function () {
+                var screenPointAfterAction = getAutomationPoint(_this.element, offsetX, offsetY);
+                var clientPositionAfterAction = testCafeCore.positionUtils.getClientPosition(_this.element);
+                var clientPoint = convertToClient(_this.element, screenPointAfterAction);
+                var expectedElement = testCafeCore.positionUtils.containsOffset(_this.element, offsetX, offsetY) ? _this.element : null;
+                return fromPoint(clientPoint.x, clientPoint.y, expectedElement)
+                    .then(function (_a) {
+                    var element = _a.element, corrected = _a.corrected;
+                    var foundElement = element;
+                    if (!foundElement)
+                        return new ElementState({});
+                    var isTarget = !expectedElement || corrected || foundElement === _this.element;
+                    if (!isTarget) {
+                        // NOTE: perform an operation with searching in dom only if necessary
+                        isTarget = testCafeCore.arrayUtils.indexOf(testCafeCore.domUtils.getParents(foundElement), _this.element) > -1;
+                    }
+                    var offsetPositionChanged = screenPointBeforeAction.x !== screenPointAfterAction.x ||
+                        screenPointBeforeAction.y !== screenPointAfterAction.y;
+                    var clientPositionChanged = clientPositionBeforeAction.x !== clientPositionAfterAction.x ||
+                        clientPositionBeforeAction.y !== clientPositionAfterAction.y;
+                    // NOTE: We consider the element moved if its offset position and client position
+                    // are changed both. If only client position was changed it means the page was
+                    // scrolled and the element keeps its position on the page. If only offset position was
+                    // changed it means the element is fixed on the page (it can be implemented via script).
+                    var targetElementIsMoving = offsetPositionChanged && clientPositionChanged;
+                    return new ElementState({
+                        element: element,
+                        clientPoint: clientPoint,
+                        screenPoint: screenPointAfterAction,
+                        isTarget: isTarget,
+                        inMoving: targetElementIsMoving
+                    });
+                });
+            });
+        };
+        VisibleElementAutomation._checkElementState = function (state, useStrictElementCheck) {
+            if (!state.element)
+                throw new Error(AUTOMATION_ERROR_TYPES.elementIsInvisibleError);
+            if (useStrictElementCheck && (!state.isTarget || state.inMoving))
+                throw new Error(AUTOMATION_ERROR_TYPES.foundElementIsNotTarget);
+            return state;
+        };
+        VisibleElementAutomation.prototype._ensureElement = function (useStrictElementCheck, skipCheckAfterMoving, skipMoving) {
+            var _this = this;
+            return this
+                ._wrapAction(function () { return _this._scrollToElement(); })
+                .then(function (state) { return VisibleElementAutomation._checkElementState(state, useStrictElementCheck); })
+                .then(function (state) {
+                return skipMoving ? state : _this._wrapAction(function () { return _this._moveToElement(); });
+            })
+                .then(function (state) {
+                if (!skipCheckAfterMoving)
+                    VisibleElementAutomation._checkElementState(state, useStrictElementCheck);
+                return state;
+            })
+                .then(function (state) {
+                _this.emit(_this.TARGET_ELEMENT_FOUND_EVENT, { element: state.element });
+                return {
+                    element: state.element,
+                    clientPoint: state.clientPoint,
+                    screenPoint: state.screenPoint,
+                    devicePoint: state.devicePoint
+                };
+            });
+        };
+        return VisibleElementAutomation;
+    }(testCafeCore.serviceUtils.EventEmitter));
+
+    var Promise$5 = hammerhead__default.Promise;
+    function calculatePosition(el, position) {
+        var centerX = Math.floor(el.scrollWidth / 2 - el.clientWidth / 2);
+        var centerY = Math.floor(el.scrollHeight / 2 - el.clientHeight / 2);
+        var positions = {
+            'top': [centerX, 0],
+            'right': [el.scrollWidth, centerY],
+            'bottom': [centerX, el.scrollHeight],
+            'left': [0, centerY],
+            'topRight': [el.scrollWidth, 0],
+            'topLeft': [0, 0],
+            'bottomRight': [el.scrollWidth, el.scrollHeight],
+            'bottomLeft': [0, el.scrollHeight],
+            'center': [centerX, centerY],
+        };
+        return positions[position];
+    }
+    var SetScrollAutomation = /** @class */ (function (_super) {
+        __extends(SetScrollAutomation, _super);
+        function SetScrollAutomation(element, _a, offsetOptions) {
+            var _b;
+            var x = _a.x, y = _a.y, position = _a.position, byX = _a.byX, byY = _a.byY;
+            var _this = _super.call(this, element, offsetOptions) || this;
+            if (position)
+                _b = calculatePosition(element, position), x = _b[0], y = _b[1];
+            _this.scrollLeft = typeof x === 'number' ? x : element.scrollLeft;
+            _this.scrollTop = typeof y === 'number' ? y : element.scrollTop;
+            if (byX)
+                _this.scrollLeft += byX;
+            if (byY)
+                _this.scrollTop += byY;
+            return _this;
+        }
+        SetScrollAutomation.prototype.run = function (useStrictElementCheck) {
+            var _this = this;
+            var promise = Promise$5.resolve();
+            if (this.element !== document.scrollingElement && this.element !== document.documentElement)
+                promise = this._ensureElement(useStrictElementCheck, true, true);
+            return promise
+                .then(function () {
+                _this.element.scrollLeft = _this.scrollLeft;
+                _this.element.scrollTop = _this.scrollTop;
+            });
+        };
+        return SetScrollAutomation;
+    }(VisibleElementAutomation));
+
+    var ScrollIntoViewAutomation = /** @class */ (function (_super) {
+        __extends(ScrollIntoViewAutomation, _super);
+        function ScrollIntoViewAutomation(element, offsetOptions) {
+            return _super.call(this, element, offsetOptions) || this;
+        }
+        ScrollIntoViewAutomation.prototype.run = function (useStrictElementCheck) {
+            return this._ensureElement(useStrictElementCheck, true, true);
+        };
+        return ScrollIntoViewAutomation;
+    }(VisibleElementAutomation));
+
+    // Ensure command element properties
+    function ensureElementEditable(element) {
+        if (!testCafeCore.domUtils.isEditableElement(element))
+            throw new ActionElementNonEditableError();
+    }
+    function ensureTextAreaElement(element) {
+        if (!testCafeCore.domUtils.isTextAreaElement(element))
+            throw new ActionElementNotTextAreaError();
+    }
+    function ensureContentEditableElement(element, argumentTitle) {
+        if (!testCafeCore.domUtils.isContentEditableElement(element))
+            throw new ActionElementNonContentEditableError(argumentTitle);
+    }
+    function ensureRootContainer(elements) {
+        // NOTE: We should find a common element for the nodes to perform the select action
+        if (!testCafeCore.contentEditable.getNearestCommonAncestor(elements[0], elements[1]))
+            throw new ActionRootContainerNotFoundError();
+        return elements;
+    }
+    function ensureFileInput(element) {
+        if (!testCafeCore.domUtils.isFileInput(element))
+            throw new ActionElementIsNotFileInputError();
+    }
+    function ensureOffsetOptions(element, options) {
+        var _a = testcafeAutomation.getOffsetOptions(element, options.offsetX, options.offsetY), offsetX = _a.offsetX, offsetY = _a.offsetY;
+        options.offsetX = offsetX;
+        options.offsetY = offsetY;
+    }
+    var MAX_DELAY_AFTER_EXECUTION = 2000;
+    var CHECK_ELEMENT_IN_AUTOMATIONS_INTERVAL = 250;
+    var DateCtor$2 = hammerhead.nativeMethods.date;
+    var ActionExecutor = /** @class */ (function () {
+        function ActionExecutor(command, globalSelectorTimeout, statusBar, testSpeed) {
+            this.command = command;
+            this.globalSelectorTimeout = globalSelectorTimeout;
+            this.statusBar = statusBar;
+            this.testSpeed = testSpeed;
+            this.targetElement = null;
+            this.elements = [];
+            this.ensureElementsPromise = null;
+            this.ensureElementsStartTime = null;
+            this.executionStartTime = null;
+            this.executionStartedHandler = null;
+            this.commandSelectorTimeout = null;
+        }
+        ActionExecutor.prototype._getSpecificTimeout = function () {
+            var hasSpecificTimeout = this.command.selector && typeof this.command.selector.timeout === 'number';
+            return hasSpecificTimeout ? this.command.selector.timeout : this.globalSelectorTimeout;
+        };
+        ActionExecutor.prototype._delayAfterExecution = function () {
+            if (!this.command.options || this.command.options.speed === 1)
+                return hammerhead.Promise.resolve();
+            return testCafeCore.delay((1 - this.command.options.speed) * MAX_DELAY_AFTER_EXECUTION);
+        };
+        ActionExecutor.prototype._isExecutionTimeoutExpired = function () {
+            return hammerhead.nativeMethods.dateNow() - this.executionStartTime >= this.commandSelectorTimeout;
+        };
+        ActionExecutor.prototype._ensureCommandArguments = function () {
+            if (this.command.type === COMMAND_TYPE.pressKey) {
+                var parsedKeySequence = testCafeCore.parseKeySequence(this.command.keys);
+                if (parsedKeySequence.error)
+                    throw new ActionIncorrectKeysError('keys');
+            }
+        };
+        ActionExecutor.prototype._ensureCommandElements = function () {
+            var _this = this;
+            var elementDescriptors = [];
+            if (this.command.selector)
+                elementDescriptors.push(createElementDescriptor(this.command.selector));
+            if (this.command.type === COMMAND_TYPE.dragToElement)
+                elementDescriptors.push(createAdditionalElementDescriptor(this.command.destinationSelector, 'destinationSelector'));
+            else if (this.command.type === COMMAND_TYPE.selectEditableContent) {
+                elementDescriptors.push(createAdditionalElementDescriptor(this.command.startSelector, 'startSelector'));
+                elementDescriptors.push(createAdditionalElementDescriptor(this.command.endSelector || this.command.startSelector, 'endSelector'));
+            }
+            else if (this.command.type === COMMAND_TYPE.dispatchEvent && this.command.relatedTarget)
+                elementDescriptors.push(createAdditionalElementDescriptor(this.command.relatedTarget, 'relatedTarget'));
+            return ensureElements(elementDescriptors, this.globalSelectorTimeout)
+                .then(function (elements) {
+                _this.elements = elements;
+            });
+        };
+        ActionExecutor.prototype._ensureCommandElementsProperties = function () {
+            if (this.command.type === COMMAND_TYPE.selectText)
+                ensureElementEditable(this.elements[0]);
+            else if (this.command.type === COMMAND_TYPE.selectTextAreaContent)
+                ensureTextAreaElement(this.elements[0]);
+            else if (this.command.type === COMMAND_TYPE.selectEditableContent) {
+                ensureContentEditableElement(this.elements[0], 'startSelector');
+                ensureContentEditableElement(this.elements[1], 'endSelector');
+                ensureRootContainer(this.elements);
+            }
+            else if (this.command.type === COMMAND_TYPE.setFilesToUpload || this.command.type === COMMAND_TYPE.clearUpload)
+                ensureFileInput(this.elements[0]);
+        };
+        ActionExecutor.prototype._ensureCommandOptions = function () {
+            if (this.elements.length && this.command.options && 'offsetX' in this.command.options && 'offsetY' in this.command.options)
+                ensureOffsetOptions(this.elements[0], this.command.options);
+        };
+        ActionExecutor.prototype._createAutomation = function () {
+            var selectArgs = null;
+            switch (this.command.type) {
+                case COMMAND_TYPE.dispatchEvent:
+                    if (this.elements[1])
+                        this.command.options.relatedTarget = this.elements[1];
+                    return new testcafeAutomation.DispatchEvent(this.elements[0], this.command.eventName, this.command.options);
+                case COMMAND_TYPE.click:
+                    if (/option|optgroup/.test(testCafeCore.domUtils.getTagName(this.elements[0])))
+                        return new testcafeAutomation.SelectChildClick(this.elements[0], this.command.options);
+                    return new testcafeAutomation.Click(this.elements[0], this.command.options);
+                case COMMAND_TYPE.rightClick:
+                    return new testcafeAutomation.RClick(this.elements[0], this.command.options);
+                case COMMAND_TYPE.doubleClick:
+                    return new testcafeAutomation.DblClick(this.elements[0], this.command.options);
+                case COMMAND_TYPE.hover:
+                    return new testcafeAutomation.Hover(this.elements[0], this.command.options);
+                case COMMAND_TYPE.drag:
+                    return new testcafeAutomation.DragToOffset(this.elements[0], this.command.dragOffsetX, this.command.dragOffsetY, this.command.options);
+                case COMMAND_TYPE.dragToElement:
+                    return new testcafeAutomation.DragToElement(this.elements[0], this.elements[1], this.command.options);
+                case COMMAND_TYPE.scroll: {
+                    var _a = this.command, x = _a.x, y = _a.y, position = _a.position, options = _a.options;
+                    return new SetScrollAutomation(this.elements[0], { x: x, y: y, position: position }, options);
+                }
+                case COMMAND_TYPE.scrollBy: {
+                    var _b = this.command, byX = _b.byX, byY = _b.byY, options = _b.options;
+                    return new SetScrollAutomation(this.elements[0], { byX: byX, byY: byY }, options);
+                }
+                case COMMAND_TYPE.scrollIntoView: {
+                    return new ScrollIntoViewAutomation(this.elements[0], this.command.options);
+                }
+                case COMMAND_TYPE.typeText:
+                    // eslint-disable-next-line no-restricted-properties
+                    return new testcafeAutomation.Type(this.elements[0], this.command.text, this.command.options);
+                case COMMAND_TYPE.selectText:
+                case COMMAND_TYPE.selectTextAreaContent:
+                    selectArgs = testcafeAutomation.calculateSelectTextArguments(this.elements[0], this.command);
+                    return new testcafeAutomation.SelectText(this.elements[0], selectArgs.startPos, selectArgs.endPos, this.command.options);
+                case COMMAND_TYPE.selectEditableContent:
+                    return new testcafeAutomation.SelectEditableContent(this.elements[0], this.elements[1], this.command.options);
+                case COMMAND_TYPE.pressKey:
+                    return new testcafeAutomation.Press(testCafeCore.parseKeySequence(this.command.keys).combinations, this.command.options);
+                case COMMAND_TYPE.setFilesToUpload:
+                    return new testcafeAutomation.Upload(this.elements[0], this.command.filePath, function (filePaths, scannedFilePaths) { return new ActionCannotFindFileToUploadError(filePaths, scannedFilePaths); });
+                case COMMAND_TYPE.clearUpload:
+                    return new testcafeAutomation.Upload(this.elements[0]);
+            }
+            return null;
+        };
+        ActionExecutor.prototype._runAction = function (strictElementCheck) {
+            var _this = this;
+            return this
+                ._ensureCommandElements()
+                .then(function () { return _this._ensureCommandElementsProperties(); })
+                .then(function () {
+                _this._ensureCommandOptions();
+                var automation = _this._createAutomation();
+                if (automation.TARGET_ELEMENT_FOUND_EVENT) {
+                    automation.on(automation.TARGET_ELEMENT_FOUND_EVENT, function (e) {
+                        _this.targetElement = e.element;
+                        _this.statusBar.hideWaitingElementStatus(true);
+                        _this.executionStartedHandler();
+                    });
+                }
+                else {
+                    _this.statusBar.hideWaitingElementStatus(true);
+                    _this.executionStartedHandler();
+                }
+                return automation
+                    .run(strictElementCheck);
+            });
+        };
+        ActionExecutor.prototype._runRecursively = function () {
+            var _this = this;
+            var actionFinished = false;
+            var strictElementCheck = true;
+            return testCafeCore.promiseUtils.whilst(function () { return !actionFinished; }, function () {
+                return _this
+                    ._runAction(strictElementCheck)
+                    .then(function () {
+                    actionFinished = true;
+                })
+                    .catch(function (err) {
+                    if (_this._isExecutionTimeoutExpired()) {
+                        if (err.message === testcafeAutomation.ERROR_TYPES.foundElementIsNotTarget) {
+                            // If we can't get a target element via elementFromPoint but it's
+                            // visible we click on the point where the element is located.
+                            strictElementCheck = false;
+                            return hammerhead.Promise.resolve();
+                        }
+                        throw err.message === testcafeAutomation.ERROR_TYPES.elementIsInvisibleError ?
+                            new ActionElementIsInvisibleError() : err;
+                    }
+                    return testCafeCore.delay(CHECK_ELEMENT_IN_AUTOMATIONS_INTERVAL);
+                });
+            });
+        };
+        ActionExecutor.prototype.execute = function () {
+            var _this = this;
+            if (this.command.options && !this.command.options.speed)
+                this.command.options.speed = this.testSpeed;
+            var startPromise = new hammerhead.Promise(function (resolve) {
+                _this.executionStartedHandler = resolve;
+            });
+            var completionPromise = new hammerhead.Promise(function (resolve) {
+                _this.executionStartTime = new DateCtor$2();
+                try {
+                    _this._ensureCommandArguments();
+                }
+                catch (err) {
+                    resolve(new DriverStatus({ isCommandResult: true, executionError: err }));
+                    return;
+                }
+                _this.commandSelectorTimeout = _this._getSpecificTimeout();
+                _this.statusBar.showWaitingElementStatus(_this.commandSelectorTimeout);
+                var _a = runWithBarriers(function () { return _this._runRecursively(); }), actionPromise = _a.actionPromise, barriersPromise = _a.barriersPromise;
+                actionPromise
+                    .then(function () { return hammerhead.Promise.all([
+                    _this._delayAfterExecution(),
+                    barriersPromise
+                ]); })
+                    .then(function () {
+                    var status = { isCommandResult: true };
+                    var elements = __spreadArrays(_this.elements);
+                    if (_this.targetElement)
+                        elements[0] = _this.targetElement;
+                    status.result = createReplicator(new SelectorElementActionTransform()).encode(elements);
+                    resolve(new DriverStatus(status));
+                })
+                    .catch(function (err) {
+                    return _this.statusBar.hideWaitingElementStatus(false)
+                        .then(function () { return resolve(new DriverStatus({ isCommandResult: true, executionError: err })); });
+                });
+            });
+            return { startPromise: startPromise, completionPromise: completionPromise };
         };
-        return TypeOptions;
-    }(ClickOptions));
-    // DragToElement
-    var DragToElementOptions = /** @class */ (function (_super) {
-        __extends(DragToElementOptions, _super);
-        function DragToElementOptions(obj, validate) {
-            var _this = _super.call(this, obj, validate) || this;
-            _this.destinationOffsetX = null;
-            _this.destinationOffsetY = null;
-            _this._assignFrom(obj, validate);
-            return _this;
-        }
-        DragToElementOptions.prototype._getAssignableProperties = function () {
-            return _super.prototype._getAssignableProperties.call(this).concat([
-                { name: 'destinationOffsetX', type: integerOption },
-                { name: 'destinationOffsetY', type: integerOption }
-            ]);
+        return ActionExecutor;
+    }());
+    function executeAction(command, globalSelectorTimeout, statusBar, testSpeed) {
+        var actionExecutor = new ActionExecutor(command, globalSelectorTimeout, statusBar, testSpeed);
+        return actionExecutor.execute();
+    }
+
+    // -------------------------------------------------------------
+    // WARNING: this file is used by both the client and the server.
+    // Do not use any browser or node-specific API!
+    // -------------------------------------------------------------
+    function limitNumber (value, min, max) {
+        return Math.min(Math.max(min, value), max);
+    }
+
+    function determineDimensionBounds(bounds, maximum) {
+        var hasMin = typeof bounds.min === 'number';
+        var hasMax = typeof bounds.max === 'number';
+        var hasLength = typeof bounds.length === 'number';
+        if (hasLength)
+            bounds.length = limitNumber(bounds.length, 0, maximum);
+        if (hasMin && bounds.min < 0)
+            bounds.min += maximum;
+        if (hasMax && bounds.max < 0)
+            bounds.max += maximum;
+        if (!hasMin)
+            bounds.min = hasMax && hasLength ? bounds.max - bounds.length : 0;
+        if (!hasMax)
+            bounds.max = hasLength ? bounds.min + bounds.length : maximum;
+        bounds.min = limitNumber(bounds.min, 0, maximum);
+        bounds.max = limitNumber(bounds.max, 0, maximum);
+        bounds.length = bounds.max - bounds.min;
+        return bounds;
+    }
+    function determineScrollPoint(cropStart, cropEnd, viewportBound) {
+        return Math.round(cropStart + limitNumber(cropEnd - cropStart, 0, viewportBound) / 2);
+    }
+    function ensureCropOptions(element, options) {
+        var elementRectangle = element.getBoundingClientRect();
+        var elementBounds = {
+            left: elementRectangle.left,
+            right: elementRectangle.right,
+            top: elementRectangle.top,
+            bottom: elementRectangle.bottom
         };
-        return DragToElementOptions;
-    }(MouseOptions));
-    //ResizeToFitDevice
-    var ResizeToFitDeviceOptions = /** @class */ (function (_super) {
-        __extends(ResizeToFitDeviceOptions, _super);
-        function ResizeToFitDeviceOptions(obj, validate) {
-            var _this = _super.call(this) || this;
-            _this.portraitOrientation = false;
-            _this._assignFrom(obj, validate);
-            return _this;
+        var elementMargin = testCafeCore.styleUtils.getElementMargin(element);
+        var elementPadding = testCafeCore.styleUtils.getElementPadding(element);
+        var elementBordersWidth = testCafeCore.styleUtils.getBordersWidth(element);
+        options.originOffset = { x: 0, y: 0 };
+        var scrollRight = elementBounds.left + element.scrollWidth + elementBordersWidth.left + elementBordersWidth.right;
+        var scrollBottom = elementBounds.top + element.scrollHeight + elementBordersWidth.top + elementBordersWidth.bottom;
+        elementBounds.right = Math.max(elementBounds.right, scrollRight);
+        elementBounds.bottom = Math.max(elementBounds.bottom, scrollBottom);
+        if (!options.includeBorders || !options.includePaddings) {
+            options.originOffset.x += elementBordersWidth.left;
+            options.originOffset.y += elementBordersWidth.top;
+            elementBounds.left += elementBordersWidth.left;
+            elementBounds.top += elementBordersWidth.top;
+            elementBounds.right -= elementBordersWidth.right;
+            elementBounds.bottom -= elementBordersWidth.bottom;
+            if (!options.includePaddings) {
+                options.originOffset.x += elementPadding.left;
+                options.originOffset.y += elementPadding.top;
+                elementBounds.left += elementPadding.left;
+                elementBounds.top += elementPadding.top;
+                elementBounds.right -= elementPadding.right;
+                elementBounds.bottom -= elementPadding.bottom;
+            }
         }
-        ResizeToFitDeviceOptions.prototype._getAssignableProperties = function () {
-            return [
-                { name: 'portraitOrientation', type: booleanOption }
-            ];
-        };
-        return ResizeToFitDeviceOptions;
-    }(Assignable));
-    //Assertion
-    var AssertionOptions = /** @class */ (function (_super) {
-        __extends(AssertionOptions, _super);
-        function AssertionOptions(obj, validate) {
-            var _this = _super.call(this) || this;
-            _this.timeout = void 0;
-            _this.allowUnawaitedPromise = false;
-            _this._assignFrom(obj, validate);
-            return _this;
+        else if (options.includeMargins) {
+            options.originOffset.x -= elementMargin.left;
+            options.originOffset.y -= elementMargin.top;
+            elementBounds.left -= elementMargin.left;
+            elementBounds.top -= elementMargin.top;
+            elementBounds.right += elementMargin.right;
+            elementBounds.bottom += elementMargin.bottom;
         }
-        AssertionOptions.prototype._getAssignableProperties = function () {
-            return [
-                { name: 'timeout', type: positiveIntegerOption },
-                { name: 'allowUnawaitedPromise', type: booleanOption }
-            ];
-        };
-        return AssertionOptions;
-    }(Assignable));
-
-    function isIframeWindow(window) {
-        return window.top !== window;
+        elementBounds.width = elementBounds.right - elementBounds.left;
+        elementBounds.height = elementBounds.bottom - elementBounds.top;
+        var horizontalCropBounds = determineDimensionBounds({ min: options.crop.left, max: options.crop.right, length: options.crop.width }, elementBounds.width);
+        var verticalCropBounds = determineDimensionBounds({ min: options.crop.top, max: options.crop.bottom, length: options.crop.height }, elementBounds.height);
+        options.crop.left = horizontalCropBounds.min;
+        options.crop.right = horizontalCropBounds.max;
+        options.crop.width = horizontalCropBounds.length;
+        options.crop.top = verticalCropBounds.min;
+        options.crop.bottom = verticalCropBounds.max;
+        options.crop.height = verticalCropBounds.length;
+        if (options.crop.width <= 0 || options.crop.height <= 0)
+            throw new InvalidElementScreenshotDimensionsError(options.crop.width, options.crop.height);
+        var viewportDimensions = testCafeCore.styleUtils.getViewportDimensions();
+        if (elementBounds.width > viewportDimensions.width || elementBounds.height > viewportDimensions.height)
+            options.scrollToCenter = true;
+        var hasScrollTargetX = typeof options.scrollTargetX === 'number';
+        var hasScrollTargetY = typeof options.scrollTargetY === 'number';
+        if (!hasScrollTargetX)
+            options.scrollTargetX = determineScrollPoint(options.crop.left, options.crop.right, viewportDimensions.width);
+        if (!hasScrollTargetY)
+            options.scrollTargetY = determineScrollPoint(options.crop.top, options.crop.bottom, viewportDimensions.height);
+        var _a = testcafeAutomation.getOffsetOptions(element, options.scrollTargetX, options.scrollTargetY), offsetX = _a.offsetX, offsetY = _a.offsetY;
+        options.scrollTargetX = offsetX;
+        options.scrollTargetY = offsetY;
+        var isScrollTargetXValid = !hasScrollTargetX || options.scrollTargetX >= options.crop.left && options.scrollTargetX <= options.crop.right;
+        var isScrollTargetYValid = !hasScrollTargetY || options.scrollTargetY >= options.crop.top && options.scrollTargetY <= options.crop.bottom;
+        if (!isScrollTargetXValid || !isScrollTargetYValid)
+            throw new ActionInvalidScrollTargetError(isScrollTargetXValid, isScrollTargetYValid);
     }
 
-    var messageSandbox$1 = hammerhead.eventSandbox.message;
+    var messageSandbox$3 = hammerhead.eventSandbox.message;
     var HIDING_UI_RELAYOUT_DELAY = 500;
     var POSSIBLE_RESIZE_ERROR_DELAY = 200;
     var MANIPULATION_REQUEST_CMD = 'driver|browser-manipulation|request';
     var MANIPULATION_RESPONSE_CMD = 'driver|browser-manipulation|response';
     // Setup cross-iframe interaction
-    messageSandbox$1.on(messageSandbox$1.SERVICE_MSG_RECEIVED_EVENT, function (e) {
+    messageSandbox$3.on(messageSandbox$3.SERVICE_MSG_RECEIVED_EVENT, function (e) {
         if (e.message.cmd === MANIPULATION_REQUEST_CMD) {
             var element = testCafeCore.domUtils.findIframeByWindow(e.source);
             var _a = e.message, command = _a.command, cropDimensions = _a.cropDimensions;
@@ -3199,7 +4544,7 @@
             manipulation.element = element;
             manipulation
                 .execute()
-                .then(function (result) { return messageSandbox$1.sendServiceMsg({ cmd: MANIPULATION_RESPONSE_CMD, result: result }, e.source); });
+                .then(function (result) { return messageSandbox$3.sendServiceMsg({ cmd: MANIPULATION_RESPONSE_CMD, result: result }, e.source); });
         }
     });
     var ManipulationExecutor = /** @class */ (function () {
@@ -3271,15 +4616,15 @@
             });
         };
         ManipulationExecutor.prototype._hideUI = function () {
-            testcafeUi.hide();
+            testCafeUI.hide();
             if (this.command.markData)
-                testcafeUi.showScreenshotMark(this.command.markData);
+                testCafeUI.showScreenshotMark(this.command.markData);
             return testCafeCore.delay(HIDING_UI_RELAYOUT_DELAY);
         };
         ManipulationExecutor.prototype._showUI = function () {
             if (this.command.markData)
-                testcafeUi.hideScreenshotMark();
-            testcafeUi.show();
+                testCafeUI.hideScreenshotMark();
+            testCafeUI.show();
         };
         ManipulationExecutor.prototype._requestManipulation = function () {
             if (!isIframeWindow(window))
@@ -3392,21 +4737,21 @@
         });
     }
 
-    var Promise$1 = hammerhead__default.Promise;
+    var Promise$6 = hammerhead__default.Promise;
     function executeChildWindowDriverLinkSelector(selector, childWindowLinks) {
         if (typeof selector === 'string') {
             var foundChildWindowDriverLink = testCafeCore.arrayUtils.find(childWindowLinks, function (link) { return link.windowId === selector; });
             if (!foundChildWindowDriverLink) {
                 var error = new ChildWindowNotFoundError();
-                return Promise$1.reject(error);
+                return Promise$6.reject(error);
             }
             // NOTE: We cannot pass the driver window of the found child window driver link
             // because the current Promise implementation checks the type of the value passed to the 'resolve' function.
             // It causes an unhandled JavaScript error on accessing to cross-domain iframe.
-            return Promise$1.resolve(foundChildWindowDriverLink);
+            return Promise$6.resolve(foundChildWindowDriverLink);
         }
         // TODO:  Query url and title properties of the all driverLinks' windows
-        return Promise$1.resolve(null);
+        return Promise$6.resolve(null);
     }
 
     var ChildWindowDriverLink = /** @class */ (function () {
@@ -3480,11 +4825,11 @@
 
     var settings = hammerhead__default.settings;
     var transport = hammerhead__default.transport;
-    var Promise$2 = hammerhead__default.Promise;
-    var messageSandbox$2 = hammerhead__default.eventSandbox.message;
+    var Promise$7 = hammerhead__default.Promise;
+    var messageSandbox$4 = hammerhead__default.eventSandbox.message;
     var storages = hammerhead__default.storages;
-    var nativeMethods$4 = hammerhead__default.nativeMethods;
-    var DateCtor$3 = nativeMethods$4.date;
+    var nativeMethods$8 = hammerhead__default.nativeMethods;
+    var DateCtor$3 = nativeMethods$8.date;
     var listeners = hammerhead__default.eventSandbox.listeners;
     var TEST_DONE_SENT_FLAG = 'testcafe|driver|test-done-sent-flag';
     var PENDING_STATUS = 'testcafe|driver|pending-status';
@@ -3561,10 +4906,12 @@
             hammerhead__default.on(hammerhead__default.EVENTS.beforeFormSubmit, function (e) { return _this._onFormSubmit(e); });
             hammerhead__default.on(hammerhead__default.EVENTS.windowOpened, function (e) { return _this._onChildWindowOpened(e); });
             _this.setCustomCommandHandlers(COMMAND_TYPE.unlockPage, function () { return _this._unlockPageAfterTestIsDone(); });
+            _this.setCustomCommandHandlers(COMMAND_TYPE.getActiveElement, function () { return _this._getActiveElement(); });
             // NOTE: initiate the child links restoring process before the window is reloaded
             listeners.addInternalEventBeforeListener(window, ['beforeunload'], function () {
                 _this._sendStartToRestoreCommand();
             });
+            _this.replicator = createReplicator([new SelectorNodeTransform()]);
             return _this;
         }
         Driver.prototype._isOpenedInIframe = function () {
@@ -3620,7 +4967,7 @@
             // NOTE: we should not send any message to the server if we've
             // sent the 'test-done' message but haven't got the response.
             if (this.skipJsErrors || this.contextStorage.getItem(TEST_DONE_SENT_FLAG))
-                return Promise$2.resolve();
+                return Promise$7.resolve();
             var error = new UncaughtErrorOnPage(err.stack, err.pageUrl);
             if (!this.contextStorage.getItem(PENDING_PAGE_ERROR))
                 this.contextStorage.setItem(PENDING_PAGE_ERROR, error);
@@ -3628,7 +4975,16 @@
         };
         Driver.prototype._unlockPageAfterTestIsDone = function () {
             testCafeCore.disableRealEventsPreventing();
-            return Promise$2.resolve();
+            return Promise$7.resolve();
+        };
+        Driver.prototype._getActiveElement = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var activeElement;
+                return __generator(this, function (_a) {
+                    activeElement = testCafeCore.domUtils.getActiveElement();
+                    return [2 /*return*/, this.replicator.encode(activeElement)];
+                });
+            });
         };
         Driver.prototype._failIfClientCodeExecutionIsInterrupted = function () {
             // NOTE: ClientFunction should be used primarily for observation. We raise
@@ -3659,7 +5015,7 @@
             var _this = this;
             if (this.checkClosedChildWindowIntervalId)
                 return;
-            this.checkClosedChildWindowIntervalId = nativeMethods$4.setInterval.call(window, function () {
+            this.checkClosedChildWindowIntervalId = nativeMethods$8.setInterval.call(window, function () {
                 var firstClosedChildWindowDriverLink = testCafeCore.arrayUtils.find(_this.childWindowDriverLinks, function (childWindowDriverLink) { return childWindowDriverLink.driverWindow.closed; });
                 if (!firstClosedChildWindowDriverLink)
                     return;
@@ -3668,7 +5024,7 @@
                 if (!firstClosedChildWindowDriverLink.ignoreMasterSwitching)
                     _this._setCurrentWindowAsMaster();
                 if (!_this.childWindowDriverLinks.length) {
-                    nativeMethods$4.clearInterval.call(window, _this.checkClosedChildWindowIntervalId);
+                    nativeMethods$8.clearInterval.call(window, _this.checkClosedChildWindowIntervalId);
                     delete _this.checkClosedChildWindowIntervalId;
                 }
             }, CHECK_CHILD_WINDOW_CLOSED_INTERVAL);
@@ -3682,7 +5038,7 @@
                 return;
             this.setAsMasterInProgress = true;
             this._clearActiveChildIframeInfo();
-            Promise$2.resolve()
+            Promise$7.resolve()
                 .then(function () {
                 return testCafeCore.browser.setActiveWindowId(_this.browserActiveWindowId, hammerhead__default.createNativeXHR, _this.windowId);
             })
@@ -3803,7 +5159,7 @@
             childIframeDriverLink.sendConfirmationMessage(id);
         };
         Driver.prototype._getTargetWindowNotFoundResult = function (errCode, errMsg) {
-            return Promise$2.resolve({
+            return Promise$7.resolve({
                 success: false,
                 errCode: errCode,
                 errMsg: errMsg
@@ -3864,7 +5220,7 @@
                             searchQueries = this.childWindowDriverLinks.map(function (childWindowDriverLink) {
                                 return childWindowDriverLink.findChildWindows(msg, WindowValidationMessageCtor);
                             });
-                            return [4 /*yield*/, Promise$2.all(searchQueries)];
+                            return [4 /*yield*/, Promise$7.all(searchQueries)];
                         case 1:
                             searchResults = _a.sent();
                             return [2 /*return*/, this._getChildWindowValidateResult(searchResults)];
@@ -3882,18 +5238,18 @@
         };
         Driver.prototype._getCloseWindowFoundResult = function () {
             if (!this.parentWindowDriverLink) {
-                return Promise$2.resolve({
+                return Promise$7.resolve({
                     success: false,
                     errCode: TEST_RUN_ERRORS.cannotCloseWindowWithoutParent
                 });
             }
             if (this.childWindowDriverLinks.length) {
-                return Promise$2.resolve({
+                return Promise$7.resolve({
                     success: false,
                     errCode: TEST_RUN_ERRORS.cannotCloseWindowWithChildrenError
                 });
             }
-            return Promise$2.resolve({ success: true });
+            return Promise$7.resolve({ success: true });
         };
         Driver.prototype._handleCloseWindowValidation = function (msg, wnd) {
             var _this = this;
@@ -3904,7 +5260,7 @@
         };
         Driver.prototype._handleSwitchToWindowValidation = function (msg, wnd) {
             var getWindowFoundResult = function () {
-                return Promise$2.resolve({ success: true });
+                return Promise$7.resolve({ success: true });
             };
             return this._handleWindowValidation(msg, wnd, getWindowFoundResult, SwitchToWindowValidationMessage);
         };
@@ -3932,14 +5288,14 @@
         };
         Driver.prototype._closeWindow = function (msg) {
             if (!this.childWindowDriverLinks.length)
-                return Promise$2.resolve();
+                return Promise$7.resolve();
             var childWindowToClose = this.childWindowDriverLinks.find(function (link) { return link.windowId === msg.windowId; });
             if (childWindowToClose)
                 return this._closeWindowAndWait(childWindowToClose, msg);
             var searchQueries = this.childWindowDriverLinks.map(function (childWindowDriverLink) {
                 return childWindowDriverLink.findChildWindows(msg, CloseWindowCommandMessage);
             });
-            return Promise$2.all(searchQueries);
+            return Promise$7.all(searchQueries);
         };
         Driver.prototype._getWindows = function () {
             return __awaiter(this, void 0, void 0, function () {
@@ -3952,7 +5308,7 @@
                             searchQueries = this.childWindowDriverLinks.map(function (childWindowDriverLink) {
                                 return childWindowDriverLink.findChildWindows({}, GetWindowsMessage);
                             });
-                            return [4 /*yield*/, Promise$2.all(searchQueries)];
+                            return [4 /*yield*/, Promise$7.all(searchQueries)];
                         case 1:
                             searchResults = _a.sent();
                             result = [this._getWindowInfo()];
@@ -4003,14 +5359,14 @@
         Driver.prototype._switchToWindow = function (msg) {
             var _this = this;
             if (this._isTargetWindow(msg)) {
-                return Promise$2.resolve()
+                return Promise$7.resolve()
                     .then(function () {
                     _this._setCurrentWindowAsMaster();
                 });
             }
             if (!this.childWindowDriverLinks.length)
-                return Promise$2.resolve();
-            return Promise$2.all(this.childWindowDriverLinks.map(function (childWindowDriverLink) {
+                return Promise$7.resolve();
+            return Promise$7.all(this.childWindowDriverLinks.map(function (childWindowDriverLink) {
                 return childWindowDriverLink.findChildWindows(msg, SwitchToWindowCommandMessage);
             }));
         };
@@ -4026,7 +5382,7 @@
                 requestMsgId: msg.id,
                 window: wnd
             });
-            Promise$2.resolve()
+            Promise$7.resolve()
                 .then(function () {
                 return testCafeCore.browser.setActiveWindowId(_this.browserActiveWindowId, hammerhead__default.createNativeXHR, _this.windowId);
             })
@@ -4082,7 +5438,7 @@
             var _this = this;
             // NOTE: when the child window is opened in iframe we need to wait until the
             // child window is fully loaded
-            this._pendingChildWindowInIFrame = new Promise$2(function (resolve) {
+            this._pendingChildWindowInIFrame = new Promise$7(function (resolve) {
                 _this._resolvePendingChildWindowInIframe = resolve;
             });
         };
@@ -4098,7 +5454,7 @@
         };
         Driver.prototype._initChildDriverListening = function () {
             var _this = this;
-            messageSandbox$2.on(messageSandbox$2.SERVICE_MSG_RECEIVED_EVENT, function (e) {
+            messageSandbox$4.on(messageSandbox$4.SERVICE_MSG_RECEIVED_EVENT, function (e) {
                 var msg = e.message;
                 var window = e.source;
                 switch (msg.type) {
@@ -4148,7 +5504,7 @@
         };
         Driver.prototype._runInActiveIframe = function (command) {
             var _this = this;
-            var runningChain = Promise$2.resolve();
+            var runningChain = Promise$7.resolve();
             var activeIframeSelector = this.contextStorage.getItem(ACTIVE_IFRAME_SELECTOR);
             // NOTE: if the page was reloaded we restore the active child driver link via the iframe selector
             if (!this.activeChildIframeDriverLink && activeIframeSelector)
@@ -4167,7 +5523,7 @@
         Driver.prototype._onCommandExecutedInIframe = function (status) {
             var _this = this;
             this.contextStorage.setItem(this.EXECUTING_IN_IFRAME_FLAG, false);
-            var promise = Promise$2.resolve();
+            var promise = Promise$7.resolve();
             if (this._pendingChildWindowInIFrame)
                 promise = this._pendingChildWindowInIFrame;
             promise.then(function () {
@@ -4200,7 +5556,7 @@
                 .then(function (iframe) {
                 if (!testCafeCore.domUtils.isIframeElement(iframe))
                     throw new ActionElementNotIframeError();
-                return _this._ensureChildIframeDriverLink(nativeMethods$4.contentWindowGetter.call(iframe), iframeErrorCtors.NotLoadedError, commandSelectorTimeout);
+                return _this._ensureChildIframeDriverLink(nativeMethods$8.contentWindowGetter.call(iframe), iframeErrorCtors.NotLoadedError, commandSelectorTimeout);
             })
                 .then(function (childDriverLink) {
                 childDriverLink.availabilityTimeout = commandSelectorTimeout;
@@ -4211,24 +5567,24 @@
         Driver.prototype._createWaitForEventPromise = function (eventName, timeout) {
             var _this = this;
             var eventHandler = null;
-            var timeoutPromise = new Promise$2(function (resolve) {
-                nativeMethods$4.setTimeout.call(window, function () {
+            var timeoutPromise = new Promise$7(function (resolve) {
+                nativeMethods$8.setTimeout.call(window, function () {
                     _this.off(eventName, eventHandler);
                     resolve();
                 }, timeout);
             });
-            var resultPromise = new Promise$2(function (resolve) {
+            var resultPromise = new Promise$7(function (resolve) {
                 eventHandler = function () {
                     this.off(eventName, eventHandler);
                     resolve();
                 };
                 _this.on(eventName, eventHandler);
             });
-            return Promise$2.race([timeoutPromise, resultPromise]);
+            return Promise$7.race([timeoutPromise, resultPromise]);
         };
         Driver.prototype._waitForCurrentCommandCompletion = function () {
             if (!this.contextStorage.getItem(this.COMMAND_EXECUTING_FLAG))
-                return Promise$2.resolve();
+                return Promise$7.resolve();
             return this._createWaitForEventPromise(STATUS_WITH_COMMAND_RESULT_EVENT, COMMAND_EXECUTION_MAX_TIMEOUT);
         };
         Driver.prototype._waitForEmptyCommand = function () {
@@ -4289,7 +5645,7 @@
             var _this = this;
             if (opts === void 0) { opts = {}; }
             this.contextStorage.setItem(this.PENDING_WINDOW_SWITCHING_FLAG, true);
-            return Promise$2.resolve()
+            return Promise$7.resolve()
                 .then(function () {
                 _this._stopInternal();
                 return parentWindowSwitchFn(opts);
@@ -4317,7 +5673,7 @@
         Driver.prototype._setNativeDialogHandlerInIframes = function (dialogHandler) {
             var msg = new SetNativeDialogHandlerMessage(dialogHandler);
             for (var i = 0; i < this.childIframeDriverLinks.length; i++)
-                messageSandbox$2.sendServiceMsg(msg, this.childIframeDriverLinks[i].driverWindow);
+                messageSandbox$4.sendServiceMsg(msg, this.childIframeDriverLinks[i].driverWindow);
         };
         // Commands handling
         Driver.prototype._onActionCommand = function (command) {
@@ -4511,7 +5867,7 @@
                         case 0:
                             if (!this.contextStorage.getItem(PENDING_CHILD_WINDOW_COUNT))
                                 return [2 /*return*/];
-                            restoreChildWindowsPromise = new Promise$2(function (resolve) {
+                            restoreChildWindowsPromise = new Promise$7(function (resolve) {
                                 _this._restoreChildWindowsPromiseResolver = resolve;
                             });
                             _a.label = 1;
@@ -4569,7 +5925,7 @@
         };
         Driver.prototype._onShowAssertionRetriesStatusCommand = function (command) {
             this.contextStorage.setItem(ASSERTION_RETRIES_TIMEOUT, command.timeout);
-            this.contextStorage.setItem(ASSERTION_RETRIES_START_TIME, nativeMethods$4.dateNow());
+            this.contextStorage.setItem(ASSERTION_RETRIES_START_TIME, nativeMethods$8.dateNow());
             this.statusBar.showWaitingAssertionRetriesStatus(command.timeout);
             this._onReady(new DriverStatus({ isCommandResult: true }));
         };
@@ -4612,12 +5968,12 @@
         Driver.prototype._closeAllChildWindows = function () {
             var _this = this;
             if (!this.childWindowDriverLinks.length)
-                return Promise$2.resolve();
-            return Promise$2.all(this.childWindowDriverLinks.map(function (childWindowDriverLink) {
+                return Promise$7.resolve();
+            return Promise$7.all(this.childWindowDriverLinks.map(function (childWindowDriverLink) {
                 return childWindowDriverLink.closeAllChildWindows();
             }))
                 .then(function () {
-                nativeMethods$4.arrayForEach.call(_this.childWindowDriverLinks, function (childWindowDriverLink) {
+                nativeMethods$8.arrayForEach.call(_this.childWindowDriverLinks, function (childWindowDriverLink) {
                     childWindowDriverLink.driverWindow.close();
                 });
             });
@@ -4849,7 +6205,7 @@
         Driver.prototype._init = function () {
             this.contextStorage = new Storage(window, this.testRunId, this.windowId);
             this.nativeDialogsTracker = new NativeDialogTracker(this.contextStorage, this.dialogHandler);
-            this.statusBar = new testcafeUi.StatusBar(this.userAgent, this.fixtureName, this.testName, this.contextStorage);
+            this.statusBar = new testCafeUI.StatusBar(this.userAgent, this.fixtureName, this.testName, this.contextStorage);
             this.statusBar.on(this.statusBar.UNLOCK_PAGE_BTN_CLICK, testCafeCore.disableRealEventsPreventing);
             this.speed = this.initialSpeed;
             this._initConsoleMessages();
@@ -4918,21 +6274,21 @@
         return ParentIframeDriverLink;
     }());
 
-    var messageSandbox$3 = hammerhead__default.eventSandbox.message;
+    var messageSandbox$5 = hammerhead__default.eventSandbox.message;
     var IframeNativeDialogTracker = /** @class */ (function (_super) {
         __extends(IframeNativeDialogTracker, _super);
         function IframeNativeDialogTracker(dialogHandler) {
             return _super.call(this, null, dialogHandler) || this;
         }
         IframeNativeDialogTracker.prototype._defaultDialogHandler = function (type) {
-            messageSandbox$3.sendServiceMsg({
+            messageSandbox$5.sendServiceMsg({
                 type: MESSAGE_TYPE.unexpectedDialog,
                 dialogType: type,
                 url: NativeDialogTracker._getPageUrl()
             }, window.top);
         };
         IframeNativeDialogTracker.prototype._addAppearedDialogs = function (type, text) {
-            messageSandbox$3.sendServiceMsg({
+            messageSandbox$5.sendServiceMsg({
                 type: MESSAGE_TYPE.appearedDialog,
                 dialogType: type,
                 text: text,
@@ -4940,7 +6296,7 @@
             }, window.top);
         };
         IframeNativeDialogTracker.prototype._onHandlerError = function (type, message) {
-            messageSandbox$3.sendServiceMsg({
+            messageSandbox$5.sendServiceMsg({
                 type: MESSAGE_TYPE.handlerError,
                 dialogType: type,
                 message: message,
@@ -4950,7 +6306,7 @@
         return IframeNativeDialogTracker;
     }(NativeDialogTracker));
 
-    var messageSandbox$4 = hammerhead.eventSandbox.message;
+    var messageSandbox$6 = hammerhead.eventSandbox.message;
     var IframeDriver = /** @class */ (function (_super) {
         __extends(IframeDriver, _super);
         function IframeDriver(testRunId, options) {
@@ -4970,7 +6326,7 @@
         // NOTE: when the new page is opened in the iframe we send a message to the top window
         // to start waiting for the new page is loaded
         IframeDriver.prototype._onChildWindowOpened = function () {
-            messageSandbox$4.sendServiceMsg(new ChildWindowIsOpenedInFrameMessage(), window.top);
+            messageSandbox$6.sendServiceMsg(new ChildWindowIsOpenedInFrameMessage(), window.top);
         };
         // Messaging between drivers
         IframeDriver.prototype._initParentDriverListening = function () {
@@ -5012,7 +6368,7 @@
         IframeDriver.prototype.start = function () {
             var _this = this;
             this.nativeDialogsTracker = new IframeNativeDialogTracker(this.dialogHandler);
-            this.statusBar = new testcafeUi.IframeStatusBar();
+            this.statusBar = new testCafeUI.IframeStatusBar();
             var initializePromise = this.parentDriverLink
                 .establishConnection()
                 .then(function (id) {
@@ -5046,21 +6402,21 @@
         testCafeDriverInstance: '%testCafeDriverInstance%'
     };
 
-    var nativeMethods$5 = hammerhead__default.nativeMethods;
+    var nativeMethods$9 = hammerhead__default.nativeMethods;
     var evalIframeScript = hammerhead__default.EVENTS.evalIframeScript;
-    nativeMethods$5.objectDefineProperty(window, INTERNAL_PROPERTIES.testCafeDriver, { configurable: true, value: Driver });
-    nativeMethods$5.objectDefineProperty(window, INTERNAL_PROPERTIES.testCafeIframeDriver, { configurable: true, value: IframeDriver });
-    nativeMethods$5.objectDefineProperty(window, INTERNAL_PROPERTIES.scriptExecutionBarrier, {
+    nativeMethods$9.objectDefineProperty(window, INTERNAL_PROPERTIES.testCafeDriver, { configurable: true, value: Driver });
+    nativeMethods$9.objectDefineProperty(window, INTERNAL_PROPERTIES.testCafeIframeDriver, { configurable: true, value: IframeDriver });
+    nativeMethods$9.objectDefineProperty(window, INTERNAL_PROPERTIES.scriptExecutionBarrier, {
         configurable: true,
         value: ScriptExecutionBarrier
     });
-    nativeMethods$5.objectDefineProperty(window, INTERNAL_PROPERTIES.testCafeEmbeddingUtils, { configurable: true, value: embeddingUtils });
+    nativeMethods$9.objectDefineProperty(window, INTERNAL_PROPERTIES.testCafeEmbeddingUtils, { configurable: true, value: embeddingUtils });
     // eslint-disable-next-line no-undef
-    hammerhead__default.on(evalIframeScript, function (e) { return initTestCafeClientDrivers(nativeMethods$5.contentWindowGetter.call(e.iframe), true); });
+    hammerhead__default.on(evalIframeScript, function (e) { return initTestCafeClientDrivers(nativeMethods$9.contentWindowGetter.call(e.iframe), true); });
 
 }(window['%hammerhead%'], window['%hammerhead%'].Promise, window['%testCafeCore%'], window['%testCafeAutomation%'], window['%testCafeUI%']));
-
-    }
-
-    initTestCafeClientDrivers(window);
-})();
+
+    }
+
+    initTestCafeClientDrivers(window);
+})();