testcafe 1.18.3 → 1.18.4

package/lib/client/automation/index.js

@@ -30,7 +30,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         if (underTopShadowUIElement === void 0) { underTopShadowUIElement = false; }
         return testCafeUI.hide(underTopShadowUIElement)
             .then(function () {
-            var topElement = positionUtils.getElementFromPoint(point.x, point.y);
+            var topElement = positionUtils.getElementFromPoint(point);
             return testCafeUI.show(underTopShadowUIElement)
                 .then(function () { return topElement; });
         });
@@ -103,58 +103,75 @@ window['%hammerhead%'].utils.removeInjectedScript();
         }
     }
 
-    var browserUtils = hammerhead__default.utils.browser;
-    var MoveEventSequenceBase = /** @class */ (function () {
-        function MoveEventSequenceBase(_a) {
-            var moveEvent = _a.moveEvent;
-            this.dragAndDropMode = false;
-            this.dropAllowed = false;
-            this.moveEvent = moveEvent;
+    var lastHoveredElement = null;
+    var lastHoveredElementHolder = {
+        get: function () {
+            return lastHoveredElement;
+        },
+        set: function (element) {
+            lastHoveredElement = element;
+        },
+    };
+
+    var AxisValues = /** @class */ (function () {
+        function AxisValues(x, y) {
+            this.x = x;
+            this.y = y;
         }
-        MoveEventSequenceBase.prototype.setup = function () {
-            this.dragAndDropMode = false;
-            this.dropAllowed = false;
+        AxisValues.create = function (a) {
+            if ('left' in a)
+                return new AxisValues(a.left, a.top);
+            else if ('right' in a)
+                return new AxisValues(a.right, a.bottom);
+            return new AxisValues(a.x, a.y);
         };
-        MoveEventSequenceBase.prototype.leaveElement = function ( /* currentElement, prevElement, commonAncestor, options */) {
+        AxisValues.prototype.add = function (p) {
+            this.x += p.x;
+            this.y += p.y;
+            return this;
         };
-        MoveEventSequenceBase.prototype.move = function ( /* element, options */) {
+        AxisValues.prototype.sub = function (p) {
+            this.x -= p.x;
+            this.y -= p.y;
+            return this;
         };
-        MoveEventSequenceBase.prototype.enterElement = function ( /* currentElement, prevElement, commonAncestor, options */) {
+        AxisValues.prototype.round = function (fn) {
+            if (fn === void 0) { fn = Math.round; }
+            this.x = fn(this.x);
+            this.y = fn(this.y);
+            return this;
         };
-        MoveEventSequenceBase.prototype.dragAndDrop = function ( /* dragElement, currentElement, prevElement, options, dragDataStore */) {
+        AxisValues.prototype.eql = function (p) {
+            return this.x === p.x && this.y === p.y;
         };
-        MoveEventSequenceBase.prototype.teardown = function ( /* currentElement, eventOptions, prevElement */) {
+        AxisValues.prototype.mul = function (n) {
+            this.x *= n;
+            this.y *= n;
+            return this;
         };
-        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.isIE)
-                this.move(currentElement, options);
-            if (elementChanged && testCafeCore.domUtils.isElementInDocument(currentElement))
-                this.enterElement(currentElement, prevElement, commonAncestor, options);
-            if (!browserUtils.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 };
+        AxisValues.prototype.distance = function (p) {
+            return Math.sqrt(Math.pow(this.x - p.x, 2) + Math.pow(this.y - p.y, 2));
         };
-        return MoveEventSequenceBase;
+        return AxisValues;
     }());
 
+    function getDevicePoint(clientPoint) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!clientPoint)
+                    return [2 /*return*/, null];
+                return [2 /*return*/, adapter.PromiseCtor.resolve(adapter.position.getWindowPosition())
+                        .then(function (windowPosition) {
+                        var screenLeft = windowPosition.x;
+                        var screenTop = windowPosition.y;
+                        var x = screenLeft + clientPoint.x;
+                        var y = screenTop + clientPoint.y;
+                        return new AxisValues(x, y);
+                    })];
+            });
+        });
+    }
+
     var eventSimulator = hammerhead__default.eventSandbox.eventSimulator;
     var extend = hammerhead__default.utils.extend;
     var nativeMethods = hammerhead__default.nativeMethods;
@@ -206,6 +223,98 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return DragAndDropBehavior;
     }());
 
+    var positionUtils$1 = testCafeCore__default.positionUtils, domUtils = testCafeCore__default.domUtils, eventUtils = testCafeCore__default.eventUtils;
+    function ensureMouseEventAfterScroll(currentElement, element, wasScrolled) {
+        return __awaiter(this, void 0, hammerhead__default.Promise, function () {
+            var elementUnderCursorContainsTarget, prevElement, commonAncestor, clientPosition, devicePoint, options;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        elementUnderCursorContainsTarget = !!currentElement && domUtils.contains(element, currentElement);
+                        if (!elementUnderCursorContainsTarget || !wasScrolled)
+                            return [2 /*return*/];
+                        prevElement = lastHoveredElementHolder.get();
+                        commonAncestor = domUtils.getCommonAncestor(currentElement, prevElement);
+                        return [4 /*yield*/, positionUtils$1.getClientPosition(currentElement)];
+                    case 1:
+                        clientPosition = _a.sent();
+                        return [4 /*yield*/, getDevicePoint(clientPosition)];
+                    case 2:
+                        devicePoint = _a.sent();
+                        if (!devicePoint)
+                            return [2 /*return*/];
+                        options = {
+                            clientX: clientPosition.x,
+                            clientY: clientPosition.y,
+                            screenX: devicePoint.x,
+                            screenY: devicePoint.y,
+                            ctrl: false,
+                            alt: false,
+                            shift: false,
+                            meta: false,
+                            buttons: eventUtils.BUTTONS_PARAMETER.leftButton,
+                        };
+                        MoveBehaviour.leaveElement(currentElement, prevElement, commonAncestor, options);
+                        MoveBehaviour.enterElement(currentElement, prevElement, commonAncestor, options);
+                        lastHoveredElementHolder.set(currentElement);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+
+    var browserUtils = 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.isIE)
+                this.move(currentElement, options);
+            if (elementChanged && testCafeCore.domUtils.isElementInDocument(currentElement))
+                this.enterElement(currentElement, prevElement, commonAncestor, options);
+            if (!browserUtils.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$1 = hammerhead__default.eventSandbox.eventSimulator;
     var TOUCH_MOVE_EVENT_NAME = 'touchmove';
     var MoveEventSequence = /** @class */ (function (_super) {
@@ -294,70 +403,600 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return new DragAndDropFirstMoveEventSequence(options);
     }
 
-    var nativeMethods$1 = hammerhead__default.nativeMethods, Promise = hammerhead__default.Promise, _a = hammerhead__default.utils, browser = _a.browser, featureDetection = _a.featureDetection;
-    var dom = testCafeCore__default.domUtils, position = testCafeCore__default.positionUtils, ScrollAutomation = testCafeCore__default.ScrollAutomation, style = testCafeCore__default.styleUtils, event = testCafeCore__default.eventUtils;
-    initializeAdapter({
-        PromiseCtor: Promise,
-        nativeMethods: nativeMethods$1,
-        scroll: function (el, scrollOptions) { return new ScrollAutomation(el, scrollOptions).run(); },
-        getElementExceptUI: getElementFromPoint,
-        dom: dom, position: position, style: style, event: event, browser: browser, featureDetection: featureDetection,
-        createEventSequence: createEventSequence,
-        sendRequestToFrame: testCafeCore__default.sendRequestToFrame,
-    });
+    var Promise = hammerhead__default.Promise;
+    var messageSandbox = hammerhead__default.eventSandbox.message;
+    function sendRequestToFrame(msg, responseCmd, receiverWindow) {
+        return new Promise(function (resolve) {
+            function onMessage(e) {
+                if (e.message.cmd === responseCmd) {
+                    messageSandbox.off(messageSandbox.SERVICE_MSG_RECEIVED_EVENT, onMessage);
+                    resolve(e.message);
+                }
+            }
+            messageSandbox.on(messageSandbox.SERVICE_MSG_RECEIVED_EVENT, onMessage);
+            messageSandbox.sendServiceMsg(msg, receiverWindow);
+        });
+    }
 
-    var nativeMethods$2 = hammerhead__default.nativeMethods;
-    var MOUSE_EVENT_NAME_RE = /^((mouse\w+)|((dbl)?click)|(contextmenu))$/;
-    var DRAG_EVENT_NAME_RE = /^((drag\w*)|(drop))$/;
-    var KEY_EVENT_NAME_RE = /^key\w+$/;
-    var INPUT_EVENT_NAME_RE = /^(before)?input$/;
-    var FOCUS_EVENT_NAME_RE = /^(blur|(focus(in|out)?))$/;
-    var POINTER_EVENT_NAME_RE = /^pointer\w+/;
-    var DEFAULT_MOUSE_EVENT_DETAIL_PROP_VALUE = {
-        click: 1,
-        dblclick: 2,
-        mousedown: 1,
-        mouseup: 1,
-    };
-    // NOTE: default e.buttons for left button pressed
-    var DEFAULT_BUTTONS_PARAMETER = 1;
-    var EVENT_CTORS = {
-        MouseEvent: 'MouseEvent',
-        PointerEvent: 'PointerEvent',
-        KeyboardEvent: 'KeyboardEvent',
-        InputEvent: 'InputEvent',
-        FocusEvent: 'FocusEvent',
-    };
-    var DispatchEventAutomation = /** @class */ (function () {
-        function DispatchEventAutomation(element, eventName, options) {
-            this.element = element;
-            this.eventName = eventName;
-            this.options = options;
+    function isIframeWindow(window) {
+        return window.top !== window;
+    }
+
+    var Promise$1 = hammerhead__default.Promise;
+    var nativeMethods$1 = hammerhead__default.nativeMethods;
+    var browserUtils$1 = hammerhead__default.utils.browser;
+    var focusBlurSandbox = hammerhead__default.eventSandbox.focusBlur;
+    var contentEditable = testCafeCore__default.contentEditable;
+    var textSelection = testCafeCore__default.textSelection;
+    var domUtils$1 = testCafeCore__default.domUtils;
+    var styleUtils = testCafeCore__default.styleUtils;
+    var messageSandbox$1 = hammerhead__default.eventSandbox.message;
+    var GET_IFRAME_REQUEST_CMD = 'automation|iframe|request';
+    var GET_IFRAME_RESPONSE_CMD = 'automation|iframe|response';
+    messageSandbox$1.on(messageSandbox$1.SERVICE_MSG_RECEIVED_EVENT, function (e) {
+        if (e.message.cmd === GET_IFRAME_REQUEST_CMD) {
+            var iframeElement = domUtils$1.findIframeByWindow(e.source);
+            focusBlurSandbox.focus(iframeElement, function () {
+                messageSandbox$1.sendServiceMsg({ cmd: GET_IFRAME_RESPONSE_CMD }, e.source);
+            }, false);
         }
-        DispatchEventAutomation.prototype.run = function () {
-            var _a = this.options, bubbles = _a.bubbles, cancelable = _a.cancelable, detail = _a.detail, view = _a.view, buttons = _a.buttons;
-            bubbles = bubbles !== false;
-            cancelable = cancelable !== false;
-            detail = detail || DEFAULT_MOUSE_EVENT_DETAIL_PROP_VALUE[this.eventName];
-            view = window;
-            buttons = buttons === void 0 ? DEFAULT_BUTTONS_PARAMETER : buttons;
-            // eslint-disable-next-line no-restricted-globals
-            Object.assign(this.options, { bubbles: bubbles, cancelable: cancelable, detail: detail, view: view, buttons: buttons });
-            var Ctor = DispatchEventAutomation._getEventCtorByEventType(this.eventName, this.options.eventConstructor);
-            if (Ctor) {
-                var event_1 = new Ctor(this.eventName, this.options);
-                this.element.dispatchEvent(event_1);
-            }
-        };
-        DispatchEventAutomation._getEventCtorByEventType = function (eventName, eventConstructor) {
-            if (eventConstructor && typeof DispatchEventAutomation._getEventCtorFromWindow(eventConstructor) === 'function') {
-                var Ctor = DispatchEventAutomation._getEventCtorFromNativeMethods(eventConstructor);
-                if (Ctor && typeof Ctor === 'function')
-                    return Ctor;
+    });
+    function setCaretPosition(element, caretPos) {
+        var isTextEditable = domUtils$1.isTextEditableElement(element);
+        var isContentEditable = domUtils$1.isContentEditableElement(element);
+        if (isTextEditable || isContentEditable) {
+            if (isContentEditable && isNaN(parseInt(caretPos, 10)))
+                textSelection.setCursorToLastVisiblePosition(element);
+            else {
+                var position = isNaN(parseInt(caretPos, 10)) ? domUtils$1.getElementValue(element).length : caretPos;
+                textSelection.select(element, position, position);
             }
-            if (MOUSE_EVENT_NAME_RE.test(eventName))
-                return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.MouseEvent);
-            if (DRAG_EVENT_NAME_RE.test(eventName))
+        }
+        else {
+            // NOTE: if focus is called for a non-contentEditable element (like 'img' or 'button') inside
+            // a contentEditable parent, we should try to set the right window selection. Generally, we can't
+            // set the right window selection object because after the selection setup, the window.getSelection
+            // method returns a different object, which depends on the browser.
+            var contentEditableParent = contentEditable.findContentEditableParent(element);
+            if (contentEditableParent)
+                textSelection.setCursorToLastVisiblePosition(contentEditable.findContentEditableParent(contentEditableParent));
+        }
+    }
+    function focusAndSetSelection(element, simulateFocus, caretPos) {
+        var _this = this;
+        return new Promise$1(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
+            var activeElement, isTextEditable, labelWithForAttr, isElementFocusable, shouldFocusByRelatedElement, isContentEditable, elementForFocus, focusWithSilentMode, focusForMouseEvent, preventScrolling, curDocument, curActiveElement, isActiveElementBody, focusableParent, elementChildOfActiveElement;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!isIframeWindow(window)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, sendRequestToFrame({ cmd: GET_IFRAME_REQUEST_CMD }, GET_IFRAME_RESPONSE_CMD, window.parent)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        activeElement = domUtils$1.getActiveElement();
+                        isTextEditable = domUtils$1.isTextEditableElement(element);
+                        labelWithForAttr = domUtils$1.closest(element, 'label[for]');
+                        isElementFocusable = domUtils$1.isElementFocusable(element);
+                        shouldFocusByRelatedElement = !isElementFocusable && labelWithForAttr;
+                        isContentEditable = domUtils$1.isContentEditableElement(element);
+                        elementForFocus = isContentEditable ? contentEditable.findContentEditableParent(element) : element;
+                        // NOTE: in WebKit, if selection was never set in an input element, the focus method selects all the
+                        // text in this element. So, we should call select before focus to set the caret to the first symbol.
+                        if (simulateFocus && browserUtils$1.isWebKit && isTextEditable)
+                            textSelection.select(element, 0, 0);
+                        // NOTE: we should call focus for the element related with a 'label' that has the 'for' attribute
+                        if (shouldFocusByRelatedElement) {
+                            if (simulateFocus)
+                                focusByLabel(labelWithForAttr);
+                            resolve();
+                            return [2 /*return*/];
+                        }
+                        focusWithSilentMode = !simulateFocus;
+                        focusForMouseEvent = true;
+                        preventScrolling = false;
+                        if (!isElementFocusable && !isContentEditable) {
+                            curDocument = domUtils$1.findDocument(elementForFocus);
+                            curActiveElement = nativeMethods$1.documentActiveElementGetter.call(curDocument);
+                            isActiveElementBody = domUtils$1.isBodyElement(curActiveElement);
+                            focusableParent = domUtils$1.isBodyElement(elementForFocus) ?
+                                elementForFocus : domUtils$1.getFocusableParent(elementForFocus);
+                            elementChildOfActiveElement = curActiveElement && !isActiveElementBody &&
+                                domUtils$1.containsElement(curActiveElement, elementForFocus);
+                            if (elementChildOfActiveElement || isActiveElementBody && domUtils$1.isBodyElement(focusableParent)) {
+                                resolve();
+                                return [2 /*return*/];
+                            }
+                            elementForFocus = focusableParent || curDocument.body;
+                            preventScrolling = true;
+                        }
+                        focusBlurSandbox.focus(elementForFocus, function () {
+                            // NOTE: if a different element was focused in the focus event handler, we should not set selection
+                            if (simulateFocus && !isContentEditable && element !== domUtils$1.getActiveElement()) {
+                                resolve();
+                                return;
+                            }
+                            setCaretPosition(element, caretPos);
+                            // NOTE: we can't avoid the element being focused because the setSelection method leads to focusing.
+                            // So, we just focus the previous active element without handlers if we don't need focus here
+                            if (!simulateFocus && domUtils$1.getActiveElement() !== activeElement)
+                                focusBlurSandbox.focus(activeElement, resolve, true, true);
+                            else
+                                resolve();
+                        }, focusWithSilentMode, focusForMouseEvent, false, preventScrolling);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    }
+    function getElementBoundToLabel(element) {
+        var labelWithForAttr = domUtils$1.closest(element, 'label[for]');
+        var control = labelWithForAttr && (labelWithForAttr.control || document.getElementById(labelWithForAttr.htmlFor));
+        var isControlVisible = control && styleUtils.isElementVisible(control);
+        return isControlVisible ? control : null;
+    }
+    function focusByLabel(label) {
+        if (domUtils$1.isElementFocusable(label))
+            focusBlurSandbox.focus(label, testCafeCore__default.noop, false, true);
+        else
+            focusByRelatedElement(label);
+    }
+    function focusByRelatedElement(element) {
+        var elementForFocus = getElementBoundToLabel(element);
+        if (!elementForFocus || domUtils$1.getActiveElement() === elementForFocus)
+            return;
+        focusBlurSandbox.focus(elementForFocus, testCafeCore__default.noop, false, true);
+    }
+
+    var Promise$2 = hammerhead__default.Promise;
+    var nativeMethods$2 = hammerhead__default.nativeMethods;
+    function nextTick () {
+        return new Promise$2(function (resolve) { return nativeMethods$2.setTimeout.call(window, resolve, 0); });
+    }
+
+    var browserUtils$2 = hammerhead__default.utils.browser;
+    var eventSimulator$3 = hammerhead__default.eventSandbox.eventSimulator;
+    var listeners = hammerhead__default.eventSandbox.listeners;
+    var nativeMethods$3 = hammerhead__default.nativeMethods;
+    var domUtils$2 = testCafeCore__default.domUtils;
+    var styleUtils$1 = testCafeCore__default.styleUtils;
+    var selectElementUI = testCafeUI.selectElement;
+    var ElementClickCommand = /** @class */ (function () {
+        function ElementClickCommand(eventState, eventArgs) {
+            this.eventState = eventState;
+            this.eventArgs = eventArgs;
+        }
+        ElementClickCommand.prototype.run = function () {
+            if (this.eventState.clickElement)
+                eventSimulator$3.click(this.eventState.clickElement, this.eventArgs.options);
+            if (!domUtils$2.isElementFocusable(this.eventArgs.element))
+                focusByRelatedElement(this.eventArgs.element);
+        };
+        return ElementClickCommand;
+    }());
+    var LabelElementClickCommand = /** @class */ (function (_super) {
+        __extends(LabelElementClickCommand, _super);
+        function LabelElementClickCommand(eventState, eventArgs) {
+            var _this = _super.call(this, eventState, eventArgs) || this;
+            _this.label = _this.eventArgs.element;
+            _this.input = getElementBoundToLabel(_this.eventArgs.element);
+            return _this;
+        }
+        LabelElementClickCommand.prototype.run = function () {
+            var _this = this;
+            var focusRaised = false;
+            var ensureFocusRaised = function (e) {
+                focusRaised = nativeMethods$3.eventTargetGetter.call(e) === _this.input;
+            };
+            listeners.addInternalEventBeforeListener(window, ['focus'], ensureFocusRaised);
+            _super.prototype.run.call(this);
+            listeners.removeInternalEventBeforeListener(window, ['focus'], ensureFocusRaised);
+            if (domUtils$2.isElementFocusable(this.label) && !focusRaised)
+                this._ensureBoundElementFocusRaised();
+        };
+        LabelElementClickCommand.prototype._ensureBoundElementFocusRaised = function () {
+            eventSimulator$3.focus(this.input);
+        };
+        return LabelElementClickCommand;
+    }(ElementClickCommand));
+    var SelectElementClickCommand = /** @class */ (function (_super) {
+        __extends(SelectElementClickCommand, _super);
+        function SelectElementClickCommand(eventState, eventArgs) {
+            return _super.call(this, eventState, eventArgs) || this;
+        }
+        SelectElementClickCommand.prototype.run = function () {
+            _super.prototype.run.call(this);
+            this._toggleSelectOptionList();
+        };
+        SelectElementClickCommand.prototype._toggleSelectOptionList = function () {
+            // NOTE: Emulating the click event on the 'select' element doesn't expand the
+            // dropdown with options (except chrome), therefore we should emulate it.
+            var element = this.eventArgs.element;
+            var isSelectWithDropDown = styleUtils$1.getSelectElementSize(element) === 1;
+            if (isSelectWithDropDown && this.eventState.simulateDefaultBehavior !== false) {
+                if (selectElementUI.isOptionListExpanded(element))
+                    selectElementUI.collapseOptionList();
+                else
+                    selectElementUI.expandOptionList(element);
+            }
+        };
+        return SelectElementClickCommand;
+    }(ElementClickCommand));
+    var OptionElementClickCommand = /** @class */ (function (_super) {
+        __extends(OptionElementClickCommand, _super);
+        function OptionElementClickCommand(eventState, eventArgs) {
+            return _super.call(this, eventState, eventArgs) || this;
+        }
+        OptionElementClickCommand.prototype.run = function () {
+            return this.eventArgs.element;
+        };
+        return OptionElementClickCommand;
+    }(ElementClickCommand));
+    var LabelledCheckboxElementClickCommand = /** @class */ (function (_super) {
+        __extends(LabelledCheckboxElementClickCommand, _super);
+        function LabelledCheckboxElementClickCommand(eventState, eventArgs) {
+            var _this = _super.call(this, eventState, eventArgs) || this;
+            _this.checkbox = _this.input;
+            return _this;
+        }
+        LabelledCheckboxElementClickCommand.prototype.run = function () {
+            var changed = false;
+            var onChange = function () {
+                changed = true;
+            };
+            listeners.addInternalEventBeforeListener(window, ['change'], onChange);
+            _super.prototype.run.call(this);
+            listeners.removeInternalEventBeforeListener(window, ['change'], onChange);
+            if (browserUtils$2.isChrome && !changed)
+                this._ensureCheckboxStateChanged();
+        };
+        LabelledCheckboxElementClickCommand.prototype._ensureCheckboxStateChanged = function () {
+            this.checkbox.checked = !this.checkbox.checked;
+            eventSimulator$3.change(this.checkbox);
+        };
+        return LabelledCheckboxElementClickCommand;
+    }(LabelElementClickCommand));
+    function createClickCommand (eventState, eventArgs) {
+        var elementBoundToLabel = getElementBoundToLabel(eventArgs.element);
+        var isSelectElement = domUtils$2.isSelectElement(eventArgs.element);
+        var isOptionElement = domUtils$2.isOptionElement(eventArgs.element);
+        var isLabelElement = domUtils$2.isLabelElement(eventArgs.element) && elementBoundToLabel;
+        var isLabelledCheckbox = elementBoundToLabel && domUtils$2.isCheckboxElement(elementBoundToLabel);
+        if (isSelectElement)
+            return new SelectElementClickCommand(eventState, eventArgs);
+        if (isOptionElement)
+            return new OptionElementClickCommand(eventState, eventArgs);
+        if (isLabelledCheckbox)
+            return new LabelledCheckboxElementClickCommand(eventState, eventArgs);
+        if (isLabelElement)
+            return new LabelElementClickCommand(eventState, eventArgs);
+        return new ElementClickCommand(eventState, eventArgs);
+    }
+
+    var MouseClickStrategyBase = /** @class */ (function () {
+        function MouseClickStrategyBase() {
+        }
+        return MouseClickStrategyBase;
+    }());
+    var MouseClickStrategyEmpty = /** @class */ (function (_super) {
+        __extends(MouseClickStrategyEmpty, _super);
+        function MouseClickStrategyEmpty() {
+            return _super.call(this) || this;
+        }
+        MouseClickStrategyEmpty.prototype.mousedown = function () {
+            throw new Error('not implemented');
+        };
+        MouseClickStrategyEmpty.prototype.mouseup = function () {
+            throw new Error('not implemented');
+        };
+        return MouseClickStrategyEmpty;
+    }(MouseClickStrategyBase));
+
+    // @ts-ignore
+    var Promise$3 = hammerhead__default.Promise;
+    var browserUtils$3 = hammerhead__default.utils.browser;
+    var featureDetection = hammerhead__default.utils.featureDetection;
+    var eventSimulator$4 = hammerhead__default.eventSandbox.eventSimulator;
+    var listeners$1 = hammerhead__default.eventSandbox.listeners;
+    var domUtils$3 = testCafeCore__default.domUtils;
+    var eventUtils$1 = testCafeCore__default.eventUtils;
+    var arrayUtils = testCafeCore__default.arrayUtils;
+    function _getElementForClick(mouseDownElement, topElement, mouseDownElementParentNodes) {
+        var topElementParentNodes = domUtils$3.getParents(topElement);
+        var areElementsSame = domUtils$3.isTheSameNode(topElement, mouseDownElement);
+        // NOTE: Mozilla Firefox always skips click, if an element under cursor has been changed after mousedown.
+        if (browserUtils$3.isFirefox)
+            return areElementsSame ? mouseDownElement : null;
+        if (!areElementsSame) {
+            // @ts-ignore
+            if (mouseDownElement.contains(topElement) && !domUtils$3.isEditableFormElement(topElement))
+                return mouseDownElement;
+            // @ts-ignore
+            if (topElement.contains(mouseDownElement))
+                return topElement;
+            // NOTE: If elements are not in the parent-child relationships,
+            // non-ff browsers raise the `click` event for their common parent.
+            return arrayUtils.getCommonElement(topElementParentNodes, mouseDownElementParentNodes);
+        }
+        // NOTE: In case the target element and the top element are the same,
+        // non-FF browsers are dispatching the `click` event if the target
+        // element hasn't changed its position in the DOM after mousedown.
+        return arrayUtils.equals(mouseDownElementParentNodes, topElementParentNodes) ? mouseDownElement : null;
+    }
+    var MouseClickStrategy = /** @class */ (function (_super) {
+        __extends(MouseClickStrategy, _super);
+        function MouseClickStrategy(element, caretPos) {
+            var _this = _super.call(this) || this;
+            _this.element = element;
+            _this.caretPos = caretPos;
+            _this.targetElementParentNodes = [];
+            _this.activeElementBeforeMouseDown = null;
+            _this.mouseDownElement = null;
+            _this.eventState = {
+                mousedownPrevented: false,
+                blurRaised: false,
+                simulateDefaultBehavior: true,
+                clickElement: null,
+                touchStartCancelled: false,
+                touchEndCancelled: false,
+            };
+            return _this;
+        }
+        MouseClickStrategy.prototype.mousedown = function (eventArgs) {
+            var _this = this;
+            this.targetElementParentNodes = domUtils$3.getParents(eventArgs.element);
+            this.mouseDownElement = eventArgs.element;
+            this._raiseTouchEvents(eventArgs);
+            var activeElement = domUtils$3.getActiveElement();
+            this.activeElementBeforeMouseDown = activeElement;
+            // NOTE: In WebKit and IE, the mousedown event opens the select element's dropdown;
+            // therefore, we should prevent mousedown and hide the dropdown (B236416).
+            var needCloseSelectDropDown = (browserUtils$3.isWebKit || browserUtils$3.isIE) &&
+                domUtils$3.isSelectElement(this.mouseDownElement);
+            if (needCloseSelectDropDown)
+                this._bindMousedownHandler();
+            this._bindBlurHandler(activeElement);
+            if (!this._isTouchEventWasCancelled())
+                this.eventState.simulateDefaultBehavior = eventSimulator$4.mousedown(eventArgs.element, eventArgs.options);
+            if (this.eventState.simulateDefaultBehavior === false)
+                this.eventState.simulateDefaultBehavior = needCloseSelectDropDown && !this.eventState.mousedownPrevented;
+            return this._ensureActiveElementBlur(activeElement)
+                .then(function () { return _this._focus(eventArgs); });
+        };
+        MouseClickStrategy.prototype.mouseup = function (element, eventArgs) {
+            eventArgs.element = element;
+            this.eventState.clickElement = _getElementForClick(this.mouseDownElement, element, this.targetElementParentNodes);
+            var timeStamp = {};
+            var getTimeStamp = function (e) {
+                timeStamp = e.timeStamp;
+                listeners$1.removeInternalEventBeforeListener(window, ['mouseup'], getTimeStamp);
+            };
+            if (!browserUtils$3.isIE)
+                listeners$1.addInternalEventBeforeListener(window, ['mouseup'], getTimeStamp);
+            if (!this._isTouchEventWasCancelled())
+                eventSimulator$4.mouseup(element, eventArgs.options);
+            if (eventArgs.options)
+                eventArgs.options.timeStamp = timeStamp;
+            return this._click(eventArgs);
+        };
+        MouseClickStrategy.prototype._click = function (eventArgs) {
+            return __awaiter(this, void 0, hammerhead__default.Promise, function () {
+                var clickCommand;
+                return __generator(this, function (_a) {
+                    clickCommand = createClickCommand(this.eventState, eventArgs);
+                    if (!this._isTouchEventWasCancelled())
+                        clickCommand.run();
+                    return [2 /*return*/, eventArgs];
+                });
+            });
+        };
+        // NOTE:
+        // If `touchstart`, `touchmove`, or `touchend` are canceled, we should not dispatch any mouse event
+        // that would be a consequential result of the prevented touch event
+        MouseClickStrategy.prototype._isTouchEventWasCancelled = function () {
+            return this.eventState.touchStartCancelled || this.eventState.touchEndCancelled;
+        };
+        MouseClickStrategy.prototype._bindMousedownHandler = function () {
+            var _this = this;
+            var onmousedown = function (e) {
+                _this.eventState.mousedownPrevented = e.defaultPrevented;
+                eventUtils$1.preventDefault(e);
+                eventUtils$1.unbind(_this.element, 'mousedown', onmousedown);
+            };
+            eventUtils$1.bind(this.element, 'mousedown', onmousedown);
+        };
+        MouseClickStrategy.prototype._bindBlurHandler = function (element) {
+            var _this = this;
+            var onblur = function () {
+                _this.eventState.blurRaised = true;
+                eventUtils$1.unbind(element, 'blur', onblur, true);
+            };
+            eventUtils$1.bind(element, 'blur', onblur, true);
+        };
+        MouseClickStrategy.prototype._ensureActiveElementBlur = function (element) {
+            var _this = this;
+            // NOTE: In some cases, mousedown may lead to active element change (browsers raise blur).
+            // We simulate the blur event if the active element was changed after the mousedown, and
+            // the blur event does not get raised automatically (B239273, B253520)
+            return new Promise$3(function (resolve) {
+                var simulateBlur = domUtils$3.getActiveElement() !== element && !_this.eventState.blurRaised;
+                if (!simulateBlur) {
+                    resolve();
+                    return;
+                }
+                if (browserUtils$3.isIE && browserUtils$3.version < 12) {
+                    // NOTE: In whatever way an element is blurred from the client script, the
+                    // blur event is raised asynchronously in IE (in MSEdge focus/blur is sync)
+                    nextTick()
+                        .then(function () {
+                        if (!_this.eventState.blurRaised)
+                            eventSimulator$4.blur(element);
+                        resolve();
+                    });
+                }
+                else {
+                    eventSimulator$4.blur(element);
+                    resolve();
+                }
+            });
+        };
+        MouseClickStrategy.prototype._focus = function (eventArgs) {
+            if (this.eventState.simulateDefaultBehavior === false)
+                return Promise$3.resolve();
+            // NOTE: If a target element is a contentEditable element, we need to call focusAndSetSelection directly for
+            // this element. Otherwise, if the element obtained by elementFromPoint is a child of the contentEditable
+            // element, a selection position may be calculated incorrectly (by using the caretPos option).
+            var elementForFocus = domUtils$3.isContentEditableElement(this.element) ? this.element : eventArgs.element;
+            // NOTE: IE doesn't perform focus if active element has been changed while executing mousedown
+            var simulateFocus = !browserUtils$3.isIE || this.activeElementBeforeMouseDown === domUtils$3.getActiveElement();
+            return focusAndSetSelection(elementForFocus, simulateFocus, this.caretPos);
+        };
+        MouseClickStrategy.prototype._raiseTouchEvents = function (eventArgs) {
+            if (featureDetection.isTouchDevice) {
+                this.eventState.touchStartCancelled = !eventSimulator$4.touchstart(eventArgs.element, eventArgs.options);
+                this.eventState.touchEndCancelled = !eventSimulator$4.touchend(eventArgs.element, eventArgs.options);
+            }
+        };
+        return MouseClickStrategy;
+    }(MouseClickStrategyBase));
+    function createMouseClickStrategy(element, caretPos) {
+        return new MouseClickStrategy(element, caretPos);
+    }
+
+    var Cursor = /** @class */ (function () {
+        function Cursor(activeWin, ui) {
+            this._ui = ui;
+            // NOTE: the default position should be outside of the page (GH-794)
+            this._x = -1;
+            this._y = -1;
+            this._activeWindow = activeWin;
+        }
+        Cursor.prototype._ensureActiveWindow = function (win) {
+            if (this._activeWindow === win || this._activeWindow === win.parent)
+                return;
+            if (this._activeWindow.parent !== win)
+                this._activeWindow = win;
+        };
+        Cursor.prototype.isActive = function (currWin) {
+            this._ensureActiveWindow(currWin);
+            return this._activeWindow === currWin;
+        };
+        Cursor.prototype.setActiveWindow = function (win) {
+            this._activeWindow = win;
+        };
+        Cursor.prototype.getActiveWindow = function (currWin) {
+            this._ensureActiveWindow(currWin);
+            return this._activeWindow;
+        };
+        Cursor.prototype.getPosition = function () {
+            return new AxisValues(this._x, this._y);
+        };
+        Cursor.prototype.move = function (point) {
+            this._x = point.x;
+            this._y = point.y;
+            return this._ui.move(point);
+        };
+        Cursor.prototype.hide = function () {
+            if (this._ui.hide)
+                return this._ui.hide();
+            return adapter.PromiseCtor.resolve();
+        };
+        Cursor.prototype.show = function () {
+            if (this._ui.show)
+                return this._ui.show();
+            return adapter.PromiseCtor.resolve();
+        };
+        Cursor.prototype.leftButtonDown = function () {
+            return this._ui.leftButtonDown();
+        };
+        Cursor.prototype.rightButtonDown = function () {
+            return this._ui.rightButtonDown();
+        };
+        Cursor.prototype.buttonUp = function () {
+            return this._ui.buttonUp();
+        };
+        return Cursor;
+    }());
+
+    var cursorUI = !isIframeWindow(window) ? testCafeUI.cursorUI : testCafeUI.iframeCursorUI;
+    var cursor = new Cursor(window.top, cursorUI);
+
+    var nativeMethods$4 = hammerhead__default.nativeMethods, Promise$4 = hammerhead__default.Promise, _a = hammerhead__default.utils, browser = _a.browser, featureDetection$1 = _a.featureDetection, extend$1 = _a.extend;
+    var dom = testCafeCore__default.domUtils, position = testCafeCore__default.positionUtils, ScrollAutomation = testCafeCore__default.ScrollAutomation, style = testCafeCore__default.styleUtils, event = testCafeCore__default.eventUtils;
+    initializeAdapter({
+        PromiseCtor: Promise$4,
+        nativeMethods: nativeMethods$4,
+        scroll: function (el, scrollOptions) { return new ScrollAutomation(el, scrollOptions).run(); },
+        getElementExceptUI: getElementFromPoint,
+        dom: dom, position: position, style: style, event: event, browser: browser, featureDetection: featureDetection$1,
+        utils: { extend: extend$1 },
+        createEventSequence: createEventSequence,
+        sendRequestToFrame: testCafeCore__default.sendRequestToFrame,
+        ensureMouseEventAfterScroll: ensureMouseEventAfterScroll,
+        automations: {
+            click: {
+                createMouseClickStrategy: createMouseClickStrategy,
+            },
+            _ensureWindowAndCursorForLegacyTests: function (automation) {
+                automation.window = automation.window || window;
+                automation.cursor = cursor;
+            },
+        },
+    });
+
+    var nativeMethods$5 = hammerhead__default.nativeMethods;
+    var MOUSE_EVENT_NAME_RE = /^((mouse\w+)|((dbl)?click)|(contextmenu))$/;
+    var DRAG_EVENT_NAME_RE = /^((drag\w*)|(drop))$/;
+    var KEY_EVENT_NAME_RE = /^key\w+$/;
+    var INPUT_EVENT_NAME_RE = /^(before)?input$/;
+    var FOCUS_EVENT_NAME_RE = /^(blur|(focus(in|out)?))$/;
+    var POINTER_EVENT_NAME_RE = /^pointer\w+/;
+    var DEFAULT_MOUSE_EVENT_DETAIL_PROP_VALUE = {
+        click: 1,
+        dblclick: 2,
+        mousedown: 1,
+        mouseup: 1,
+    };
+    // NOTE: default e.buttons for left button pressed
+    var DEFAULT_BUTTONS_PARAMETER = 1;
+    var EVENT_CTORS = {
+        MouseEvent: 'MouseEvent',
+        PointerEvent: 'PointerEvent',
+        KeyboardEvent: 'KeyboardEvent',
+        InputEvent: 'InputEvent',
+        FocusEvent: 'FocusEvent',
+    };
+    var DispatchEventAutomation = /** @class */ (function () {
+        function DispatchEventAutomation(element, eventName, options) {
+            this.element = element;
+            this.eventName = eventName;
+            this.options = options;
+        }
+        DispatchEventAutomation.prototype.run = function () {
+            var _a = this.options, bubbles = _a.bubbles, cancelable = _a.cancelable, detail = _a.detail, view = _a.view, buttons = _a.buttons;
+            bubbles = bubbles !== false;
+            cancelable = cancelable !== false;
+            detail = detail || DEFAULT_MOUSE_EVENT_DETAIL_PROP_VALUE[this.eventName];
+            view = window;
+            buttons = buttons === void 0 ? DEFAULT_BUTTONS_PARAMETER : buttons;
+            // eslint-disable-next-line no-restricted-globals
+            Object.assign(this.options, { bubbles: bubbles, cancelable: cancelable, detail: detail, view: view, buttons: buttons });
+            var Ctor = DispatchEventAutomation._getEventCtorByEventType(this.eventName, this.options.eventConstructor);
+            if (Ctor) {
+                var event_1 = new Ctor(this.eventName, this.options);
+                this.element.dispatchEvent(event_1);
+            }
+        };
+        DispatchEventAutomation._getEventCtorByEventType = function (eventName, eventConstructor) {
+            if (eventConstructor && typeof DispatchEventAutomation._getEventCtorFromWindow(eventConstructor) === 'function') {
+                var Ctor = DispatchEventAutomation._getEventCtorFromNativeMethods(eventConstructor);
+                if (Ctor && typeof Ctor === 'function')
+                    return Ctor;
+            }
+            if (MOUSE_EVENT_NAME_RE.test(eventName))
+                return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.MouseEvent);
+            if (DRAG_EVENT_NAME_RE.test(eventName))
                 return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.MouseEvent);
             if (POINTER_EVENT_NAME_RE.test(eventName))
                 return DispatchEventAutomation._getEventCtorFromNativeMethods(EVENT_CTORS.PointerEvent);
@@ -370,7 +1009,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             return DispatchEventAutomation._getEventCtorFromNativeMethods('CustomEvent');
         };
         DispatchEventAutomation._getEventCtorFromNativeMethods = function (eventCtor) {
-            var ctor = nativeMethods$2['Window' + eventCtor] || DispatchEventAutomation._getEventCtorFromWindow(eventCtor);
+            var ctor = nativeMethods$5['Window' + eventCtor] || DispatchEventAutomation._getEventCtorFromWindow(eventCtor);
             return ctor;
         };
         DispatchEventAutomation._getEventCtorFromWindow = function (eventCtor) {
@@ -380,35 +1019,37 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return DispatchEventAutomation;
     }());
 
-    var browserUtils$1 = hammerhead__default.utils.browser;
-    function getAutomationPoint(element, offsetX, offsetY) {
-        var roundFn = browserUtils$1.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 getAutomationPoint(element, offset) {
+        return adapter.PromiseCtor.resolve(adapter.dom.isDocumentElement(element))
+            .then(function (isDocEl) {
+            if (isDocEl)
+                return new AxisValues(0, 0);
+            var roundFn = adapter.browser.isFirefox ? Math.ceil : Math.round;
+            return adapter.PromiseCtor.resolve(adapter.position.getOffsetPosition(element, roundFn))
+                .then(function (elementOffset) { return AxisValues.create(elementOffset); });
+        })
+            .then(function (point) { return point.add(offset); });
     }
 
     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 };
+        return __awaiter(this, void 0, void 0, function () {
+            var elementScroll, hasScroll;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, adapter.style.getElementScroll(element)];
+                    case 1:
+                        elementScroll = _a.sent();
+                        return [4 /*yield*/, adapter.style.hasScroll(element)];
+                    case 2:
+                        hasScroll = _a.sent();
+                        if (!/html/i.test(element.tagName) && hasScroll) {
+                            point.x -= elementScroll.left;
+                            point.y -= elementScroll.top;
+                        }
+                        return [2 /*return*/, adapter.position.offsetToClientCoords(point)];
+                }
+            });
+        });
     }
 
     function calcOffset(size) {
@@ -416,104 +1057,108 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return offset < 1 ? 0 : Math.round(offset);
     }
     function getDefaultAutomationOffsets(element) {
-        var rect = testCafeCore.positionUtils.getElementRectangle(element);
-        var offsetX = calcOffset(rect.width);
-        var offsetY = calcOffset(rect.height);
-        return { offsetX: offsetX, offsetY: offsetY };
+        return __awaiter(this, void 0, void 0, function () {
+            var rect, offsetX, offsetY;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, adapter.position.getElementRectangle(element)];
+                    case 1:
+                        rect = _a.sent();
+                        offsetX = calcOffset(rect.width);
+                        offsetY = calcOffset(rect.height);
+                        return [2 /*return*/, { offsetX: offsetX, offsetY: offsetY }];
+                }
+            });
+        });
     }
     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,
-        };
+        return __awaiter(this, void 0, void 0, function () {
+            var defaultOffsets, dimensions, width, height, maxX, maxY;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, getDefaultAutomationOffsets(element)];
+                    case 1:
+                        defaultOffsets = _a.sent();
+                        offsetX = typeof offsetX === 'number' ? Math.round(offsetX) : defaultOffsets.offsetX;
+                        offsetY = typeof offsetY === 'number' ? Math.round(offsetY) : defaultOffsets.offsetY;
+                        if (offsetX > 0 && offsetY > 0)
+                            return [2 /*return*/, { offsetX: offsetX, offsetY: offsetY }];
+                        return [4 /*yield*/, adapter.position.getClientDimensions(element)];
+                    case 2:
+                        dimensions = _a.sent();
+                        width = Math.round(Math.max(element.scrollWidth, dimensions.width));
+                        height = Math.round(Math.max(element.scrollHeight, dimensions.height));
+                        maxX = dimensions.scrollbar.right + dimensions.border.left + dimensions.border.right + width;
+                        maxY = dimensions.scrollbar.bottom + dimensions.border.top + dimensions.border.bottom + height;
+                        return [2 /*return*/, {
+                                offsetX: offsetX < 0 ? maxX + offsetX : offsetX,
+                                offsetY: offsetY < 0 ? maxY + offsetY : offsetY,
+                            }];
+                }
+            });
+        });
     }
 
-    function isIframeWindow(window) {
-        return window.top !== window;
+    function isIframeWindow$1(window) {
+        return !window.parent || window.parent !== window;
     }
 
-    var browserUtils$2 = hammerhead__default.utils.browser;
-    var Promise$1 = hammerhead__default.Promise;
-    var nativeMethods$3 = hammerhead__default.nativeMethods;
-    var positionUtils$1 = testCafeCore__default.positionUtils;
-    var domUtils = testCafeCore__default.domUtils;
-    function fromPoint(point /*: AxisValuesData<number>*/, underTopShadowUIElement) {
-        var topElement = null;
-        return testCafeUI.hide(underTopShadowUIElement)
-            .then(function () {
-            topElement = positionUtils$1.getElementFromPoint(point.x, point.y);
-            return testCafeUI.show(underTopShadowUIElement);
-        })
-            .then(function () { return topElement; });
-    }
     function ensureImageMap(imgElement, areaElement) {
-        var mapElement = domUtils.closest(areaElement, 'map');
-        return mapElement && mapElement.name === imgElement.useMap.substring(1) ? areaElement : imgElement;
+        return adapter.PromiseCtor.resolve(adapter.dom.closest(areaElement, 'map'))
+            .then(function (mapElement) {
+            return mapElement && mapElement.name === adapter.dom.getImgMapName(imgElement) ? areaElement : imgElement;
+        });
     }
-    function findElementOrNonEmptyChildFromPoint(x, y, element) {
-        var topElement = positionUtils$1.getElementFromPoint(x, y);
-        var isNonEmptyChild = domUtils.containsElement(element, topElement) &&
-            nativeMethods$3.nodeTextContentGetter.call(topElement).length;
-        if (topElement && topElement === element || isNonEmptyChild)
-            return topElement;
-        return null;
+    function findElementOrNonEmptyChildFromPoint(point, element) {
+        return adapter.PromiseCtor.resolve(adapter.position.getElementFromPoint(point))
+            .then(function (topElement) {
+            return adapter.PromiseCtor.resolve(adapter.dom.containsElement(element, topElement))
+                .then(function (containsEl) { return containsEl && adapter.dom.getNodeText(topElement); })
+                .then(function (isNonEmptyChild) { return isNonEmptyChild || topElement && adapter.dom.isNodeEqual(topElement, element) ? topElement : null; });
+        });
     }
     function correctTopElementByExpectedElement(topElement, expectedElement) {
-        var expectedElementDefined = expectedElement && domUtils.isDomElement(expectedElement);
-        if (!expectedElementDefined || !topElement || topElement === expectedElement)
+        if (!expectedElement || !topElement || adapter.dom.isNodeEqual(topElement, expectedElement))
             return topElement;
-        var isTREFElement = domUtils.getTagName(expectedElement) === 'tref';
+        var isTREFElement = adapter.dom.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.getTagName(expectedElement) === 'area' && domUtils.isImgElement(topElement);
-        if (browserUtils$2.isFirefox && isImageMapArea)
+        var isImageMapArea = adapter.dom.getTagName(expectedElement) === 'area' && adapter.dom.isImgElement(topElement);
+        if (adapter.browser.isFirefox && isImageMapArea)
             return ensureImageMap(topElement, expectedElement);
         // NOTE: try to find a multi-line link by its rectangle (T163678)
-        var isLinkOrChildExpected = domUtils.isAnchorElement(expectedElement) ||
-            domUtils.getParents(expectedElement, 'a').length;
-        var isTopElementChildOfLink = isLinkOrChildExpected &&
-            domUtils.containsElement(expectedElement, topElement) &&
-            nativeMethods$3.nodeTextContentGetter.call(topElement).length;
-        var shouldSearchForMultilineLink = isLinkOrChildExpected && !isTopElementChildOfLink &&
-            nativeMethods$3.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;
+        return adapter.PromiseCtor.resolve(adapter.dom.closest(expectedElement, 'a'))
+            .then(function (anchor) { return !!anchor; })
+            .then(function (isLinkOrChildExpected) {
+            if (!isLinkOrChildExpected)
+                return false;
+            return adapter.PromiseCtor.resolve(adapter.dom.containsElement(expectedElement, topElement))
+                .then(function (containsElement) { return containsElement && adapter.dom.getNodeText(topElement); })
+                .then(function (isTopElementChildOfLink) { return !isTopElementChildOfLink && adapter.dom.getNodeText(expectedElement); });
+        })
+            .then(function (shouldSearchForMultilineLink) {
+            if (!shouldSearchForMultilineLink)
+                return topElement;
+            return adapter.PromiseCtor.resolve(adapter.position.getClientDimensions(expectedElement))
+                .then(function (linkRect) { return findElementOrNonEmptyChildFromPoint({ x: linkRect.right - 1, y: linkRect.top + 1 }, expectedElement)
+                .then(function (el) { return el || findElementOrNonEmptyChildFromPoint({ x: linkRect.left + 1, y: linkRect.bottom - 1 }, expectedElement); })
+                .then(function (el) { return el || topElement; }); });
+        });
     }
-    function getElementFromPoint$1(point /*: AxisValuesData<number>*/, expectedElement) {
-        return fromPoint(point)
+    function getElementFromPoint$1(point, win, expectedEl) {
+        return adapter.getElementExceptUI(point)
             .then(function (topElement) {
-            var 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) && point.x > 0 && point.y > 0) {
-                resChain = resChain
-                    .then(function () { return fromPoint(point, true); })
-                    .then(function (element) {
-                    foundElement = element;
-                    return element;
-                });
-            }
-            return resChain.then(function (element) { return correctTopElementByExpectedElement(element, expectedElement); });
+            var resChain = adapter.PromiseCtor.resolve(topElement);
+            if (!topElement && isIframeWindow$1(win) && point.x > 0 && point.y > 0)
+                resChain = resChain.then(function () { return adapter.getElementExceptUI(point, true); });
+            return resChain.then(function (element) { return correctTopElementByExpectedElement(element, expectedEl); });
         });
     }
 
@@ -566,6 +1211,15 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return AutomationSettings;
     }());
 
+    function delay(ms) {
+        var setTimeout = adapter.nativeMethods.setTimeout;
+        return new adapter.PromiseCtor(function (resolve) { return setTimeout(resolve, ms); });
+    }
+
+    function nextTick$1() {
+        return delay(0);
+    }
+
     // -------------------------------------------------------------
     // WARNING: this file is used by both the client and the server.
     // Do not use any browser or node-specific API!
@@ -1405,206 +2059,26 @@ window['%hammerhead%'].utils.removeInjectedScript();
             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));
-
-    var AxisValues = /** @class */ (function () {
-        function AxisValues(x, y) {
-            this.x = x;
-            this.y = y;
-        }
-        AxisValues.create = function (a) {
-            if ('left' in a)
-                return new AxisValues(a.left, a.top);
-            else if ('right' in a)
-                return new AxisValues(a.right, a.bottom);
-            return new AxisValues(a.x, a.y);
-        };
-        AxisValues.prototype.add = function (p) {
-            this.x += p.x;
-            this.y += p.y;
-            return this;
-        };
-        AxisValues.prototype.sub = function (p) {
-            this.x -= p.x;
-            this.y -= p.y;
-            return this;
-        };
-        AxisValues.prototype.round = function (fn) {
-            if (fn === void 0) { fn = Math.round; }
-            this.x = fn(this.x);
-            this.y = fn(this.y);
-            return this;
-        };
-        AxisValues.prototype.eql = function (p) {
-            return this.x === p.x && this.y === p.y;
-        };
-        AxisValues.prototype.mul = function (n) {
-            this.x *= n;
-            this.y *= n;
-            return this;
-        };
-        AxisValues.prototype.distance = function (p) {
-            return Math.sqrt(Math.pow(this.x - p.x, 2) + Math.pow(this.y - p.y, 2));
-        };
-        return AxisValues;
-    }());
-
-    var Cursor = /** @class */ (function () {
-        function Cursor(activeWin, ui) {
-            this._ui = ui;
-            // NOTE: the default position should be outside of the page (GH-794)
-            this._x = -1;
-            this._y = -1;
-            this._activeWindow = activeWin;
-        }
-        Cursor.prototype._ensureActiveWindow = function (win) {
-            if (this._activeWindow === win || this._activeWindow === win.parent)
-                return;
-            if (this._activeWindow.parent !== win)
-                this._activeWindow = win;
-        };
-        Cursor.prototype.isActive = function (currWin) {
-            this._ensureActiveWindow(currWin);
-            return this._activeWindow === currWin;
-        };
-        Cursor.prototype.setActiveWindow = function (win) {
-            this._activeWindow = win;
-        };
-        Cursor.prototype.getActiveWindow = function (currWin) {
-            this._ensureActiveWindow(currWin);
-            return this._activeWindow;
-        };
-        Cursor.prototype.getPosition = function () {
-            return new AxisValues(this._x, this._y);
-        };
-        Cursor.prototype.move = function (point) {
-            this._x = point.x;
-            this._y = point.y;
-            return this._ui.move(point);
-        };
-        Cursor.prototype.hide = function () {
-            if (this._ui.hide)
-                return this._ui.hide();
-            return adapter.PromiseCtor.resolve();
-        };
-        Cursor.prototype.show = function () {
-            if (this._ui.show)
-                return this._ui.show();
-            return adapter.PromiseCtor.resolve();
-        };
-        Cursor.prototype.leftButtonDown = function () {
-            return this._ui.leftButtonDown();
-        };
-        Cursor.prototype.rightButtonDown = function () {
-            return this._ui.rightButtonDown();
-        };
-        Cursor.prototype.buttonUp = function () {
-            return this._ui.buttonUp();
+            ];
         };
-        return Cursor;
-    }());
-
-    var cursorUI = !isIframeWindow(window) ? testCafeUI.cursorUI : testCafeUI.iframeCursorUI;
-    var cursor = new Cursor(window.top, cursorUI);
-
-    function getLineYByXCoord(startLine, endLine, x) {
-        if (endLine.x === startLine.x)
-            return 0;
-        var equationSlope = (endLine.y - startLine.y) / (endLine.x - startLine.x);
-        var equationYIntercept = startLine.x * (startLine.y - endLine.y) / (endLine.x - startLine.x) + startLine.y;
-        return Math.round(equationSlope * x + equationYIntercept);
-    }
-    function getLineXByYCoord(startLine, endLine, y) {
-        if (endLine.y - startLine.y === 0)
-            return 0;
-        var equationSlope = (endLine.x - startLine.x) / (endLine.y - startLine.y);
-        var equationXIntercept = startLine.y * (startLine.x - endLine.x) / (endLine.y - startLine.y) + startLine.x;
-        return Math.round(equationSlope * y + equationXIntercept);
-    }
-
-    function findIntersectionHorizontal(startLinePoint, endLinePoint, rectSide) {
-        var intersectionX = getLineXByYCoord(startLinePoint, endLinePoint, rectSide.top);
-        var haveIntersectionInBounds = intersectionX && intersectionX >= rectSide.left && intersectionX <= rectSide.right;
-        return haveIntersectionInBounds ? new AxisValues(intersectionX, rectSide.top) : null;
-    }
-    function findIntersectionVertical(startLinePoint, endLinePoint, rectSide) {
-        var intersectionY = getLineYByXCoord(startLinePoint, endLinePoint, rectSide.left);
-        var haveIntersectionInBounds = intersectionY && intersectionY >= rectSide.top && intersectionY <= rectSide.bottom;
-        return haveIntersectionInBounds ? new AxisValues(rectSide.left, intersectionY) : null;
-    }
-    function getLineRectIntersection (startLine, endLine, rect) {
-        var res = [];
-        var rectLines = [
-            { left: rect.left, top: rect.top, right: rect.left, bottom: rect.bottom, isHorizontal: false },
-            { left: rect.right, top: rect.top, right: rect.right, bottom: rect.bottom, isHorizontal: false },
-            { left: rect.left, top: rect.top, right: rect.right, bottom: rect.top, isHorizontal: true },
-            { left: rect.left, top: rect.bottom, right: rect.right, bottom: rect.bottom, isHorizontal: true },
-        ];
-        for (var _i = 0, rectLines_1 = rectLines; _i < rectLines_1.length; _i++) {
-            var rectLine = rectLines_1[_i];
-            var intersection = rectLine.isHorizontal
-                ? findIntersectionHorizontal(startLine, endLine, rectLine)
-                : findIntersectionVertical(startLine, endLine, rectLine);
-            if (intersection)
-                res.push(intersection);
+        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;
         }
-        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 res[0].distance(startLine) < res[1].distance(startLine) ? res[0] : res[1];
-    }
-
-    var lastHoveredElement = null;
-    var lastHoveredElementHolder = {
-        get: function () {
-            return lastHoveredElement;
-        },
-        set: function (element) {
-            lastHoveredElement = element;
-        },
-    };
-
-    function delay(ms) {
-        var setTimeout = adapter.nativeMethods.setTimeout;
-        return new adapter.PromiseCtor(function (resolve) { return setTimeout(resolve, ms); });
-    }
-
-    function nextTick() {
-        return delay(0);
-    }
-
-    function getAutomationPoint$1(element, offset) {
-        return adapter.PromiseCtor.resolve(adapter.dom.isDocumentElement(element))
-            .then(function (isDocEl) {
-            if (isDocEl)
-                return new AxisValues(0, 0);
-            var roundFn = adapter.browser.isFirefox ? Math.ceil : Math.round;
-            return adapter.PromiseCtor.resolve(adapter.position.getOffsetPosition(element, roundFn))
-                .then(function (elementOffset) { return AxisValues.create(elementOffset); });
-        })
-            .then(function (point) { return point.add(offset); });
-    }
+        PressOptions.prototype._getAssignableProperties = function () {
+            return _super.prototype._getAssignableProperties.call(this).concat([
+                { name: 'confidential', type: booleanOption },
+            ]);
+        };
+        return PressOptions;
+    }(ActionOptions));
 
     function whilst(condition, iterator) {
         return __awaiter(this, void 0, void 0, function () {
@@ -1622,27 +2096,10 @@ window['%hammerhead%'].utils.removeInjectedScript();
         });
     }
 
-    function getDevicePoint$1(clientPoint) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                if (!clientPoint)
-                    return [2 /*return*/, null];
-                return [2 /*return*/, adapter.PromiseCtor.resolve(adapter.position.getWindowPosition())
-                        .then(function (windowPosition) {
-                        var screenLeft = windowPosition.x;
-                        var screenTop = windowPosition.y;
-                        var x = screenLeft + clientPoint.x;
-                        var y = screenTop + clientPoint.y;
-                        return new AxisValues(x, y);
-                    })];
-            });
-        });
-    }
-
     var MOVE_REQUEST_CMD = 'automation|move|request';
     var MOVE_RESPONSE_CMD = 'automation|move|response';
     var MoveAutomation = /** @class */ (function () {
-        function MoveAutomation(el, offset, win, cursor, moveOptions) {
+        function MoveAutomation(el, offset, moveOptions, win, cursor) {
             this.touchMode = adapter.featureDetection.isTouchDevice;
             this.moveEvent = this.touchMode ? 'touchmove' : 'mousemove';
             this.automationSettings = new AutomationSettings(moveOptions.speed);
@@ -1658,7 +2115,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             this.speed = moveOptions.speed;
             this.firstMovingStepOccured = false;
         }
-        MoveAutomation.create = function (el, win, cursor, moveOptions) {
+        MoveAutomation.create = function (el, moveOptions, win, cursor) {
             return __awaiter(this, void 0, void 0, function () {
                 var _a, element, offset;
                 return __generator(this, function (_b) {
@@ -1666,7 +2123,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                         case 0: return [4 /*yield*/, MoveAutomation.getTarget(el, win, new AxisValues(moveOptions.offsetX, moveOptions.offsetY))];
                         case 1:
                             _a = _b.sent(), element = _a.element, offset = _a.offset;
-                            return [2 /*return*/, new MoveAutomation(element, offset, win, cursor, moveOptions)];
+                            return [2 /*return*/, new MoveAutomation(element, offset, moveOptions, win, cursor)];
                     }
                 });
             });
@@ -1678,7 +2135,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 .then(function (containsOffset) {
                 if (!containsOffset) {
                     return Promise$f.all([
-                        getAutomationPoint$1(element, offset),
+                        getAutomationPoint(element, offset),
                         adapter.dom.getDocumentElement(window),
                     ])
                         .then(function (_a) {
@@ -1711,7 +2168,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         MoveAutomation.prototype._getEventSequenceOptions = function (currPosition) {
             var _this = this;
             var button = adapter.event.BUTTONS_PARAMETER.noButton;
-            return getDevicePoint$1(currPosition)
+            return getDevicePoint(currPosition)
                 .then(function (devicePoint) {
                 var eventOptions = {
                     clientX: currPosition.x,
@@ -1764,7 +2221,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                     return null;
                 return _this._emulateEvents(currentElement, currPosition);
             })
-                .then(nextTick);
+                .then(nextTick$1);
         };
         MoveAutomation.prototype._getCorrectedTopElement = function (topElement) {
             return topElement;
@@ -1874,152 +2331,121 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return MoveAutomation;
     }());
 
-    var eventSimulator$3 = hammerhead__default.eventSandbox.eventSimulator;
-    var messageSandbox = hammerhead__default.eventSandbox.message;
-    var positionUtils$2 = testCafeCore__default.positionUtils;
-    var domUtils$1 = testCafeCore__default.domUtils;
-    var styleUtils = testCafeCore__default.styleUtils;
-    var MOVE_REQUEST_CMD$1 = 'automation|move|request';
-    var MOVE_RESPONSE_CMD$1 = 'automation|move|response';
-    function onMoveToIframeRequest(e) {
-        var iframePoint = new AxisValues(e.message.endX, e.message.endY);
-        var iframeWin = e.source;
-        var iframe = domUtils$1.findIframeByWindow(iframeWin);
-        var iframeBorders = styleUtils.getBordersWidth(iframe);
-        var iframePadding = styleUtils.getElementPadding(iframe);
-        var iframeRectangle = positionUtils$2.getIframeClientCoordinates(iframe);
-        var iframePointRelativeToParent = positionUtils$2.getIframePointRelativeToParentFrame(iframePoint, iframeWin);
-        var cursorPosition = cursor.getPosition();
-        var intersectionPoint = positionUtils$2.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 responseMsg = {
-            cmd: MOVE_RESPONSE_CMD$1,
-            x: intersectionRelatedToIframe.x,
-            y: intersectionRelatedToIframe.y,
+    var EventEmitter = /** @class */ (function () {
+        function EventEmitter() {
+            this._eventsListeners = {};
+        }
+        EventEmitter.prototype.on = function (evt, listener) {
+            if (!this._eventsListeners[evt])
+                this._eventsListeners[evt] = [];
+            this._eventsListeners[evt].push(listener);
         };
-        if (cursor.getActiveWindow(window) !== iframeWin) {
-            // const moveAutomation = new MoveAutomation(iframe, moveOptions);
-            MoveAutomation.create(iframe, window, cursor, moveOptions)
-                .then(function (moveAutomation) {
-                return moveAutomation.run();
-            })
-                .then(function () {
-                cursor.setActiveWindow(iframeWin);
-                messageSandbox.sendServiceMsg(responseMsg, iframeWin);
+        EventEmitter.prototype.once = function (evt, listener) {
+            var _this = this;
+            this.on(evt, function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                _this.off(evt, listener);
+                return listener.apply(void 0, args);
             });
-        }
-        else
-            messageSandbox.sendServiceMsg(responseMsg, iframeWin);
-    }
-    function onMoveOutRequest(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 });
+        EventEmitter.prototype.off = function (evt, listener) {
+            var listeners = this._eventsListeners[evt];
+            if (listeners)
+                this._eventsListeners[evt] = adapter.nativeMethods.arrayFilter.call(listeners, function (item) { return item !== listener; });
+        };
+        EventEmitter.prototype.offAll = function (evt) {
+            if (evt)
+                this._eventsListeners[evt] = [];
+            else
+                this._eventsListeners = {};
+        };
+        EventEmitter.prototype.emit = function (evt) {
+            var args = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                args[_i - 1] = arguments[_i];
             }
-            messageSandbox.sendServiceMsg({ cmd: MOVE_RESPONSE_CMD$1 }, parentWin);
-            return;
-        }
-        var cursorPosition = cursor.getPosition();
-        var startPoint = AxisValues.create(iframeRectangle).add(cursorPosition);
-        var endPoint = new AxisValues(e.message.endX, 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.sendServiceMsg({
-                cmd: MOVE_RESPONSE_CMD$1,
-                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);
-        MoveAutomation.create(document.documentElement, window, cursor, moveOptions)
-            .then(function (moveAutomation) {
-            return moveAutomation.run();
-        })
-            .then(function () {
-            var responseMsg = {
-                cmd: MOVE_RESPONSE_CMD$1,
-                x: intersectionPoint.x,
-                y: intersectionPoint.y,
-            };
-            cursor.setActiveWindow(parentWin);
-            messageSandbox.sendServiceMsg(responseMsg, parentWin);
-        });
-    }
-    // Setup cross-iframe interaction
-    messageSandbox.on(messageSandbox.SERVICE_MSG_RECEIVED_EVENT, function (e) {
-        if (e.message.cmd === MOVE_REQUEST_CMD$1) {
-            if (e.source.parent === window)
-                onMoveToIframeRequest(e);
-            else {
-                hammerhead__default.on(hammerhead__default.EVENTS.beforeUnload, function () { return messageSandbox.sendServiceMsg({ cmd: MOVE_RESPONSE_CMD$1 }, e.source); });
-                onMoveOutRequest(e);
+            var listeners = this._eventsListeners[evt];
+            if (!listeners)
+                return;
+            for (var i = 0; i < listeners.length; i++) {
+                try {
+                    listeners[i].apply(this, args);
+                }
+                catch (e) {
+                    // Hack for IE: after document.write calling IFrameSandbox event handlers
+                    // rises 'Can't execute code from a freed script' exception because document has been
+                    // recreated
+                    if (e.message && e.message.indexOf('freed script') > -1)
+                        this.off(evt, listeners[i]);
+                    else
+                        throw e;
+                }
             }
-        }
-    });
+        };
+        return EventEmitter;
+    }());
 
-    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;
+            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, _g = _a.devicePoint, devicePoint = _g === void 0 ? null : _g;
             this.element = element;
             this.clientPoint = clientPoint;
             this.screenPoint = screenPoint;
+            this.devicePoint = devicePoint;
             this.isTarget = isTarget;
             this.inMoving = inMoving;
-            this.devicePoint = getDevicePoint(clientPoint);
         }
+        ElementState.create = function (_a) {
+            var element = _a.element, clientPoint = _a.clientPoint, screenPoint = _a.screenPoint, isTarget = _a.isTarget, inMoving = _a.inMoving;
+            return __awaiter(this, void 0, void 0, function () {
+                var devicePoint, state;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            devicePoint = null;
+                            if (!clientPoint) return [3 /*break*/, 2];
+                            return [4 /*yield*/, getDevicePoint(clientPoint)];
+                        case 1:
+                            devicePoint = _b.sent();
+                            _b.label = 2;
+                        case 2:
+                            state = new ElementState({ element: element, clientPoint: clientPoint, screenPoint: screenPoint, isTarget: isTarget, inMoving: inMoving, devicePoint: devicePoint });
+                            return [2 /*return*/, state];
+                    }
+                });
+            });
+        };
         return ElementState;
     }());
     var VisibleElementAutomation = /** @class */ (function (_super) {
         __extends(VisibleElementAutomation, _super);
-        function VisibleElementAutomation(element, offsetOptions) {
+        function VisibleElementAutomation(element, offsetOptions, win, cursor) {
             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);
+            _this.automationSettings = new AutomationSettings(offsetOptions.speed || 1);
+            _this.window = win;
+            _this.cursor = cursor;
+            // NOTE: only for legacy API
+            adapter.automations._ensureWindowAndCursorForLegacyTests(_this);
             return _this;
         }
         VisibleElementAutomation.prototype._getElementForEvent = function (eventArgs) {
-            var expectedElement = testCafeCore.positionUtils.containsOffset(this.element, this.options.offsetX, this.options.offsetY) ? this.element : null;
-            return getElementFromPoint$1(eventArgs.point, expectedElement);
+            return __awaiter(this, void 0, void 0, function () {
+                var expectedElement;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, adapter.position.containsOffset(this.element, this.options.offsetX, this.options.offsetY)];
+                        case 1:
+                            expectedElement = (_a.sent()) ? this.element : null;
+                            return [2 /*return*/, getElementFromPoint$1(eventArgs.point, this.window, expectedElement)];
+                    }
+                });
+            });
         };
         VisibleElementAutomation.prototype._moveToElement = function () {
             return __awaiter(this, void 0, void 0, function () {
@@ -2028,97 +2454,112 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
-                            moveOptions = new MoveOptions(extend$1({ skipScrolling: true }, this.options), false);
-                            return [4 /*yield*/, MoveAutomation.create(this.element, window, cursor, moveOptions)];
+                            moveOptions = new MoveOptions(adapter.utils.extend({ skipScrolling: true }, this.options), false);
+                            return [4 /*yield*/, MoveAutomation.create(this.element, moveOptions, this.window, this.cursor)];
                         case 1:
                             moveAutomation = _a.sent();
                             return [2 /*return*/, moveAutomation
                                     .run()
-                                    .then(function () { return testCafeCore.delay(_this.automationSettings.mouseActionStepDelay); })];
+                                    .then(function () { return delay(_this.automationSettings.mouseActionStepDelay); })];
                     }
                 });
             });
         };
         VisibleElementAutomation.prototype._scrollToElement = function () {
             var _this = this;
-            var scrollOptions = new ScrollOptions(this.options);
-            var scrollAutomation = new testCafeCore.ScrollAutomation(this.element, scrollOptions);
             var wasScrolled = false;
-            return scrollAutomation
-                .run()
+            var scrollOptions = new ScrollOptions(this.options, false);
+            return adapter.scroll(this.element, scrollOptions)
                 .then(function (scrollWasPerformed) {
                 wasScrolled = scrollWasPerformed;
-                return testCafeCore.delay(_this.automationSettings.mouseActionStepDelay);
+                return delay(_this.automationSettings.mouseActionStepDelay);
             })
-                .then(function () { return getElementFromPoint$1(cursor.getPosition()); })
+                .then(function () { return getElementFromPoint$1(_this.cursor.getPosition(), _this.window); })
                 .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 adapter.ensureMouseEventAfterScroll(currentElement, _this.element, wasScrolled);
+            })
+                .then(function () {
                 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 };
+            return __awaiter(this, void 0, void 0, function () {
+                var defaultOffsets, _a, offsetX, offsetY;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, getOffsetOptions(this.element)];
+                        case 1:
+                            defaultOffsets = _b.sent();
+                            _a = this.options, offsetX = _a.offsetX, offsetY = _a.offsetY;
+                            offsetX = offsetX || offsetX === 0 ? offsetX : defaultOffsets.offsetX;
+                            offsetY = offsetY || offsetY === 0 ? offsetY : defaultOffsets.offsetY;
+                            return [2 /*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 getElementFromPoint$1(clientPoint, expectedElement)
-                    .then(function (element) {
-                    if (!element)
-                        return new ElementState({});
-                    var isTarget = !expectedElement || element === expectedElement || element === _this.element;
-                    if (!isTarget) {
-                        // NOTE: perform an operation with searching in dom only if necessary
-                        isTarget = testCafeCore.arrayUtils.indexOf(testCafeCore.domUtils.getParents(element), _this.element) > -1;
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, x, y, screenPointBeforeAction, clientPositionBeforeAction, screenPointAfterAction, clientPositionAfterAction, clientPoint, expectedElement, element, isTarget, offsetPositionChanged, clientPositionChanged, targetElementIsMoving;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, this._getElementOffset()];
+                        case 1:
+                            _a = _b.sent(), x = _a.offsetX, y = _a.offsetY;
+                            return [4 /*yield*/, getAutomationPoint(this.element, { x: x, y: y })];
+                        case 2:
+                            screenPointBeforeAction = _b.sent();
+                            return [4 /*yield*/, adapter.position.getClientPosition(this.element)];
+                        case 3:
+                            clientPositionBeforeAction = _b.sent();
+                            return [4 /*yield*/, action()];
+                        case 4:
+                            _b.sent();
+                            return [4 /*yield*/, getAutomationPoint(this.element, { x: x, y: y })];
+                        case 5:
+                            screenPointAfterAction = _b.sent();
+                            return [4 /*yield*/, adapter.position.getClientPosition(this.element)];
+                        case 6:
+                            clientPositionAfterAction = _b.sent();
+                            return [4 /*yield*/, convertToClient(this.element, screenPointAfterAction)];
+                        case 7:
+                            clientPoint = _b.sent();
+                            return [4 /*yield*/, adapter.position.containsOffset(this.element, x, y)];
+                        case 8:
+                            expectedElement = (_b.sent()) ? this.element : null;
+                            return [4 /*yield*/, getElementFromPoint$1(clientPoint, this.window, expectedElement)];
+                        case 9:
+                            element = _b.sent();
+                            if (!element) {
+                                return [2 /*return*/, ElementState.create({
+                                        element: null,
+                                        clientPoint: null,
+                                        screenPoint: null,
+                                        isTarget: false,
+                                        inMoving: false,
+                                    })];
+                            }
+                            isTarget = !expectedElement || element === expectedElement || element === this.element;
+                            if (!!isTarget) return [3 /*break*/, 11];
+                            return [4 /*yield*/, this._contains(this.element, element)];
+                        case 10:
+                            // NOTE: perform an operation with searching in dom only if necessary
+                            isTarget = _b.sent();
+                            _b.label = 11;
+                        case 11:
+                            offsetPositionChanged = screenPointBeforeAction.x !== screenPointAfterAction.x ||
+                                screenPointBeforeAction.y !== screenPointAfterAction.y;
+                            clientPositionChanged = clientPositionBeforeAction.x !== clientPositionAfterAction.x ||
+                                clientPositionBeforeAction.y !== clientPositionAfterAction.y;
+                            targetElementIsMoving = offsetPositionChanged && clientPositionChanged;
+                            return [2 /*return*/, ElementState.create({
+                                    element: element,
+                                    clientPoint: clientPoint,
+                                    screenPoint: screenPointAfterAction,
+                                    isTarget: isTarget,
+                                    inMoving: targetElementIsMoving,
+                                })];
                     }
-                    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,
-                    });
                 });
             });
         };
@@ -2131,6 +2572,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
         };
         VisibleElementAutomation.prototype._ensureElement = function (useStrictElementCheck, skipCheckAfterMoving, skipMoving) {
             var _this = this;
+            if (skipCheckAfterMoving === void 0) { skipCheckAfterMoving = false; }
+            if (skipMoving === void 0) { skipMoving = false; }
             return this
                 ._wrapAction(function () { return _this._scrollToElement(); })
                 .then(function (state) { return VisibleElementAutomation._checkElementState(state, useStrictElementCheck); })
@@ -2143,551 +2586,320 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 return state;
             })
                 .then(function (state) {
-                _this.emit(_this.TARGET_ELEMENT_FOUND_EVENT, { element: state.element });
+                _this.emit(_this.TARGET_ELEMENT_FOUND_EVENT, { element: (state === null || state === void 0 ? void 0 : state.element) || null });
                 return {
-                    element: state.element,
-                    clientPoint: state.clientPoint,
-                    screenPoint: state.screenPoint,
-                    devicePoint: state.devicePoint,
+                    element: (state === null || state === void 0 ? void 0 : state.element) || null,
+                    clientPoint: (state === null || state === void 0 ? void 0 : state.clientPoint) || null,
+                    screenPoint: (state === null || state === void 0 ? void 0 : state.screenPoint) || null,
+                    devicePoint: (state === null || state === void 0 ? void 0 : state.devicePoint) || null,
                 };
             });
         };
-        return VisibleElementAutomation;
-    }(testCafeCore.serviceUtils.EventEmitter));
-
-    var Promise$2 = 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$2.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));
-
-    var Promise$3 = hammerhead__default.Promise;
-    var messageSandbox$1 = hammerhead__default.eventSandbox.message;
-    function sendRequestToFrame(msg, responseCmd, receiverWindow) {
-        return new Promise$3(function (resolve) {
-            function onMessage(e) {
-                if (e.message.cmd === responseCmd) {
-                    messageSandbox$1.off(messageSandbox$1.SERVICE_MSG_RECEIVED_EVENT, onMessage);
-                    resolve(e.message);
-                }
-            }
-            messageSandbox$1.on(messageSandbox$1.SERVICE_MSG_RECEIVED_EVENT, onMessage);
-            messageSandbox$1.sendServiceMsg(msg, receiverWindow);
-        });
-    }
-
-    var Promise$4 = hammerhead__default.Promise;
-    var nativeMethods$4 = hammerhead__default.nativeMethods;
-    var browserUtils$3 = hammerhead__default.utils.browser;
-    var focusBlurSandbox = hammerhead__default.eventSandbox.focusBlur;
-    var contentEditable = testCafeCore__default.contentEditable;
-    var textSelection = testCafeCore__default.textSelection;
-    var domUtils$2 = testCafeCore__default.domUtils;
-    var styleUtils$1 = testCafeCore__default.styleUtils;
-    var messageSandbox$2 = hammerhead__default.eventSandbox.message;
-    var GET_IFRAME_REQUEST_CMD = 'automation|iframe|request';
-    var GET_IFRAME_RESPONSE_CMD = 'automation|iframe|response';
-    messageSandbox$2.on(messageSandbox$2.SERVICE_MSG_RECEIVED_EVENT, function (e) {
-        if (e.message.cmd === GET_IFRAME_REQUEST_CMD) {
-            var iframeElement = domUtils$2.findIframeByWindow(e.source);
-            focusBlurSandbox.focus(iframeElement, function () {
-                messageSandbox$2.sendServiceMsg({ cmd: GET_IFRAME_RESPONSE_CMD }, e.source);
-            }, false);
-        }
-    });
-    function setCaretPosition(element, caretPos) {
-        var isTextEditable = domUtils$2.isTextEditableElement(element);
-        var isContentEditable = domUtils$2.isContentEditableElement(element);
-        if (isTextEditable || isContentEditable) {
-            if (isContentEditable && isNaN(parseInt(caretPos, 10)))
-                textSelection.setCursorToLastVisiblePosition(element);
-            else {
-                var position = isNaN(parseInt(caretPos, 10)) ? domUtils$2.getElementValue(element).length : caretPos;
-                textSelection.select(element, position, position);
-            }
-        }
-        else {
-            // NOTE: if focus is called for a non-contentEditable element (like 'img' or 'button') inside
-            // a contentEditable parent, we should try to set the right window selection. Generally, we can't
-            // set the right window selection object because after the selection setup, the window.getSelection
-            // method returns a different object, which depends on the browser.
-            var contentEditableParent = contentEditable.findContentEditableParent(element);
-            if (contentEditableParent)
-                textSelection.setCursorToLastVisiblePosition(contentEditable.findContentEditableParent(contentEditableParent));
-        }
-    }
-    function focusAndSetSelection(element, simulateFocus, caretPos) {
-        var _this = this;
-        return new Promise$4(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
-            var activeElement, isTextEditable, labelWithForAttr, isElementFocusable, shouldFocusByRelatedElement, isContentEditable, elementForFocus, focusWithSilentMode, focusForMouseEvent, preventScrolling, curDocument, curActiveElement, isActiveElementBody, focusableParent, elementChildOfActiveElement;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!isIframeWindow(window)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, sendRequestToFrame({ cmd: GET_IFRAME_REQUEST_CMD }, GET_IFRAME_RESPONSE_CMD, window.parent)];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        activeElement = domUtils$2.getActiveElement();
-                        isTextEditable = domUtils$2.isTextEditableElement(element);
-                        labelWithForAttr = domUtils$2.closest(element, 'label[for]');
-                        isElementFocusable = domUtils$2.isElementFocusable(element);
-                        shouldFocusByRelatedElement = !isElementFocusable && labelWithForAttr;
-                        isContentEditable = domUtils$2.isContentEditableElement(element);
-                        elementForFocus = isContentEditable ? contentEditable.findContentEditableParent(element) : element;
-                        // NOTE: in WebKit, if selection was never set in an input element, the focus method selects all the
-                        // text in this element. So, we should call select before focus to set the caret to the first symbol.
-                        if (simulateFocus && browserUtils$3.isWebKit && isTextEditable)
-                            textSelection.select(element, 0, 0);
-                        // NOTE: we should call focus for the element related with a 'label' that has the 'for' attribute
-                        if (shouldFocusByRelatedElement) {
-                            if (simulateFocus)
-                                focusByLabel(labelWithForAttr);
-                            resolve();
-                            return [2 /*return*/];
-                        }
-                        focusWithSilentMode = !simulateFocus;
-                        focusForMouseEvent = true;
-                        preventScrolling = false;
-                        if (!isElementFocusable && !isContentEditable) {
-                            curDocument = domUtils$2.findDocument(elementForFocus);
-                            curActiveElement = nativeMethods$4.documentActiveElementGetter.call(curDocument);
-                            isActiveElementBody = domUtils$2.isBodyElement(curActiveElement);
-                            focusableParent = domUtils$2.isBodyElement(elementForFocus) ?
-                                elementForFocus : domUtils$2.getFocusableParent(elementForFocus);
-                            elementChildOfActiveElement = curActiveElement && !isActiveElementBody &&
-                                domUtils$2.containsElement(curActiveElement, elementForFocus);
-                            if (elementChildOfActiveElement || isActiveElementBody && domUtils$2.isBodyElement(focusableParent)) {
-                                resolve();
-                                return [2 /*return*/];
-                            }
-                            elementForFocus = focusableParent || curDocument.body;
-                            preventScrolling = true;
-                        }
-                        focusBlurSandbox.focus(elementForFocus, function () {
-                            // NOTE: if a different element was focused in the focus event handler, we should not set selection
-                            if (simulateFocus && !isContentEditable && element !== domUtils$2.getActiveElement()) {
-                                resolve();
-                                return;
+        VisibleElementAutomation.prototype._contains = function (parent, child) {
+            return __awaiter(this, void 0, void 0, function () {
+                var parents, _i, parents_1, el;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, adapter.dom.getParents(child)];
+                        case 1:
+                            parents = _a.sent();
+                            for (_i = 0, parents_1 = parents; _i < parents_1.length; _i++) {
+                                el = parents_1[_i];
+                                if (el === parent)
+                                    return [2 /*return*/, true];
                             }
-                            setCaretPosition(element, caretPos);
-                            // NOTE: we can't avoid the element being focused because the setSelection method leads to focusing.
-                            // So, we just focus the previous active element without handlers if we don't need focus here
-                            if (!simulateFocus && domUtils$2.getActiveElement() !== activeElement)
-                                focusBlurSandbox.focus(activeElement, resolve, true, true);
-                            else
-                                resolve();
-                        }, focusWithSilentMode, focusForMouseEvent, false, preventScrolling);
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    }
-    function getElementBoundToLabel(element) {
-        var labelWithForAttr = domUtils$2.closest(element, 'label[for]');
-        var control = labelWithForAttr && (labelWithForAttr.control || document.getElementById(labelWithForAttr.htmlFor));
-        var isControlVisible = control && styleUtils$1.isElementVisible(control);
-        return isControlVisible ? control : null;
-    }
-    function focusByLabel(label) {
-        if (domUtils$2.isElementFocusable(label))
-            focusBlurSandbox.focus(label, testCafeCore__default.noop, false, true);
-        else
-            focusByRelatedElement(label);
-    }
-    function focusByRelatedElement(element) {
-        var elementForFocus = getElementBoundToLabel(element);
-        if (!elementForFocus || domUtils$2.getActiveElement() === elementForFocus)
-            return;
-        focusBlurSandbox.focus(elementForFocus, testCafeCore__default.noop, false, true);
-    }
-
-    var Promise$5 = hammerhead__default.Promise;
-    var nativeMethods$5 = hammerhead__default.nativeMethods;
-    function nextTick$1 () {
-        return new Promise$5(function (resolve) { return nativeMethods$5.setTimeout.call(window, resolve, 0); });
-    }
-
-    var browserUtils$4 = hammerhead__default.utils.browser;
-    var eventSimulator$4 = hammerhead__default.eventSandbox.eventSimulator;
-    var listeners = hammerhead__default.eventSandbox.listeners;
-    var nativeMethods$6 = hammerhead__default.nativeMethods;
-    var domUtils$3 = testCafeCore__default.domUtils;
-    var styleUtils$2 = testCafeCore__default.styleUtils;
-    var selectElementUI = testCafeUI.selectElement;
-    var ElementClickCommand = /** @class */ (function () {
-        function ElementClickCommand(eventState, eventArgs) {
-            this.eventState = eventState;
-            this.eventArgs = eventArgs;
-        }
-        ElementClickCommand.prototype.run = function () {
-            if (this.eventState.clickElement)
-                eventSimulator$4.click(this.eventState.clickElement, this.eventArgs.options);
-            if (!domUtils$3.isElementFocusable(this.eventArgs.element))
-                focusByRelatedElement(this.eventArgs.element);
-        };
-        return ElementClickCommand;
-    }());
-    var LabelElementClickCommand = /** @class */ (function (_super) {
-        __extends(LabelElementClickCommand, _super);
-        function LabelElementClickCommand(eventState, eventArgs) {
-            var _this = _super.call(this, eventState, eventArgs) || this;
-            _this.label = _this.eventArgs.element;
-            _this.input = getElementBoundToLabel(_this.eventArgs.element);
-            return _this;
-        }
-        LabelElementClickCommand.prototype.run = function () {
-            var _this = this;
-            var focusRaised = false;
-            var ensureFocusRaised = function (e) {
-                focusRaised = nativeMethods$6.eventTargetGetter.call(e) === _this.input;
-            };
-            listeners.addInternalEventBeforeListener(window, ['focus'], ensureFocusRaised);
-            _super.prototype.run.call(this);
-            listeners.removeInternalEventBeforeListener(window, ['focus'], ensureFocusRaised);
-            if (domUtils$3.isElementFocusable(this.label) && !focusRaised)
-                this._ensureBoundElementFocusRaised();
-        };
-        LabelElementClickCommand.prototype._ensureBoundElementFocusRaised = function () {
-            eventSimulator$4.focus(this.input);
-        };
-        return LabelElementClickCommand;
-    }(ElementClickCommand));
-    var SelectElementClickCommand = /** @class */ (function (_super) {
-        __extends(SelectElementClickCommand, _super);
-        function SelectElementClickCommand(eventState, eventArgs) {
-            return _super.call(this, eventState, eventArgs) || this;
-        }
-        SelectElementClickCommand.prototype.run = function () {
-            _super.prototype.run.call(this);
-            this._toggleSelectOptionList();
-        };
-        SelectElementClickCommand.prototype._toggleSelectOptionList = function () {
-            // NOTE: Emulating the click event on the 'select' element doesn't expand the
-            // dropdown with options (except chrome), therefore we should emulate it.
-            var element = this.eventArgs.element;
-            var isSelectWithDropDown = styleUtils$2.getSelectElementSize(element) === 1;
-            if (isSelectWithDropDown && this.eventState.simulateDefaultBehavior !== false) {
-                if (selectElementUI.isOptionListExpanded(element))
-                    selectElementUI.collapseOptionList();
-                else
-                    selectElementUI.expandOptionList(element);
-            }
-        };
-        return SelectElementClickCommand;
-    }(ElementClickCommand));
-    var OptionElementClickCommand = /** @class */ (function (_super) {
-        __extends(OptionElementClickCommand, _super);
-        function OptionElementClickCommand(eventState, eventArgs) {
-            return _super.call(this, eventState, eventArgs) || this;
-        }
-        OptionElementClickCommand.prototype.run = function () {
-            return this.eventArgs.element;
+                            return [2 /*return*/, false];
+                    }
+                });
+            });
         };
-        return OptionElementClickCommand;
-    }(ElementClickCommand));
-    var LabelledCheckboxElementClickCommand = /** @class */ (function (_super) {
-        __extends(LabelledCheckboxElementClickCommand, _super);
-        function LabelledCheckboxElementClickCommand(eventState, eventArgs) {
-            var _this = _super.call(this, eventState, eventArgs) || this;
-            _this.checkbox = _this.input;
+        return VisibleElementAutomation;
+    }(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, window, cursor) || 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;
         }
-        LabelledCheckboxElementClickCommand.prototype.run = function () {
-            var changed = false;
-            var onChange = function () {
-                changed = true;
-            };
-            listeners.addInternalEventBeforeListener(window, ['change'], onChange);
-            _super.prototype.run.call(this);
-            listeners.removeInternalEventBeforeListener(window, ['change'], onChange);
-            if (browserUtils$4.isChrome && !changed)
-                this._ensureCheckboxStateChanged();
+        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;
+            });
         };
-        LabelledCheckboxElementClickCommand.prototype._ensureCheckboxStateChanged = function () {
-            this.checkbox.checked = !this.checkbox.checked;
-            eventSimulator$4.change(this.checkbox);
+        return SetScrollAutomation;
+    }(VisibleElementAutomation));
+
+    var ScrollIntoViewAutomation = /** @class */ (function (_super) {
+        __extends(ScrollIntoViewAutomation, _super);
+        function ScrollIntoViewAutomation(element, offsetOptions) {
+            return _super.call(this, element, offsetOptions, window, cursor) || this;
+        }
+        ScrollIntoViewAutomation.prototype.run = function (useStrictElementCheck) {
+            return this._ensureElement(useStrictElementCheck, true, true);
         };
-        return LabelledCheckboxElementClickCommand;
-    }(LabelElementClickCommand));
-    function createClickCommand (eventState, eventArgs) {
-        var elementBoundToLabel = getElementBoundToLabel(eventArgs.element);
-        var isSelectElement = domUtils$3.isSelectElement(eventArgs.element);
-        var isOptionElement = domUtils$3.isOptionElement(eventArgs.element);
-        var isLabelElement = domUtils$3.isLabelElement(eventArgs.element) && elementBoundToLabel;
-        var isLabelledCheckbox = elementBoundToLabel && domUtils$3.isCheckboxElement(elementBoundToLabel);
-        if (isSelectElement)
-            return new SelectElementClickCommand(eventState, eventArgs);
-        if (isOptionElement)
-            return new OptionElementClickCommand(eventState, eventArgs);
-        if (isLabelledCheckbox)
-            return new LabelledCheckboxElementClickCommand(eventState, eventArgs);
-        if (isLabelElement)
-            return new LabelElementClickCommand(eventState, eventArgs);
-        return new ElementClickCommand(eventState, eventArgs);
-    }
+        return ScrollIntoViewAutomation;
+    }(VisibleElementAutomation));
 
-    var Promise$6 = hammerhead__default.Promise;
-    var extend$2 = hammerhead__default.utils.extend;
-    var browserUtils$5 = hammerhead__default.utils.browser;
-    var featureDetection$1 = hammerhead__default.utils.featureDetection;
-    var eventSimulator$5 = hammerhead__default.eventSandbox.eventSimulator;
-    var listeners$1 = hammerhead__default.eventSandbox.listeners;
-    var domUtils$4 = testCafeCore__default.domUtils;
-    var eventUtils = testCafeCore__default.eventUtils;
-    var arrayUtils = testCafeCore__default.arrayUtils;
-    var delay$1 = testCafeCore__default.delay;
     var ClickAutomation = /** @class */ (function (_super) {
         __extends(ClickAutomation, _super);
-        function ClickAutomation(element, clickOptions) {
-            var _this = _super.call(this, element, clickOptions) || this;
+        function ClickAutomation(element, clickOptions, win, cursor) {
+            var _this = _super.call(this, element, clickOptions, win, cursor) || this;
             _this.modifiers = clickOptions.modifiers;
-            _this.caretPos = clickOptions.caretPos;
-            _this.targetElementParentNodes = [];
-            _this.activeElementBeforeMouseDown = null;
-            _this.mouseDownElement = null;
-            _this.eventState = {
-                mousedownPrevented: false,
-                blurRaised: false,
-                simulateDefaultBehavior: true,
-                clickElement: null,
-                touchStartCancelled: false,
-                touchEndCancelled: false,
-            };
+            _this.strategy = adapter.automations.click.createMouseClickStrategy(_this.element, clickOptions.caretPos);
             return _this;
         }
-        ClickAutomation.prototype._bindMousedownHandler = function () {
-            var _this = this;
-            var onmousedown = function (e) {
-                _this.eventState.mousedownPrevented = e.defaultPrevented;
-                eventUtils.preventDefault(e);
-                eventUtils.unbind(_this.element, 'mousedown', onmousedown);
-            };
-            eventUtils.bind(this.element, 'mousedown', onmousedown);
-        };
-        ClickAutomation.prototype._bindBlurHandler = function (element) {
-            var _this = this;
-            var onblur = function () {
-                _this.eventState.blurRaised = true;
-                eventUtils.unbind(element, 'blur', onblur, true);
-            };
-            eventUtils.bind(element, 'blur', onblur, true);
-        };
-        // NOTE:
-        // If `touchstart`, `touchmove`, or `touchend` are canceled, we should not dispatch any mouse event
-        // that would be a consequential result of the prevented touch event
-        ClickAutomation.prototype._isTouchEventWasCancelled = function () {
-            return this.eventState.touchStartCancelled || this.eventState.touchEndCancelled;
-        };
-        ClickAutomation.prototype._raiseTouchEvents = function (eventArgs) {
-            if (featureDetection$1.isTouchDevice) {
-                this.eventState.touchStartCancelled = !eventSimulator$5.touchstart(eventArgs.element, eventArgs.options);
-                this.eventState.touchEndCancelled = !eventSimulator$5.touchend(eventArgs.element, eventArgs.options);
-            }
-        };
         ClickAutomation.prototype._mousedown = function (eventArgs) {
-            var _this = this;
-            this.targetElementParentNodes = domUtils$4.getParents(eventArgs.element);
-            this.mouseDownElement = eventArgs.element;
-            return cursor
-                .leftButtonDown()
-                .then(function () {
-                _this._raiseTouchEvents(eventArgs);
-                var activeElement = domUtils$4.getActiveElement();
-                _this.activeElementBeforeMouseDown = activeElement;
-                // NOTE: In WebKit and IE, the mousedown event opens the select element's dropdown;
-                // therefore, we should prevent mousedown and hide the dropdown (B236416).
-                var needCloseSelectDropDown = (browserUtils$5.isWebKit || browserUtils$5.isIE) &&
-                    domUtils$4.isSelectElement(_this.mouseDownElement);
-                if (needCloseSelectDropDown)
-                    _this._bindMousedownHandler();
-                _this._bindBlurHandler(activeElement);
-                if (!_this._isTouchEventWasCancelled())
-                    _this.eventState.simulateDefaultBehavior = eventSimulator$5.mousedown(eventArgs.element, eventArgs.options);
-                if (_this.eventState.simulateDefaultBehavior === false)
-                    _this.eventState.simulateDefaultBehavior = needCloseSelectDropDown && !_this.eventState.mousedownPrevented;
-                return _this._ensureActiveElementBlur(activeElement);
-            })
-                .then(function () { return _this._focus(eventArgs); });
-        };
-        ClickAutomation.prototype._ensureActiveElementBlur = function (element) {
-            var _this = this;
-            // NOTE: In some cases, mousedown may lead to active element change (browsers raise blur).
-            // We simulate the blur event if the active element was changed after the mousedown, and
-            // the blur event does not get raised automatically (B239273, B253520)
-            return new Promise$6(function (resolve) {
-                var simulateBlur = domUtils$4.getActiveElement() !== element && !_this.eventState.blurRaised;
-                if (!simulateBlur) {
-                    resolve();
-                    return;
-                }
-                if (browserUtils$5.isIE && browserUtils$5.version < 12) {
-                    // NOTE: In whatever way an element is blurred from the client script, the
-                    // blur event is raised asynchronously in IE (in MSEdge focus/blur is sync)
-                    nextTick$1()
-                        .then(function () {
-                        if (!_this.eventState.blurRaised)
-                            eventSimulator$5.blur(element);
-                        resolve();
-                    });
-                }
-                else {
-                    eventSimulator$5.blur(element);
-                    resolve();
-                }
-            });
-        };
-        ClickAutomation.prototype._focus = function (eventArgs) {
-            if (this.eventState.simulateDefaultBehavior === false)
-                return Promise$6.resolve();
-            // NOTE: If a target element is a contentEditable element, we need to call focusAndSetSelection directly for
-            // this element. Otherwise, if the element obtained by elementFromPoint is a child of the contentEditable
-            // element, a selection position may be calculated incorrectly (by using the caretPos option).
-            var elementForFocus = domUtils$4.isContentEditableElement(this.element) ? this.element : eventArgs.element;
-            // NOTE: IE doesn't perform focus if active element has been changed while executing mousedown
-            var simulateFocus = !browserUtils$5.isIE || this.activeElementBeforeMouseDown === domUtils$4.getActiveElement();
-            return focusAndSetSelection(elementForFocus, simulateFocus, this.caretPos);
+            return this.strategy.mousedown(eventArgs);
         };
-        ClickAutomation._getElementForClick = function (mouseDownElement, topElement, mouseDownElementParentNodes) {
-            var topElementParentNodes = domUtils$4.getParents(topElement);
-            var areElementsSame = domUtils$4.isTheSameNode(topElement, mouseDownElement);
-            // NOTE: Mozilla Firefox always skips click, if an element under cursor has been changed after mousedown.
-            if (browserUtils$5.isFirefox)
-                return areElementsSame ? mouseDownElement : null;
-            if (!areElementsSame) {
-                if (mouseDownElement.contains(topElement) && !domUtils$4.isEditableFormElement(topElement))
-                    return mouseDownElement;
-                if (topElement.contains(mouseDownElement))
-                    return topElement;
-                // NOTE: If elements are not in the parent-child relationships,
-                // non-ff browsers raise the `click` event for their common parent.
-                return arrayUtils.getCommonElement(topElementParentNodes, mouseDownElementParentNodes);
-            }
-            // NOTE: In case the target element and the top element are the same,
-            // non-FF browsers are dispatching the `click` event if the target
-            // element hasn't changed its position in the DOM after mousedown.
-            return arrayUtils.equals(mouseDownElementParentNodes, topElementParentNodes) ? mouseDownElement : null;
+        ClickAutomation.prototype._mouseup = function (element, eventArgs) {
+            return this.strategy.mouseup(element, eventArgs);
         };
-        ClickAutomation.prototype._mouseup = function (eventArgs) {
+        ClickAutomation.prototype.run = function (useStrictElementCheck) {
             var _this = this;
-            return cursor
-                .buttonUp()
+            var eventArgs;
+            return this
+                ._ensureElement(useStrictElementCheck)
+                .then(function (_a) {
+                var element = _a.element, clientPoint = _a.clientPoint, screenPoint = _a.screenPoint, devicePoint = _a.devicePoint;
+                eventArgs = {
+                    point: clientPoint,
+                    screenPoint: screenPoint,
+                    element: element,
+                    options: adapter.utils.extend({
+                        clientX: clientPoint === null || clientPoint === void 0 ? void 0 : clientPoint.x,
+                        clientY: clientPoint === null || clientPoint === void 0 ? void 0 : clientPoint.y,
+                        screenX: devicePoint === null || devicePoint === void 0 ? void 0 : devicePoint.x,
+                        screenY: devicePoint === null || devicePoint === void 0 ? void 0 : devicePoint.y,
+                    }, _this.modifiers),
+                };
+                // NOTE: we should raise mouseup event with 'mouseActionStepDelay' after we trigger
+                // mousedown event regardless of how long mousedown event handlers were executing
+                return Promise$f.all([delay(_this.automationSettings.mouseActionStepDelay), _this.cursor
+                        .leftButtonDown()
+                        .then(function () { return _this._mousedown(eventArgs); }),
+                ]);
+            })
+                .then(function () { return _this.cursor.buttonUp(); })
                 .then(function () { return _this._getElementForEvent(eventArgs); })
                 .then(function (element) {
-                eventArgs.element = element;
-                _this.eventState.clickElement = ClickAutomation._getElementForClick(_this.mouseDownElement, element, _this.targetElementParentNodes);
-                var timeStamp = {};
-                var getTimeStamp = function (e) {
-                    timeStamp = e.timeStamp;
-                    listeners$1.removeInternalEventBeforeListener(window, ['mouseup'], getTimeStamp);
-                };
-                if (!browserUtils$5.isIE)
-                    listeners$1.addInternalEventBeforeListener(window, ['mouseup'], getTimeStamp);
-                if (!_this._isTouchEventWasCancelled())
-                    eventSimulator$5.mouseup(element, eventArgs.options);
-                return { timeStamp: timeStamp };
+                return element ? _this._mouseup(element, eventArgs) : null;
             });
         };
-        ClickAutomation.prototype._click = function (eventArgs) {
-            var clickCommand = createClickCommand(this.eventState, eventArgs);
-            if (!this._isTouchEventWasCancelled())
-                clickCommand.run();
-            return eventArgs;
+        return ClickAutomation;
+    }(VisibleElementAutomation));
+
+    function getLineYByXCoord(startLine, endLine, x) {
+        if (endLine.x === startLine.x)
+            return 0;
+        var equationSlope = (endLine.y - startLine.y) / (endLine.x - startLine.x);
+        var equationYIntercept = startLine.x * (startLine.y - endLine.y) / (endLine.x - startLine.x) + startLine.y;
+        return Math.round(equationSlope * x + equationYIntercept);
+    }
+    function getLineXByYCoord(startLine, endLine, y) {
+        if (endLine.y - startLine.y === 0)
+            return 0;
+        var equationSlope = (endLine.x - startLine.x) / (endLine.y - startLine.y);
+        var equationXIntercept = startLine.y * (startLine.x - endLine.x) / (endLine.y - startLine.y) + startLine.x;
+        return Math.round(equationSlope * y + equationXIntercept);
+    }
+
+    function findIntersectionHorizontal(startLinePoint, endLinePoint, rectSide) {
+        var intersectionX = getLineXByYCoord(startLinePoint, endLinePoint, rectSide.top);
+        var haveIntersectionInBounds = intersectionX && intersectionX >= rectSide.left && intersectionX <= rectSide.right;
+        return haveIntersectionInBounds ? new AxisValues(intersectionX, rectSide.top) : null;
+    }
+    function findIntersectionVertical(startLinePoint, endLinePoint, rectSide) {
+        var intersectionY = getLineYByXCoord(startLinePoint, endLinePoint, rectSide.left);
+        var haveIntersectionInBounds = intersectionY && intersectionY >= rectSide.top && intersectionY <= rectSide.bottom;
+        return haveIntersectionInBounds ? new AxisValues(rectSide.left, intersectionY) : null;
+    }
+    function getLineRectIntersection (startLine, endLine, rect) {
+        var res = [];
+        var rectLines = [
+            { left: rect.left, top: rect.top, right: rect.left, bottom: rect.bottom, isHorizontal: false },
+            { left: rect.right, top: rect.top, right: rect.right, bottom: rect.bottom, isHorizontal: false },
+            { left: rect.left, top: rect.top, right: rect.right, bottom: rect.top, isHorizontal: true },
+            { left: rect.left, top: rect.bottom, right: rect.right, bottom: rect.bottom, isHorizontal: true },
+        ];
+        for (var _i = 0, rectLines_1 = rectLines; _i < rectLines_1.length; _i++) {
+            var rectLine = rectLines_1[_i];
+            var intersection = rectLine.isHorizontal
+                ? findIntersectionHorizontal(startLine, endLine, rectLine)
+                : findIntersectionVertical(startLine, endLine, rectLine);
+            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 res[0].distance(startLine) < res[1].distance(startLine) ? res[0] : res[1];
+    }
+
+    var eventSimulator$5 = hammerhead__default.eventSandbox.eventSimulator;
+    var messageSandbox$2 = hammerhead__default.eventSandbox.message;
+    var positionUtils$2 = testCafeCore__default.positionUtils;
+    var domUtils$4 = testCafeCore__default.domUtils;
+    var styleUtils$2 = testCafeCore__default.styleUtils;
+    var MOVE_REQUEST_CMD$1 = 'automation|move|request';
+    var MOVE_RESPONSE_CMD$1 = 'automation|move|response';
+    function onMoveToIframeRequest(e) {
+        var iframePoint = new AxisValues(e.message.endX, e.message.endY);
+        var iframeWin = e.source;
+        var iframe = domUtils$4.findIframeByWindow(iframeWin);
+        var iframeBorders = styleUtils$2.getBordersWidth(iframe);
+        var iframePadding = styleUtils$2.getElementPadding(iframe);
+        var iframeRectangle = positionUtils$2.getIframeClientCoordinates(iframe);
+        var iframePointRelativeToParent = positionUtils$2.getIframePointRelativeToParentFrame(iframePoint, iframeWin);
+        var cursorPosition = cursor.getPosition();
+        var intersectionPoint = positionUtils$2.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 responseMsg = {
+            cmd: MOVE_RESPONSE_CMD$1,
+            x: intersectionRelatedToIframe.x,
+            y: intersectionRelatedToIframe.y,
         };
-        ClickAutomation.prototype.run = function (useStrictElementCheck) {
-            var _this = this;
-            var eventArgs = null;
-            return this
-                ._ensureElement(useStrictElementCheck)
-                .then(function (_a) {
-                var element = _a.element, clientPoint = _a.clientPoint, screenPoint = _a.screenPoint, devicePoint = _a.devicePoint;
-                eventArgs = {
-                    point: clientPoint,
-                    screenPoint: screenPoint,
-                    element: element,
-                    options: extend$2({
-                        clientX: clientPoint.x,
-                        clientY: clientPoint.y,
-                        screenX: devicePoint.x,
-                        screenY: devicePoint.y,
-                    }, _this.modifiers),
-                };
-                // NOTE: we should raise mouseup event with 'mouseActionStepDelay' after we trigger
-                // mousedown event regardless of how long mousedown event handlers were executing
-                return Promise$6.all([delay$1(_this.automationSettings.mouseActionStepDelay), _this._mousedown(eventArgs)]);
+        if (cursor.getActiveWindow(window) !== iframeWin) {
+            // const moveAutomation = new MoveAutomation(iframe, moveOptions);
+            MoveAutomation.create(iframe, moveOptions, window, cursor)
+                .then(function (moveAutomation) {
+                return moveAutomation.run();
             })
-                .then(function () { return _this._mouseup(eventArgs); })
-                .then(function (_a) {
-                var timeStamp = _a.timeStamp;
-                eventArgs.options.timeStamp = timeStamp;
-                return _this._click(eventArgs);
+                .then(function () {
+                cursor.setActiveWindow(iframeWin);
+                messageSandbox$2.sendServiceMsg(responseMsg, iframeWin);
             });
+        }
+        else
+            messageSandbox$2.sendServiceMsg(responseMsg, iframeWin);
+    }
+    function onMoveOutRequest(e) {
+        var parentWin = e.source;
+        var iframeRectangle = {
+            left: e.message.left,
+            right: e.message.right,
+            top: e.message.top,
+            bottom: e.message.bottom,
         };
-        return ClickAutomation;
-    }(VisibleElementAutomation));
+        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$5.mouseout(element, { clientX: clientX, clientY: clientY, relatedTarget: null });
+                eventSimulator$5.mouseleave(element, { clientX: clientX, clientY: clientY, relatedTarget: null });
+            }
+            messageSandbox$2.sendServiceMsg({ cmd: MOVE_RESPONSE_CMD$1 }, parentWin);
+            return;
+        }
+        var cursorPosition = cursor.getPosition();
+        var startPoint = AxisValues.create(iframeRectangle).add(cursorPosition);
+        var endPoint = new AxisValues(e.message.endX, 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$1,
+                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);
+        MoveAutomation.create(document.documentElement, moveOptions, window, cursor)
+            .then(function (moveAutomation) {
+            return moveAutomation.run();
+        })
+            .then(function () {
+            var responseMsg = {
+                cmd: MOVE_RESPONSE_CMD$1,
+                x: intersectionPoint.x,
+                y: intersectionPoint.y,
+            };
+            cursor.setActiveWindow(parentWin);
+            messageSandbox$2.sendServiceMsg(responseMsg, parentWin);
+        });
+    }
+    // Setup cross-iframe interaction
+    messageSandbox$2.on(messageSandbox$2.SERVICE_MSG_RECEIVED_EVENT, function (e) {
+        if (e.message.cmd === MOVE_REQUEST_CMD$1) {
+            if (e.source.parent === window)
+                onMoveToIframeRequest(e);
+            else {
+                hammerhead__default.on(hammerhead__default.EVENTS.beforeUnload, function () { return messageSandbox$2.sendServiceMsg({ cmd: MOVE_RESPONSE_CMD$1 }, e.source); });
+                onMoveOutRequest(e);
+            }
+        }
+    });
 
-    var Promise$7 = hammerhead__default.Promise;
-    var browserUtils$6 = hammerhead__default.utils.browser;
+    var Promise$6 = hammerhead__default.Promise;
+    var browserUtils$4 = hammerhead__default.utils.browser;
     var featureDetection$2 = hammerhead__default.utils.featureDetection;
     var eventSimulator$6 = hammerhead__default.eventSandbox.eventSimulator;
     var focusBlurSandbox$1 = hammerhead__default.eventSandbox.focusBlur;
-    var nativeMethods$7 = hammerhead__default.nativeMethods;
+    var nativeMethods$6 = hammerhead__default.nativeMethods;
     var domUtils$5 = testCafeCore__default.domUtils;
     var styleUtils$3 = testCafeCore__default.styleUtils;
-    var delay$2 = testCafeCore__default.delay;
+    var delay$1 = testCafeCore__default.delay;
     var selectElementUI$1 = testCafeUI.selectElement;
     var FOCUS_DELAY = featureDetection$2.isTouchDevice ? 0 : 160;
     var SelectChildClickAutomation = /** @class */ (function () {
@@ -2708,7 +2920,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 var selectedIndex = this.parentSelect.selectedIndex;
                 this.childIndex = isOption ? domUtils$5.getElementIndexInParent(this.parentSelect, this.element) :
                     domUtils$5.getElementIndexInParent(this.parentSelect, this.element);
-                var parent_1 = nativeMethods$7.nodeParentNodeGetter.call(this.element);
+                var parent_1 = nativeMethods$6.nodeParentNodeGetter.call(this.element);
                 var parentOptGroup = domUtils$5.isOptionGroupElement(parent_1) ? parent_1 : null;
                 var isDisabled = this.element.disabled || parentOptGroup && parentOptGroup.disabled;
                 this.clickCausesChange = isOption && !isDisabled && this.childIndex !== selectedIndex;
@@ -2723,7 +2935,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             var parentSelectSize = styleUtils$3.getSelectElementSize(this.parentSelect) > 1;
             return {
                 options: this.modifiers,
-                element: browserUtils$6.isIE && parentSelectSize ? this.parentSelect : childElement,
+                element: browserUtils$4.isIE && parentSelectSize ? this.parentSelect : childElement,
             };
         };
         SelectChildClickAutomation.prototype._getMoveArguments = function () {
@@ -2753,21 +2965,21 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 speed: speed,
                 modifiers: this.modifiers,
             }, false);
-            return MoveAutomation.create(element, window, cursor, moveOptions)
+            return MoveAutomation.create(element, moveOptions, window, cursor)
                 .then(function (moveAutomation) {
                 return moveAutomation.run();
             })
-                .then(function () { return delay$2(_this.automationSettings.mouseActionStepDelay); });
+                .then(function () { return delay$1(_this.automationSettings.mouseActionStepDelay); });
         };
         SelectChildClickAutomation.prototype._mousedown = function () {
             var _this = this;
-            if (browserUtils$6.isFirefox) {
+            if (browserUtils$4.isFirefox) {
                 eventSimulator$6.mousedown(this.eventsArgs.element, this.eventsArgs.options);
                 if (this.clickCausesChange)
                     this.parentSelect.selectedIndex = this.childIndex;
                 return this._focus();
             }
-            if (browserUtils$6.isIE) {
+            if (browserUtils$4.isIE) {
                 eventSimulator$6.mousedown(this.eventsArgs.element, this.eventsArgs.options);
                 return this._focus();
             }
@@ -2776,7 +2988,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             // That's why we should change the event order and raise focus before mousedown.
             return this
                 ._focus()
-                .then(function () { return delay$2(FOCUS_DELAY); })
+                .then(function () { return delay$1(FOCUS_DELAY); })
                 .then(function () {
                 eventSimulator$6.mousedown(_this.eventsArgs.element, _this.eventsArgs.options);
                 if (_this.clickCausesChange)
@@ -2785,23 +2997,23 @@ window['%hammerhead%'].utils.removeInjectedScript();
         };
         SelectChildClickAutomation.prototype._focus = function () {
             var _this = this;
-            return new Promise$7(function (resolve) {
+            return new Promise$6(function (resolve) {
                 focusBlurSandbox$1.focus(_this.parentSelect, resolve, false, true);
             });
         };
         SelectChildClickAutomation.prototype._mouseup = function () {
-            var elementForMouseupEvent = browserUtils$6.isIE ? this.parentSelect : this.eventsArgs.element;
+            var elementForMouseupEvent = browserUtils$4.isIE ? this.parentSelect : this.eventsArgs.element;
             eventSimulator$6.mouseup(elementForMouseupEvent, this.eventsArgs.options);
-            if (browserUtils$6.isIE && this.clickCausesChange)
+            if (browserUtils$4.isIE && this.clickCausesChange)
                 this.parentSelect.selectedIndex = this.childIndex;
-            var simulateInputEventOnValueChange = browserUtils$6.isFirefox || browserUtils$6.isSafari ||
-                browserUtils$6.isChrome && browserUtils$6.version >= 53;
-            var simulateChangeEventOnValueChange = simulateInputEventOnValueChange || browserUtils$6.isIE;
+            var simulateInputEventOnValueChange = browserUtils$4.isFirefox || browserUtils$4.isSafari ||
+                browserUtils$4.isChrome && browserUtils$4.version >= 53;
+            var simulateChangeEventOnValueChange = simulateInputEventOnValueChange || browserUtils$4.isIE;
             if (simulateInputEventOnValueChange && this.clickCausesChange)
                 eventSimulator$6.input(this.parentSelect);
             if (simulateChangeEventOnValueChange && this.clickCausesChange)
                 eventSimulator$6.change(this.parentSelect);
-            return Promise$7.resolve();
+            return Promise$6.resolve();
         };
         SelectChildClickAutomation.prototype._click = function () {
             eventSimulator$6.click(this.eventsArgs.element, this.eventsArgs.options);
@@ -2810,7 +3022,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             var _this = this;
             if (!this.parentSelect) {
                 eventSimulator$6.click(this.eventsArgs.element, this.eventsArgs.options);
-                return Promise$7.resolve();
+                return Promise$6.resolve();
             }
             if (!this.optionListExpanded)
                 selectElementUI$1.scrollOptionListByChild(this.element);
@@ -2831,15 +3043,15 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }());
 
     var featureDetection$3 = hammerhead__default.utils.featureDetection;
-    var browserUtils$7 = hammerhead__default.utils.browser;
+    var browserUtils$5 = hammerhead__default.utils.browser;
     var eventSimulator$7 = hammerhead__default.eventSandbox.eventSimulator;
-    var eventUtils$1 = testCafeCore__default.eventUtils;
-    var delay$3 = testCafeCore__default.delay;
+    var eventUtils$2 = testCafeCore__default.eventUtils;
+    var delay$2 = testCafeCore__default.delay;
     var FIRST_CLICK_DELAY = featureDetection$3.isTouchDevice ? 0 : 160;
     var DblClickAutomation = /** @class */ (function (_super) {
         __extends(DblClickAutomation, _super);
         function DblClickAutomation(element, clickOptions) {
-            var _this = _super.call(this, element, clickOptions) || this;
+            var _this = _super.call(this, element, clickOptions, window, cursor) || this;
             _this.modifiers = clickOptions.modifiers;
             _this.caretPos = clickOptions.caretPos;
             _this.speed = clickOptions.speed;
@@ -2857,18 +3069,18 @@ window['%hammerhead%'].utils.removeInjectedScript();
             // NOTE: we should always perform click with the highest speed
             var clickOptions = new ClickOptions(this.options);
             clickOptions.speed = 1;
-            var clickAutomation = new ClickAutomation(this.element, clickOptions);
+            var clickAutomation = new ClickAutomation(this.element, clickOptions, window, cursor);
             clickAutomation.on(clickAutomation.TARGET_ELEMENT_FOUND_EVENT, function (e) { return _this.emit(_this.TARGET_ELEMENT_FOUND_EVENT, e); });
             return clickAutomation.run(useStrictElementCheck)
                 .then(function (clickEventArgs) {
-                return delay$3(FIRST_CLICK_DELAY).then(function () { return clickEventArgs; });
+                return delay$2(FIRST_CLICK_DELAY).then(function () { return clickEventArgs; });
             });
         };
         DblClickAutomation.prototype._secondClick = function (eventArgs) {
             var _this = this;
             //NOTE: we should not call focus after the second mousedown (except in IE) because of the native browser behavior
-            if (browserUtils$7.isIE)
-                eventUtils$1.bind(document, 'focus', eventUtils$1.preventDefault, true);
+            if (browserUtils$5.isIE)
+                eventUtils$2.bind(document, 'focus', eventUtils$2.preventDefault, true);
             var clickOptions = new ClickOptions({
                 offsetX: eventArgs.screenPoint.x,
                 offsetY: eventArgs.screenPoint.y,
@@ -2876,14 +3088,14 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 modifiers: this.modifiers,
                 speed: 1,
             });
-            var clickAutomation = new ClickAutomation(document.documentElement, clickOptions);
+            var clickAutomation = new ClickAutomation(document.documentElement, clickOptions, window, cursor);
             return clickAutomation.run()
                 .then(function (clickEventArgs) {
                 // NOTE: We should raise the `dblclick` event on an element that
                 // has been actually clicked during the second click automation.
-                _this.eventState.dblClickElement = clickAutomation.eventState.clickElement;
-                if (browserUtils$7.isIE)
-                    eventUtils$1.unbind(document, 'focus', eventUtils$1.preventDefault, true);
+                _this.eventState.dblClickElement = clickAutomation.strategy.eventState.clickElement;
+                if (browserUtils$5.isIE)
+                    eventUtils$2.unbind(document, 'focus', eventUtils$2.preventDefault, true);
                 return clickEventArgs;
             });
         };
@@ -2902,6 +3114,82 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return DblClickAutomation;
     }(VisibleElementAutomation));
 
+    var browserUtils$6 = hammerhead__default.utils.browser;
+    var Promise$7 = hammerhead__default.Promise;
+    var nativeMethods$7 = hammerhead__default.nativeMethods;
+    var positionUtils$3 = testCafeCore__default.positionUtils;
+    var domUtils$6 = testCafeCore__default.domUtils;
+    function fromPoint(point /*: AxisValuesData<number>*/, underTopShadowUIElement) {
+        var topElement = null;
+        return testCafeUI.hide(underTopShadowUIElement)
+            .then(function () { return positionUtils$3.getElementFromPoint(point); })
+            .then(function (el) {
+            topElement = el;
+            return testCafeUI.show(underTopShadowUIElement);
+        })
+            .then(function () { return topElement; });
+    }
+    function ensureImageMap$1(imgElement, areaElement) {
+        var mapElement = domUtils$6.closest(areaElement, 'map');
+        return mapElement && mapElement.name === imgElement.useMap.substring(1) ? areaElement : imgElement;
+    }
+    function findElementOrNonEmptyChildFromPoint$1(x, y, element) {
+        var topElement = positionUtils$3.getElementFromPoint(x, y);
+        var isNonEmptyChild = domUtils$6.containsElement(element, topElement) &&
+            nativeMethods$7.nodeTextContentGetter.call(topElement).length;
+        if (topElement && topElement === element || isNonEmptyChild)
+            return topElement;
+        return null;
+    }
+    function correctTopElementByExpectedElement$1(topElement, expectedElement) {
+        var expectedElementDefined = expectedElement && domUtils$6.isDomElement(expectedElement);
+        if (!expectedElementDefined || !topElement || topElement === expectedElement)
+            return topElement;
+        var isTREFElement = domUtils$6.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$6.getTagName(expectedElement) === 'area' && domUtils$6.isImgElement(topElement);
+        if (browserUtils$6.isFirefox && isImageMapArea)
+            return ensureImageMap$1(topElement, expectedElement);
+        // NOTE: try to find a multi-line link by its rectangle (T163678)
+        var isLinkOrChildExpected = domUtils$6.isAnchorElement(expectedElement) ||
+            domUtils$6.getParents(expectedElement, 'a').length;
+        var isTopElementChildOfLink = isLinkOrChildExpected &&
+            domUtils$6.containsElement(expectedElement, topElement) &&
+            nativeMethods$7.nodeTextContentGetter.call(topElement).length;
+        var shouldSearchForMultilineLink = isLinkOrChildExpected && !isTopElementChildOfLink &&
+            nativeMethods$7.nodeTextContentGetter.call(expectedElement).length;
+        if (!shouldSearchForMultilineLink)
+            return topElement;
+        var linkRect = expectedElement.getBoundingClientRect();
+        return findElementOrNonEmptyChildFromPoint$1(linkRect.right - 1, linkRect.top + 1, expectedElement) ||
+            findElementOrNonEmptyChildFromPoint$1(linkRect.left + 1, linkRect.bottom - 1, expectedElement) ||
+            topElement;
+    }
+    function getElementFromPoint$2(point /*: AxisValuesData<number>*/, expectedElement) {
+        return fromPoint(point)
+            .then(function (topElement) {
+            var 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$7.resolve(topElement);
+            if (!foundElement && isIframeWindow(window) && point.x > 0 && point.y > 0) {
+                resChain = resChain
+                    .then(function () { return fromPoint(point, true); })
+                    .then(function (element) {
+                    foundElement = element;
+                    return element;
+                });
+            }
+            return resChain.then(function (element) { return correctTopElementByExpectedElement$1(element, expectedElement); });
+        });
+    }
+
     var DragAndDropState = /** @class */ (function () {
         function DragAndDropState() {
             this.enabled = false;
@@ -2919,8 +3207,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var urlUtils = hammerhead__default.utils.url;
     var DataTransfer = hammerhead__default.eventSandbox.DataTransfer;
     var DragDataStore = hammerhead__default.eventSandbox.DragDataStore;
-    var eventUtils$2 = testCafeCore__default.eventUtils;
-    var domUtils$6 = testCafeCore__default.domUtils;
+    var eventUtils$3 = testCafeCore__default.eventUtils;
+    var domUtils$7 = testCafeCore__default.domUtils;
     // Utils
     function findDraggableElement(element) {
         var parentNode = element;
@@ -2933,13 +3221,13 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }
     var DragMoveAutomation = /** @class */ (function (_super) {
         __extends(DragMoveAutomation, _super);
-        function DragMoveAutomation(element, offset, win, cursor, moveOptions) {
-            var _this = _super.call(this, element, offset, win, cursor, moveOptions) || this;
+        function DragMoveAutomation(element, offset, moveOptions, win, cursor) {
+            var _this = _super.call(this, element, offset, moveOptions, win, cursor) || this;
             _this.dragElement = null;
             _this.dragAndDropState = new DragAndDropState();
             return _this;
         }
-        DragMoveAutomation.create = function (el, win, cursor, moveOptions) {
+        DragMoveAutomation.create = function (el, moveOptions, win, cursor) {
             return __awaiter(this, void 0, void 0, function () {
                 var _a, element, offset;
                 return __generator(this, function (_b) {
@@ -2947,7 +3235,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                         case 0: return [4 /*yield*/, MoveAutomation.getTarget(el, win, new AxisValues(moveOptions.offsetX, moveOptions.offsetY))];
                         case 1:
                             _a = _b.sent(), element = _a.element, offset = _a.offset;
-                            return [2 /*return*/, new DragMoveAutomation(element, offset, win, cursor, moveOptions)];
+                            return [2 /*return*/, new DragMoveAutomation(element, offset, moveOptions, win, cursor)];
                     }
                 });
             });
@@ -2961,7 +3249,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 .then(function (_a) {
                 var eventOptions = _a.eventOptions, eventSequenceOptions = _a.eventSequenceOptions;
                 eventOptions.dataTransfer = _this.dragAndDropState.dataTransfer;
-                eventOptions.buttons = eventUtils$2.BUTTONS_PARAMETER.leftButton;
+                eventOptions.buttons = eventUtils$3.BUTTONS_PARAMETER.leftButton;
                 eventSequenceOptions.holdLeftButton = true;
                 return { eventOptions: eventOptions, eventSequenceOptions: eventSequenceOptions };
             });
@@ -2981,7 +3269,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         };
         DragMoveAutomation.prototype.run = function () {
             var _this = this;
-            return getElementFromPoint$1(this.cursor.getPosition())
+            return getElementFromPoint$2(this.cursor.getPosition())
                 .then(function (topElement) {
                 _this.dragElement = topElement;
                 var draggable = findDraggableElement(_this.dragElement);
@@ -2992,8 +3280,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
                     _this.dragAndDropState.element = _this.dragElement;
                     _this.dragAndDropState.dataStore = new DragDataStore();
                     _this.dragAndDropState.dataTransfer = new DataTransfer(_this.dragAndDropState.dataStore);
-                    var isLink = domUtils$6.isAnchorElement(_this.dragElement);
-                    if (isLink || domUtils$6.isImgElement(_this.dragElement)) {
+                    var isLink = domUtils$7.isAnchorElement(_this.dragElement);
+                    if (isLink || domUtils$7.isImgElement(_this.dragElement)) {
                         var srcAttr = isLink ? 'href' : 'src';
                         var parsedUrl = urlUtils.parseProxyUrl(_this.dragElement[srcAttr]);
                         var src = parsedUrl ? parsedUrl.destUrl : _this.dragElement[srcAttr];
@@ -3012,14 +3300,14 @@ window['%hammerhead%'].utils.removeInjectedScript();
 
     var MIN_MOVING_TIME = 25;
     var Promise$8 = hammerhead__default.Promise;
-    var extend$3 = hammerhead__default.utils.extend;
+    var extend$2 = hammerhead__default.utils.extend;
     var featureDetection$5 = hammerhead__default.utils.featureDetection;
     var eventSimulator$8 = hammerhead__default.eventSandbox.eventSimulator;
     var focusBlurSandbox$2 = hammerhead__default.eventSandbox.focusBlur;
     var DragAutomationBase = /** @class */ (function (_super) {
         __extends(DragAutomationBase, _super);
         function DragAutomationBase(element, mouseOptions) {
-            var _this = _super.call(this, element, mouseOptions) || this;
+            var _this = _super.call(this, element, mouseOptions, window, cursor) || this;
             _this.modifiers = mouseOptions.modifiers;
             _this.speed = mouseOptions.speed;
             _this.offsetX = mouseOptions.offsetX;
@@ -3056,24 +3344,33 @@ window['%hammerhead%'].utils.removeInjectedScript();
             throw new Error('Not implemented');
         };
         DragAutomationBase.prototype._drag = function () {
-            var _this = this;
-            var _a = this._getDestination(), element = _a.element, offsets = _a.offsets, endPoint = _a.endPoint;
-            this.endPoint = endPoint;
-            var dragOptions = new MoveOptions({
-                offsetX: offsets.offsetX,
-                offsetY: offsets.offsetY,
-                modifiers: this.modifiers,
-                speed: this.speed,
-                minMovingTime: MIN_MOVING_TIME,
-                skipDefaultDragBehavior: this.simulateDefaultBehavior === false,
-            }, false);
-            return DragMoveAutomation.create(element, window, cursor, dragOptions)
-                .then(function (moveAutomation) {
-                return moveAutomation.run();
-            })
-                .then(function (dragAndDropState) {
-                _this.dragAndDropState = dragAndDropState;
-                return testCafeCore.delay(_this.automationSettings.mouseActionStepDelay);
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, element, offsets, endPoint, dragOptions;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, this._getDestination()];
+                        case 1:
+                            _a = _b.sent(), element = _a.element, offsets = _a.offsets, endPoint = _a.endPoint;
+                            this.endPoint = endPoint;
+                            dragOptions = new MoveOptions({
+                                offsetX: offsets.offsetX,
+                                offsetY: offsets.offsetY,
+                                modifiers: this.modifiers,
+                                speed: this.speed,
+                                minMovingTime: MIN_MOVING_TIME,
+                                skipDefaultDragBehavior: this.simulateDefaultBehavior === false,
+                            }, false);
+                            return [2 /*return*/, DragMoveAutomation.create(element, dragOptions, window, cursor)
+                                    .then(function (moveAutomation) {
+                                    return moveAutomation.run();
+                                })
+                                    .then(function (dragAndDropState) {
+                                    _this.dragAndDropState = dragAndDropState;
+                                    return testCafeCore.delay(_this.automationSettings.mouseActionStepDelay);
+                                })];
+                    }
+                });
             });
         };
         DragAutomationBase.prototype._mouseup = function () {
@@ -3083,11 +3380,11 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 .then(function () {
                 var point = testCafeCore.positionUtils.offsetToClientCoords(_this.endPoint);
                 var topElement = null;
-                var options = extend$3({
+                var options = extend$2({
                     clientX: point.x,
                     clientY: point.y,
                 }, _this.modifiers);
-                return getElementFromPoint$1(point)
+                return getElementFromPoint$2(point)
                     .then(function (element) {
                     topElement = element;
                     if (!topElement)
@@ -3101,7 +3398,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                     }
                     else
                         eventSimulator$8[_this.upEvent](topElement, options);
-                    return getElementFromPoint$1(point);
+                    return getElementFromPoint$2(point);
                 })
                     .then(function (element) {
                     //B231323
@@ -3120,7 +3417,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 eventArgs = {
                     point: clientPoint,
                     element: element,
-                    options: extend$3({
+                    options: extend$2({
                         clientX: clientPoint.x,
                         clientY: clientPoint.y,
                     }, _this.modifiers),
@@ -3135,6 +3432,18 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return DragAutomationBase;
     }(VisibleElementAutomation));
 
+    var browserUtils$7 = hammerhead__default.utils.browser;
+    function getAutomationPoint$1(element, offsetX, offsetY) {
+        var roundFn = browserUtils$7.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,
+        };
+    }
+
     var styleUtils$4 = testCafeCore__default.styleUtils;
     var DragToOffsetAutomation = /** @class */ (function (_super) {
         __extends(DragToOffsetAutomation, _super);
@@ -3145,7 +3454,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             return _this;
         }
         DragToOffsetAutomation.prototype._getDestination = function () {
-            var startPoint = getAutomationPoint(this.element, this.offsetX, this.offsetY);
+            var startPoint = getAutomationPoint$1(this.element, this.offsetX, this.offsetY);
             var maxX = styleUtils$4.getWidth(document);
             var maxY = styleUtils$4.getHeight(document);
             var endPoint = {
@@ -3166,7 +3475,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return DragToOffsetAutomation;
     }(DragAutomationBase));
 
-    var positionUtils$3 = testCafeCore__default.positionUtils;
+    var positionUtils$4 = testCafeCore__default.positionUtils;
     var DragToElementAutomation = /** @class */ (function (_super) {
         __extends(DragToElementAutomation, _super);
         function DragToElementAutomation(element, destinationElement, dragToElementOptions) {
@@ -3177,14 +3486,24 @@ window['%hammerhead%'].utils.removeInjectedScript();
             return _this;
         }
         DragToElementAutomation.prototype._getDestination = function () {
-            var element = this.destinationElement;
-            var elementRect = positionUtils$3.getElementRectangle(element);
-            var offsets = getOffsetOptions(element, this.destinationOffsetX, this.destinationOffsetY);
-            var endPoint = {
-                x: elementRect.left + offsets.offsetX,
-                y: elementRect.top + offsets.offsetY,
-            };
-            return { element: element, offsets: offsets, endPoint: endPoint };
+            return __awaiter(this, void 0, void 0, function () {
+                var element, elementRect, offsets, endPoint;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            element = this.destinationElement;
+                            elementRect = positionUtils$4.getElementRectangle(element);
+                            return [4 /*yield*/, getOffsetOptions(element, this.destinationOffsetX, this.destinationOffsetY)];
+                        case 1:
+                            offsets = _a.sent();
+                            endPoint = {
+                                x: elementRect.left + offsets.offsetX,
+                                y: elementRect.top + offsets.offsetY,
+                            };
+                            return [2 /*return*/, { element: element, offsets: offsets, endPoint: endPoint }];
+                    }
+                });
+            });
         };
         return DragToElementAutomation;
     }(DragAutomationBase));
@@ -3192,7 +3511,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var HoverAutomation = /** @class */ (function (_super) {
         __extends(HoverAutomation, _super);
         function HoverAutomation(element, hoverOptions) {
-            return _super.call(this, element, hoverOptions) || this;
+            return _super.call(this, element, hoverOptions, window, cursor) || this;
         }
         HoverAutomation.prototype.run = function (useStrictElementCheck) {
             return this._ensureElement(useStrictElementCheck, true);
@@ -3205,7 +3524,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var eventSimulator$9 = hammerhead__default.eventSandbox.eventSimulator;
     var listeners$2 = hammerhead__default.eventSandbox.listeners;
     var nativeMethods$9 = hammerhead__default.nativeMethods;
-    var domUtils$7 = testCafeCore__default.domUtils;
+    var domUtils$8 = testCafeCore__default.domUtils;
     var contentEditable$1 = testCafeCore__default.contentEditable;
     var textSelection$1 = testCafeCore__default.textSelection;
     var WHITE_SPACES_RE = / /g;
@@ -3227,7 +3546,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         var startParent = nativeMethods$9.nodeParentNodeGetter.call(startNode);
         var hasStartParent = startParent && startNode.parentElement;
         var browserRequiresSelectionUpdating = browserUtils$8.isChrome && browserUtils$8.version < 58 || browserUtils$8.isSafari;
-        if (browserRequiresSelectionUpdating || !hasStartParent || !domUtils$7.isElementContainsNode(element, startNode)) {
+        if (browserRequiresSelectionUpdating || !hasStartParent || !domUtils$8.isElementContainsNode(element, startNode)) {
             selection = _getSelectionInElement(element);
             if (textSelection$1.hasInverseSelectionContentEditable(element)) {
                 selection = {
@@ -3244,7 +3563,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         var textLength = text.length;
         var selectPosition = { node: nodeForTyping, offset: textLength };
         var parent = nativeMethods$9.nodeParentNodeGetter.call(elementNode);
-        if (domUtils$7.getTagName(elementNode) === 'br')
+        if (domUtils$8.getTagName(elementNode) === 'br')
             parent.insertBefore(nodeForTyping, elementNode);
         else if (offset > 0) {
             var childNodes = nativeMethods$9.nodeChildNodesGetter.call(elementNode);
@@ -3257,7 +3576,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     function _typeTextInChildTextNode(element, selection, text) {
         var startNode = selection.startPos.node;
         // NOTE: startNode could be moved or deleted on textInput event. Need ensure startNode.
-        if (!domUtils$7.isElementContainsNode(element, startNode)) {
+        if (!domUtils$8.isElementContainsNode(element, startNode)) {
             selection = _excludeInvisibleSymbolsFromSelection(_getSelectionInElement(element));
             startNode = selection.startPos.node;
         }
@@ -3346,7 +3665,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             listeners$2.addInternalEventBeforeListener(window, ['textinput'], onTextInput);
         };
         var afterContentChanged = function () {
-            nextTick$1()
+            nextTick()
                 .then(function () {
                 if (needRaiseInputEvent)
                     eventSimulator$9.input(element, text);
@@ -3354,10 +3673,10 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 listeners$2.removeInternalEventBeforeListener(window, ['textinput'], onTextInput);
             });
         };
-        if (!startNode || !endNode || !domUtils$7.isContentEditableElement(startNode) ||
-            !domUtils$7.isContentEditableElement(endNode))
+        if (!startNode || !endNode || !domUtils$8.isContentEditableElement(startNode) ||
+            !domUtils$8.isContentEditableElement(endNode))
             return;
-        if (!domUtils$7.isTheSameNode(startNode, endNode)) {
+        if (!domUtils$8.isTheSameNode(startNode, endNode)) {
             textSelection$1.deleteSelectionContents(element);
             // NOTE: after deleting the selection contents we should refresh the stored startNode because
             // contentEditable element's content could change and we can no longer find parent elements
@@ -3365,7 +3684,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             currentSelection = _updateSelectionAfterDeletionContent(element, currentSelection);
             startNode = currentSelection.startPos.node;
         }
-        if (!startNode || !domUtils$7.isContentEditableElement(startNode) || !domUtils$7.isRenderedNode(startNode))
+        if (!startNode || !domUtils$8.isContentEditableElement(startNode) || !domUtils$8.isRenderedNode(startNode))
             return;
         if (!simulateBeforeInput(element, text, browserUtils$8.isChrome || browserUtils$8.isFirefox))
             return;
@@ -3374,7 +3693,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             needProcessInput = simulateBeforeInput(element, text, browserUtils$8.isSafari);
         if (needProcessInput) {
             // NOTE: we can type only to the text nodes; for nodes with the 'element-node' type, we use a special behavior
-            if (domUtils$7.isElementNode(startNode))
+            if (domUtils$8.isElementNode(startNode))
                 _typeTextInElementNode(startNode, text);
             else
                 _typeTextInChildTextNode(element, _excludeInvisibleSymbolsFromSelection(currentSelection), text);
@@ -3382,11 +3701,11 @@ window['%hammerhead%'].utils.removeInjectedScript();
         afterContentChanged();
     }
     function _typeTextToTextEditable(element, text) {
-        var elementValue = domUtils$7.getElementValue(element);
+        var elementValue = domUtils$8.getElementValue(element);
         var textLength = text.length;
         var startSelection = textSelection$1.getSelectionStart(element);
         var endSelection = textSelection$1.getSelectionEnd(element);
-        var isInputTypeNumber = domUtils$7.isInputElement(element) && element.type === 'number';
+        var isInputTypeNumber = domUtils$8.isInputElement(element) && element.type === 'number';
         if (!simulateBeforeInput(element, text, browserUtils$8.isChrome || browserUtils$8.isFirefox))
             return;
         var needProcessInput = simulateTextInput(element, text);
@@ -3405,7 +3724,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 startSelection += 1;
                 endSelection += 1;
             }
-            domUtils$7.setElementValue(element, newElementValue);
+            domUtils$8.setElementValue(element, newElementValue);
             textSelection$1.select(element, startSelection + textLength, startSelection + textLength);
         }
         // NOTE: We should simulate the 'input' event after typing a char (B253410, T138385)
@@ -3413,21 +3732,21 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }
     function _typeTextToNonTextEditable(element, text, caretPos) {
         if (caretPos !== null) {
-            var elementValue = domUtils$7.getElementValue(element);
-            domUtils$7.setElementValue(element, elementValue.substr(0, caretPos) + text + elementValue.substr(caretPos + text.length));
+            var elementValue = domUtils$8.getElementValue(element);
+            domUtils$8.setElementValue(element, elementValue.substr(0, caretPos) + text + elementValue.substr(caretPos + text.length));
         }
         else
-            domUtils$7.setElementValue(element, text);
+            domUtils$8.setElementValue(element, text);
         eventSimulator$9.change(element);
         eventSimulator$9.input(element, text);
     }
     function typeText (element, text, caretPos) {
-        if (domUtils$7.isContentEditableElement(element))
+        if (domUtils$8.isContentEditableElement(element))
             _typeTextToContentEditable(element, text);
-        if (!domUtils$7.isElementReadOnly(element)) {
-            if (domUtils$7.isTextEditableElement(element))
+        if (!domUtils$8.isElementReadOnly(element)) {
+            if (domUtils$8.isTextEditableElement(element))
                 _typeTextToTextEditable(element, text);
-            else if (domUtils$7.isInputElement(element))
+            else if (domUtils$8.isInputElement(element))
                 _typeTextToNonTextEditable(element, text, caretPos);
         }
     }
@@ -3677,7 +3996,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }
 
     var browserUtils$a = hammerhead__default.utils.browser;
-    var extend$4 = hammerhead__default.utils.extend;
+    var extend$3 = hammerhead__default.utils.extend;
     var eventSimulator$a = hammerhead__default.eventSandbox.eventSimulator;
     var KeyPressSimulator = /** @class */ (function () {
         function KeyPressSimulator(key, eventKeyProperty) {
@@ -3729,7 +4048,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             }
         };
         KeyPressSimulator.prototype._addKeyPropertyToEventOptions = function (eventOptions) {
-            extend$4(eventOptions, getKeyProperties(eventOptions.type === 'keypress', this.keyProperty, this.keyIdentifierProperty));
+            extend$3(eventOptions, getKeyProperties(eventOptions.type === 'keypress', this.keyProperty, this.keyIdentifierProperty));
             return eventOptions;
         };
         KeyPressSimulator.prototype.down = function (modifiersState) {
@@ -3740,7 +4059,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 this.keyProperty = changeLetterCase(this.keyProperty);
             var eventOptions = { keyCode: this.keyCode, type: 'keydown' };
             this._addKeyPropertyToEventOptions(eventOptions);
-            return eventSimulator$a.keydown(this.storedActiveElement, extend$4(eventOptions, modifiersState));
+            return eventSimulator$a.keydown(this.storedActiveElement, extend$3(eventOptions, modifiersState));
         };
         KeyPressSimulator.prototype.press = function (modifiersState) {
             if (!(this.isChar || this.specialKeyCode))
@@ -3758,7 +4077,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             this.storedActiveElement = activeElement;
             var eventOptions = { keyCode: charCode, charCode: charCode, type: 'keypress' };
             this._addKeyPropertyToEventOptions(eventOptions);
-            var raiseDefault = browserUtils$a.isAndroid || eventSimulator$a.keypress(activeElement, extend$4(eventOptions, modifiersState));
+            var raiseDefault = browserUtils$a.isAndroid || eventSimulator$a.keypress(activeElement, extend$3(eventOptions, modifiersState));
             if (!raiseDefault)
                 return raiseDefault;
             activeElement = getDeepActiveElement(this.topSameDomainDocument);
@@ -3779,7 +4098,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 modifiersState[this.sanitizedKey] = false;
             var eventOptions = { keyCode: this.keyCode, type: 'keyup' };
             this._addKeyPropertyToEventOptions(eventOptions);
-            var raiseDefault = eventSimulator$a.keyup(getDeepActiveElement(this.topSameDomainDocument), extend$4(eventOptions, modifiersState));
+            var raiseDefault = eventSimulator$a.keyup(getDeepActiveElement(this.topSameDomainDocument), extend$3(eventOptions, modifiersState));
             var activeElement = getDeepActiveElement(this.topSameDomainDocument);
             // NOTE: in some browsers we should emulate click on active input element while pressing "space" key
             var emulateClick = !browserUtils$a.isFirefox && !browserUtils$a.isSafari &&
@@ -3827,20 +4146,20 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var eventSimulator$b = hammerhead__default.eventSandbox.eventSimulator;
     var elementEditingWatcher = hammerhead__default.eventSandbox.elementEditingWatcher;
     var textSelection$2 = testCafeCore__default.textSelection;
-    var eventUtils$3 = testCafeCore__default.eventUtils;
-    var domUtils$8 = testCafeCore__default.domUtils;
+    var eventUtils$4 = testCafeCore__default.eventUtils;
+    var domUtils$9 = testCafeCore__default.domUtils;
     var selectElement = testCafeUI.selectElement;
     var currentTextarea = null;
     var currentTextareaCursorIndent = null;
     function onTextAreaBlur() {
         currentTextarea = null;
         currentTextareaCursorIndent = null;
-        eventUtils$3.unbind(this, 'blur', onTextAreaBlur, true);
+        eventUtils$4.unbind(this, 'blur', onTextAreaBlur, true);
     }
     function updateTextAreaIndent(element) {
-        if (domUtils$8.isTextAreaElement(element)) {
+        if (domUtils$9.isTextAreaElement(element)) {
             if (currentTextarea !== element) {
-                eventUtils$3.bind(element, 'blur', onTextAreaBlur, true);
+                eventUtils$4.bind(element, 'blur', onTextAreaBlur, true);
                 currentTextarea = element;
             }
             currentTextareaCursorIndent = getLineIndentInTextarea(element);
@@ -3848,16 +4167,16 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }
     function getLineIndentInTextarea(textarea) {
         var inverseSelection = textSelection$2.hasInverseSelection(textarea);
-        var textareaValue = domUtils$8.getTextAreaValue(textarea);
+        var textareaValue = domUtils$9.getTextAreaValue(textarea);
         var cursorPosition = inverseSelection ?
             textSelection$2.getSelectionStart(textarea) :
             textSelection$2.getSelectionEnd(textarea);
         if (!textareaValue || !cursorPosition)
             return 0;
-        return domUtils$8.getTextareaIndentInLine(textarea, cursorPosition);
+        return domUtils$9.getTextareaIndentInLine(textarea, cursorPosition);
     }
     function moveTextAreaCursorUp(element, withSelection) {
-        var textareaValue = domUtils$8.getTextAreaValue(element);
+        var textareaValue = domUtils$9.getTextAreaValue(element);
         if (!textareaValue)
             return;
         var startPos = textSelection$2.getSelectionStart(element);
@@ -3873,7 +4192,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         moveTextAreaCursor(element, startPos, endPos, hasInverseSelection, newPosition, withSelection);
     }
     function moveTextAreaCursorDown(element, withSelection) {
-        var textareaValue = domUtils$8.getTextAreaValue(element);
+        var textareaValue = domUtils$9.getTextAreaValue(element);
         if (!textareaValue)
             return;
         var startPos = textSelection$2.getSelectionStart(element);
@@ -3914,13 +4233,13 @@ window['%hammerhead%'].utils.removeInjectedScript();
         textSelection$2.select(element, newStart, newEnd);
     }
     function setElementValue(element, value, position) {
-        if (domUtils$8.isInputElement(element) && element.type === 'number') {
+        if (domUtils$9.isInputElement(element) && element.type === 'number') {
             if (value.charAt(0) === '-' && value.charAt(1) === '.')
                 value = value.substring(1);
             if (value.charAt(value.length - 1) === '.')
                 value = value.substring(0, value.length - 1);
         }
-        domUtils$8.setElementValue(element, value);
+        domUtils$9.setElementValue(element, value);
         textSelection$2.select(element, position, position);
         eventSimulator$b.input(element);
     }
@@ -3936,11 +4255,11 @@ window['%hammerhead%'].utils.removeInjectedScript();
         }
         if (submitButton)
             eventSimulator$b.click(submitButton);
-        else if (domUtils$8.blocksImplicitSubmission(inputElement)) {
+        else if (domUtils$9.blocksImplicitSubmission(inputElement)) {
             var formInputs = form.getElementsByTagName('input');
             var textInputs = [];
             for (i = 0; i < formInputs.length; i++) {
-                if (domUtils$8.blocksImplicitSubmission(formInputs[i]))
+                if (domUtils$9.blocksImplicitSubmission(formInputs[i]))
                     textInputs.push(formInputs[i]);
             }
             // NOTE: the form is submitted on enter press if there is only one input of the following types on it
@@ -3954,15 +4273,15 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }
     //shortcuts
     function selectAll(element) {
-        if (domUtils$8.isEditableElement(element))
+        if (domUtils$9.isEditableElement(element))
             textSelection$2.select(element);
         return Promise$a.resolve();
     }
     function backspace(element) {
-        if (domUtils$8.isTextEditableElementAndEditingAllowed(element)) {
+        if (domUtils$9.isTextEditableElementAndEditingAllowed(element)) {
             var startPos = textSelection$2.getSelectionStart(element);
             var endPos = textSelection$2.getSelectionEnd(element);
-            var value = domUtils$8.getElementValue(element).replace(/\r\n/g, '\n');
+            var value = domUtils$9.getElementValue(element).replace(/\r\n/g, '\n');
             if (endPos === startPos) {
                 if (startPos > 0) {
                     setElementValue(element, value.substring(0, startPos - 1) +
@@ -3972,15 +4291,15 @@ window['%hammerhead%'].utils.removeInjectedScript();
             else
                 setElementValue(element, value.substring(0, startPos) + value.substring(endPos, value.length), startPos);
         }
-        if (domUtils$8.isContentEditableElement(element))
+        if (domUtils$9.isContentEditableElement(element))
             textSelection$2.deleteSelectionContents(element);
         return Promise$a.resolve();
     }
     function del(element) {
-        if (domUtils$8.isTextEditableElementAndEditingAllowed(element)) {
+        if (domUtils$9.isTextEditableElementAndEditingAllowed(element)) {
             var startPos = textSelection$2.getSelectionStart(element);
             var endPos = textSelection$2.getSelectionEnd(element);
-            var value = domUtils$8.getElementValue(element).replace(/\r\n/g, '\n');
+            var value = domUtils$9.getElementValue(element).replace(/\r\n/g, '\n');
             if (endPos === startPos) {
                 if (startPos < value.length) {
                     setElementValue(element, value.substring(0, startPos) +
@@ -3992,25 +4311,25 @@ window['%hammerhead%'].utils.removeInjectedScript();
                     value.substring(endPos, value.length), startPos);
             }
         }
-        if (domUtils$8.isContentEditableElement(element))
+        if (domUtils$9.isContentEditableElement(element))
             textSelection$2.deleteSelectionContents(element);
         return Promise$a.resolve();
     }
     function left(element) {
         var startPosition = null;
         var endPosition = null;
-        if (domUtils$8.isSelectElement(element))
+        if (domUtils$9.isSelectElement(element))
             selectElement.switchOptionsByKeys(element, 'left');
         if (isRadioButtonNavigationRequired(element))
             return focusAndCheckNextRadioButton(element, true);
-        if (domUtils$8.isTextEditableElement(element)) {
+        if (domUtils$9.isTextEditableElement(element)) {
             startPosition = textSelection$2.getSelectionStart(element) || 0;
             endPosition = textSelection$2.getSelectionEnd(element);
             var newPosition = startPosition === endPosition ? startPosition - 1 : startPosition;
             textSelection$2.select(element, newPosition, newPosition);
             updateTextAreaIndent(element);
         }
-        if (domUtils$8.isContentEditableElement(element)) {
+        if (domUtils$9.isContentEditableElement(element)) {
             startPosition = textSelection$2.getSelectionStart(element);
             endPosition = textSelection$2.getSelectionEnd(element);
             // NOTE: we only remove selection
@@ -4028,20 +4347,20 @@ window['%hammerhead%'].utils.removeInjectedScript();
     function right(element) {
         var startPosition = null;
         var endPosition = null;
-        if (domUtils$8.isSelectElement(element))
+        if (domUtils$9.isSelectElement(element))
             selectElement.switchOptionsByKeys(element, 'right');
         if (isRadioButtonNavigationRequired(element))
             return focusAndCheckNextRadioButton(element, false);
-        if (domUtils$8.isTextEditableElement(element)) {
+        if (domUtils$9.isTextEditableElement(element)) {
             startPosition = textSelection$2.getSelectionStart(element);
             endPosition = textSelection$2.getSelectionEnd(element);
             var newPosition = startPosition === endPosition ? endPosition + 1 : endPosition;
-            if (startPosition === domUtils$8.getElementValue(element).length)
+            if (startPosition === domUtils$9.getElementValue(element).length)
                 newPosition = startPosition;
             textSelection$2.select(element, newPosition, newPosition);
             updateTextAreaIndent(element);
         }
-        if (domUtils$8.isContentEditableElement(element)) {
+        if (domUtils$9.isContentEditableElement(element)) {
             startPosition = textSelection$2.getSelectionStart(element);
             endPosition = textSelection$2.getSelectionEnd(element);
             //NOTE: we only remove selection
@@ -4057,41 +4376,41 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return Promise$a.resolve();
     }
     function up(element) {
-        if (domUtils$8.isSelectElement(element))
+        if (domUtils$9.isSelectElement(element))
             selectElement.switchOptionsByKeys(element, 'up');
         if (isRadioButtonNavigationRequired(element))
             return focusAndCheckNextRadioButton(element, true);
-        if (browserUtils$b.isWebKit && domUtils$8.isInputElement(element))
+        if (browserUtils$b.isWebKit && domUtils$9.isInputElement(element))
             return home(element);
-        if (domUtils$8.isTextAreaElement(element))
+        if (domUtils$9.isTextAreaElement(element))
             moveTextAreaCursorUp(element, false);
         return Promise$a.resolve();
     }
     function down(element) {
-        if (domUtils$8.isSelectElement(element))
+        if (domUtils$9.isSelectElement(element))
             selectElement.switchOptionsByKeys(element, 'down');
         if (isRadioButtonNavigationRequired(element))
             return focusAndCheckNextRadioButton(element, false);
-        if (browserUtils$b.isWebKit && domUtils$8.isInputElement(element))
+        if (browserUtils$b.isWebKit && domUtils$9.isInputElement(element))
             return end(element);
-        if (domUtils$8.isTextAreaElement(element))
+        if (domUtils$9.isTextAreaElement(element))
             moveTextAreaCursorDown(element, false);
         return Promise$a.resolve();
     }
     function home(element, withSelection) {
-        if (domUtils$8.isTextEditableElement(element)) {
+        if (domUtils$9.isTextEditableElement(element)) {
             var startPos = textSelection$2.getSelectionStart(element);
             var endPos = textSelection$2.getSelectionEnd(element);
             var inverseSelection = textSelection$2.hasInverseSelection(element);
             var referencePosition = null;
-            var isSingleLineSelection = !domUtils$8.isTextAreaElement(element) ? true :
-                domUtils$8.getTextareaLineNumberByPosition(element, startPos) ===
-                    domUtils$8.getTextareaLineNumberByPosition(element, endPos);
+            var isSingleLineSelection = !domUtils$9.isTextAreaElement(element) ? true :
+                domUtils$9.getTextareaLineNumberByPosition(element, startPos) ===
+                    domUtils$9.getTextareaLineNumberByPosition(element, endPos);
             if (isSingleLineSelection)
                 referencePosition = inverseSelection ? endPos : startPos;
             else
                 referencePosition = inverseSelection ? startPos : endPos;
-            var valueBeforeCursor = domUtils$8.getElementValue(element).substring(0, referencePosition);
+            var valueBeforeCursor = domUtils$9.getElementValue(element).substring(0, referencePosition);
             var lastLineBreakIndex = valueBeforeCursor.lastIndexOf('\n');
             var newPosition = lastLineBreakIndex === -1 ? 0 : lastLineBreakIndex + 1;
             var newStartPos = null;
@@ -4109,19 +4428,19 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return Promise$a.resolve();
     }
     function end(element, withSelection) {
-        if (domUtils$8.isTextEditableElement(element)) {
+        if (domUtils$9.isTextEditableElement(element)) {
             var startPos = textSelection$2.getSelectionStart(element);
             var endPos = textSelection$2.getSelectionEnd(element);
             var inverseSelection = textSelection$2.hasInverseSelection(element);
             var referencePosition = null;
-            var isSingleLineSelection = !domUtils$8.isTextAreaElement(element) ? true :
-                domUtils$8.getTextareaLineNumberByPosition(element, startPos) ===
-                    domUtils$8.getTextareaLineNumberByPosition(element, endPos);
+            var isSingleLineSelection = !domUtils$9.isTextAreaElement(element) ? true :
+                domUtils$9.getTextareaLineNumberByPosition(element, startPos) ===
+                    domUtils$9.getTextareaLineNumberByPosition(element, endPos);
             if (isSingleLineSelection)
                 referencePosition = inverseSelection ? endPos : startPos;
             else
                 referencePosition = inverseSelection ? startPos : endPos;
-            var valueAsterCursor = domUtils$8.getElementValue(element).substring(referencePosition);
+            var valueAsterCursor = domUtils$9.getElementValue(element).substring(referencePosition);
             var firstLineBreakIndex = valueAsterCursor.indexOf('\n');
             var newPosition = referencePosition;
             var newStartPos = null;
@@ -4140,26 +4459,26 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return Promise$a.resolve();
     }
     function esc(element) {
-        if (domUtils$8.isSelectElement(element))
+        if (domUtils$9.isSelectElement(element))
             selectElement.collapseOptionList();
         return Promise$a.resolve();
     }
     function shiftUp(element) {
-        if (browserUtils$b.isWebKit && domUtils$8.isInputElement(element))
+        if (browserUtils$b.isWebKit && domUtils$9.isInputElement(element))
             return shiftHome(element);
-        if (domUtils$8.isTextAreaElement(element))
+        if (domUtils$9.isTextAreaElement(element))
             moveTextAreaCursorUp(element, true);
         return Promise$a.resolve();
     }
     function shiftDown(element) {
-        if (browserUtils$b.isWebKit && domUtils$8.isInputElement(element))
+        if (browserUtils$b.isWebKit && domUtils$9.isInputElement(element))
             return shiftEnd(element);
-        if (domUtils$8.isTextAreaElement(element))
+        if (domUtils$9.isTextAreaElement(element))
             moveTextAreaCursorDown(element, true);
         return Promise$a.resolve();
     }
     function shiftLeft(element) {
-        if (domUtils$8.isTextEditableElement(element)) {
+        if (domUtils$9.isTextEditableElement(element)) {
             var startPos = textSelection$2.getSelectionStart(element);
             var endPos = textSelection$2.getSelectionEnd(element);
             if (startPos === endPos || textSelection$2.hasInverseSelection(element))
@@ -4171,10 +4490,10 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return Promise$a.resolve();
     }
     function shiftRight(element) {
-        if (domUtils$8.isTextEditableElement(element)) {
+        if (domUtils$9.isTextEditableElement(element)) {
             var startPos = textSelection$2.getSelectionStart(element);
             var endPos = textSelection$2.getSelectionEnd(element);
-            var valueLength = domUtils$8.getElementValue(element).length;
+            var valueLength = domUtils$9.getElementValue(element).length;
             if (startPos === endPos || !textSelection$2.hasInverseSelection(element))
                 textSelection$2.select(element, startPos, Math.min(endPos + 1, valueLength));
             else
@@ -4190,33 +4509,33 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return end(element, true);
     }
     function enter(element) {
-        if (domUtils$8.isSelectElement(element))
+        if (domUtils$9.isSelectElement(element))
             selectElement.collapseOptionList();
         //submit form on enter pressed
-        if (domUtils$8.isInputElement(element)) {
+        if (domUtils$9.isInputElement(element)) {
             if (!browserUtils$b.isIE)
                 elementEditingWatcher.processElementChanging(element);
-            var form = domUtils$8.getParents(element, 'form')[0];
+            var form = domUtils$9.getParents(element, 'form')[0];
             // NOTE: if a user presses enter when a form input is focused and the form has
             // a submit button, the browser sends the click event to the submit button
             if (form)
                 submitFormOnEnterPressInInput(form, element);
         }
-        else if (domUtils$8.isTextAreaElement(element)) {
+        else if (domUtils$9.isTextAreaElement(element)) {
             var startPos = textSelection$2.getSelectionStart(element);
-            var value = domUtils$8.getTextAreaValue(element);
+            var value = domUtils$9.getTextAreaValue(element);
             var valueBeforeCursor = value.substring(0, startPos);
             var valueAfterCursor = value.substring(startPos);
             var newPosition = startPos + 1;
             setElementValue(element, valueBeforeCursor + String.fromCharCode(10) + valueAfterCursor, newPosition);
         }
         //S173120
-        else if (element.tagName && domUtils$8.isAnchorElement(element))
+        else if (element.tagName && domUtils$9.isAnchorElement(element))
             eventSimulator$b.click(element);
         return Promise$a.resolve();
     }
     function isRadioButtonNavigationRequired(element) {
-        return domUtils$8.isRadioButtonElement(element) && !browserUtils$b.isFirefox;
+        return domUtils$9.isRadioButtonElement(element) && !browserUtils$b.isFirefox;
     }
     function focusAndCheckNextRadioButton(element, reverse) {
         return focusNextElementOnNavigationButton(element, reverse, false)
@@ -4229,11 +4548,11 @@ window['%hammerhead%'].utils.removeInjectedScript();
         if (skipRadioGroups === void 0) { skipRadioGroups = true; }
         if (!element)
             return Promise$a.resolve();
-        if (domUtils$8.isSelectElement(element))
+        if (domUtils$9.isSelectElement(element))
             selectElement.collapseOptionList();
         return focusNextElement(element, reverse, skipRadioGroups)
             .then(function (nextElement) {
-            if (nextElement && domUtils$8.isTextEditableInput(nextElement))
+            if (nextElement && domUtils$9.isTextEditableInput(nextElement))
                 textSelection$2.select(nextElement);
             return nextElement;
         });
@@ -4397,14 +4716,14 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }());
 
     var Promise$c = hammerhead__default.Promise;
-    var extend$5 = hammerhead__default.utils.extend;
+    var extend$4 = hammerhead__default.utils.extend;
     var browserUtils$d = hammerhead__default.utils.browser;
     var eventSimulator$c = hammerhead__default.eventSandbox.eventSimulator;
-    var domUtils$9 = testCafeCore__default.domUtils, eventUtils$4 = testCafeCore__default.eventUtils, delay$4 = testCafeCore__default.delay;
+    var domUtils$a = testCafeCore__default.domUtils, eventUtils$5 = testCafeCore__default.eventUtils, delay$3 = testCafeCore__default.delay;
     var RClickAutomation = /** @class */ (function (_super) {
         __extends(RClickAutomation, _super);
         function RClickAutomation(element, clickOptions) {
-            var _this = _super.call(this, element, clickOptions) || this;
+            var _this = _super.call(this, element, clickOptions, window, cursor) || this;
             _this.modifiers = clickOptions.modifiers;
             _this.caretPos = clickOptions.caretPos;
             _this.eventState = {
@@ -4418,22 +4737,22 @@ window['%hammerhead%'].utils.removeInjectedScript();
             return cursor
                 .rightButtonDown()
                 .then(function () {
-                _this.eventState.activeElementBeforeMouseDown = domUtils$9.getActiveElement();
+                _this.eventState.activeElementBeforeMouseDown = domUtils$a.getActiveElement();
                 _this.eventState.simulateDefaultBehavior = eventSimulator$c.mousedown(eventArgs.element, eventArgs.options);
                 return _this._focus(eventArgs);
             });
         };
         RClickAutomation.prototype._focus = function (eventArgs) {
             if (this.simulateDefaultBehavior === false)
-                return nextTick$1();
+                return nextTick();
             // NOTE: If a target element is a contentEditable element, we need to call focusAndSetSelection directly for
             // this element. Otherwise, if the element obtained by elementFromPoint is a child of the contentEditable
             // element, a selection position may be calculated incorrectly (by using the caretPos option).
-            var elementForFocus = domUtils$9.isContentEditableElement(this.element) ? this.element : eventArgs.element;
+            var elementForFocus = domUtils$a.isContentEditableElement(this.element) ? this.element : eventArgs.element;
             // NOTE: IE doesn't perform focus if active element has been changed while executing mousedown
-            var simulateFocus = !browserUtils$d.isIE || this.eventState.activeElementBeforeMouseDown === domUtils$9.getActiveElement();
+            var simulateFocus = !browserUtils$d.isIE || this.eventState.activeElementBeforeMouseDown === domUtils$a.getActiveElement();
             return focusAndSetSelection(elementForFocus, simulateFocus, this.caretPos)
-                .then(function () { return nextTick$1(); });
+                .then(function () { return nextTick(); });
         };
         RClickAutomation.prototype._mouseup = function (eventArgs) {
             var _this = this;
@@ -4447,7 +4766,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 ._getElementForEvent(eventArgs)
                 .then(function (element) {
                 eventSimulator$c.contextmenu(element, eventArgs.options);
-                if (!domUtils$9.isElementFocusable(element))
+                if (!domUtils$a.isElementFocusable(element))
                     focusByRelatedElement(element);
             });
         };
@@ -4461,17 +4780,17 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 eventArgs = {
                     point: clientPoint,
                     element: element,
-                    options: extend$5({
+                    options: extend$4({
                         clientX: clientPoint.x,
                         clientY: clientPoint.y,
                         screenX: devicePoint.x,
                         screenY: devicePoint.y,
-                        button: eventUtils$4.BUTTON.right,
+                        button: eventUtils$5.BUTTON.right,
                     }, _this.modifiers),
                 };
                 // NOTE: we should raise mouseup event with 'mouseActionStepDelay' after we trigger
                 // mousedown event regardless of how long mousedown event handlers were executing
-                return Promise$c.all([delay$4(_this.automationSettings.mouseActionStepDelay), _this._mousedown(eventArgs)]);
+                return Promise$c.all([delay$3(_this.automationSettings.mouseActionStepDelay), _this._mousedown(eventArgs)]);
             })
                 .then(function () { return _this._mouseup(eventArgs); })
                 .then(function () { return _this._contextmenu(eventArgs); });
@@ -4480,23 +4799,23 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }(VisibleElementAutomation));
 
     var browserUtils$e = hammerhead__default.utils.browser;
-    var domUtils$a = testCafeCore__default.domUtils;
-    var positionUtils$4 = testCafeCore__default.positionUtils;
+    var domUtils$b = testCafeCore__default.domUtils;
+    var positionUtils$5 = testCafeCore__default.positionUtils;
     var styleUtils$5 = testCafeCore__default.styleUtils;
     var contentEditable$2 = testCafeCore__default.contentEditable;
     var arrayUtils$1 = testCafeCore__default.arrayUtils;
     var MODIFIERS_LIST = ['direction', 'font-family', 'font-size', 'font-size-adjust', 'font-variant', 'font-weight', 'font-style', 'letter-spacing', 'line-height', 'text-align', 'text-indent', 'text-transform', 'word-wrap', 'word-spacing', 'padding-top', 'padding-left', 'padding-right', 'padding-bottom', 'margin-top', 'margin-left', 'margin-right', 'margin-bottom', 'border-top-width', 'border-left-width', 'border-right-width', 'border-bottom-width'];
     function ensureRectangleInsideElement(element, rect) {
         var elementBorders = styleUtils$5.getBordersWidth(element);
-        var elementOffset = positionUtils$4.getOffsetPosition(element);
+        var elementOffset = positionUtils$5.getOffsetPosition(element);
         // NOTE: strange behavior in Chrome - for some elements (e.g., for the 'font' element)
         // scrollHeight is 0, so we use getBoundingClientRect
         var elementHeight = element.scrollHeight || element.getBoundingClientRect().height;
         var left = Math.ceil(rect.left);
         var top = Math.ceil(rect.top);
         var bottom = Math.floor(rect.bottom);
-        if (!domUtils$a.isTextAreaElement(element)) {
-            var clientOffset = positionUtils$4.offsetToClientCoords({
+        if (!domUtils$b.isTextAreaElement(element)) {
+            var clientOffset = positionUtils$5.offsetToClientCoords({
                 x: elementOffset.left,
                 y: elementOffset.top,
             });
@@ -4523,7 +4842,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         };
     }
     function getSelectionRectangleInContentEditableElement(element, position) {
-        var range = domUtils$a.findDocument(element).createRange();
+        var range = domUtils$b.findDocument(element).createRange();
         var selectionPosition = contentEditable$2.calculateNodeAndOffsetByPosition(element, position);
         range.setStart(selectionPosition.node, Math.min(selectionPosition.offset, selectionPosition.node.length));
         range.setEnd(selectionPosition.node, Math.min(selectionPosition.offset, selectionPosition.node.length));
@@ -4544,13 +4863,13 @@ window['%hammerhead%'].utils.removeInjectedScript();
         var clientRectAfterFakeDiv = element.getBoundingClientRect();
         var topBoundDiff = clientRectAfterFakeDiv.top - clientRectBeforeFakeDiv.top;
         var leftBoundDiff = clientRectAfterFakeDiv.left - clientRectBeforeFakeDiv.left;
-        var valueLength = domUtils$a.getElementValue(element).length;
+        var valueLength = domUtils$b.getElementValue(element).length;
         try {
             var range = document.createRange(); //B254723
             range.setStart(hammerhead__default.nativeMethods.nodeFirstChildGetter.call(fakeDiv), Math.min(position, valueLength));
             // NOTE: The range.getClientRects function returns wrong result if range length is 0 in Safari 11
             range.setEnd(hammerhead__default.nativeMethods.nodeFirstChildGetter.call(fakeDiv), Math.min(position + 1, valueLength + 1));
-            if (domUtils$a.isTextAreaElement(element)) {
+            if (domUtils$b.isTextAreaElement(element)) {
                 rect = range.getBoundingClientRect();
                 if (rect.width === 0 && rect.height === 0)
                     rect = range.getClientRects()[0];
@@ -4561,7 +4880,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         catch (err) {
             rect = null;
         }
-        domUtils$a.remove(fakeDiv);
+        domUtils$b.remove(fakeDiv);
         if (!rect)
             return null;
         return {
@@ -4575,7 +4894,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }
     function createFakeDiv(element) {
         var body = document.body;
-        var elementOffset = positionUtils$4.getOffsetPosition(element);
+        var elementOffset = positionUtils$5.getOffsetPosition(element);
         var elementMargin = styleUtils$5.getElementMargin(element);
         var elementTop = elementOffset.top - elementMargin.top;
         var elementLeft = elementOffset.left - elementMargin.left;
@@ -4599,13 +4918,13 @@ window['%hammerhead%'].utils.removeInjectedScript();
             width: element.scrollWidth + 'px',
             height: element.scrollHeight + 'px',
         });
-        hammerhead__default.nativeMethods.nodeTextContentSetter.call(fakeDiv, domUtils$a.getElementValue(element) + ' ');
+        hammerhead__default.nativeMethods.nodeTextContentSetter.call(fakeDiv, domUtils$b.getElementValue(element) + ' ');
         body.appendChild(fakeDiv);
         return fakeDiv;
     }
     function getPositionCoordinates(element, position) {
         var rect = null;
-        if (domUtils$a.isContentEditableElement(element))
+        if (domUtils$b.isContentEditableElement(element))
             rect = getSelectionRectangleInContentEditableElement(element, position);
         else if (typeof element.createTextRange === 'function')
             rect = getTextSelectionRectangle(element, position);
@@ -4621,16 +4940,16 @@ window['%hammerhead%'].utils.removeInjectedScript();
         };
     }
     function getSelectionCoordinatesByPosition(element, position) {
-        var isTextEditable = domUtils$a.isTextEditableElement(element);
-        var isContentEditable = domUtils$a.isContentEditableElement(element);
-        var hasText = isTextEditable && domUtils$a.getElementValue(element).length > 0 ||
+        var isTextEditable = domUtils$b.isTextEditableElement(element);
+        var isContentEditable = domUtils$b.isContentEditableElement(element);
+        var hasText = isTextEditable && domUtils$b.getElementValue(element).length > 0 ||
             isContentEditable && contentEditable$2.getContentEditableValue(element).length;
         if (!hasText)
-            return positionUtils$4.findCenter(element);
+            return positionUtils$5.findCenter(element);
         return getPositionCoordinates(element, position);
     }
     function getSelectionCoordinatesByNodeAndOffset(element, node, offset) {
-        var range = domUtils$a.findDocument(element).createRange();
+        var range = domUtils$b.findDocument(element).createRange();
         range.setStart(node, Math.min(offset, node.length));
         range.setEnd(node, Math.min(offset, node.length));
         var rect = range.getClientRects()[0];
@@ -4656,20 +4975,20 @@ window['%hammerhead%'].utils.removeInjectedScript();
         }
         if (!currentPoint) {
             currentPoint = getPositionCoordinates(element, startPos) ||
-                positionUtils$4.findCenter(element);
+                positionUtils$5.findCenter(element);
         }
         return currentPoint;
     }
     function scrollEditableElementByPoint(element, point) {
-        if (!domUtils$a.isEditableElement(element))
+        if (!domUtils$b.isEditableElement(element))
             return;
-        var isTextarea = domUtils$a.isTextAreaElement(element);
-        var isInputElement = domUtils$a.isInputElement(element);
+        var isTextarea = domUtils$b.isTextAreaElement(element);
+        var isInputElement = domUtils$b.isInputElement(element);
         // NOTE: we don't need to scroll input elements in Mozilla and
         // IE > 10 because it happens automatically on selection setting
         if (isInputElement && (browserUtils$e.isFirefox || browserUtils$e.isIE && browserUtils$e.version > 10))
             return;
-        var elementOffset = positionUtils$4.getOffsetPosition(element);
+        var elementOffset = positionUtils$5.getOffsetPosition(element);
         var elementBorders = styleUtils$5.getBordersWidth(element);
         var elementScroll = styleUtils$5.getElementScroll(element);
         var offsetX = point.x - elementOffset.left - elementBorders.left;
@@ -4692,11 +5011,11 @@ window['%hammerhead%'].utils.removeInjectedScript();
             styleUtils$5.setScrollLeft(element, Math.round(scrollValue));
     }
     function excludeElementScroll(element, point) {
-        var isTextEditable = domUtils$a.isTextEditableElement(element);
-        var isInputElement = domUtils$a.isInputElement(element);
-        if (!(isTextEditable || domUtils$a.isContentEditableElement(element)))
+        var isTextEditable = domUtils$b.isTextEditableElement(element);
+        var isInputElement = domUtils$b.isInputElement(element);
+        if (!(isTextEditable || domUtils$b.isContentEditableElement(element)))
             return point;
-        var elementOffset = positionUtils$4.getOffsetPosition(element);
+        var elementOffset = positionUtils$5.getOffsetPosition(element);
         var elementBorders = styleUtils$5.getBordersWidth(element);
         var elementScroll = styleUtils$5.getElementScroll(element);
         var maxLeft = elementOffset.left + elementBorders.left + element.clientWidth;
@@ -4721,14 +5040,14 @@ window['%hammerhead%'].utils.removeInjectedScript();
     var eventSimulator$d = hammerhead__default.eventSandbox.eventSimulator;
     var focusBlurSandbox$4 = hammerhead__default.eventSandbox.focusBlur;
     var contentEditable$3 = testCafeCore__default.contentEditable;
-    var domUtils$b = testCafeCore__default.domUtils;
-    var positionUtils$5 = testCafeCore__default.positionUtils;
-    var eventUtils$5 = testCafeCore__default.eventUtils;
-    var delay$5 = testCafeCore__default.delay;
+    var domUtils$c = testCafeCore__default.domUtils;
+    var positionUtils$6 = testCafeCore__default.positionUtils;
+    var eventUtils$6 = testCafeCore__default.eventUtils;
+    var delay$4 = testCafeCore__default.delay;
     var SelectBaseAutomation = /** @class */ (function (_super) {
         __extends(SelectBaseAutomation, _super);
         function SelectBaseAutomation(element, actionOptions) {
-            var _this = _super.call(this, element, actionOptions) || this;
+            var _this = _super.call(this, element, actionOptions, window, cursor) || this;
             _this.absoluteStartPoint = null;
             _this.absoluteEndPoint = null;
             _this.clientPoint = null;
@@ -4746,8 +5065,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
             return _this;
         }
         SelectBaseAutomation._calculateEventArguments = function (point) {
-            var clientPoint = positionUtils$5.offsetToClientCoords(point);
-            return getElementFromPoint$1(clientPoint)
+            var clientPoint = positionUtils$6.offsetToClientCoords(point);
+            return getElementFromPoint$2(clientPoint)
                 .then(function (element) {
                 if (!element)
                     throw new Error(ERROR_TYPES.elementIsInvisibleError);
@@ -4764,20 +5083,20 @@ window['%hammerhead%'].utils.removeInjectedScript();
             var _this = this;
             var element = _a.element, offsetX = _a.offsetX, offsetY = _a.offsetY, speed = _a.speed;
             var moveOptions = new MoveOptions({ offsetX: offsetX, offsetY: offsetY, speed: speed }, false);
-            return MoveAutomation.create(element, window, cursor, moveOptions)
+            return MoveAutomation.create(element, moveOptions, window, cursor)
                 .then(function (moveAutomation) {
                 return moveAutomation.run();
             })
-                .then(function () { return delay$5(_this.automationSettings.mouseActionStepDelay); });
+                .then(function () { return delay$4(_this.automationSettings.mouseActionStepDelay); });
         };
         SelectBaseAutomation.prototype._bindMousedownHandler = function () {
             var _this = this;
             var onmousedown = function (e) {
                 _this.eventState.mousedownPrevented = e.defaultPrevented;
-                eventUtils$5.preventDefault(e);
-                eventUtils$5.unbind(_this.element, 'mousedown', onmousedown);
+                eventUtils$6.preventDefault(e);
+                eventUtils$6.unbind(_this.element, 'mousedown', onmousedown);
             };
-            eventUtils$5.bind(this.element, 'mousedown', onmousedown);
+            eventUtils$6.bind(this.element, 'mousedown', onmousedown);
         };
         SelectBaseAutomation.prototype._calculateAbsoluteStartPoint = function () {
             throw new Error('Not implemented');
@@ -4806,7 +5125,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 // NOTE: In WebKit and IE, the mousedown event opens the select element's dropdown;
                 // therefore, we should prevent mousedown and hide the dropdown (B236416).
                 var needCloseSelectDropDown = (browserUtils$f.isWebKit || browserUtils$f.isIE) &&
-                    domUtils$b.isSelectElement(_this.element);
+                    domUtils$c.isSelectElement(_this.element);
                 if (needCloseSelectDropDown)
                     _this._bindMousedownHandler();
                 _this.eventState.simulateDefaultBehavior = eventSimulator$d[_this.downEvent](_this.eventArgs.element, _this.eventArgs.options);
@@ -4819,7 +5138,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             var _this = this;
             return new Promise$d(function (resolve) {
                 // NOTE: If the target element is a child of a contentEditable element, we need to call focus for its parent
-                var elementForFocus = domUtils$b.isContentEditableElement(_this.element) ?
+                var elementForFocus = domUtils$c.isContentEditableElement(_this.element) ?
                     contentEditable$3.findContentEditableParent(_this.element) : _this.element;
                 focusBlurSandbox$4.focus(elementForFocus, resolve, false, true);
             });
@@ -4854,8 +5173,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }(VisibleElementAutomation));
 
     var textSelection$3 = testCafeCore__default.textSelection;
-    var domUtils$c = testCafeCore__default.domUtils;
-    var positionUtils$6 = testCafeCore__default.positionUtils;
+    var domUtils$d = testCafeCore__default.domUtils;
+    var positionUtils$7 = testCafeCore__default.positionUtils;
     var SelectTextAutomation = /** @class */ (function (_super) {
         __extends(SelectTextAutomation, _super);
         function SelectTextAutomation(element, startPos, endPos, actionOptions) {
@@ -4866,20 +5185,20 @@ window['%hammerhead%'].utils.removeInjectedScript();
         }
         SelectTextAutomation.prototype._calculateAbsoluteStartPoint = function () {
             var point = getSelectionCoordinatesByPosition(this.element, this.startPos);
-            return point || positionUtils$6.findCenter(this.element);
+            return point || positionUtils$7.findCenter(this.element);
         };
         SelectTextAutomation.prototype._calculateAbsoluteEndPoint = function () {
             var point = getSelectionCoordinatesByPosition(this.element, this.endPos);
             if (point)
                 return point;
             // NOTE: if selection ends on an invisible symbol, we should try to find the last visible selection position
-            if (domUtils$c.isContentEditableElement(this.element))
+            if (domUtils$d.isContentEditableElement(this.element))
                 return getLastVisibleSelectionPosition(this.element, this.startPos, this.endPos);
-            return positionUtils$6.findCenter(this.element);
+            return positionUtils$7.findCenter(this.element);
         };
         SelectTextAutomation.prototype._setSelection = function () {
-            var isTextEditable = domUtils$c.isTextEditableElement(this.element);
-            var isContentEditable = domUtils$c.isContentEditableElement(this.element);
+            var isTextEditable = domUtils$d.isTextEditableElement(this.element);
+            var isContentEditable = domUtils$d.isContentEditableElement(this.element);
             if (!(isTextEditable || isContentEditable) || this.eventState.simulateDefaultBehavior === false)
                 return;
             textSelection$3.select(this.element, this.startPos, this.endPos);
@@ -4895,7 +5214,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
 
     var textSelection$4 = testCafeCore__default.textSelection;
     var contentEditable$4 = testCafeCore__default.contentEditable;
-    var positionUtils$7 = testCafeCore__default.positionUtils;
+    var positionUtils$8 = testCafeCore__default.positionUtils;
     var SelectEditableContentAutomation = /** @class */ (function (_super) {
         __extends(SelectEditableContentAutomation, _super);
         function SelectEditableContentAutomation(startNode, endNode, actionOptions) {
@@ -4922,11 +5241,11 @@ window['%hammerhead%'].utils.removeInjectedScript();
         }
         SelectEditableContentAutomation.prototype._calculateAbsoluteStartPoint = function () {
             var point = getSelectionCoordinatesByNodeAndOffset(this.element, this.startNode, this.startOffset);
-            return point || positionUtils$7.findCenter(this.element);
+            return point || positionUtils$8.findCenter(this.element);
         };
         SelectEditableContentAutomation.prototype._calculateAbsoluteEndPoint = function () {
             var point = getSelectionCoordinatesByNodeAndOffset(this.element, this.endNode, this.endOffset);
-            return point || positionUtils$7.findCenter(this.element);
+            return point || positionUtils$8.findCenter(this.element);
         };
         SelectEditableContentAutomation.prototype._setSelection = function () {
             if (this.eventState.simulateDefaultBehavior === false)
@@ -4941,15 +5260,15 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }(SelectBaseAutomation));
 
     var Promise$e = hammerhead__default.Promise;
-    var extend$6 = hammerhead__default.utils.extend;
+    var extend$5 = hammerhead__default.utils.extend;
     var browserUtils$g = hammerhead__default.utils.browser;
     var eventSimulator$e = hammerhead__default.eventSandbox.eventSimulator;
     var elementEditingWatcher$1 = hammerhead__default.eventSandbox.elementEditingWatcher;
-    var domUtils$d = testCafeCore__default.domUtils;
+    var domUtils$e = testCafeCore__default.domUtils;
     var promiseUtils = testCafeCore__default.promiseUtils;
     var contentEditable$5 = testCafeCore__default.contentEditable;
     var textSelection$5 = testCafeCore__default.textSelection;
-    var delay$6 = testCafeCore__default.delay;
+    var delay$5 = testCafeCore__default.delay;
     var SPECIAL_KEYS = testCafeCore__default.KEY_MAPS.specialKeys;
     var TypeAutomation = /** @class */ (function () {
         function TypeAutomation(element, text, typeOptions) {
@@ -4982,10 +5301,10 @@ window['%hammerhead%'].utils.removeInjectedScript();
         }
         TypeAutomation.findTextEditableChild = function (element) {
             var innerElement = null;
-            if (!domUtils$d.isEditableElement(element)) {
+            if (!domUtils$e.isEditableElement(element)) {
                 var allChildren = element.querySelectorAll('*');
                 for (var i = 0; i < allChildren.length; i++) {
-                    if (domUtils$d.isTextEditableElementAndEditingAllowed(allChildren[i])) {
+                    if (domUtils$e.isTextEditableElementAndEditingAllowed(allChildren[i])) {
                         innerElement = allChildren[i];
                         break;
                     }
@@ -4994,23 +5313,23 @@ window['%hammerhead%'].utils.removeInjectedScript();
             return innerElement;
         };
         TypeAutomation.prototype._calculateEventArguments = function (isPressEvent) {
-            var activeElement = domUtils$d.getActiveElement();
-            var isContentEditable = domUtils$d.isContentEditableElement(this.element);
+            var activeElement = domUtils$e.getActiveElement();
+            var isContentEditable = domUtils$e.isContentEditableElement(this.element);
             var element = this.eventArgs.element || this.element;
             // T162478: Wrong typing and keys pressing in editor
             if (!isContentEditable && activeElement !== element)
                 element = TypeAutomation.findTextEditableChild(activeElement) || activeElement;
-            var options = extend$6({
+            var options = extend$5({
                 keyCode: isPressEvent ? this.currentCharCode : this.currentKeyCode,
             }, this.modifiers);
             if (isPressEvent)
                 options.charCode = this.currentCharCode;
-            extend$6(options, getKeyProperties(isPressEvent, this.currentKey, this.currentKeyIdentifier));
+            extend$5(options, getKeyProperties(isPressEvent, this.currentKey, this.currentKeyIdentifier));
             return { element: element, options: options };
         };
         TypeAutomation.prototype._calculateTargetElement = function () {
-            var activeElement = domUtils$d.getActiveElement();
-            var isContentEditable = domUtils$d.isContentEditableElement(this.element);
+            var activeElement = domUtils$e.getActiveElement();
+            var isContentEditable = domUtils$e.isContentEditableElement(this.element);
             if (isContentEditable) {
                 if (activeElement !== contentEditable$5.findContentEditableParent(this.element)) {
                     this.eventState.skipType = true;
@@ -5025,9 +5344,9 @@ window['%hammerhead%'].utils.removeInjectedScript();
         };
         TypeAutomation.prototype._click = function (useStrictElementCheck) {
             var _this = this;
-            var activeElement = domUtils$d.getActiveElement();
-            var isTextEditable = domUtils$d.isTextEditableElementAndEditingAllowed(this.element);
-            var isContentEditable = domUtils$d.isContentEditableElement(this.element);
+            var activeElement = domUtils$e.getActiveElement();
+            var isTextEditable = domUtils$e.isTextEditableElementAndEditingAllowed(this.element);
+            var isContentEditable = domUtils$e.isContentEditableElement(this.element);
             if (activeElement !== this.element) {
                 var _a = getDefaultAutomationOffsets(this.element), offsetX = _a.offsetX, offsetY = _a.offsetY;
                 var clickOptions = new ClickOptions({
@@ -5037,10 +5356,10 @@ window['%hammerhead%'].utils.removeInjectedScript();
                     caretPos: this.caretPos,
                     modifiers: this.modifiers,
                 });
-                var clickAutomation = new ClickAutomation(this.element, clickOptions);
+                var clickAutomation = new ClickAutomation(this.element, clickOptions, window, cursor);
                 return clickAutomation
                     .run(useStrictElementCheck)
-                    .then(function () { return delay$6(_this.automationSettings.mouseActionStepDelay); });
+                    .then(function () { return delay$5(_this.automationSettings.mouseActionStepDelay); });
             }
             if (isTextEditable)
                 elementEditingWatcher$1.watchElementEditing(this.element);
@@ -5056,9 +5375,9 @@ window['%hammerhead%'].utils.removeInjectedScript();
             var _this = this;
             if (this.eventState.skipType)
                 return Promise$e.resolve();
-            var isContentEditable = domUtils$d.isContentEditableElement(this.element);
+            var isContentEditable = domUtils$e.isContentEditableElement(this.element);
             if (this.replace) {
-                if (domUtils$d.isTextEditableElementAndEditingAllowed(this.element))
+                if (domUtils$e.isTextEditableElementAndEditingAllowed(this.element))
                     textSelection$5.select(this.element);
                 else if (isContentEditable)
                     textSelection$5.deleteSelectionContents(this.element, true);
@@ -5074,7 +5393,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             this.currentCharCode = this.typingText.charCodeAt(this.currentPos);
             this.currentKey = this.currentKeyCode === SPECIAL_KEYS['enter'] ? 'Enter' : char;
             this.currentKeyIdentifier = getKeyIdentifier(this.currentKey);
-            this.ignoreChangeEvent = domUtils$d.getElementValue(this.element) === elementEditingWatcher$1.getElementSavedValue(this.element);
+            this.ignoreChangeEvent = domUtils$e.getElementValue(this.element) === elementEditingWatcher$1.getElementSavedValue(this.element);
             this._keydown();
             this._keypress();
             return this._keyup();
@@ -5093,8 +5412,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
             var _this = this;
             var elementForTyping = this.eventArgs.element;
             this.eventArgs = this._calculateEventArguments();
-            var isTextEditableElement = domUtils$d.isTextEditableElement(this.element);
-            var isContentEditable = domUtils$d.isContentEditableElement(this.element);
+            var isTextEditableElement = domUtils$e.isTextEditableElement(this.element);
+            var isContentEditable = domUtils$e.isContentEditableElement(this.element);
             var shouldTypeAllText = this.paste || !isTextEditableElement && !isContentEditable;
             return Promise$e
                 .resolve()
@@ -5117,30 +5436,30 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 // was changed before the prevented keypress or keydown (GH-4881)
                 if (this.ignoreChangeEvent)
                     elementEditingWatcher$1.restartWatchingElementEditing(element);
-                return delay$6(this.automationSettings.keyActionStepDelay);
+                return delay$5(this.automationSettings.keyActionStepDelay);
             }
             var currentChar = this.typingText.charAt(this.currentPos);
             var isDigit = /^\d$/.test(currentChar);
             var prevChar = this.currentPos === 0 ? null : this.typingText.charAt(this.currentPos - 1);
-            var isInputTypeNumber = domUtils$d.isInputElement(element) && element.type === 'number';
+            var isInputTypeNumber = domUtils$e.isInputElement(element) && element.type === 'number';
             if (isInputTypeNumber) {
                 var selectionStart = textSelection$5.getSelectionStart(element);
-                var valueLength = domUtils$d.getInputValue(element).length;
+                var valueLength = domUtils$e.getInputValue(element).length;
                 var textHasDigits = /^\d/.test(this.typingText);
                 var isPermissibleSymbol = currentChar === '.' || currentChar === '-' && valueLength;
                 if (!isDigit && (textHasDigits || !isPermissibleSymbol || selectionStart !== 0))
-                    return delay$6(this.automationSettings.keyActionStepDelay);
+                    return delay$5(this.automationSettings.keyActionStepDelay);
                 // NOTE: allow to type '.' or '-' only if it is the first symbol and the input already has
                 // a value, or if '.' or '-' are added to a digit. Otherwise, the value won't be set.
                 if (isDigit && (prevChar === '.' || prevChar === '-' && !valueLength))
                     currentChar = prevChar + currentChar;
             }
             typeText(element, currentChar, null);
-            return delay$6(this.automationSettings.keyActionStepDelay);
+            return delay$5(this.automationSettings.keyActionStepDelay);
         };
         TypeAutomation.prototype._typeAllText = function (element) {
             typeText(element, this.typingText, this.caretPos);
-            return delay$6(this.automationSettings.keyActionStepDelay);
+            return delay$5(this.automationSettings.keyActionStepDelay);
         };
         TypeAutomation.prototype.run = function (useStrictElementCheck) {
             var _this = this;
@@ -5174,10 +5493,10 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return UploadAutomation;
     }());
 
-    var domUtils$e = testCafeCore__default.domUtils;
+    var domUtils$f = testCafeCore__default.domUtils;
     var contentEditable$6 = testCafeCore__default.contentEditable;
     function getSelectTextAreaContentArguments(element, argumentsObject) {
-        var value = domUtils$e.getTextAreaValue(element);
+        var value = domUtils$f.getTextAreaValue(element);
         var linesArray = value && value.length ? value.split('\n') : [];
         var lastLineIndex = linesArray.length - 1;
         var startLineIndex = !argumentsObject.startLine ? 0 : Math.min(argumentsObject.startLine, lastLineIndex);
@@ -5189,8 +5508,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
         var endPos = argumentsObject.endPos === void 0 ||
             argumentsObject.endPos ===
                 null ? endLineLength : Math.min(argumentsObject.endPos, endLineLength);
-        var startLinePosition = domUtils$e.getTextareaPositionByLineAndOffset(element, startLineIndex, 0);
-        var endLinePosition = domUtils$e.getTextareaPositionByLineAndOffset(element, endLineIndex, 0);
+        var startLinePosition = domUtils$f.getTextareaPositionByLineAndOffset(element, startLineIndex, 0);
+        var endLinePosition = domUtils$f.getTextareaPositionByLineAndOffset(element, endLineIndex, 0);
         return {
             startPos: startLinePosition + startPos,
             endPos: endLinePosition + endPos,
@@ -5198,9 +5517,9 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }
     function calculateSelectTextArguments (element, argumentsObject) {
         if (argumentsObject === void 0) { argumentsObject = {}; }
-        var isTextEditable = domUtils$e.isTextEditableElement(element);
+        var isTextEditable = domUtils$f.isTextEditableElement(element);
         var firstPos = isTextEditable ? 0 : contentEditable$6.getFirstVisiblePosition(element);
-        var lastPos = isTextEditable ? domUtils$e.getElementValue(element).length : contentEditable$6.getLastVisiblePosition(element);
+        var lastPos = isTextEditable ? domUtils$f.getElementValue(element).length : contentEditable$6.getLastVisiblePosition(element);
         var startPos = !argumentsObject.startPos ? firstPos : Math.min(argumentsObject.startPos, lastPos);
         var endPos = argumentsObject.endPos === void 0 ||
             argumentsObject.endPos === null ? lastPos : Math.min(argumentsObject.endPos, lastPos);
@@ -5246,7 +5565,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     exports$1.getNextFocusableElement = getNextFocusableElement;
     exports$1.SHORTCUT_TYPE = SHORTCUT_TYPE;
     exports$1.getSelectionCoordinatesByPosition = getSelectionCoordinatesByPosition;
-    exports$1.getElementFromPoint = getElementFromPoint$1;
+    exports$1.getElementFromPoint = getElementFromPoint$2;
     var nativeMethods$c = hammerhead__default.nativeMethods;
     var evalIframeScript = hammerhead__default.EVENTS.evalIframeScript;
     nativeMethods$c.objectDefineProperty(window, '%testCafeAutomation%', { configurable: true, value: exports$1 });