testcafe 2.3.1-rc.2 → 2.4.0-rc.1

package/lib/client/ui/index.js

@@ -7,20 +7,35 @@ window['%hammerhead%'].utils.removeInjectedScript();
     function initTestCafeUI(window) {
         var document = window.document;
 
-        (function (hammerhead, testCafeCore, Promise$3) {
-    var hammerhead__default = 'default' in hammerhead ? hammerhead['default'] : hammerhead;
+        (function (hammerhead$1, testCafeCore, Promise$3) {
+    var hammerhead$1__default = 'default' in hammerhead$1 ? hammerhead$1['default'] : hammerhead$1;
     var testCafeCore__default = 'default' in testCafeCore ? testCafeCore['default'] : testCafeCore;
     Promise$3 = Promise$3 && Object.prototype.hasOwnProperty.call(Promise$3, 'default') ? Promise$3['default'] : Promise$3;
 
+    var PANELS_CONTAINER_CLASS = 'panels-container';
     var uiRoot = {
         uiRoot: null,
+        container: null,
         element: function () {
             if (!this.uiRoot) {
                 this.uiRoot = document.createElement('div');
-                hammerhead.shadowUI.getRoot().appendChild(this.uiRoot);
+                hammerhead$1.shadowUI.getRoot().appendChild(this.uiRoot);
             }
             return this.uiRoot;
         },
+        panelsContainer: function () {
+            if (!this.container) {
+                this.container = document.createElement('div');
+                hammerhead$1.shadowUI.addClass(this.container, PANELS_CONTAINER_CLASS);
+                this.element().appendChild(this.container);
+            }
+            return this.container;
+        },
+        insertFirstChildToPanelsContainer: function (element) {
+            var panelsContainer = this.panelsContainer();
+            var firstChild = hammerhead$1.nativeMethods.nodeFirstChildGetter.call(panelsContainer);
+            panelsContainer.insertBefore(element, firstChild);
+        },
         hide: function () {
             if (!this.uiRoot)
                 return;
@@ -32,19 +47,19 @@ window['%hammerhead%'].utils.removeInjectedScript();
             this.uiRoot.style.visibility = '';
         },
         remove: function () {
-            var shadowRoot = hammerhead.shadowUI.getRoot();
-            var parent = hammerhead.nativeMethods.nodeParentNodeGetter.call(shadowRoot);
+            var shadowRoot = hammerhead$1.shadowUI.getRoot();
+            var parent = hammerhead$1.nativeMethods.nodeParentNodeGetter.call(shadowRoot);
             parent.removeChild(shadowRoot);
         },
     };
 
     //NOTE: we can't manipulate (open/close option list) with a native select element during test running, so we
-    var shadowUI = hammerhead__default.shadowUI;
-    var browserUtils = hammerhead__default.utils.browser;
-    var featureDetection = hammerhead__default.utils.featureDetection;
-    var nativeMethods = hammerhead__default.nativeMethods;
-    var eventSimulator = hammerhead__default.eventSandbox.eventSimulator;
-    var listeners = hammerhead__default.eventSandbox.listeners;
+    var shadowUI = hammerhead$1__default.shadowUI;
+    var browserUtils = hammerhead$1__default.utils.browser;
+    var featureDetection = hammerhead$1__default.utils.featureDetection;
+    var nativeMethods = hammerhead$1__default.nativeMethods;
+    var eventSimulator = hammerhead$1__default.eventSandbox.eventSimulator;
+    var listeners = hammerhead$1__default.eventSandbox.listeners;
     var positionUtils = testCafeCore__default.positionUtils;
     var domUtils = testCafeCore__default.domUtils;
     var styleUtils = testCafeCore__default.styleUtils;
@@ -228,15 +243,15 @@ window['%hammerhead%'].utils.removeInjectedScript();
         var root = uiRoot.element();
         backgroundDiv = document.createElement('div');
         root.appendChild(backgroundDiv);
-        hammerhead.shadowUI.addClass(backgroundDiv, BACKGROUND_CLASS);
+        hammerhead$1.shadowUI.addClass(backgroundDiv, BACKGROUND_CLASS);
         loadingTextDiv = document.createElement('div');
-        hammerhead.nativeMethods.nodeTextContentSetter.call(loadingTextDiv, LOADING_TEXT);
+        hammerhead$1.nativeMethods.nodeTextContentSetter.call(loadingTextDiv, LOADING_TEXT);
         root.appendChild(loadingTextDiv);
-        hammerhead.shadowUI.addClass(loadingTextDiv, LOADING_TEXT_CLASS);
+        hammerhead$1.shadowUI.addClass(loadingTextDiv, LOADING_TEXT_CLASS);
         loadingIconDiv = document.createElement('div');
         testCafeCore.styleUtils.set(loadingIconDiv, 'visibility', 'hidden');
         root.appendChild(loadingIconDiv);
-        hammerhead.shadowUI.addClass(loadingIconDiv, LOADING_ICON_CLASS);
+        hammerhead$1.shadowUI.addClass(loadingIconDiv, LOADING_ICON_CLASS);
     }
     //Behavior
     function adjustLoadingTextPos() {
@@ -291,7 +306,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
                 if (document.body)
                     initAndShow();
                 else
-                    hammerhead.nativeMethods.setTimeout.call(window, tryShowBeforeReady, 0);
+                    hammerhead$1.nativeMethods.setTimeout.call(window, tryShowBeforeReady, 0);
             }
         };
         tryShowBeforeReady();
@@ -331,7 +346,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         hideLoadingIcon: hideLoadingIcon
     });
 
-    var shadowUI$1 = hammerhead__default.shadowUI;
+    var shadowUI$1 = hammerhead$1__default.shadowUI;
     var styleUtils$1 = testCafeCore__default.styleUtils;
     var CONTAINER_CLASS = 'progress-bar';
     var VALUE_CLASS = 'value';
@@ -358,8 +373,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return ProgressBar;
     }());
 
-    var shadowUI$2 = hammerhead__default.shadowUI;
-    var nativeMethods$1 = hammerhead__default.nativeMethods;
+    var shadowUI$2 = hammerhead$1__default.shadowUI;
+    var nativeMethods$1 = hammerhead$1__default.nativeMethods;
     var eventUtils$1 = testCafeCore__default.eventUtils;
     var styleUtils$2 = testCafeCore__default.styleUtils;
     var PANEL_CLASS = 'progress-panel';
@@ -523,10 +538,98 @@ window['%hammerhead%'].utils.removeInjectedScript();
         extendStatics(d, b);
         function __() { this.constructor = d; }
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise$3))(function (resolve, reject) {
+            function fulfilled(value) { try {
+                step(generator.next(value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function rejected(value) { try {
+                step(generator["throw"](value));
+            }
+            catch (e) {
+                reject(e);
+            } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function () { if (t[0] & 1)
+                throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f)
+                throw new TypeError("Generator is already executing.");
+            while (g && (g = 0, op[0] && (_ = 0)), _)
+                try {
+                    if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                        return t;
+                    if (y = 0, t)
+                        op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2])
+                                _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                }
+                catch (e) {
+                    op = [6, e];
+                    y = 0;
+                }
+                finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5)
+                throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
     }
 
-    var shadowUI$3 = hammerhead__default.shadowUI;
-    var nativeMethods$2 = hammerhead__default.nativeMethods;
+    var shadowUI$3 = hammerhead$1__default.shadowUI;
+    var nativeMethods$2 = hammerhead$1__default.nativeMethods;
     var styleUtils$3 = testCafeCore__default.styleUtils;
     var DETERMINATE_STYLE_CLASS = 'determinate';
     var ANIMATION_UPDATE_INTERVAL$1 = 10;
@@ -574,8 +677,8 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return Math.round(equationSlope * x + equationYIntercept);
     }
 
-    var shadowUI$4 = hammerhead__default.shadowUI;
-    var nativeMethods$3 = hammerhead__default.nativeMethods;
+    var shadowUI$4 = hammerhead$1__default.shadowUI;
+    var nativeMethods$3 = hammerhead$1__default.nativeMethods;
     var styleUtils$4 = testCafeCore__default.styleUtils;
     var FIRST_VALUE_ANIMATION_OPTIONS = {
         time: 2800,
@@ -706,7 +809,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return IndeterminateIndicator;
     }());
 
-    var shadowUI$5 = hammerhead__default.shadowUI;
+    var shadowUI$5 = hammerhead$1__default.shadowUI;
     var styleUtils$5 = testCafeCore__default.styleUtils;
     var PROGRESS_BAR_CLASS = 'progress-bar';
     var CONTAINER_CLASS$1 = 'value-container';
@@ -761,13 +864,13 @@ window['%hammerhead%'].utils.removeInjectedScript();
         return window.top !== window;
     }
 
-    var Promise = hammerhead__default.Promise;
-    var shadowUI$6 = hammerhead__default.shadowUI;
-    var nativeMethods$4 = hammerhead__default.nativeMethods;
-    var messageSandbox = hammerhead__default.eventSandbox.message;
-    var browserUtils$1 = hammerhead__default.utils.browser;
-    var featureDetection$1 = hammerhead__default.utils.featureDetection;
-    var listeners$1 = hammerhead__default.eventSandbox.listeners;
+    var Promise = hammerhead$1__default.Promise;
+    var shadowUI$6 = hammerhead$1__default.shadowUI;
+    var nativeMethods$4 = hammerhead$1__default.nativeMethods;
+    var messageSandbox = hammerhead$1__default.eventSandbox.message;
+    var browserUtils$1 = hammerhead$1__default.utils.browser;
+    var featureDetection$1 = hammerhead$1__default.utils.featureDetection;
+    var listeners$1 = hammerhead$1__default.eventSandbox.listeners;
     var styleUtils$6 = testCafeCore__default.styleUtils;
     var eventUtils$2 = testCafeCore__default.eventUtils;
     var domUtils$1 = testCafeCore__default.domUtils;
@@ -930,7 +1033,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
             this.progressBar = new ProgressBar$1(this.infoContainer);
             this.progressBar.indeterminateIndicator.start();
             this.progressBar.show();
-            uiRoot.element().appendChild(this.statusBar);
+            uiRoot.panelsContainer().appendChild(this.statusBar);
             this._bindHandlers();
             this.state.created = true;
         };
@@ -1167,7 +1270,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     }(serviceUtils.EventEmitter));
 
     var sendRequestToFrame = testCafeCore__default.sendRequestToFrame;
-    var messageSandbox$1 = hammerhead__default.eventSandbox.message;
+    var messageSandbox$1 = hammerhead$1__default.eventSandbox.message;
     var IframeStatusBar = /** @class */ (function (_super) {
         __extends(IframeStatusBar, _super);
         function IframeStatusBar() {
@@ -1202,11 +1305,11 @@ window['%hammerhead%'].utils.removeInjectedScript();
         buttonUpResponse: 'ui|cursor|buttonup|response',
     };
 
-    var Promise$1 = hammerhead__default.Promise;
-    var shadowUI$7 = hammerhead__default.shadowUI;
-    var browserUtils$2 = hammerhead__default.utils.browser;
-    var featureDetection$2 = hammerhead__default.utils.featureDetection;
-    var messageSandbox$2 = hammerhead__default.eventSandbox.message;
+    var Promise$1 = hammerhead$1__default.Promise;
+    var shadowUI$7 = hammerhead$1__default.shadowUI;
+    var browserUtils$2 = hammerhead$1__default.utils.browser;
+    var featureDetection$2 = hammerhead$1__default.utils.featureDetection;
+    var messageSandbox$2 = hammerhead$1__default.eventSandbox.message;
     var styleUtils$7 = testCafeCore__default.styleUtils;
     var positionUtils$1 = testCafeCore__default.positionUtils;
     var CURSOR_CLASS = 'cursor';
@@ -1311,7 +1414,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
         },
     };
 
-    var browserUtils$3 = hammerhead__default.utils.browser;
+    var browserUtils$3 = hammerhead$1__default.utils.browser;
     // HACK: In most browsers, the iframe's getElementFromPoint function ignores elements
     // from the parent frame. But in IE it doesn't, and our cursor overlaps the target
     // element. So, we move the cursor to a position one pixel farther to avoid this.
@@ -1352,12 +1455,12 @@ window['%hammerhead%'].utils.removeInjectedScript();
         screenshotMark: null,
         _createMark: function () {
             this.screenshotMark = document.createElement('img');
-            hammerhead.shadowUI.addClass(this.screenshotMark, 'screenshot-mark');
+            hammerhead$1.shadowUI.addClass(this.screenshotMark, 'screenshot-mark');
             this.screenshotMark.style.right = MARK_RIGHT_MARGIN / window.devicePixelRatio + 'px';
             this.screenshotMark.style.width = MARK_LENGTH / window.devicePixelRatio + 'px';
             this.screenshotMark.style.height = MARK_HEIGHT / window.devicePixelRatio + 'px';
             this.hide();
-            hammerhead.shadowUI.getRoot().appendChild(this.screenshotMark);
+            hammerhead$1.shadowUI.getRoot().appendChild(this.screenshotMark);
         },
         hide: function () {
             if (!this.screenshotMark)
@@ -1367,13 +1470,3091 @@ window['%hammerhead%'].utils.removeInjectedScript();
         show: function (url) {
             if (!this.screenshotMark)
                 this._createMark();
-            hammerhead.nativeMethods.imageSrcSetter.call(this.screenshotMark, url);
+            hammerhead$1.nativeMethods.imageSrcSetter.call(this.screenshotMark, url);
             this.screenshotMark.style.visibility = '';
         },
     };
 
-    var Promise$2 = hammerhead__default.Promise;
-    var messageSandbox$3 = hammerhead__default.eventSandbox.message;
+    var shadowUI$8 = hammerhead$1__default.shadowUI;
+    var nativeMethods$5 = hammerhead$1__default.nativeMethods;
+    function createElementFromDescriptor(descriptor) {
+        // eslint-disable-next-line no-restricted-properties
+        var _a = descriptor.tag, tag = _a === void 0 ? 'div' : _a, className = descriptor.class, src = descriptor.src, text = descriptor.text, type = descriptor.type, value = descriptor.value;
+        var element = document.createElement(tag);
+        if (type)
+            nativeMethods$5.setAttribute.call(element, 'type', type);
+        if (value)
+            nativeMethods$5.inputValueSetter.call(element, value);
+        if (src)
+            nativeMethods$5.setAttribute.call(element, 'src', src);
+        if (className)
+            shadowUI$8.addClass(element, className);
+        if (text)
+            nativeMethods$5.nodeTextContentSetter.call(element, text);
+        return element;
+    }
+
+    /* eslint-disable no-restricted-properties */
+    var styleUtils$8 = testCafeCore__default.styleUtils;
+    function setStyles(element, styles) {
+        for (var key in styles)
+            styleUtils$8.set(element, key, styles[key]);
+    }
+
+    var pickButton = {
+        tag: 'input',
+        type: 'button',
+        value: 'Pick',
+        class: 'pick-button',
+    };
+    var selectorInput = {
+        tag: 'input',
+        type: 'text',
+        class: 'selector-input',
+    };
+    var matchIndicator = {
+        class: 'match-indicator',
+        text: 'No Matching Elements',
+    };
+    var expandSelectorsList = {
+        class: 'expand-selector-list',
+    };
+    var selectorInputContainer = {
+        class: 'selector-input-container',
+    };
+    var copyButton = {
+        tag: 'input',
+        type: 'button',
+        value: 'Copy',
+    };
+    var selectorsList = {
+        class: 'selectors-list',
+    };
+    var panel = {
+        class: 'selector-inspector-panel',
+    };
+    var elementFrame = {
+        class: 'element-frame',
+    };
+    var tooltip = {
+        class: 'tooltip',
+    };
+    var arrow = {
+        class: 'arrow',
+    };
+    var auxiliaryCopyInput = {
+        tag: 'input',
+        type: 'text',
+        class: 'auxiliary-input',
+    };
+
+    /* eslint-disable no-restricted-properties */
+    function addToUiRoot(element) {
+        if (!element.parentElement) {
+            var panelsContainer = uiRoot.panelsContainer();
+            uiRoot.element().insertBefore(element, panelsContainer);
+        }
+    }
+    function removeFromUiRoot(element) {
+        if (element.parentElement)
+            uiRoot.element().removeChild(element);
+    }
+    function getChildren() {
+        return uiRoot.element().children;
+    }
+
+    var TESTCAFE_CORE = window['%testCafeCore%'];
+
+    function findIndex(array, predicate) {
+        var length = array.length;
+        for (var i = 0; i < length; i++) {
+            if (predicate(array[i]))
+                return i;
+        }
+        return -1;
+    }
+
+    var SelectorRule = /** @class */ (function () {
+        function SelectorRule(type, editable) {
+            if (editable === void 0) { editable = false; }
+            this.type = type;
+            this.editable = editable;
+            this.disabled = void 0;
+        }
+        return SelectorRule;
+    }());
+
+    var CustomSelectorRule = /** @class */ (function (_super) {
+        __extends(CustomSelectorRule, _super);
+        function CustomSelectorRule(type) {
+            return _super.call(this, type.toLowerCase(), true) || this;
+        }
+        return CustomSelectorRule;
+    }(SelectorRule));
+
+    /* eslint-disable sort-keys */
+    // TODO: users should be able to call a custom-attr 'text' for example
+    // and the name 'class-dom' should not be considered as default compound rule but as custom attr.
+    var RULE_TYPE = {
+        edited: '$edited$',
+        byTagName: '$tagName$',
+        byId: 'id',
+        byText: '$text$',
+        byClassAttr: 'class',
+        byAttr: '$attr$',
+        byTagTree: '$dom$',
+    };
+
+    var DEFAULT_SELECTOR_RULES = [
+        new SelectorRule(RULE_TYPE.byTagName),
+        new SelectorRule(RULE_TYPE.byId),
+        new SelectorRule(RULE_TYPE.byText),
+        new SelectorRule(RULE_TYPE.byClassAttr),
+        new SelectorRule(RULE_TYPE.byAttr),
+        new SelectorRule(RULE_TYPE.byTagTree),
+    ];
+
+    var UNSWITCHABLE_RULE_TYPE = RULE_TYPE.byTagTree;
+
+    var RULES = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        CustomSelectorRule: CustomSelectorRule,
+        DEFAULT_SELECTOR_RULES: DEFAULT_SELECTOR_RULES,
+        RULE_TYPE: RULE_TYPE,
+        SelectorRule: SelectorRule,
+        UNSWITCHABLE_RULE_TYPE: UNSWITCHABLE_RULE_TYPE
+    });
+
+    var FilterOption = /** @class */ (function () {
+        function FilterOption(type, value) {
+            this.type = type;
+            this.filter = value;
+        }
+        FilterOption.prototype.concat = function (option) {
+            if (option.type === this.type)
+                return new FilterOption(this.type, this.filter.concat(' ', option.filter));
+            return null;
+        };
+        return FilterOption;
+    }());
+
+    var byText = 'text';
+    var byIndex = 'index';
+    var byTag = 'tag';
+    var byAttr = 'attr';
+
+    var domUtils$2 = TESTCAFE_CORE.domUtils, arrayUtils$2 = TESTCAFE_CORE.arrayUtils;
+    function getNthFilterOptions(el, parent) {
+        var index = domUtils$2.getElementIndexInParent(parent, el);
+        var tagFilterOption = new FilterOption(byTag, domUtils$2.getTagName(el));
+        if (index === 0)
+            return [tagFilterOption];
+        var indexFilterOption = new FilterOption(byIndex, index);
+        return [tagFilterOption, indexFilterOption];
+    }
+    function getParentsUntil(el, boundElement) {
+        var parent = el.parentElement;
+        var parents = [];
+        while (parent) {
+            if (parent === boundElement)
+                return parents;
+            parents.push(parent);
+            parent = parent.parentElement;
+        }
+        return parents;
+    }
+    function getTagTreeFilterOptions(element, parents) {
+        var filterOptions = arrayUtils$2.reverse(getNthFilterOptions(element, parents[0]));
+        var parentLength = parents.length;
+        for (var i = 0; i < parentLength - 1; i++) {
+            var currentParent = parents[i];
+            var parent_1 = parents[i + 1];
+            var _a = getNthFilterOptions(currentParent, parent_1), tagOption = _a[0], indexOption = _a[1];
+            if (indexOption)
+                filterOptions.push(indexOption);
+            filterOptions.push(tagOption);
+        }
+        return arrayUtils$2.reverse(filterOptions);
+    }
+    function isHtmlOrBodyElement(element) {
+        return /html|body/.test(domUtils$2.getTagName(element).toLowerCase());
+    }
+
+    var domUtils$3 = TESTCAFE_CORE.domUtils, arrayUtils$3 = TESTCAFE_CORE.arrayUtils;
+    function optionsToStringArray(options) {
+        var strings = [];
+        for (var _i = 0, options_1 = options; _i < options_1.length; _i++) {
+            var option = options_1[_i];
+            if (arrayUtils$3.indexOf(options, option) === 0)
+                strings.push("Selector('".concat(option.filter, "')"));
+            else if (option.type === byText)
+                strings.push(".withText('".concat(option.filter, "')"));
+            else if (option.type === byIndex)
+                strings.push(".nth(".concat(option.filter, ")"));
+            else if (option.type === byTag)
+                strings.push(".find('".concat(option.filter, "')"));
+            else if (option.type === byAttr) {
+                var attrValueString = option.filter.attrValueRe ? ", ".concat(option.filter.attrValueRe) : '';
+                strings.push(".withAttribute('".concat(option.filter.attrName, "'").concat(attrValueString, ")"));
+            }
+        }
+        return strings;
+    }
+    var SelectorDescriptor = /** @class */ (function () {
+        function SelectorDescriptor(obj) {
+            this.ruleType = obj.ruleType;
+            this.isCustomRule = obj.isCustomRule;
+            this.element = obj.element;
+            this.ancestorSelectorDescriptor = obj.ancestorSelectorDescriptor;
+            this.cssSelector = obj.cssSelector;
+            this.filterOptions = arrayUtils$3.concat([], obj.filterOptions || []);
+            this.filter = obj.filter;
+            this.stringArray = this._getStringArrayRepresentation();
+        }
+        Object.defineProperty(SelectorDescriptor.prototype, "isCustom", {
+            get: function () {
+                return this.ancestorSelectorDescriptor ?
+                    this.isCustomRule || this.ancestorSelectorDescriptor.isCustomRule :
+                    this.isCustomRule;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        SelectorDescriptor.prototype._getStringArrayRepresentation = function () {
+            return optionsToStringArray(this._concatFilterOptions());
+        };
+        SelectorDescriptor.prototype._addFilterByIndex = function (elements) {
+            if (elements.length > 1) {
+                var elementIndex = arrayUtils$3.indexOf(elements, this.element);
+                if (elementIndex !== 0)
+                    this.filterOptions.push(new FilterOption(byIndex, elementIndex));
+            }
+        };
+        SelectorDescriptor.prototype._concatFilterOptions = function () {
+            var ancestorSelectorDescriptor = this.ancestorSelectorDescriptor;
+            var initialOptions = [];
+            if (ancestorSelectorDescriptor) {
+                var ancestorOptions = ancestorSelectorDescriptor._concatFilterOptions();
+                initialOptions = ancestorOptions;
+            }
+            if (this.cssSelector)
+                initialOptions.push(new FilterOption(byTag, this.cssSelector));
+            var concatenatedOpts = arrayUtils$3.concat(initialOptions, this.filterOptions);
+            return arrayUtils$3.reduce(concatenatedOpts, function (options, option) {
+                if (option.type === byTag && options.length) {
+                    var lastOption = options[options.length - 1];
+                    if (lastOption.type === byTag) {
+                        options[options.length - 1] = lastOption.concat(option);
+                        return options;
+                    }
+                }
+                options.push(option);
+                return options;
+            }, []);
+        };
+        SelectorDescriptor.prototype._getElements = function () {
+            // NOTE: we should not check the receipt of an element for a selector
+            // composed by tag tree because it cannot returns wrong result
+            if (this.ruleType === RULE_TYPE.byTagTree)
+                return [this.element];
+            var ancestor = this.ancestorSelectorDescriptor ? this.ancestorSelectorDescriptor.element : domUtils$3.findDocument(this.element);
+            var elements = null;
+            if (this.cssSelector) {
+                // NOTE: querySelectorAll method can raise error in case of invalid markup
+                // (e.g. id attribute starts with number)
+                try {
+                    /* eslint-disable no-eval */
+                    var evaluatedString = window.eval("(function(){return '".concat(this.cssSelector, "';})();"));
+                    /* eslint-enable no-eval */
+                    elements = arrayUtils$3.from(ancestor.querySelectorAll(evaluatedString));
+                }
+                catch (err) {
+                    return null;
+                }
+            }
+            else
+                elements = [ancestor];
+            elements = elements.length && this.filter ? this.filter(elements) : elements;
+            if (elements.length === 0 || arrayUtils$3.indexOf(elements, this.element) === -1)
+                return [];
+            return elements;
+        };
+        SelectorDescriptor.createFromInstance = function (descriptor, ancestorSelectorDescriptor) {
+            return new SelectorDescriptor({
+                ancestorSelectorDescriptor: ancestorSelectorDescriptor,
+                cssSelector: descriptor.cssSelector,
+                element: descriptor.element,
+                filter: descriptor.filter,
+                filterOptions: [].concat(descriptor.filterOptions || []),
+                isCustomRule: descriptor.isCustomRule,
+                ruleType: descriptor.ruleType,
+            });
+        };
+        SelectorDescriptor.prototype.makeUnique = function () {
+            var ancestorSelectorDescriptor = this.ancestorSelectorDescriptor;
+            var ancestorElements = ancestorSelectorDescriptor ? ancestorSelectorDescriptor._getElements() : [];
+            var elements = !ancestorSelectorDescriptor || ancestorElements ? this._getElements() : null;
+            if (elements) {
+                if (ancestorSelectorDescriptor)
+                    ancestorSelectorDescriptor._addFilterByIndex(ancestorElements);
+                this._addFilterByIndex(elements);
+                this.stringArray = this._getStringArrayRepresentation();
+            }
+        };
+        return SelectorDescriptor;
+    }());
+
+    /* eslint-disable no-empty-function, class-methods-use-this */
+    var BaseCreator = /** @class */ (function () {
+        function BaseCreator(type) {
+            this.type = type;
+            this.element = null;
+        }
+        BaseCreator.prototype._init = function () {
+        };
+        BaseCreator.prototype._shouldCreate = function () {
+            throw new Error('Not implemented');
+        };
+        BaseCreator.prototype._getDescriptor = function ( /*ancestorSelectorDescriptor*/) {
+            throw new Error('Not implemented');
+        };
+        BaseCreator.prototype.create = function (el, ancestorSelectorDescriptor) {
+            this.element = el;
+            this._init();
+            if (this._shouldCreate(ancestorSelectorDescriptor))
+                return this._getDescriptor(ancestorSelectorDescriptor);
+            return null;
+        };
+        return BaseCreator;
+    }());
+
+    var domUtils$4 = TESTCAFE_CORE.domUtils;
+    var TOP_LEVEL_TAGS_RE = /html|body/;
+    var UNIQUE_TAGS_RE = /header|footer|main/;
+    var TagNameSelectorCreator = /** @class */ (function (_super) {
+        __extends(TagNameSelectorCreator, _super);
+        function TagNameSelectorCreator(useTopLevelTags) {
+            if (useTopLevelTags === void 0) { useTopLevelTags = true; }
+            var _this = _super.call(this, RULE_TYPE.byTagName) || this;
+            _this.tagName = '';
+            _this.useTopLevelParents = useTopLevelTags;
+            return _this;
+        }
+        TagNameSelectorCreator.prototype._init = function () {
+            this.tagName = domUtils$4.getTagName(this.element);
+        };
+        TagNameSelectorCreator.prototype._shouldCreate = function () {
+            return this.useTopLevelParents && TOP_LEVEL_TAGS_RE.test(this.tagName) || UNIQUE_TAGS_RE.test(this.tagName);
+        };
+        TagNameSelectorCreator.prototype._getDescriptor = function () {
+            return new SelectorDescriptor({
+                ruleType: this.type,
+                element: this.element,
+                cssSelector: this.tagName,
+            });
+        };
+        return TagNameSelectorCreator;
+    }(BaseCreator));
+
+    /* eslint-disable no-useless-escape */
+    function escapeAttrValue(text) {
+        return text
+            .replace(/\\/g, '\\\\\\$&')
+            .replace(/'/g, '\\\\\\$&')
+            .replace(/"/g, '\\\\$&');
+    }
+    function escapeSpecifiedSymbols(text) {
+        return text
+            .replace(/\\/g, '\\\\\\$&')
+            .replace(/'/g, '\\\\\\$&')
+            .replace(/(\!|#|"|\$|%|&|\(|\||\)|\*|\+|,|\.|\/|:|;|<|=|>|\?|@|\[|\]|\^|`|{|\||}|~)/g, '\\\\$&');
+    }
+    function escapeIdValue(idValue) {
+        return escapeSpecifiedSymbols(idValue).replace(/\s/g, '\\\\ ');
+    }
+    function escapeValueForSelectorWithRegExp(text) {
+        return text
+            .replace(/'|"|\\|\||\-|\*|\?|\+|\^|\$|\[|\]/g, '\\$&')
+            .replace(/\(|\)/g, '\\S');
+    }
+
+    var hammerhead = window['%hammerhead%'];
+
+    // NOTE: taken from hammerhead i.e. https://github.com/benjamingr/RegExp.escape
+    var SYMBOLS_TO_ESCAPE_RE = /[\\^$*+?.()|[\]{}]/g;
+    function escapeRe(str) {
+        return str.replace(SYMBOLS_TO_ESCAPE_RE, '\\$&');
+    }
+
+    var selectorAttributeFilter = TESTCAFE_CORE.selectorAttributeFilter, arrayUtils$4 = TESTCAFE_CORE.arrayUtils;
+    var nativeMethods$6 = hammerhead.nativeMethods;
+    function makeRegExp(str) {
+        return typeof str === 'string' ? new RegExp(escapeRe(str)) : str;
+    }
+    function getTextFilter(text) {
+        return function (elements) {
+            return arrayUtils$4.filter(elements, function (el) {
+                var elementText = nativeMethods$6.htmlElementInnerTextGetter.call(el) ||
+                    nativeMethods$6.nodeTextContentGetter.call(el);
+                return elementText.indexOf(text) > -1;
+            });
+        };
+    }
+    function getAttributeRegExpFilter(_a) {
+        var attrName = _a.attrName, attrValueRe = _a.attrValueRe;
+        return function (elements) {
+            return arrayUtils$4.filter(elements, function (el) { return selectorAttributeFilter(el, 0, void 0, makeRegExp(attrName), makeRegExp(attrValueRe)); });
+        };
+    }
+
+    var domUtils$5 = TESTCAFE_CORE.domUtils, arrayUtils$5 = TESTCAFE_CORE.arrayUtils;
+    var ASP_AUTOGENERATED_ATTR_RE = /\$ctl\d+|ctl\d+\$|_ctl\d+|ctl\d+_|^ctl\d+$/g;
+    var SEPARATOR_CONST = '!!!!!separator!!!!!';
+    var ANY_NUMBER_CONST = '!!!!!anyNumber!!!!!';
+    var SEPARATOR_RE = new RegExp(SEPARATOR_CONST, 'g');
+    var ANY_NUMBER_RE = new RegExp(ANY_NUMBER_CONST, 'g');
+    var SOME_SPACES_RE = /\s{2,}/g;
+    var MAX_TEXT_LENGTH_IN_SELECTOR = 50;
+    var CLASS_ATTRIBUTE_NAME = 'class';
+    // eslint-disable-next-line max-params
+    function getRegExpAttributesDescriptor(ruleType, el, cssSelector, filterRegExpValue, ancestorSelectorDescriptor) {
+        return new SelectorDescriptor({
+            ancestorSelectorDescriptor: ancestorSelectorDescriptor,
+            cssSelector: cssSelector,
+            element: el,
+            filter: getAttributeRegExpFilter(filterRegExpValue),
+            filterOptions: new FilterOption(byAttr, filterRegExpValue),
+            ruleType: ruleType,
+        });
+    }
+    // eslint-disable-next-line max-lines-per-function, max-params
+    function getAttributesDescriptor(ruleType, el, attributes, ancestorSelectorDescriptor) {
+        var tagName = domUtils$5.getTagName(el);
+        var cssSelector = '';
+        var attrRegExpObject = null;
+        arrayUtils$5.forEach(attributes, function (_a) {
+            var name = _a.name, value = _a.value;
+            var valueWasCut = false;
+            var shouldUseRegExp = false;
+            if (value.replace(SOME_SPACES_RE, ' ').length > MAX_TEXT_LENGTH_IN_SELECTOR) {
+                value = value.substr(0, MAX_TEXT_LENGTH_IN_SELECTOR);
+                valueWasCut = true;
+            }
+            if (ASP_AUTOGENERATED_ATTR_RE.test(value)) {
+                shouldUseRegExp = true;
+                value = value.replace(ASP_AUTOGENERATED_ATTR_RE, function (substr) { return substr.replace(/\d+/, ANY_NUMBER_CONST); });
+            }
+            if (SOME_SPACES_RE.test(value)) {
+                shouldUseRegExp = true;
+                value = value.replace(SOME_SPACES_RE, SEPARATOR_CONST);
+            }
+            if (shouldUseRegExp) {
+                if (!attrRegExpObject) {
+                    value = escapeValueForSelectorWithRegExp(value);
+                    value = value.replace(ANY_NUMBER_RE, '\\d+').replace(SEPARATOR_RE, '\\s+');
+                    attrRegExpObject = { attrName: name, attrValueRe: new RegExp(value) };
+                }
+            }
+            else {
+                value = name === CLASS_ATTRIBUTE_NAME ? escapeSpecifiedSymbols(value).trimEnd() : escapeAttrValue(value);
+                if (name === CLASS_ATTRIBUTE_NAME && !valueWasCut)
+                    cssSelector += (' ' + value).replace(/\s+/g, '.');
+                else
+                    cssSelector += "[".concat(name).concat(valueWasCut ? '^' : '').concat(value ? "=\"".concat(value, "\"") : '', "]");
+            }
+        });
+        if (attrRegExpObject) {
+            var selector = cssSelector || tagName;
+            return getRegExpAttributesDescriptor(ruleType, el, selector, attrRegExpObject, ancestorSelectorDescriptor);
+        }
+        return new SelectorDescriptor({
+            ruleType: ruleType,
+            element: el,
+            ancestorSelectorDescriptor: ancestorSelectorDescriptor,
+            cssSelector: cssSelector,
+        });
+    }
+
+    var domUtils$6 = TESTCAFE_CORE.domUtils;
+    var ASP_AUTOGENERATED_ID_PART_RE = /_ctl\d+|ctl\d+_|^ctl\d+$/g;
+    var IdSelectorCreator = /** @class */ (function (_super) {
+        __extends(IdSelectorCreator, _super);
+        function IdSelectorCreator() {
+            var _this = _super.call(this, RULE_TYPE.byId) || this;
+            _this.idAttr = null;
+            return _this;
+        }
+        IdSelectorCreator.prototype._init = function () {
+            this.idAttr = this.element.getAttribute('id');
+        };
+        IdSelectorCreator.prototype._shouldCreate = function () {
+            return !!this.idAttr;
+        };
+        IdSelectorCreator.prototype._getDescriptor = function () {
+            if (ASP_AUTOGENERATED_ID_PART_RE.test(this.idAttr)) {
+                var idRegExp = escapeValueForSelectorWithRegExp(this.idAttr);
+                idRegExp = idRegExp.replace(ASP_AUTOGENERATED_ID_PART_RE, function (substr) { return substr.replace(/\d+/, '\\d+'); });
+                var tagName = domUtils$6.getTagName(this.element);
+                var filterValue = { attrName: 'id', attrValueRe: new RegExp(idRegExp) };
+                return getRegExpAttributesDescriptor(RULE_TYPE.byId, this.element, tagName, filterValue);
+            }
+            return new SelectorDescriptor({
+                ruleType: RULE_TYPE.byId,
+                element: this.element,
+                cssSelector: '#' + escapeIdValue(this.idAttr),
+            });
+        };
+        return IdSelectorCreator;
+    }(BaseCreator));
+
+    var domUtils$7 = TESTCAFE_CORE.domUtils;
+    var trim = hammerhead.utils.trim;
+    var nativeMethods$7 = hammerhead.nativeMethods;
+    var ELEMENTS_WITH_TEXT_RE = /^i$|^b$|^big$|^small$|^em$|^strong$|^dfn$|^code$|^samp$|^kbd$|^var$|^cite$|^abbr$|^acronym$|^sub$|^sup$|span$|^bdo$|^address$|^div$|^a$|^object$|^p$|^h\d$|^pre$|^q$|^ins$|^del$|^dt$|^dd$|^li$|^label$|^option$|^fieldset$|^legend$|^button$|^caption$|^td$|^th$|^title$/;
+    var MAX_TEXT_LENGTH_IN_SELECTOR$1 = 50;
+    var SYMBOLS_TO_ESCAPE_RE$1 = /['"\\]/g;
+    var PROHIBITED_TEXT_SYMBOL_RE = /\r?\n|\r/i;
+    function getTextPart(text) {
+        text = text.trim().replace(SYMBOLS_TO_ESCAPE_RE$1, '\\$&');
+        var endMatch = PROHIBITED_TEXT_SYMBOL_RE.exec(text);
+        var endIndex = endMatch ? endMatch.index : text.length;
+        return trim(text.substring(0, Math.min(endIndex, MAX_TEXT_LENGTH_IN_SELECTOR$1)));
+    }
+    function hasOwnTextForSelector(el, elementText) {
+        if (!ELEMENTS_WITH_TEXT_RE.test(domUtils$7.getTagName(el)))
+            return '';
+        elementText = trim(elementText.replace(/\s+/g, ' '));
+        return /\S/.test(elementText);
+    }
+    function getOwnTextForSelector(el) {
+        /*eslint-disable-next-line no-restricted-properties*/
+        var text = domUtils$7.isHtmlElement(el) ? nativeMethods$7.htmlElementInnerTextGetter.call(el) : el.innerText;
+        if (text)
+            return getTextPart(text);
+        if (domUtils$7.isOptionElement(el)) {
+            var optionText = nativeMethods$7.nodeTextContentGetter.call(el);
+            return optionText ? getTextPart(optionText) : '';
+        }
+        return '';
+    }
+
+    var domUtils$8 = TESTCAFE_CORE.domUtils;
+    var TextSelectorCreator = /** @class */ (function (_super) {
+        __extends(TextSelectorCreator, _super);
+        function TextSelectorCreator() {
+            var _this = _super.call(this, RULE_TYPE.byText) || this;
+            _this.elementText = '';
+            return _this;
+        }
+        TextSelectorCreator.prototype._init = function () {
+            this.elementText = getOwnTextForSelector(this.element);
+        };
+        TextSelectorCreator.prototype._shouldCreate = function () {
+            return hasOwnTextForSelector(this.element, this.elementText);
+        };
+        TextSelectorCreator.prototype._getDescriptor = function () {
+            return new SelectorDescriptor({
+                ruleType: this.type,
+                element: this.element,
+                cssSelector: domUtils$8.getTagName(this.element),
+                filterOptions: new FilterOption(byText, this.elementText),
+                filter: getTextFilter(this.elementText),
+            });
+        };
+        return TextSelectorCreator;
+    }(BaseCreator));
+
+    var domUtils$9 = TESTCAFE_CORE.domUtils, arrayUtils$6 = TESTCAFE_CORE.arrayUtils;
+    var nativeMethods$8 = hammerhead.nativeMethods;
+    var STORED_ATTRIBUTES_PROPERTY = '%testcafe-stored-attributes%';
+    var CUSTOM_STORED_ATTRIBUTES_PROPERTY = '%testcafe-custom-stored-attributes%';
+    var ALLOWED_ATTRIBUTE_NAMES_RE = /(^alt$|^name$|^class$|^title$|^data-\S+)/;
+    var GOOGLE_ANALYTICS_ATTRIBUTE_RE = /^data-ga\S+/;
+    function isAttributeAcceptableForSelector(attribute, customAttrNames) {
+        if (customAttrNames === void 0) { customAttrNames = []; }
+        var name = attribute.nodeName;
+        var value = attribute.nodeValue;
+        if (!value)
+            return false;
+        // NOTE: we don't take into account attributes added by TestCafe
+        return ALLOWED_ATTRIBUTE_NAMES_RE.test(name) &&
+            arrayUtils$6.indexOf(customAttrNames, name) === -1 &&
+            !GOOGLE_ANALYTICS_ATTRIBUTE_RE.test(name) &&
+            !domUtils$9.isHammerheadAttr(name);
+    }
+    function getAttributesForSelector(element, customAttrNames) {
+        if (customAttrNames === void 0) { customAttrNames = []; }
+        var storedAttributes = element[STORED_ATTRIBUTES_PROPERTY];
+        // NOTE: we don't take class into account because we have a separate rule for it
+        if (storedAttributes)
+            return arrayUtils$6.filter(storedAttributes, function (attr) { return attr.name !== CLASS_ATTRIBUTE_NAME; });
+        var attributes = nativeMethods$8.elementAttributesGetter.call(element);
+        var attributesForSelector = [];
+        var attribute = null;
+        for (var i = 0; i < attributes.length; i++) {
+            attribute = attributes[i];
+            if (attribute.nodeName !== CLASS_ATTRIBUTE_NAME && isAttributeAcceptableForSelector(attribute, customAttrNames))
+                attributesForSelector.push({ name: attribute.nodeName, value: attribute.nodeValue });
+        }
+        return attributesForSelector;
+    }
+    function getAttributeValue(element, attrName) {
+        var attributes = element[STORED_ATTRIBUTES_PROPERTY] || nativeMethods$8.elementAttributesGetter.call(element);
+        var attribute = null;
+        for (var i = 0; i < attributes.length; i++) {
+            attribute = attributes[i];
+            /*eslint-disable no-restricted-properties*/
+            if (attribute.name === attrName && attribute.value)
+                return attribute.value;
+            /*eslint-enable*/
+        }
+        return null;
+    }
+    function getCustomAttributeForSelector(el, customAttrName) {
+        var customStoredAttributes = el[CUSTOM_STORED_ATTRIBUTES_PROPERTY];
+        if (customStoredAttributes) {
+            var storedAttr = arrayUtils$6.find(customStoredAttributes, function (attr) { return attr.name === customAttrName; });
+            return storedAttr ? storedAttr : null;
+        }
+        return el.hasAttribute(customAttrName) ?
+            { name: customAttrName, value: el.getAttribute(customAttrName) } : null;
+    }
+
+    var AttrSelectorCreator = /** @class */ (function (_super) {
+        __extends(AttrSelectorCreator, _super);
+        function AttrSelectorCreator(customAttrNames) {
+            if (customAttrNames === void 0) { customAttrNames = []; }
+            var _this = _super.call(this, RULE_TYPE.byAttr) || this;
+            _this.customAttrNames = customAttrNames;
+            _this.elementAttributes = [];
+            return _this;
+        }
+        AttrSelectorCreator.prototype._init = function () {
+            this.elementAttributes = getAttributesForSelector(this.element, this.customAttrNames);
+        };
+        AttrSelectorCreator.prototype._shouldCreate = function () {
+            return !!this.elementAttributes.length;
+        };
+        AttrSelectorCreator.prototype._getDescriptor = function () {
+            return getAttributesDescriptor(this.type, this.element, this.elementAttributes);
+        };
+        return AttrSelectorCreator;
+    }(BaseCreator));
+
+    var ClassSelectorCreator = /** @class */ (function (_super) {
+        __extends(ClassSelectorCreator, _super);
+        function ClassSelectorCreator() {
+            var _this = _super.call(this, RULE_TYPE.byClassAttr) || this;
+            _this.className = '';
+            return _this;
+        }
+        ClassSelectorCreator.prototype._init = function () {
+            this.className = getAttributeValue(this.element, CLASS_ATTRIBUTE_NAME);
+        };
+        ClassSelectorCreator.prototype._shouldCreate = function () {
+            return !!this.className;
+        };
+        ClassSelectorCreator.prototype._getDescriptor = function () {
+            return getAttributesDescriptor(this.type, this.element, [{
+                    name: CLASS_ATTRIBUTE_NAME,
+                    value: this.className,
+                }]);
+        };
+        return ClassSelectorCreator;
+    }(BaseCreator));
+
+    var domUtils$a = TESTCAFE_CORE.domUtils, arrayUtils$7 = TESTCAFE_CORE.arrayUtils;
+    var TagTreeSelectorCreator = /** @class */ (function (_super) {
+        __extends(TagTreeSelectorCreator, _super);
+        function TagTreeSelectorCreator() {
+            var _this = _super.call(this, RULE_TYPE.byTagTree) || this;
+            _this.parents = [];
+            return _this;
+        }
+        TagTreeSelectorCreator.prototype._shouldCreate = function (ancestorSelectorDescriptor) {
+            var ancestor = ancestorSelectorDescriptor ?
+                ancestorSelectorDescriptor.element : domUtils$a.findDocument(this.element).body;
+            this.parents = getParentsUntil(this.element, ancestor);
+            this.parents.push(ancestor);
+            // NOTE: in some cases 'parentElement' is undefined for 'svg' element in IE
+            return this.parents.length;
+        };
+        TagTreeSelectorCreator.prototype._getDescriptor = function (ancestorSelectorDescriptor) {
+            var cssSelector = '';
+            var filterOptions = [];
+            if (isHtmlOrBodyElement(this.element))
+                filterOptions.push(new FilterOption(byTag, domUtils$a.getTagName(this.element)));
+            else
+                filterOptions = getTagTreeFilterOptions(this.element, this.parents);
+            if (ancestorSelectorDescriptor) {
+                return new SelectorDescriptor({
+                    ruleType: this.type,
+                    element: this.element,
+                    ancestorSelectorDescriptor: ancestorSelectorDescriptor,
+                    filterOptions: filterOptions,
+                });
+            }
+            if (filterOptions.length) {
+                cssSelector = filterOptions[0].filter;
+                arrayUtils$7.splice(filterOptions, 0, 1);
+            }
+            return new SelectorDescriptor({
+                ruleType: this.type,
+                element: this.element,
+                cssSelector: cssSelector,
+                filterOptions: filterOptions,
+            });
+        };
+        return TagTreeSelectorCreator;
+    }(BaseCreator));
+
+    var _a;
+    var SELECTOR_CREATORS = (_a = {},
+        _a[RULE_TYPE.byTagName] = new TagNameSelectorCreator(),
+        _a[RULE_TYPE.byId] = new IdSelectorCreator(),
+        _a[RULE_TYPE.byText] = new TextSelectorCreator(),
+        _a[RULE_TYPE.byClassAttr] = new ClassSelectorCreator(),
+        _a[RULE_TYPE.byAttr] = new AttrSelectorCreator(),
+        _a[RULE_TYPE.byTagTree] = new TagTreeSelectorCreator(),
+        _a);
+
+    var CustomAttrSelectorCreator = /** @class */ (function (_super) {
+        __extends(CustomAttrSelectorCreator, _super);
+        function CustomAttrSelectorCreator(attrName) {
+            var _this = _super.call(this, attrName) || this;
+            _this.attrName = attrName;
+            _this.elementAttributes = [];
+            return _this;
+        }
+        CustomAttrSelectorCreator.prototype._init = function () {
+            var attr = getCustomAttributeForSelector(this.element, this.attrName);
+            this.elementAttributes = attr ? [attr] : [];
+        };
+        CustomAttrSelectorCreator.prototype._shouldCreate = function () {
+            return !!this.elementAttributes.length;
+        };
+        CustomAttrSelectorCreator.prototype._getDescriptor = function () {
+            var descriptor = getAttributesDescriptor(this.type, this.element, this.elementAttributes);
+            descriptor.isCustomRule = true;
+            return descriptor;
+        };
+        return CustomAttrSelectorCreator;
+    }(BaseCreator));
+
+    var arrayUtils$8 = TESTCAFE_CORE.arrayUtils;
+    var COMPOUNDABLE_ANCESTOR_RULE_TYPES = [
+        RULE_TYPE.byTagName,
+        RULE_TYPE.byId,
+        RULE_TYPE.byClassAttr,
+        RULE_TYPE.byAttr,
+    ];
+    var COMPOUNDABLE_CHILD_RULE_TYPES = [
+        RULE_TYPE.byText,
+        RULE_TYPE.byClassAttr,
+        RULE_TYPE.byAttr,
+        RULE_TYPE.byTagTree,
+    ];
+    function isSelectorDescriptorCompoundable(selectorDescriptor) {
+        return selectorDescriptor.isCustomRule ||
+            arrayUtils$8.indexOf(COMPOUNDABLE_CHILD_RULE_TYPES, selectorDescriptor.ruleType) !== -1 &&
+                selectorDescriptor.ruleType !== RULE_TYPE.byTagTree;
+    }
+    function isChildRuleCompoundable(rule) {
+        return rule.editable || arrayUtils$8.indexOf(COMPOUNDABLE_CHILD_RULE_TYPES, rule.type) !== -1;
+    }
+    function isAncestorRuleCompoundable(rule) {
+        return rule.editable || arrayUtils$8.indexOf(COMPOUNDABLE_ANCESTOR_RULE_TYPES, rule.type) !== -1;
+    }
+
+    var PARENT_CHILD_RULES_SEPARATOR = ' > ';
+    // NOTE: prior to introducing the selector prioritization,
+    // selectors only were able to have ruleType (parent-child).
+    // Currently selector has ruleType and ancestorRuleType.
+    function getSelectorType(elementRuleType, ancestorRuleType) {
+        return ancestorRuleType ?
+            ancestorRuleType + PARENT_CHILD_RULES_SEPARATOR + elementRuleType :
+            elementRuleType;
+    }
+
+    var DEFAULT_PRIORITY = 1;
+    function calculateRulesPriority(rules) {
+        var priority = {};
+        var rulePriority = DEFAULT_PRIORITY;
+        for (var _i = 0, rules_1 = rules; _i < rules_1.length; _i++) {
+            var ancestorRule = rules_1[_i];
+            priority[ancestorRule.type] = rulePriority++;
+            if (isAncestorRuleCompoundable(ancestorRule)) {
+                for (var _a = 0, rules_2 = rules; _a < rules_2.length; _a++) {
+                    var childRule = rules_2[_a];
+                    if (isChildRuleCompoundable(childRule)) {
+                        var resultRuleType = getSelectorType(childRule.type, ancestorRule.type);
+                        priority[resultRuleType] = rulePriority++;
+                    }
+                }
+            }
+        }
+        return priority;
+    }
+
+    var domUtils$b = TESTCAFE_CORE.domUtils, arrayUtils$9 = TESTCAFE_CORE.arrayUtils;
+    var MAX_DEFAULT_SELECTOR_COUNT = 10;
+    function generateSelectorDescriptorsByCreators(el, selectorCreators, ancestorSelectorDescriptor) {
+        var selectorDescriptors = [];
+        for (var _i = 0, selectorCreators_1 = selectorCreators; _i < selectorCreators_1.length; _i++) {
+            var creator = selectorCreators_1[_i];
+            var selectorDescriptor = creator.create(el, ancestorSelectorDescriptor);
+            if (selectorDescriptor)
+                selectorDescriptors.push(selectorDescriptor);
+        }
+        return selectorDescriptors;
+    }
+    function getAncestorSelectorDescriptor(ancestors, ancestorSelectorCreator) {
+        for (var _i = 0, ancestors_1 = ancestors; _i < ancestors_1.length; _i++) {
+            var ancestor = ancestors_1[_i];
+            var ancestorSelectorDescriptor = ancestorSelectorCreator.create(ancestor);
+            if (ancestorSelectorDescriptor)
+                return ancestorSelectorDescriptor;
+        }
+        return null;
+    }
+    function generateAncestorSelectorDescriptorsByCreators(ancestors, selectorCreators) {
+        var selectorDescriptors = [];
+        for (var _i = 0, selectorCreators_2 = selectorCreators; _i < selectorCreators_2.length; _i++) {
+            var creator = selectorCreators_2[_i];
+            var selectorDescriptor = getAncestorSelectorDescriptor(ancestors, creator);
+            if (selectorDescriptor)
+                selectorDescriptors.push(selectorDescriptor);
+        }
+        return selectorDescriptors;
+    }
+    function removeRepetitiveSelectorDescriptors(selectorDescriptors) {
+        var resultSelectorDescriptors = [];
+        var repetitiveStringIndex = function (descriptor) { return findIndex(resultSelectorDescriptors, function (desc) {
+            return arrayUtils$9.join(desc.stringArray, '') === arrayUtils$9.join(descriptor.stringArray, '');
+        }); };
+        for (var _i = 0, selectorDescriptors_1 = selectorDescriptors; _i < selectorDescriptors_1.length; _i++) {
+            var descriptor = selectorDescriptors_1[_i];
+            var index = repetitiveStringIndex(descriptor);
+            if (index === -1)
+                resultSelectorDescriptors.push(descriptor);
+            else if (resultSelectorDescriptors[index].priority > descriptor.priority)
+                arrayUtils$9.splice(resultSelectorDescriptors, index, 1, descriptor);
+        }
+        return resultSelectorDescriptors;
+    }
+    function removeRedundantCompoundSelectorDescriptors(selectorDescriptors) {
+        var defaultRuleSelectors = arrayUtils$9.filter(selectorDescriptors, function (descriptor) { return !descriptor.isCustom; });
+        var defaultCompoundRuleSelectors = arrayUtils$9.filter(defaultRuleSelectors, function (descriptor) { return descriptor.ancestorSelectorDescriptor; });
+        var compoundSelectorCount = defaultCompoundRuleSelectors.length;
+        var elementSelectorCount = defaultRuleSelectors.length - compoundSelectorCount;
+        var expectedCompoundRuleCount = MAX_DEFAULT_SELECTOR_COUNT - elementSelectorCount;
+        var getAncestorType = function (descriptor) {
+            return descriptor && descriptor.ancestorSelectorDescriptor ?
+                descriptor.ancestorSelectorDescriptor.ruleType : null;
+        };
+        var currentIndex = compoundSelectorCount - 1;
+        while (compoundSelectorCount > expectedCompoundRuleCount) {
+            var descriptor = defaultCompoundRuleSelectors[currentIndex];
+            var ancestorRuleType = getAncestorType(descriptor);
+            while (getAncestorType(defaultCompoundRuleSelectors[currentIndex - 1]) === ancestorRuleType) {
+                arrayUtils$9.remove(selectorDescriptors, defaultCompoundRuleSelectors[currentIndex]);
+                compoundSelectorCount--;
+                if (compoundSelectorCount <= expectedCompoundRuleCount)
+                    break;
+                currentIndex--;
+            }
+            currentIndex--;
+        }
+    }
+    var SelectorGenerator = /** @class */ (function () {
+        function SelectorGenerator(rules) {
+            if (rules === void 0) { rules = DEFAULT_SELECTOR_RULES; }
+            this.rules = arrayUtils$9.filter(rules, function (rule) { return !rule.disabled; });
+            var _a = SelectorGenerator._processRules(this.rules), customRules = _a.customRules, defaultRules = _a.defaultRules;
+            this.customRules = customRules;
+            this.defaultRules = defaultRules;
+            this.customAttrNames = [];
+            this.customSelectorCreators = [];
+            this.elementSelectorCreators = [];
+            this.ancestorSelectorCreators = [];
+            this._createCustomSelectorCreators();
+            this._createElementSelectorCreators();
+            this._createAncestorSelectorCreators();
+            this.rulePriority = calculateRulesPriority(this.rules);
+        }
+        SelectorGenerator._priorityComparator = function (first, second) {
+            return first.priority - second.priority;
+        };
+        SelectorGenerator._getSelectorType = function (selectorDescriptor) {
+            var ancestorSelectorDescriptor = selectorDescriptor.ancestorSelectorDescriptor;
+            var ancestorSelectorType = ancestorSelectorDescriptor ? ancestorSelectorDescriptor.ruleType : '';
+            return getSelectorType(selectorDescriptor.ruleType, ancestorSelectorType);
+        };
+        SelectorGenerator._processRules = function (rules) {
+            var defaultRules = [];
+            var customRules = [];
+            arrayUtils$9.filter(rules, function (rule) {
+                if (rule.editable)
+                    customRules.push(rule);
+                else
+                    defaultRules.push(rule);
+            });
+            return { customRules: customRules, defaultRules: defaultRules };
+        };
+        SelectorGenerator.prototype._createCustomSelectorCreators = function () {
+            var _this = this;
+            arrayUtils$9.forEach(this.customRules, function (rule) {
+                _this.customAttrNames.push(rule.type);
+                _this.customSelectorCreators.push(new CustomAttrSelectorCreator(rule.type));
+            });
+        };
+        SelectorGenerator.prototype._createElementSelectorCreators = function () {
+            var _this = this;
+            var defaultCreators = [];
+            arrayUtils$9.forEach(this.defaultRules, function (rule) {
+                var creator = rule.type === RULE_TYPE.byAttr ?
+                    new AttrSelectorCreator(_this.customAttrNames) :
+                    SELECTOR_CREATORS[rule.type];
+                defaultCreators.push(creator);
+            });
+            this.elementSelectorCreators = arrayUtils$9.concat(defaultCreators, this.customSelectorCreators);
+        };
+        SelectorGenerator.prototype._createAncestorSelectorCreators = function () {
+            for (var _i = 0, _a = this.customRules; _i < _a.length; _i++) {
+                var rule = _a[_i];
+                this.ancestorSelectorCreators.push(new CustomAttrSelectorCreator(rule.type));
+            }
+            for (var _b = 0, _c = this.defaultRules; _b < _c.length; _b++) {
+                var rule = _c[_b];
+                if (isAncestorRuleCompoundable(rule)) {
+                    if (rule.type === RULE_TYPE.byTagName)
+                        this.ancestorSelectorCreators.push(new TagNameSelectorCreator(false));
+                    else
+                        this.ancestorSelectorCreators.push(SELECTOR_CREATORS[rule.type]);
+                }
+            }
+        };
+        SelectorGenerator.prototype._generateCompoundSelectorDescriptor = function (el, ancestors, elementSelectorDescriptors) {
+            var compoundSelectorDescriptors = arrayUtils$9.filter(elementSelectorDescriptors, isSelectorDescriptorCompoundable);
+            var ancestorSelectorDescriptors = generateAncestorSelectorDescriptorsByCreators(ancestors, this.ancestorSelectorCreators);
+            var selectorDescriptors = [];
+            var descriptor = null;
+            var ancestorDescriptor = null;
+            for (var _i = 0, ancestorSelectorDescriptors_1 = ancestorSelectorDescriptors; _i < ancestorSelectorDescriptors_1.length; _i++) {
+                var ancestorSelectorDescriptor = ancestorSelectorDescriptors_1[_i];
+                for (var _a = 0, compoundSelectorDescriptors_1 = compoundSelectorDescriptors; _a < compoundSelectorDescriptors_1.length; _a++) {
+                    var elementSelectorDescriptor = compoundSelectorDescriptors_1[_a];
+                    ancestorDescriptor = SelectorDescriptor.createFromInstance(ancestorSelectorDescriptor);
+                    descriptor = SelectorDescriptor.createFromInstance(elementSelectorDescriptor, ancestorDescriptor);
+                    selectorDescriptors.push(descriptor);
+                }
+                //TODO: check ancestorDescriptor and ancestorSelectorDescriptor
+                ancestorDescriptor = SelectorDescriptor.createFromInstance(ancestorSelectorDescriptor);
+                descriptor = generateSelectorDescriptorsByCreators(el, [SELECTOR_CREATORS[RULE_TYPE.byTagTree]], ancestorSelectorDescriptor);
+                selectorDescriptors = arrayUtils$9.concat(selectorDescriptors, descriptor);
+            }
+            return selectorDescriptors;
+        };
+        SelectorGenerator.prototype._cleanAndSortDescriptors = function (selectorDescriptors) {
+            var result = [];
+            for (var _i = 0, selectorDescriptors_2 = selectorDescriptors; _i < selectorDescriptors_2.length; _i++) {
+                var descriptor = selectorDescriptors_2[_i];
+                descriptor.makeUnique();
+                var selectorType = SelectorGenerator._getSelectorType(descriptor);
+                var priority = this.rulePriority[selectorType];
+                if (priority !== null) {
+                    descriptor.priority = priority;
+                    result.push(descriptor);
+                }
+            }
+            result = removeRepetitiveSelectorDescriptors(result);
+            result = result.sort(SelectorGenerator._priorityComparator);
+            removeRedundantCompoundSelectorDescriptors(result);
+            return result;
+        };
+        SelectorGenerator.prototype._generateDescriptors = function (el) {
+            var elementSelectorDescriptors = generateSelectorDescriptorsByCreators(el, this.elementSelectorCreators);
+            var ancestors = getParentsUntil(el, domUtils$b.findDocument(el).body);
+            var compoundSelectorDescriptors = this._generateCompoundSelectorDescriptor(el, ancestors, elementSelectorDescriptors);
+            var selectorDescriptors = arrayUtils$9.concat(elementSelectorDescriptors, compoundSelectorDescriptors);
+            return this._cleanAndSortDescriptors(selectorDescriptors);
+        };
+        SelectorGenerator.prototype.generate = function (element) {
+            var selectorDescriptors = this._generateDescriptors(element);
+            return arrayUtils$9.map(selectorDescriptors, function (selectorDescriptor) {
+                var stringArray = selectorDescriptor.stringArray, ruleType = selectorDescriptor.ruleType, ancestorSelectorDescriptor = selectorDescriptor.ancestorSelectorDescriptor;
+                var selector = {
+                    value: arrayUtils$9.join(stringArray, ''),
+                    rules: [ruleType],
+                };
+                if (ancestorSelectorDescriptor)
+                    selector.rules.push(ancestorSelectorDescriptor.ruleType);
+                return selector;
+            });
+        };
+        SelectorGenerator.RULES = RULES;
+        return SelectorGenerator;
+    }());
+
+    var selectorGenerator = new SelectorGenerator();
+
+    function getRectInAbsoluteCoordinates(element) {
+        var rect = element.getBoundingClientRect();
+        var scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+        var scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
+        return {
+            top: rect.top + scrollTop,
+            left: rect.left + scrollLeft,
+            height: rect.height,
+            width: rect.width,
+            bottom: rect.bottom + scrollTop,
+            right: rect.right + scrollLeft,
+        };
+    }
+
+    var Higthlighter = /** @class */ (function () {
+        function Higthlighter() {
+            this.targets = new Map();
+        }
+        Higthlighter.prototype._remove = function (target, frame) {
+            this.targets.delete(target);
+            removeFromUiRoot(frame);
+        };
+        Higthlighter.prototype._setPosition = function (target, frame) {
+            var rect = getRectInAbsoluteCoordinates(target);
+            var styles = {};
+            for (var _i = 0, _a = ['top', 'left', 'width', 'height']; _i < _a.length; _i++) {
+                var key = _a[_i];
+                styles[key] = rect[key] + 'px';
+            }
+            setStyles(frame, styles);
+        };
+        Higthlighter.prototype.highlight = function (target) {
+            if (!target || this.targets.has(target))
+                return;
+            var frame = createElementFromDescriptor(elementFrame);
+            this.targets.set(target, frame);
+            this._setPosition(target, frame);
+            addToUiRoot(frame);
+        };
+        Higthlighter.prototype.stopHighlighting = function () {
+            var _this = this;
+            this.targets.forEach(function (frame, target) { return _this._remove(target, frame); });
+        };
+        return Higthlighter;
+    }());
+    var highlighter = new Higthlighter();
+
+    /* eslint-disable no-restricted-properties */
+    var nativeMethods$9 = hammerhead$1__default.nativeMethods;
+    var ARROW_OFFSET_LEFT = 12;
+    function getViewportRect() {
+        return {
+            width: document.documentElement.clientWidth,
+            height: document.documentElement.clientHeight,
+        };
+    }
+    var Tooltip = /** @class */ (function () {
+        function Tooltip() {
+            this._createElements();
+        }
+        Tooltip.prototype._createElements = function () {
+            this.tooltip = createElementFromDescriptor(tooltip);
+            this.arrow = createElementFromDescriptor(arrow);
+        };
+        Tooltip.prototype._setTooltipText = function (selector) {
+            nativeMethods$9.nodeTextContentSetter.call(this.tooltip, selector);
+        };
+        Tooltip.prototype._getTooltipLeft = function (tooltipWidth, targetLeft, viewportWidth, scrollLeft) {
+            if (tooltipWidth >= viewportWidth)
+                return scrollLeft;
+            if (tooltipWidth >= viewportWidth - targetLeft)
+                return viewportWidth + scrollLeft - tooltipWidth;
+            return targetLeft + scrollLeft;
+        };
+        Tooltip.prototype._getArrowLeft = function (arrowWidth, targetLeft, viewportWidth, scrollLeft) {
+            if (arrowWidth + ARROW_OFFSET_LEFT >= viewportWidth - targetLeft)
+                return viewportWidth + scrollLeft - arrowWidth;
+            return targetLeft + scrollLeft + ARROW_OFFSET_LEFT;
+        };
+        Tooltip.prototype._getVerticalPostionStyles = function (tooltipRect, arrowRect, targetRect, viewportRect) {
+            var tooltip = {};
+            var arrow = {};
+            var scrollTop = document.documentElement.scrollTop;
+            var elementsHeight = tooltipRect.height + arrowRect.height;
+            if (targetRect.top >= elementsHeight) {
+                tooltip.top = targetRect.top + scrollTop - elementsHeight + 'px';
+                arrow.top = targetRect.top + scrollTop - arrowRect.height + 'px';
+                arrow.transform = 'none';
+                arrow.visibility = 'visible';
+            }
+            else if (viewportRect.height - targetRect.bottom >= elementsHeight) {
+                tooltip.top = targetRect.bottom + scrollTop + arrowRect.height + 'px';
+                arrow.top = targetRect.bottom + scrollTop + 'px';
+                arrow.transform = 'rotate(180deg)';
+                arrow.visibility = 'visible';
+            }
+            else {
+                tooltip.top = viewportRect.height + scrollTop - tooltipRect.height + 'px';
+                arrow.top = scrollTop + 'px';
+                arrow.transform = 'node';
+                arrow.visibility = 'hidden';
+            }
+            return { tooltip: tooltip, arrow: arrow };
+        };
+        Tooltip.prototype._getElementsStyles = function (target) {
+            var tooltipRect = this.tooltip.getBoundingClientRect();
+            var arrowRect = this.arrow.getBoundingClientRect();
+            var targetRect = target.getBoundingClientRect();
+            var viewportRect = getViewportRect();
+            var styles = this._getVerticalPostionStyles(tooltipRect, arrowRect, targetRect, viewportRect);
+            var scrollLeft = document.documentElement.scrollLeft;
+            styles.tooltip.left = this._getTooltipLeft(tooltipRect.width, targetRect.left, viewportRect.width, scrollLeft) + 'px';
+            styles.arrow.left = this._getArrowLeft(arrowRect.width, targetRect.left, viewportRect.width, scrollLeft) + 'px';
+            return styles;
+        };
+        Tooltip.prototype._placeElements = function (target) {
+            var styles = this._getElementsStyles(target);
+            setStyles(this.tooltip, styles.tooltip);
+            setStyles(this.arrow, styles.arrow);
+        };
+        Tooltip.prototype.show = function (selector, target) {
+            this._setTooltipText(selector);
+            this._placeElements(target);
+            addToUiRoot(this.tooltip);
+            addToUiRoot(this.arrow);
+        };
+        Tooltip.prototype.hide = function () {
+            removeFromUiRoot(this.tooltip);
+            removeFromUiRoot(this.arrow);
+        };
+        return Tooltip;
+    }());
+    var tooltip$1 = new Tooltip();
+
+    var listeners$2 = hammerhead$1__default.eventSandbox.listeners;
+    var styleUtils$9 = testCafeCore__default.styleUtils;
+    var serviceUtils$1 = testCafeCore__default.serviceUtils;
+    var ELEMENT_PICKED = 'element-piked';
+    var ElementPicker = /** @class */ (function (_super) {
+        __extends(ElementPicker, _super);
+        function ElementPicker() {
+            var _this = _super.call(this) || this;
+            _this.hiddenTestCafeElements = new Map();
+            _this.handlers = {
+                onClick: _this._getClickHandler(),
+                onMouseMove: _this._getMouseMoveHandler(),
+            };
+            return _this;
+        }
+        ElementPicker.prototype._hideTestCafeElements = function () {
+            var children = getChildren();
+            for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+                var element = children_1[_i];
+                var visibilityValue = styleUtils$9.get(element, 'visibility');
+                this.hiddenTestCafeElements.set(element, visibilityValue);
+                styleUtils$9.set(element, 'visibility', 'hidden');
+            }
+        };
+        ElementPicker.prototype._showTestCafeElements = function () {
+            this.hiddenTestCafeElements.forEach(function (visibilityValue, element) {
+                styleUtils$9.set(element, 'visibility', visibilityValue);
+            });
+            this.hiddenTestCafeElements.clear();
+        };
+        ElementPicker.prototype._getClickHandler = function () {
+            var _this = this;
+            return function () {
+                _this._showTestCafeElements();
+                listeners$2.removeInternalEventBeforeListener(window, ['mousemove'], _this.handlers.onMouseMove);
+                listeners$2.removeInternalEventBeforeListener(window, ['click'], _this.handlers.onClick);
+                _this.emit(ELEMENT_PICKED, _this.actualSelectors);
+                tooltip$1.hide();
+            };
+        };
+        ElementPicker.prototype._getMouseMoveHandler = function () {
+            var _this = this;
+            return function (event) {
+                var x = event.clientX;
+                var y = event.clientY;
+                var target = document.elementFromPoint(x, y);
+                if (!target || target === _this.actualTarget)
+                    return;
+                _this.actualTarget = target;
+                _this.actualSelectors = selectorGenerator.generate(target);
+                highlighter.stopHighlighting();
+                highlighter.highlight(target);
+                // eslint-disable-next-line no-restricted-properties
+                tooltip$1.show(_this.actualSelectors[0].value, target);
+            };
+        };
+        ElementPicker.prototype.start = function (startEvent) {
+            this._hideTestCafeElements();
+            listeners$2.initElementListening(window, ['mousemove', 'click']);
+            listeners$2.addFirstInternalEventBeforeListener(window, ['mousemove'], this.handlers.onMouseMove);
+            listeners$2.addFirstInternalEventBeforeListener(window, ['click'], this.handlers.onClick);
+            this.handlers.onMouseMove(startEvent);
+        };
+        return ElementPicker;
+    }(serviceUtils$1.EventEmitter));
+    var elementPicker = new ElementPicker();
+
+    var eventUtils$3 = testCafeCore__default.eventUtils;
+    var PickButton = /** @class */ (function () {
+        function PickButton() {
+            this.element = createElementFromDescriptor(pickButton);
+            eventUtils$3.bind(this.element, 'click', function (event) { return elementPicker.start(event); });
+        }
+        return PickButton;
+    }());
+
+    function createCommonjsModule(fn, module) {
+    	return module = { exports: {} }, fn(module, module.exports), module.exports;
+    }
+
+    var replicator = createCommonjsModule(function (module) {
+        // Const
+        var TRANSFORMED_TYPE_KEY = '@t';
+        var CIRCULAR_REF_KEY = '@r';
+        var KEY_REQUIRE_ESCAPING_RE = /^#*@(t|r)$/;
+        var GLOBAL = (function getGlobal() {
+            // NOTE: see http://www.ecma-international.org/ecma-262/6.0/index.html#sec-performeval step 10
+            var savedEval = eval;
+            return savedEval('this');
+        })();
+        var TYPED_ARRAY_CTORS = {
+            'Int8Array': typeof Int8Array === 'function' ? Int8Array : void 0,
+            'Uint8Array': typeof Uint8Array === 'function' ? Uint8Array : void 0,
+            'Uint8ClampedArray': typeof Uint8ClampedArray === 'function' ? Uint8ClampedArray : void 0,
+            'Int16Array': typeof Int16Array === 'function' ? Int16Array : void 0,
+            'Uint16Array': typeof Uint16Array === 'function' ? Uint16Array : void 0,
+            'Int32Array': typeof Int32Array === 'function' ? Int32Array : void 0,
+            'Uint32Array': typeof Uint32Array === 'function' ? Uint32Array : void 0,
+            'Float32Array': typeof Float32Array === 'function' ? Float32Array : void 0,
+            'Float64Array': typeof Float64Array === 'function' ? Float64Array : void 0
+        };
+        var ARRAY_BUFFER_SUPPORTED = typeof ArrayBuffer === 'function';
+        var MAP_SUPPORTED = typeof Map === 'function';
+        var SET_SUPPORTED = typeof Set === 'function';
+        var BUFFER_FROM_SUPPORTED = typeof Buffer === 'function';
+        var TYPED_ARRAY_SUPPORTED = function (typeName) {
+            return !!TYPED_ARRAY_CTORS[typeName];
+        };
+        // Saved proto functions
+        var arrSlice = Array.prototype.slice;
+        // Default serializer
+        var JSONSerializer = {
+            serialize: function (val) {
+                return JSON.stringify(val);
+            },
+            deserialize: function (val) {
+                return JSON.parse(val);
+            }
+        };
+        // EncodingTransformer
+        var EncodingTransformer = function (val, transforms) {
+            this.references = val;
+            this.transforms = transforms;
+            this.circularCandidates = [];
+            this.circularCandidatesDescrs = [];
+            this.circularRefCount = 0;
+        };
+        EncodingTransformer._createRefMark = function (idx) {
+            var obj = Object.create(null);
+            obj[CIRCULAR_REF_KEY] = idx;
+            return obj;
+        };
+        EncodingTransformer.prototype._createCircularCandidate = function (val, parent, key) {
+            this.circularCandidates.push(val);
+            this.circularCandidatesDescrs.push({ parent: parent, key: key, refIdx: -1 });
+        };
+        EncodingTransformer.prototype._applyTransform = function (val, parent, key, transform) {
+            var result = Object.create(null);
+            var serializableVal = transform.toSerializable(val);
+            if (typeof serializableVal === 'object')
+                this._createCircularCandidate(val, parent, key);
+            result[TRANSFORMED_TYPE_KEY] = transform.type;
+            result.data = this._handleValue(serializableVal, parent, key);
+            return result;
+        };
+        EncodingTransformer.prototype._handleArray = function (arr) {
+            var result = [];
+            for (var i = 0; i < arr.length; i++)
+                result[i] = this._handleValue(arr[i], result, i);
+            return result;
+        };
+        EncodingTransformer.prototype._handlePlainObject = function (obj) {
+            var replicator = this;
+            var result = Object.create(null);
+            var ownPropertyNames = Object.getOwnPropertyNames(obj);
+            ownPropertyNames.forEach(function (key) {
+                var resultKey = KEY_REQUIRE_ESCAPING_RE.test(key) ? '#' + key : key;
+                result[resultKey] = replicator._handleValue(obj[key], result, resultKey);
+            });
+            return result;
+        };
+        EncodingTransformer.prototype._handleObject = function (obj, parent, key) {
+            this._createCircularCandidate(obj, parent, key);
+            return Array.isArray(obj) ? this._handleArray(obj) : this._handlePlainObject(obj);
+        };
+        EncodingTransformer.prototype._ensureCircularReference = function (obj) {
+            var circularCandidateIdx = this.circularCandidates.indexOf(obj);
+            if (circularCandidateIdx > -1) {
+                var descr = this.circularCandidatesDescrs[circularCandidateIdx];
+                if (descr.refIdx === -1)
+                    descr.refIdx = descr.parent ? ++this.circularRefCount : 0;
+                return EncodingTransformer._createRefMark(descr.refIdx);
+            }
+            return null;
+        };
+        EncodingTransformer.prototype._handleValue = function (val, parent, key) {
+            var type = typeof val;
+            var isObject = type === 'object' && val !== null;
+            if (isObject) {
+                var refMark = this._ensureCircularReference(val);
+                if (refMark)
+                    return refMark;
+            }
+            for (var i = 0; i < this.transforms.length; i++) {
+                var transform = this.transforms[i];
+                if (transform.shouldTransform(type, val))
+                    return this._applyTransform(val, parent, key, transform);
+            }
+            if (isObject)
+                return this._handleObject(val, parent, key);
+            return val;
+        };
+        EncodingTransformer.prototype.transform = function () {
+            var references = [this._handleValue(this.references, null, null)];
+            for (var i = 0; i < this.circularCandidatesDescrs.length; i++) {
+                var descr = this.circularCandidatesDescrs[i];
+                if (descr.refIdx > 0) {
+                    references[descr.refIdx] = descr.parent[descr.key];
+                    descr.parent[descr.key] = EncodingTransformer._createRefMark(descr.refIdx);
+                }
+            }
+            return references;
+        };
+        // DecodingTransform
+        var DecodingTransformer = function (references, transformsMap) {
+            this.references = references;
+            this.transformMap = transformsMap;
+            this.activeTransformsStack = [];
+            this.visitedRefs = Object.create(null);
+        };
+        DecodingTransformer.prototype._handlePlainObject = function (obj) {
+            var replicator = this;
+            var unescaped = Object.create(null);
+            var ownPropertyNames = Object.getOwnPropertyNames(obj);
+            ownPropertyNames.forEach(function (key) {
+                replicator._handleValue(obj[key], obj, key);
+                if (KEY_REQUIRE_ESCAPING_RE.test(key)) {
+                    // NOTE: use intermediate object to avoid unescaped and escaped keys interference
+                    // E.g. unescaped "##@t" will be "#@t" which can overwrite escaped "#@t".
+                    unescaped[key.substring(1)] = obj[key];
+                    delete obj[key];
+                }
+            });
+            for (var unsecapedKey in unescaped)
+                obj[unsecapedKey] = unescaped[unsecapedKey];
+        };
+        DecodingTransformer.prototype._handleTransformedObject = function (obj, parent, key) {
+            var transformType = obj[TRANSFORMED_TYPE_KEY];
+            var transform = this.transformMap[transformType];
+            if (!transform)
+                throw new Error('Can\'t find transform for "' + transformType + '" type.');
+            this.activeTransformsStack.push(obj);
+            this._handleValue(obj.data, obj, 'data');
+            this.activeTransformsStack.pop();
+            parent[key] = transform.fromSerializable(obj.data);
+        };
+        DecodingTransformer.prototype._handleCircularSelfRefDuringTransform = function (refIdx, parent, key) {
+            // NOTE: we've hit a hard case: object reference itself during transformation.
+            // We can't dereference it since we don't have resulting object yet. And we'll
+            // not be able to restore reference lately because we will need to traverse
+            // transformed object again and reference might be unreachable or new object contain
+            // new circular references. As a workaround we create getter, so once transformation
+            // complete, dereferenced property will point to correct transformed object.
+            var references = this.references;
+            var val = void 0;
+            Object.defineProperty(parent, key, {
+                configurable: true,
+                enumerable: true,
+                get: function () {
+                    if (val === void 0)
+                        val = references[refIdx];
+                    return val;
+                },
+                set: function (value) {
+                    val = value;
+                    return val;
+                }
+            });
+        };
+        DecodingTransformer.prototype._handleCircularRef = function (refIdx, parent, key) {
+            if (this.activeTransformsStack.indexOf(this.references[refIdx]) > -1)
+                this._handleCircularSelfRefDuringTransform(refIdx, parent, key);
+            else {
+                if (!this.visitedRefs[refIdx]) {
+                    this.visitedRefs[refIdx] = true;
+                    this._handleValue(this.references[refIdx], this.references, refIdx);
+                }
+                parent[key] = this.references[refIdx];
+            }
+        };
+        DecodingTransformer.prototype._handleValue = function (val, parent, key) {
+            if (typeof val !== 'object' || val === null)
+                return;
+            var refIdx = val[CIRCULAR_REF_KEY];
+            if (refIdx !== void 0)
+                this._handleCircularRef(refIdx, parent, key);
+            else if (val[TRANSFORMED_TYPE_KEY])
+                this._handleTransformedObject(val, parent, key);
+            else if (Array.isArray(val)) {
+                for (var i = 0; i < val.length; i++)
+                    this._handleValue(val[i], val, i);
+            }
+            else
+                this._handlePlainObject(val);
+        };
+        DecodingTransformer.prototype.transform = function () {
+            this.visitedRefs[0] = true;
+            this._handleValue(this.references[0], this.references, 0);
+            return this.references[0];
+        };
+        // Transforms
+        var builtInTransforms = [
+            {
+                type: '[[NaN]]',
+                shouldTransform: function (type, val) {
+                    return type === 'number' && isNaN(val);
+                },
+                toSerializable: function () {
+                    return '';
+                },
+                fromSerializable: function () {
+                    return NaN;
+                }
+            },
+            {
+                type: '[[undefined]]',
+                shouldTransform: function (type) {
+                    return type === 'undefined';
+                },
+                toSerializable: function () {
+                    return '';
+                },
+                fromSerializable: function () {
+                    return void 0;
+                }
+            },
+            {
+                type: '[[Date]]',
+                shouldTransform: function (type, val) {
+                    return val instanceof Date;
+                },
+                toSerializable: function (date) {
+                    return date.getTime();
+                },
+                fromSerializable: function (val) {
+                    var date = new Date();
+                    date.setTime(val);
+                    return date;
+                }
+            },
+            {
+                type: '[[RegExp]]',
+                shouldTransform: function (type, val) {
+                    return val instanceof RegExp;
+                },
+                toSerializable: function (re) {
+                    var result = {
+                        src: re.source,
+                        flags: ''
+                    };
+                    if (re.global)
+                        result.flags += 'g';
+                    if (re.ignoreCase)
+                        result.flags += 'i';
+                    if (re.multiline)
+                        result.flags += 'm';
+                    return result;
+                },
+                fromSerializable: function (val) {
+                    return new RegExp(val.src, val.flags);
+                }
+            },
+            {
+                type: '[[Error]]',
+                shouldTransform: function (type, val) {
+                    return val instanceof Error;
+                },
+                toSerializable: function (err) {
+                    return {
+                        name: err.name,
+                        message: err.message,
+                        stack: err.stack
+                    };
+                },
+                fromSerializable: function (val) {
+                    var Ctor = GLOBAL[val.name] || Error;
+                    var err = new Ctor(val.message);
+                    err.stack = val.stack;
+                    return err;
+                }
+            },
+            {
+                type: '[[ArrayBuffer]]',
+                shouldTransform: function (type, val) {
+                    return ARRAY_BUFFER_SUPPORTED && val instanceof ArrayBuffer;
+                },
+                toSerializable: function (buffer) {
+                    var view = new Int8Array(buffer);
+                    return arrSlice.call(view);
+                },
+                fromSerializable: function (val) {
+                    if (ARRAY_BUFFER_SUPPORTED) {
+                        var buffer = new ArrayBuffer(val.length);
+                        var view = new Int8Array(buffer);
+                        view.set(val);
+                        return buffer;
+                    }
+                    return val;
+                }
+            },
+            {
+                type: '[[Buffer]]',
+                shouldTransform: function (type, val) {
+                    return BUFFER_FROM_SUPPORTED && val instanceof Buffer;
+                },
+                toSerializable: function (buffer) {
+                    return arrSlice.call(buffer);
+                },
+                fromSerializable: function (val) {
+                    if (BUFFER_FROM_SUPPORTED)
+                        return Buffer.from(val);
+                    return val;
+                }
+            },
+            {
+                type: '[[TypedArray]]',
+                shouldTransform: function (type, val) {
+                    return Object.keys(TYPED_ARRAY_CTORS).some(function (ctorName) {
+                        return TYPED_ARRAY_SUPPORTED(ctorName) && val instanceof TYPED_ARRAY_CTORS[ctorName];
+                    });
+                },
+                toSerializable: function (arr) {
+                    return {
+                        ctorName: arr.constructor.name,
+                        arr: arrSlice.call(arr)
+                    };
+                },
+                fromSerializable: function (val) {
+                    return TYPED_ARRAY_SUPPORTED(val.ctorName) ? new TYPED_ARRAY_CTORS[val.ctorName](val.arr) : val.arr;
+                }
+            },
+            {
+                type: '[[Map]]',
+                shouldTransform: function (type, val) {
+                    return MAP_SUPPORTED && val instanceof Map;
+                },
+                toSerializable: function (map) {
+                    var flattenedKVArr = [];
+                    map.forEach(function (val, key) {
+                        flattenedKVArr.push(key);
+                        flattenedKVArr.push(val);
+                    });
+                    return flattenedKVArr;
+                },
+                fromSerializable: function (val) {
+                    if (MAP_SUPPORTED) {
+                        // NOTE: new Map(iterable) is not supported by all browsers
+                        var map = new Map();
+                        for (var i = 0; i < val.length; i += 2)
+                            map.set(val[i], val[i + 1]);
+                        return map;
+                    }
+                    var kvArr = [];
+                    for (var j = 0; j < val.length; j += 2)
+                        kvArr.push([val[i], val[i + 1]]);
+                    return kvArr;
+                }
+            },
+            {
+                type: '[[Set]]',
+                shouldTransform: function (type, val) {
+                    return SET_SUPPORTED && val instanceof Set;
+                },
+                toSerializable: function (set) {
+                    var arr = [];
+                    set.forEach(function (val) {
+                        arr.push(val);
+                    });
+                    return arr;
+                },
+                fromSerializable: function (val) {
+                    if (SET_SUPPORTED) {
+                        // NOTE: new Set(iterable) is not supported by all browsers
+                        var set = new Set();
+                        for (var i = 0; i < val.length; i++)
+                            set.add(val[i]);
+                        return set;
+                    }
+                    return val;
+                }
+            }
+        ];
+        // Replicator
+        var Replicator = module.exports = function (serializer) {
+            this.transforms = [];
+            this.transformsMap = Object.create(null);
+            this.serializer = serializer || JSONSerializer;
+            this.addTransforms(builtInTransforms);
+        };
+        // Manage transforms
+        Replicator.prototype.addTransforms = function (transforms) {
+            transforms = Array.isArray(transforms) ? transforms : [transforms];
+            for (var i = 0; i < transforms.length; i++) {
+                var transform = transforms[i];
+                if (this.transformsMap[transform.type])
+                    throw new Error('Transform with type "' + transform.type + '" was already added.');
+                this.transforms.push(transform);
+                this.transformsMap[transform.type] = transform;
+            }
+            return this;
+        };
+        Replicator.prototype.removeTransforms = function (transforms) {
+            transforms = Array.isArray(transforms) ? transforms : [transforms];
+            for (var i = 0; i < transforms.length; i++) {
+                var transform = transforms[i];
+                var idx = this.transforms.indexOf(transform);
+                if (idx > -1)
+                    this.transforms.splice(idx, 1);
+                delete this.transformsMap[transform.type];
+            }
+            return this;
+        };
+        Replicator.prototype.encode = function (val) {
+            var transformer = new EncodingTransformer(val, this.transforms);
+            var references = transformer.transform();
+            return this.serializer.serialize(references);
+        };
+        Replicator.prototype.decode = function (val) {
+            var references = this.serializer.deserialize(val);
+            var transformer = new DecodingTransformer(references, this.transformsMap);
+            return transformer.transform();
+        };
+    });
+
+    var identity = function (val) { return val; };
+    function createReplicator(transforms) {
+        // NOTE: we will serialize replicator results
+        // to JSON with a command or command result.
+        // Therefore there is no need to do additional job here,
+        // so we use identity functions for serialization.
+        var replicator$1 = new replicator({
+            serialize: identity,
+            deserialize: identity,
+        });
+        return replicator$1.addTransforms(transforms);
+    }
+
+    // -------------------------------------------------------------
+    // WARNING: this file is used by both the client and the server.
+    // Do not use any browser or node-specific API!
+    // -------------------------------------------------------------
+    var TEST_RUN_ERRORS = {
+        uncaughtErrorOnPage: 'E1',
+        uncaughtErrorInTestCode: 'E2',
+        uncaughtNonErrorObjectInTestCode: 'E3',
+        uncaughtErrorInClientFunctionCode: 'E4',
+        uncaughtErrorInCustomDOMPropertyCode: 'E5',
+        unhandledPromiseRejection: 'E6',
+        uncaughtException: 'E7',
+        missingAwaitError: 'E8',
+        actionIntegerOptionError: 'E9',
+        actionPositiveIntegerOptionError: 'E10',
+        actionBooleanOptionError: 'E11',
+        actionSpeedOptionError: 'E12',
+        actionOptionsTypeError: 'E14',
+        actionBooleanArgumentError: 'E15',
+        actionStringArgumentError: 'E16',
+        actionNullableStringArgumentError: 'E17',
+        actionStringOrStringArrayArgumentError: 'E18',
+        actionStringArrayElementError: 'E19',
+        actionIntegerArgumentError: 'E20',
+        actionRoleArgumentError: 'E21',
+        actionPositiveIntegerArgumentError: 'E22',
+        actionSelectorError: 'E23',
+        actionElementNotFoundError: 'E24',
+        actionElementIsInvisibleError: 'E26',
+        actionSelectorMatchesWrongNodeTypeError: 'E27',
+        actionAdditionalElementNotFoundError: 'E28',
+        actionAdditionalElementIsInvisibleError: 'E29',
+        actionAdditionalSelectorMatchesWrongNodeTypeError: 'E30',
+        actionElementNonEditableError: 'E31',
+        actionElementNotTextAreaError: 'E32',
+        actionElementNonContentEditableError: 'E33',
+        actionElementIsNotFileInputError: 'E34',
+        actionRootContainerNotFoundError: 'E35',
+        actionIncorrectKeysError: 'E36',
+        actionCannotFindFileToUploadError: 'E37',
+        actionUnsupportedDeviceTypeError: 'E38',
+        actionIframeIsNotLoadedError: 'E39',
+        actionElementNotIframeError: 'E40',
+        actionInvalidScrollTargetError: 'E41',
+        currentIframeIsNotLoadedError: 'E42',
+        currentIframeNotFoundError: 'E43',
+        currentIframeIsInvisibleError: 'E44',
+        nativeDialogNotHandledError: 'E45',
+        uncaughtErrorInNativeDialogHandler: 'E46',
+        setTestSpeedArgumentError: 'E47',
+        setNativeDialogHandlerCodeWrongTypeError: 'E48',
+        clientFunctionExecutionInterruptionError: 'E49',
+        domNodeClientFunctionResultError: 'E50',
+        invalidSelectorResultError: 'E51',
+        cannotObtainInfoForElementSpecifiedBySelectorError: 'E52',
+        externalAssertionLibraryError: 'E53',
+        pageLoadError: 'E54',
+        windowDimensionsOverflowError: 'E55',
+        forbiddenCharactersInScreenshotPathError: 'E56',
+        invalidElementScreenshotDimensionsError: 'E57',
+        roleSwitchInRoleInitializerError: 'E58',
+        assertionExecutableArgumentError: 'E59',
+        assertionWithoutMethodCallError: 'E60',
+        assertionUnawaitedPromiseError: 'E61',
+        requestHookNotImplementedError: 'E62',
+        requestHookUnhandledError: 'E63',
+        uncaughtErrorInCustomClientScriptCode: 'E64',
+        uncaughtErrorInCustomClientScriptCodeLoadedFromModule: 'E65',
+        uncaughtErrorInCustomScript: 'E66',
+        uncaughtTestCafeErrorInCustomScript: 'E67',
+        childWindowIsNotLoadedError: 'E68',
+        childWindowNotFoundError: 'E69',
+        cannotSwitchToWindowError: 'E70',
+        closeChildWindowError: 'E71',
+        childWindowClosedBeforeSwitchingError: 'E72',
+        cannotCloseWindowWithChildrenError: 'E73',
+        targetWindowNotFoundError: 'E74',
+        parentWindowNotFoundError: 'E76',
+        previousWindowNotFoundError: 'E77',
+        switchToWindowPredicateError: 'E78',
+        actionFunctionArgumentError: 'E79',
+        multipleWindowsModeIsDisabledError: 'E80',
+        multipleWindowsModeIsNotSupportedInRemoteBrowserError: 'E81',
+        cannotCloseWindowWithoutParent: 'E82',
+        cannotRestoreChildWindowError: 'E83',
+        executionTimeoutExceeded: 'E84',
+        actionRequiredCookieArguments: 'E85',
+        actionCookieArgumentError: 'E86',
+        actionCookieArgumentsError: 'E87',
+        actionUrlCookieArgumentError: 'E88',
+        actionUrlsCookieArgumentError: 'E89',
+        actionStringOptionError: 'E90',
+        actionDateOptionError: 'E91',
+        actionNumberOptionError: 'E92',
+        actionUrlOptionError: 'E93',
+        actionUrlSearchParamsOptionError: 'E94',
+        actionObjectOptionError: 'E95',
+        actionUrlArgumentError: 'E96',
+        actionStringOrRegexOptionError: 'E97',
+        actionSkipJsErrorsArgumentError: 'E98',
+        actionFunctionOptionError: 'E99',
+        actionInvalidObjectPropertyError: 'E100',
+        actionElementIsNotTargetError: 'E101',
+    };
+
+    // Base
+    //--------------------------------------------------------------------
+    var TestRunErrorBase = /** @class */ (function () {
+        function TestRunErrorBase(code, callsite) {
+            this.code = code;
+            this.isTestCafeError = true;
+            this.callsite = callsite || null;
+        }
+        return TestRunErrorBase;
+    }());
+    var ActionOptionErrorBase = /** @class */ (function (_super) {
+        __extends(ActionOptionErrorBase, _super);
+        function ActionOptionErrorBase(code, optionName, actualValue) {
+            var _this = _super.call(this, code) || this;
+            _this.optionName = optionName;
+            _this.actualValue = actualValue;
+            return _this;
+        }
+        return ActionOptionErrorBase;
+    }(TestRunErrorBase));
+    // Client function errors
+    //--------------------------------------------------------------------
+    var ClientFunctionExecutionInterruptionError = /** @class */ (function (_super) {
+        __extends(ClientFunctionExecutionInterruptionError, _super);
+        function ClientFunctionExecutionInterruptionError(instantiationCallsiteName, callsite) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.clientFunctionExecutionInterruptionError, callsite) || this;
+            _this.instantiationCallsiteName = instantiationCallsiteName;
+            return _this;
+        }
+        return ClientFunctionExecutionInterruptionError;
+    }(TestRunErrorBase));
+    var DomNodeClientFunctionResultError = /** @class */ (function (_super) {
+        __extends(DomNodeClientFunctionResultError, _super);
+        function DomNodeClientFunctionResultError(instantiationCallsiteName, callsite) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.domNodeClientFunctionResultError, callsite) || this;
+            _this.instantiationCallsiteName = instantiationCallsiteName;
+            return _this;
+        }
+        return DomNodeClientFunctionResultError;
+    }(TestRunErrorBase));
+    // Selector errors
+    //--------------------------------------------------------------------
+    var SelectorErrorBase = /** @class */ (function (_super) {
+        __extends(SelectorErrorBase, _super);
+        function SelectorErrorBase(code, _a, callsite) {
+            var _b = _a === void 0 ? {} : _a, apiFnChain = _b.apiFnChain, apiFnIndex = _b.apiFnIndex, reason = _b.reason;
+            var _this = _super.call(this, code, callsite) || this;
+            _this.apiFnChain = apiFnChain;
+            _this.apiFnIndex = apiFnIndex;
+            _this.reason = reason;
+            return _this;
+        }
+        return SelectorErrorBase;
+    }(TestRunErrorBase));
+    var InvalidSelectorResultError = /** @class */ (function (_super) {
+        __extends(InvalidSelectorResultError, _super);
+        function InvalidSelectorResultError(callsite) {
+            return _super.call(this, TEST_RUN_ERRORS.invalidSelectorResultError, callsite) || this;
+        }
+        return InvalidSelectorResultError;
+    }(TestRunErrorBase));
+    var CannotObtainInfoForElementSpecifiedBySelectorError = /** @class */ (function (_super) {
+        __extends(CannotObtainInfoForElementSpecifiedBySelectorError, _super);
+        function CannotObtainInfoForElementSpecifiedBySelectorError(callsite, apiFnArgs) {
+            return _super.call(this, TEST_RUN_ERRORS.cannotObtainInfoForElementSpecifiedBySelectorError, apiFnArgs, callsite) || this;
+        }
+        return CannotObtainInfoForElementSpecifiedBySelectorError;
+    }(SelectorErrorBase));
+    // Uncaught errors
+    //--------------------------------------------------------------------
+    var UncaughtErrorOnPage = /** @class */ (function (_super) {
+        __extends(UncaughtErrorOnPage, _super);
+        function UncaughtErrorOnPage(errStack, pageDestUrl) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorOnPage) || this;
+            _this.errStack = errStack;
+            _this.pageDestUrl = pageDestUrl;
+            return _this;
+        }
+        return UncaughtErrorOnPage;
+    }(TestRunErrorBase));
+    var UncaughtErrorInClientFunctionCode = /** @class */ (function (_super) {
+        __extends(UncaughtErrorInClientFunctionCode, _super);
+        function UncaughtErrorInClientFunctionCode(instantiationCallsiteName, err, callsite) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInClientFunctionCode, callsite) || this;
+            _this.errMsg = String(err);
+            _this.instantiationCallsiteName = instantiationCallsiteName;
+            return _this;
+        }
+        return UncaughtErrorInClientFunctionCode;
+    }(TestRunErrorBase));
+    var UncaughtErrorInCustomDOMPropertyCode = /** @class */ (function (_super) {
+        __extends(UncaughtErrorInCustomDOMPropertyCode, _super);
+        function UncaughtErrorInCustomDOMPropertyCode(instantiationCallsiteName, err, prop, callsite) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInCustomDOMPropertyCode, callsite) || this;
+            _this.errMsg = String(err);
+            _this.property = prop;
+            _this.instantiationCallsiteName = instantiationCallsiteName;
+            return _this;
+        }
+        return UncaughtErrorInCustomDOMPropertyCode;
+    }(TestRunErrorBase));
+    var UncaughtErrorInCustomClientScriptCode = /** @class */ (function (_super) {
+        __extends(UncaughtErrorInCustomClientScriptCode, _super);
+        function UncaughtErrorInCustomClientScriptCode(err) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInCustomClientScriptCode) || this;
+            _this.errMsg = String(err);
+            return _this;
+        }
+        return UncaughtErrorInCustomClientScriptCode;
+    }(TestRunErrorBase));
+    var UncaughtErrorInCustomClientScriptLoadedFromModule = /** @class */ (function (_super) {
+        __extends(UncaughtErrorInCustomClientScriptLoadedFromModule, _super);
+        function UncaughtErrorInCustomClientScriptLoadedFromModule(err, moduleName) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInCustomClientScriptCodeLoadedFromModule) || this;
+            _this.errMsg = String(err);
+            _this.moduleName = moduleName;
+            return _this;
+        }
+        return UncaughtErrorInCustomClientScriptLoadedFromModule;
+    }(TestRunErrorBase));
+    // Action parameters errors
+    //--------------------------------------------------------------------
+    // Options errors
+    //--------------------------------------------------------------------
+    var ActionIntegerOptionError = /** @class */ (function (_super) {
+        __extends(ActionIntegerOptionError, _super);
+        function ActionIntegerOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionIntegerOptionError, optionName, actualValue) || this;
+        }
+        return ActionIntegerOptionError;
+    }(ActionOptionErrorBase));
+    var ActionPositiveIntegerOptionError = /** @class */ (function (_super) {
+        __extends(ActionPositiveIntegerOptionError, _super);
+        function ActionPositiveIntegerOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionPositiveIntegerOptionError, optionName, actualValue) || this;
+        }
+        return ActionPositiveIntegerOptionError;
+    }(ActionOptionErrorBase));
+    var ActionBooleanOptionError = /** @class */ (function (_super) {
+        __extends(ActionBooleanOptionError, _super);
+        function ActionBooleanOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionBooleanOptionError, optionName, actualValue) || this;
+        }
+        return ActionBooleanOptionError;
+    }(ActionOptionErrorBase));
+    var ActionSpeedOptionError = /** @class */ (function (_super) {
+        __extends(ActionSpeedOptionError, _super);
+        function ActionSpeedOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionSpeedOptionError, optionName, actualValue) || this;
+        }
+        return ActionSpeedOptionError;
+    }(ActionOptionErrorBase));
+    var ActionStringOptionError = /** @class */ (function (_super) {
+        __extends(ActionStringOptionError, _super);
+        function ActionStringOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionStringOptionError, optionName, actualValue) || this;
+        }
+        return ActionStringOptionError;
+    }(ActionOptionErrorBase));
+    var ActionStringOrRegexOptionError = /** @class */ (function (_super) {
+        __extends(ActionStringOrRegexOptionError, _super);
+        function ActionStringOrRegexOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionStringOrRegexOptionError, optionName, actualValue) || this;
+        }
+        return ActionStringOrRegexOptionError;
+    }(ActionOptionErrorBase));
+    var ActionDateOptionError = /** @class */ (function (_super) {
+        __extends(ActionDateOptionError, _super);
+        function ActionDateOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionDateOptionError, optionName, actualValue) || this;
+        }
+        return ActionDateOptionError;
+    }(ActionOptionErrorBase));
+    var ActionNumberOptionError = /** @class */ (function (_super) {
+        __extends(ActionNumberOptionError, _super);
+        function ActionNumberOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionNumberOptionError, optionName, actualValue) || this;
+        }
+        return ActionNumberOptionError;
+    }(ActionOptionErrorBase));
+    var ActionUrlOptionError = /** @class */ (function (_super) {
+        __extends(ActionUrlOptionError, _super);
+        function ActionUrlOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionUrlOptionError, optionName, actualValue) || this;
+        }
+        return ActionUrlOptionError;
+    }(ActionOptionErrorBase));
+    var ActionUrlSearchParamsOptionError = /** @class */ (function (_super) {
+        __extends(ActionUrlSearchParamsOptionError, _super);
+        function ActionUrlSearchParamsOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionUrlSearchParamsOptionError, optionName, actualValue) || this;
+        }
+        return ActionUrlSearchParamsOptionError;
+    }(ActionOptionErrorBase));
+    var ActionObjectOptionError = /** @class */ (function (_super) {
+        __extends(ActionObjectOptionError, _super);
+        function ActionObjectOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionObjectOptionError, optionName, actualValue) || this;
+        }
+        return ActionObjectOptionError;
+    }(ActionOptionErrorBase));
+    var ActionFunctionOptionError = /** @class */ (function (_super) {
+        __extends(ActionFunctionOptionError, _super);
+        function ActionFunctionOptionError(optionName, actualValue) {
+            return _super.call(this, TEST_RUN_ERRORS.actionFunctionOptionError, optionName, actualValue) || this;
+        }
+        return ActionFunctionOptionError;
+    }(ActionOptionErrorBase));
+    var ActionInvalidObjectPropertyError = /** @class */ (function (_super) {
+        __extends(ActionInvalidObjectPropertyError, _super);
+        function ActionInvalidObjectPropertyError(objectName, propertyName, availableProperties) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionInvalidObjectPropertyError) || this;
+            _this.objectName = objectName;
+            _this.propertyName = propertyName;
+            _this.availableProperties = availableProperties;
+            return _this;
+        }
+        return ActionInvalidObjectPropertyError;
+    }(TestRunErrorBase));
+    // Action execution errors
+    //--------------------------------------------------------------------
+    var ActionElementNotFoundError = /** @class */ (function (_super) {
+        __extends(ActionElementNotFoundError, _super);
+        function ActionElementNotFoundError(callsite, apiFnArgs) {
+            return _super.call(this, TEST_RUN_ERRORS.actionElementNotFoundError, apiFnArgs, callsite) || this;
+        }
+        return ActionElementNotFoundError;
+    }(SelectorErrorBase));
+    var ActionElementIsInvisibleError = /** @class */ (function (_super) {
+        __extends(ActionElementIsInvisibleError, _super);
+        function ActionElementIsInvisibleError(callsite, apiFnArgs) {
+            return _super.call(this, TEST_RUN_ERRORS.actionElementIsInvisibleError, apiFnArgs, callsite) || this;
+        }
+        return ActionElementIsInvisibleError;
+    }(SelectorErrorBase));
+    var ActionSelectorMatchesWrongNodeTypeError = /** @class */ (function (_super) {
+        __extends(ActionSelectorMatchesWrongNodeTypeError, _super);
+        function ActionSelectorMatchesWrongNodeTypeError(nodeDescription) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionSelectorMatchesWrongNodeTypeError) || this;
+            _this.nodeDescription = nodeDescription;
+            return _this;
+        }
+        return ActionSelectorMatchesWrongNodeTypeError;
+    }(TestRunErrorBase));
+    var ActionAdditionalElementNotFoundError = /** @class */ (function (_super) {
+        __extends(ActionAdditionalElementNotFoundError, _super);
+        function ActionAdditionalElementNotFoundError(argumentName, apiFnArgs) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionAdditionalElementNotFoundError, apiFnArgs) || this;
+            _this.argumentName = argumentName;
+            return _this;
+        }
+        return ActionAdditionalElementNotFoundError;
+    }(SelectorErrorBase));
+    var ActionElementIsNotTargetError = /** @class */ (function (_super) {
+        __extends(ActionElementIsNotTargetError, _super);
+        function ActionElementIsNotTargetError(callsite) {
+            return _super.call(this, TEST_RUN_ERRORS.actionElementIsNotTargetError, callsite) || this;
+        }
+        return ActionElementIsNotTargetError;
+    }(TestRunErrorBase));
+    var ActionAdditionalElementIsInvisibleError = /** @class */ (function (_super) {
+        __extends(ActionAdditionalElementIsInvisibleError, _super);
+        function ActionAdditionalElementIsInvisibleError(argumentName, apiFnArgs) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionAdditionalElementIsInvisibleError, apiFnArgs) || this;
+            _this.argumentName = argumentName;
+            return _this;
+        }
+        return ActionAdditionalElementIsInvisibleError;
+    }(SelectorErrorBase));
+    var ActionAdditionalSelectorMatchesWrongNodeTypeError = /** @class */ (function (_super) {
+        __extends(ActionAdditionalSelectorMatchesWrongNodeTypeError, _super);
+        function ActionAdditionalSelectorMatchesWrongNodeTypeError(argumentName, nodeDescription) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionAdditionalSelectorMatchesWrongNodeTypeError) || this;
+            _this.argumentName = argumentName;
+            _this.nodeDescription = nodeDescription;
+            return _this;
+        }
+        return ActionAdditionalSelectorMatchesWrongNodeTypeError;
+    }(TestRunErrorBase));
+    var ActionElementNonEditableError = /** @class */ (function (_super) {
+        __extends(ActionElementNonEditableError, _super);
+        function ActionElementNonEditableError() {
+            return _super.call(this, TEST_RUN_ERRORS.actionElementNonEditableError) || this;
+        }
+        return ActionElementNonEditableError;
+    }(TestRunErrorBase));
+    var ActionElementNotTextAreaError = /** @class */ (function (_super) {
+        __extends(ActionElementNotTextAreaError, _super);
+        function ActionElementNotTextAreaError() {
+            return _super.call(this, TEST_RUN_ERRORS.actionElementNotTextAreaError) || this;
+        }
+        return ActionElementNotTextAreaError;
+    }(TestRunErrorBase));
+    var ActionElementNonContentEditableError = /** @class */ (function (_super) {
+        __extends(ActionElementNonContentEditableError, _super);
+        function ActionElementNonContentEditableError(argumentName) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionElementNonContentEditableError) || this;
+            _this.argumentName = argumentName;
+            return _this;
+        }
+        return ActionElementNonContentEditableError;
+    }(TestRunErrorBase));
+    var ActionRootContainerNotFoundError = /** @class */ (function (_super) {
+        __extends(ActionRootContainerNotFoundError, _super);
+        function ActionRootContainerNotFoundError() {
+            return _super.call(this, TEST_RUN_ERRORS.actionRootContainerNotFoundError) || this;
+        }
+        return ActionRootContainerNotFoundError;
+    }(TestRunErrorBase));
+    var ActionIncorrectKeysError = /** @class */ (function (_super) {
+        __extends(ActionIncorrectKeysError, _super);
+        function ActionIncorrectKeysError(argumentName) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionIncorrectKeysError) || this;
+            _this.argumentName = argumentName;
+            return _this;
+        }
+        return ActionIncorrectKeysError;
+    }(TestRunErrorBase));
+    var ActionCannotFindFileToUploadError = /** @class */ (function (_super) {
+        __extends(ActionCannotFindFileToUploadError, _super);
+        function ActionCannotFindFileToUploadError(filePaths, scannedFilePaths) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionCannotFindFileToUploadError) || this;
+            _this.filePaths = filePaths;
+            _this.scannedFilePaths = scannedFilePaths;
+            return _this;
+        }
+        return ActionCannotFindFileToUploadError;
+    }(TestRunErrorBase));
+    var ActionElementIsNotFileInputError = /** @class */ (function (_super) {
+        __extends(ActionElementIsNotFileInputError, _super);
+        function ActionElementIsNotFileInputError() {
+            return _super.call(this, TEST_RUN_ERRORS.actionElementIsNotFileInputError) || this;
+        }
+        return ActionElementIsNotFileInputError;
+    }(TestRunErrorBase));
+    var ActionInvalidScrollTargetError = /** @class */ (function (_super) {
+        __extends(ActionInvalidScrollTargetError, _super);
+        function ActionInvalidScrollTargetError(scrollTargetXValid, scrollTargetYValid) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.actionInvalidScrollTargetError) || this;
+            if (!scrollTargetXValid) {
+                if (!scrollTargetYValid)
+                    _this.properties = 'scrollTargetX and scrollTargetY properties';
+                else
+                    _this.properties = 'scrollTargetX property';
+            }
+            else
+                _this.properties = 'scrollTargetY property';
+            return _this;
+        }
+        return ActionInvalidScrollTargetError;
+    }(TestRunErrorBase));
+    var InvalidElementScreenshotDimensionsError = /** @class */ (function (_super) {
+        __extends(InvalidElementScreenshotDimensionsError, _super);
+        function InvalidElementScreenshotDimensionsError(width, height) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.invalidElementScreenshotDimensionsError) || this;
+            var widthIsInvalid = width <= 0;
+            var heightIsInvalid = height <= 0;
+            if (widthIsInvalid) {
+                if (heightIsInvalid) {
+                    _this.verb = 'are';
+                    _this.dimensions = 'width and height';
+                }
+                else {
+                    _this.verb = 'is';
+                    _this.dimensions = 'width';
+                }
+            }
+            else {
+                _this.verb = 'is';
+                _this.dimensions = 'height';
+            }
+            return _this;
+        }
+        return InvalidElementScreenshotDimensionsError;
+    }(TestRunErrorBase));
+    // Iframe errors
+    //--------------------------------------------------------------------
+    var ActionElementNotIframeError = /** @class */ (function (_super) {
+        __extends(ActionElementNotIframeError, _super);
+        function ActionElementNotIframeError(callsite) {
+            return _super.call(this, TEST_RUN_ERRORS.actionElementNotIframeError, callsite) || this;
+        }
+        return ActionElementNotIframeError;
+    }(TestRunErrorBase));
+    var ActionIframeIsNotLoadedError = /** @class */ (function (_super) {
+        __extends(ActionIframeIsNotLoadedError, _super);
+        function ActionIframeIsNotLoadedError() {
+            return _super.call(this, TEST_RUN_ERRORS.actionIframeIsNotLoadedError) || this;
+        }
+        return ActionIframeIsNotLoadedError;
+    }(TestRunErrorBase));
+    var CurrentIframeIsNotLoadedError = /** @class */ (function (_super) {
+        __extends(CurrentIframeIsNotLoadedError, _super);
+        function CurrentIframeIsNotLoadedError() {
+            return _super.call(this, TEST_RUN_ERRORS.currentIframeIsNotLoadedError) || this;
+        }
+        return CurrentIframeIsNotLoadedError;
+    }(TestRunErrorBase));
+    var ChildWindowNotFoundError = /** @class */ (function (_super) {
+        __extends(ChildWindowNotFoundError, _super);
+        function ChildWindowNotFoundError() {
+            return _super.call(this, TEST_RUN_ERRORS.childWindowNotFoundError) || this;
+        }
+        return ChildWindowNotFoundError;
+    }(TestRunErrorBase));
+    var ChildWindowIsNotLoadedError = /** @class */ (function (_super) {
+        __extends(ChildWindowIsNotLoadedError, _super);
+        function ChildWindowIsNotLoadedError() {
+            return _super.call(this, TEST_RUN_ERRORS.childWindowIsNotLoadedError) || this;
+        }
+        return ChildWindowIsNotLoadedError;
+    }(TestRunErrorBase));
+    var CannotSwitchToWindowError = /** @class */ (function (_super) {
+        __extends(CannotSwitchToWindowError, _super);
+        function CannotSwitchToWindowError() {
+            return _super.call(this, TEST_RUN_ERRORS.cannotSwitchToWindowError) || this;
+        }
+        return CannotSwitchToWindowError;
+    }(TestRunErrorBase));
+    var CloseChildWindowError = /** @class */ (function (_super) {
+        __extends(CloseChildWindowError, _super);
+        function CloseChildWindowError() {
+            return _super.call(this, TEST_RUN_ERRORS.closeChildWindowError) || this;
+        }
+        return CloseChildWindowError;
+    }(TestRunErrorBase));
+    var CannotCloseWindowWithChildrenError = /** @class */ (function (_super) {
+        __extends(CannotCloseWindowWithChildrenError, _super);
+        function CannotCloseWindowWithChildrenError() {
+            return _super.call(this, TEST_RUN_ERRORS.cannotCloseWindowWithChildrenError) || this;
+        }
+        return CannotCloseWindowWithChildrenError;
+    }(TestRunErrorBase));
+    var CannotCloseWindowWithoutParentError = /** @class */ (function (_super) {
+        __extends(CannotCloseWindowWithoutParentError, _super);
+        function CannotCloseWindowWithoutParentError() {
+            return _super.call(this, TEST_RUN_ERRORS.cannotCloseWindowWithoutParent) || this;
+        }
+        return CannotCloseWindowWithoutParentError;
+    }(TestRunErrorBase));
+    var SwitchToWindowPredicateError = /** @class */ (function (_super) {
+        __extends(SwitchToWindowPredicateError, _super);
+        function SwitchToWindowPredicateError(errMsg) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.switchToWindowPredicateError) || this;
+            _this.errMsg = errMsg;
+            return _this;
+        }
+        return SwitchToWindowPredicateError;
+    }(TestRunErrorBase));
+    var WindowNotFoundError = /** @class */ (function (_super) {
+        __extends(WindowNotFoundError, _super);
+        function WindowNotFoundError() {
+            return _super.call(this, TEST_RUN_ERRORS.targetWindowNotFoundError) || this;
+        }
+        return WindowNotFoundError;
+    }(TestRunErrorBase));
+    var ParentWindowNotFoundError = /** @class */ (function (_super) {
+        __extends(ParentWindowNotFoundError, _super);
+        function ParentWindowNotFoundError() {
+            return _super.call(this, TEST_RUN_ERRORS.parentWindowNotFoundError) || this;
+        }
+        return ParentWindowNotFoundError;
+    }(TestRunErrorBase));
+    var PreviousWindowNotFoundError = /** @class */ (function (_super) {
+        __extends(PreviousWindowNotFoundError, _super);
+        function PreviousWindowNotFoundError() {
+            return _super.call(this, TEST_RUN_ERRORS.previousWindowNotFoundError) || this;
+        }
+        return PreviousWindowNotFoundError;
+    }(TestRunErrorBase));
+    var ChildWindowClosedBeforeSwitchingError = /** @class */ (function (_super) {
+        __extends(ChildWindowClosedBeforeSwitchingError, _super);
+        function ChildWindowClosedBeforeSwitchingError() {
+            return _super.call(this, TEST_RUN_ERRORS.childWindowClosedBeforeSwitchingError) || this;
+        }
+        return ChildWindowClosedBeforeSwitchingError;
+    }(TestRunErrorBase));
+    var CannotRestoreChildWindowError = /** @class */ (function (_super) {
+        __extends(CannotRestoreChildWindowError, _super);
+        function CannotRestoreChildWindowError() {
+            return _super.call(this, TEST_RUN_ERRORS.cannotRestoreChildWindowError) || this;
+        }
+        return CannotRestoreChildWindowError;
+    }(TestRunErrorBase));
+    var CurrentIframeNotFoundError = /** @class */ (function (_super) {
+        __extends(CurrentIframeNotFoundError, _super);
+        function CurrentIframeNotFoundError() {
+            return _super.call(this, TEST_RUN_ERRORS.currentIframeNotFoundError) || this;
+        }
+        return CurrentIframeNotFoundError;
+    }(TestRunErrorBase));
+    var CurrentIframeIsInvisibleError = /** @class */ (function (_super) {
+        __extends(CurrentIframeIsInvisibleError, _super);
+        function CurrentIframeIsInvisibleError() {
+            return _super.call(this, TEST_RUN_ERRORS.currentIframeIsInvisibleError) || this;
+        }
+        return CurrentIframeIsInvisibleError;
+    }(TestRunErrorBase));
+    // Native dialog errors
+    //--------------------------------------------------------------------
+    var NativeDialogNotHandledError = /** @class */ (function (_super) {
+        __extends(NativeDialogNotHandledError, _super);
+        function NativeDialogNotHandledError(dialogType, url) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.nativeDialogNotHandledError) || this;
+            _this.dialogType = dialogType;
+            _this.pageUrl = url;
+            return _this;
+        }
+        return NativeDialogNotHandledError;
+    }(TestRunErrorBase));
+    var UncaughtErrorInNativeDialogHandler = /** @class */ (function (_super) {
+        __extends(UncaughtErrorInNativeDialogHandler, _super);
+        function UncaughtErrorInNativeDialogHandler(dialogType, errMsg, url) {
+            var _this = _super.call(this, TEST_RUN_ERRORS.uncaughtErrorInNativeDialogHandler) || this;
+            _this.dialogType = dialogType;
+            _this.errMsg = errMsg;
+            _this.pageUrl = url;
+            return _this;
+        }
+        return UncaughtErrorInNativeDialogHandler;
+    }(TestRunErrorBase));
+
+    // @ts-ignore
+    function isNodeCollection(obj) {
+        return obj instanceof hammerhead$1.nativeMethods.HTMLCollection || obj instanceof hammerhead$1.nativeMethods.NodeList;
+    }
+    function castToArray(list) {
+        var length = list.length;
+        var result = [];
+        for (var i = 0; i < length; i++)
+            result.push(list[i]);
+        return result;
+    }
+    function isArrayOfNodes(obj) {
+        if (!hammerhead$1.nativeMethods.isArray(obj))
+            return false;
+        for (var i = 0; i < obj.length; i++) {
+            // @ts-ignore
+            if (!(obj[i] instanceof hammerhead$1.nativeMethods.Node))
+                return false;
+        }
+        return true;
+    }
+
+    var _a$1;
+    var SELECTOR_FILTER_ERROR = {
+        filterVisible: 1,
+        filterHidden: 2,
+        nth: 3,
+    };
+    var FILTER_ERROR_TO_API_RE = (_a$1 = {},
+        _a$1[SELECTOR_FILTER_ERROR.filterVisible] = /^\.filterVisible\(\)$/,
+        _a$1[SELECTOR_FILTER_ERROR.filterHidden] = /^\.filterHidden\(\)$/,
+        _a$1[SELECTOR_FILTER_ERROR.nth] = /^\.nth\(\d+\)$/,
+        _a$1);
+    var SelectorFilter = /** @class */ (function () {
+        function SelectorFilter() {
+            this._err = null;
+        }
+        Object.defineProperty(SelectorFilter.prototype, "error", {
+            get: function () {
+                return this._err;
+            },
+            set: function (message) {
+                if (this._err === null)
+                    this._err = message;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        SelectorFilter.prototype.filter = function (nodes, options, apiInfo) {
+            if (options.filterVisible) {
+                nodes = nodes.filter(testCafeCore.positionUtils.isElementVisible);
+                this._assertFilterError(nodes, apiInfo, SELECTOR_FILTER_ERROR.filterVisible);
+            }
+            if (options.filterHidden) {
+                nodes = nodes.filter(function (n) { return !testCafeCore.positionUtils.isElementVisible(n); });
+                this._assertFilterError(nodes, apiInfo, SELECTOR_FILTER_ERROR.filterHidden);
+            }
+            if (options.counterMode) {
+                if (options.index === null)
+                    return nodes.length;
+                return SelectorFilter._getNodeByIndex(nodes, options.index) ? 1 : 0;
+            }
+            if (options.collectionMode) {
+                if (options.index !== null) {
+                    var nodeOnIndex_1 = SelectorFilter._getNodeByIndex(nodes, options.index);
+                    nodes = nodeOnIndex_1 ? [nodeOnIndex_1] : [];
+                    this._assertFilterError(nodes, apiInfo, SELECTOR_FILTER_ERROR.nth);
+                }
+                return nodes;
+            }
+            var nodeOnIndex = SelectorFilter._getNodeByIndex(nodes, options.index || 0);
+            if (!nodeOnIndex)
+                this.error = SelectorFilter._getErrorItem(apiInfo, SELECTOR_FILTER_ERROR.nth);
+            return nodeOnIndex;
+        };
+        SelectorFilter.prototype.cast = function (searchResult) {
+            if (searchResult === null || searchResult === void 0)
+                return [];
+            else if (searchResult instanceof hammerhead$1.nativeMethods.Node)
+                return [searchResult];
+            else if (isArrayOfNodes(searchResult))
+                return searchResult;
+            else if (isNodeCollection(searchResult))
+                return castToArray(searchResult);
+            throw new InvalidSelectorResultError();
+        };
+        SelectorFilter.prototype._assertFilterError = function (filtered, apiInfo, filterError) {
+            if (filtered.length === 0)
+                this.error = SelectorFilter._getErrorItem(apiInfo, filterError);
+        };
+        SelectorFilter._getErrorItem = function (_a, err) {
+            var apiFnChain = _a.apiFnChain, apiFnID = _a.apiFnID;
+            if (err) {
+                for (var i = apiFnID; i < apiFnChain.length; i++) {
+                    if (FILTER_ERROR_TO_API_RE[err].test(apiFnChain[i]))
+                        return i;
+                }
+            }
+            return null;
+        };
+        SelectorFilter._getNodeByIndex = function (nodes, index) {
+            return index < 0 ? nodes[nodes.length + index] : nodes[index];
+        };
+        return SelectorFilter;
+    }());
+    var selectorFilter = new SelectorFilter();
+
+    // @ts-ignore
+    // NOTE: evalFunction is isolated into a separate module to
+    // restrict access to TestCafe intrinsics for the evaluated code.
+    // It also accepts `__dependencies$` argument which may be used by evaluated code.
+    function evalFunction(fnCode, __dependencies$) {
+        var FunctionCtor = hammerhead$1.nativeMethods.Function;
+        var evaluator = new FunctionCtor('fnCode', '__dependencies$', 'Promise', 
+        // NOTE: we should pass the original `RegExp`
+        // to make the `instanceof RegExp` check successful in different contexts
+        'RegExp', 
+        // NOTE: `eval` in strict mode will not override context variables
+        '"use strict"; return eval(fnCode)');
+        return evaluator(fnCode, __dependencies$, hammerhead$1.Promise, RegExp);
+    }
+
+    var FunctionTransform = /** @class */ (function () {
+        function FunctionTransform() {
+            this.type = 'Function';
+        }
+        FunctionTransform.prototype.shouldTransform = function (type) {
+            return type === 'function';
+        };
+        FunctionTransform.prototype.toSerializable = function () {
+            return '';
+        };
+        // HACK: UglifyJS + TypeScript + argument destructuring can generate incorrect code.
+        // So we have to use plain assignments here.
+        FunctionTransform.prototype.fromSerializable = function (opts) {
+            var fnCode = opts.fnCode;
+            var dependencies = opts.dependencies;
+            if ('filterOptions' in dependencies)
+                dependencies.selectorFilter = selectorFilter;
+            return evalFunction(fnCode, dependencies);
+        };
+        return FunctionTransform;
+    }());
+
+    var ClientFunctionNodeTransform = /** @class */ (function () {
+        function ClientFunctionNodeTransform(instantiationCallsiteName) {
+            this.type = 'Node';
+            this._instantiationCallsiteName = instantiationCallsiteName;
+        }
+        ClientFunctionNodeTransform.prototype.shouldTransform = function (type, val) {
+            if (val instanceof hammerhead$1.nativeMethods.Node)
+                throw new DomNodeClientFunctionResultError(this._instantiationCallsiteName);
+            return false;
+        };
+        ClientFunctionNodeTransform.prototype.toSerializable = function () {
+        };
+        ClientFunctionNodeTransform.prototype.fromSerializable = function () {
+        };
+        return ClientFunctionNodeTransform;
+    }());
+
+    var ClientFunctionExecutor = /** @class */ (function () {
+        function ClientFunctionExecutor(command) {
+            this.command = command;
+            this.replicator = this._createReplicator();
+            this.dependencies = this.replicator.decode(command.dependencies);
+            this.fn = evalFunction(command.fnCode, this.dependencies);
+        }
+        ClientFunctionExecutor.prototype.getResult = function () {
+            var _this = this;
+            return hammerhead$1.Promise.resolve()
+                .then(function () {
+                var args = _this.replicator.decode(_this.command.args);
+                return _this._executeFn(args);
+            })
+                .catch(function (err) {
+                if (!err.isTestCafeError)
+                    err = new UncaughtErrorInClientFunctionCode(_this.command.instantiationCallsiteName, err);
+                throw err;
+            });
+        };
+        ClientFunctionExecutor.prototype.encodeResult = function (result) {
+            return this.replicator.encode(result);
+        };
+        ClientFunctionExecutor.prototype._createReplicator = function () {
+            return createReplicator([
+                new ClientFunctionNodeTransform(this.command.instantiationCallsiteName),
+                new FunctionTransform(),
+            ]);
+        };
+        ClientFunctionExecutor.prototype._executeFn = function (args) {
+            return this.fn.apply(window, args);
+        };
+        return ClientFunctionExecutor;
+    }());
+
+    // -------------------------------------------------------------
+    // WARNING: this file is used by both the client and the server.
+    // Do not use any browser or node-specific API!
+    // -------------------------------------------------------------
+    var NODE_SNAPSHOT_PROPERTIES = [
+        'nodeType',
+        'textContent',
+        'childNodeCount',
+        'hasChildNodes',
+        'childElementCount',
+        'hasChildElements',
+    ];
+    var ELEMENT_ACTION_SNAPSHOT_PROPERTIES = [
+        'tagName',
+        'attributes',
+    ];
+    var ELEMENT_SNAPSHOT_PROPERTIES = [
+        'tagName',
+        'visible',
+        'focused',
+        'attributes',
+        'boundingClientRect',
+        'classNames',
+        'style',
+        'innerText',
+        'namespaceURI',
+        'id',
+        'value',
+        'checked',
+        'selected',
+        'selectedIndex',
+        'scrollWidth',
+        'scrollHeight',
+        'scrollLeft',
+        'scrollTop',
+        'offsetWidth',
+        'offsetHeight',
+        'offsetLeft',
+        'offsetTop',
+        'clientWidth',
+        'clientHeight',
+        'clientLeft',
+        'clientTop',
+    ];
+
+    var nodeSnapshotPropertyInitializers = {
+        // eslint-disable-next-line no-restricted-properties
+        childNodeCount: function (node) { return node.childNodes.length; },
+        hasChildNodes: function (node) { return !!nodeSnapshotPropertyInitializers.childNodeCount(node); },
+        childElementCount: function (node) {
+            var children = node.children;
+            if (children)
+                // eslint-disable-next-line no-restricted-properties
+                return children.length;
+            // NOTE: IE doesn't have `children` for non-element nodes =/
+            var childElementCount = 0;
+            // eslint-disable-next-line no-restricted-properties
+            var childNodeCount = node.childNodes.length;
+            for (var i = 0; i < childNodeCount; i++) {
+                // eslint-disable-next-line no-restricted-properties
+                if (node.childNodes[i].nodeType === 1)
+                    childElementCount++;
+            }
+            return childElementCount;
+        },
+        // eslint-disable-next-line no-restricted-properties
+        hasChildElements: function (node) { return !!nodeSnapshotPropertyInitializers.childElementCount(node); },
+    };
+    var BaseSnapshot = /** @class */ (function () {
+        function BaseSnapshot() {
+        }
+        BaseSnapshot.prototype._initializeProperties = function (node, properties, initializers) {
+            for (var _i = 0, properties_1 = properties; _i < properties_1.length; _i++) {
+                var property = properties_1[_i];
+                var initializer = initializers[property];
+                this[property] = initializer ? initializer(node) : node[property];
+            }
+        };
+        return BaseSnapshot;
+    }());
+    var NodeSnapshot = /** @class */ (function (_super) {
+        __extends(NodeSnapshot, _super);
+        function NodeSnapshot(node) {
+            var _this = _super.call(this) || this;
+            _this._initializeProperties(node, NODE_SNAPSHOT_PROPERTIES, nodeSnapshotPropertyInitializers);
+            return _this;
+        }
+        return NodeSnapshot;
+    }(BaseSnapshot));
+    // Element
+    var elementSnapshotPropertyInitializers = {
+        tagName: function (element) { return element.tagName.toLowerCase(); },
+        visible: function (element) { return testCafeCore.positionUtils.isElementVisible(element); },
+        focused: function (element) { return hammerhead$1.utils.dom.getActiveElement() === element; },
+        attributes: function (element) {
+            // eslint-disable-next-line no-restricted-properties
+            var attrs = element.attributes;
+            var result = {};
+            for (var i = attrs.length - 1; i >= 0; i--)
+                // eslint-disable-next-line no-restricted-properties
+                result[attrs[i].name] = attrs[i].value;
+            return result;
+        },
+        boundingClientRect: function (element) {
+            var rect = element.getBoundingClientRect();
+            return {
+                left: rect.left,
+                right: rect.right,
+                top: rect.top,
+                bottom: rect.bottom,
+                width: rect.width,
+                height: rect.height,
+            };
+        },
+        classNames: function (element) {
+            var className = element.className;
+            if (typeof className.animVal === 'string')
+                className = className.animVal;
+            return className
+                .replace(/^\s+|\s+$/g, '')
+                .split(/\s+/g);
+        },
+        style: function (element) {
+            var result = {};
+            var computed = window.getComputedStyle(element);
+            for (var i = 0; i < computed.length; i++) {
+                var prop = computed[i];
+                result[prop] = computed[prop];
+            }
+            return result;
+        },
+        // eslint-disable-next-line no-restricted-properties
+        innerText: function (element) { return element.innerText; },
+    };
+    var ElementActionSnapshot = /** @class */ (function (_super) {
+        __extends(ElementActionSnapshot, _super);
+        function ElementActionSnapshot(element) {
+            var _this = _super.call(this) || this;
+            _this._initializeProperties(element, ELEMENT_ACTION_SNAPSHOT_PROPERTIES, elementSnapshotPropertyInitializers);
+            return _this;
+        }
+        return ElementActionSnapshot;
+    }(BaseSnapshot));
+    var ElementSnapshot = /** @class */ (function (_super) {
+        __extends(ElementSnapshot, _super);
+        function ElementSnapshot(element) {
+            var _this = _super.call(this, element) || this;
+            _this._initializeProperties(element, ELEMENT_SNAPSHOT_PROPERTIES, elementSnapshotPropertyInitializers);
+            return _this;
+        }
+        return ElementSnapshot;
+    }(NodeSnapshot));
+
+    var SelectorNodeTransform = /** @class */ (function () {
+        function SelectorNodeTransform(customDOMProperties, instantiationCallsiteName) {
+            if (customDOMProperties === void 0) { customDOMProperties = {}; }
+            this.type = 'Node';
+            this._customDOMProperties = customDOMProperties;
+            this._instantiationCallsiteName = instantiationCallsiteName;
+        }
+        SelectorNodeTransform.prototype._extend = function (snapshot, node) {
+            var props = hammerhead$1.nativeMethods.objectKeys(this._customDOMProperties);
+            for (var _i = 0, props_1 = props; _i < props_1.length; _i++) {
+                var prop = props_1[_i];
+                try {
+                    snapshot[prop] = this._customDOMProperties[prop](node);
+                }
+                catch (err) {
+                    throw new UncaughtErrorInCustomDOMPropertyCode(this._instantiationCallsiteName, err, prop);
+                }
+            }
+        };
+        SelectorNodeTransform.prototype.shouldTransform = function (type, val) {
+            return val instanceof hammerhead$1.nativeMethods.Node;
+        };
+        SelectorNodeTransform.prototype.toSerializable = function (node) {
+            var snapshot = node.nodeType === 1 ? new ElementSnapshot(node) : new NodeSnapshot(node);
+            this._extend(snapshot, node);
+            return snapshot;
+        };
+        SelectorNodeTransform.prototype.fromSerializable = function () {
+        };
+        return SelectorNodeTransform;
+    }());
+
+    var CHECK_ELEMENT_DELAY = 200;
+
+    var SelectorExecutor = /** @class */ (function (_super) {
+        __extends(SelectorExecutor, _super);
+        function SelectorExecutor(command, globalTimeout, startTime, createNotFoundError, createIsInvisibleError) {
+            var _this = _super.call(this, command) || this;
+            _this.createNotFoundError = createNotFoundError;
+            _this.createIsInvisibleError = createIsInvisibleError;
+            _this.timeout = typeof command.timeout === 'number' ? command.timeout : globalTimeout;
+            _this.counterMode = _this.dependencies.filterOptions.counterMode;
+            _this.getVisibleValueMode = _this.dependencies.filterOptions.getVisibleValueMode;
+            _this.dependencies.selectorFilter = selectorFilter;
+            if (startTime) {
+                var elapsed = hammerhead$1.nativeMethods.dateNow() - startTime;
+                _this.timeout = Math.max(_this.timeout - elapsed, 0);
+            }
+            var customDOMProperties = _this.dependencies.customDOMProperties;
+            _this.replicator.addTransforms([
+                new SelectorNodeTransform(customDOMProperties, command.instantiationCallsiteName),
+            ]);
+            return _this;
+        }
+        SelectorExecutor.prototype._createReplicator = function () {
+            return createReplicator([
+                new FunctionTransform(),
+            ]);
+        };
+        SelectorExecutor.prototype._getTimeoutErrorParams = function (el) {
+            var apiFnIndex = selectorFilter.error;
+            var apiFnChain = this.command.apiFnChain;
+            var reason = testCafeCore.positionUtils.getHiddenReason(el);
+            return { apiFnIndex: apiFnIndex, apiFnChain: apiFnChain, reason: reason };
+        };
+        SelectorExecutor.prototype._getTimeoutError = function (elementExists) {
+            return elementExists ? this.createIsInvisibleError : this.createNotFoundError;
+        };
+        SelectorExecutor.prototype._validateElement = function (args, startTime) {
+            var _this = this;
+            return hammerhead$1.Promise.resolve()
+                .then(function () { return _super.prototype._executeFn.call(_this, args); })
+                .then(function (el) {
+                var element = el;
+                var isElementExists = !!element;
+                var isElementVisible = !_this.command.visibilityCheck || element && testCafeCore.positionUtils.isElementVisible(element);
+                var isTimeout = hammerhead$1.nativeMethods.dateNow() - startTime >= _this.timeout;
+                if (isElementExists && (isElementVisible || hammerhead$1.utils.dom.isShadowRoot(element)))
+                    return element;
+                if (!isTimeout)
+                    return testCafeCore.delay(CHECK_ELEMENT_DELAY).then(function () { return _this._validateElement(args, startTime); });
+                var createTimeoutError = _this.getVisibleValueMode ? null : _this._getTimeoutError(isElementExists);
+                if (createTimeoutError)
+                    throw createTimeoutError(_this._getTimeoutErrorParams(element));
+                return null;
+            });
+        };
+        SelectorExecutor.prototype._executeFn = function (args) {
+            if (this.counterMode)
+                return _super.prototype._executeFn.call(this, args);
+            return this._validateElement(args, hammerhead$1.nativeMethods.dateNow());
+        };
+        return SelectorExecutor;
+    }(ClientFunctionExecutor));
+
+    var INTERNAL_PROPERTIES = {
+        testCafeDriver: '%testCafeDriver%',
+        testCafeIframeDriver: '%testCafeIframeDriver%',
+        testCafeEmbeddingUtils: '%testCafeEmbeddingUtils%',
+        testCafeDriverInstance: '%testCafeDriverInstance%',
+    };
+
+    var GLOBAL_TIMEOUT = 5000;
+    function createNotFoundError() {
+        return null;
+    }
+    function createIsInvisibleError() {
+        return null;
+    }
+    function parseSelector(selector) {
+        return __awaiter(this, void 0, void 0, function () {
+            var communicationUrls;
+            return __generator(this, function (_a) {
+                communicationUrls = window[INTERNAL_PROPERTIES.testCafeDriverInstance].communicationUrls;
+                return [2 /*return*/, testCafeCore.browser.parseSelector(communicationUrls.parseSelector, hammerhead$1.createNativeXHR, selector)];
+            });
+        });
+    }
+    function executeSelector(parsedSelector) {
+        return __awaiter(this, void 0, void 0, function () {
+            var startTime, selectorExecutor, elements;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = hammerhead$1.nativeMethods.date();
+                        selectorExecutor = new SelectorExecutor(parsedSelector, GLOBAL_TIMEOUT, startTime, createNotFoundError, createIsInvisibleError);
+                        return [4 /*yield*/, selectorExecutor.getResult()];
+                    case 1:
+                        elements = _a.sent();
+                        return [2 /*return*/, elements];
+                }
+            });
+        });
+    }
+    function getElementsBySelector(selector) {
+        return __awaiter(this, void 0, void 0, function () {
+            var parsedSelector;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, parseSelector(selector)];
+                    case 1:
+                        parsedSelector = _a.sent();
+                        return [2 /*return*/, executeSelector(parsedSelector).catch(function () { return null; })];
+                }
+            });
+        });
+    }
+
+    var listeners$3 = hammerhead$1__default.eventSandbox.listeners;
+    var serviceUtils$2 = testCafeCore__default.serviceUtils;
+    var LIST_CHANGED = 'list-changed';
+    var SELECTOR_SELECTED = 'selector-selected';
+    var SelectorsList = /** @class */ (function (_super) {
+        __extends(SelectorsList, _super);
+        function SelectorsList() {
+            var _this = _super.call(this) || this;
+            _this._pickedSelectors = [];
+            _this.element = createElementFromDescriptor(selectorsList);
+            elementPicker.on(ELEMENT_PICKED, function (selectors) {
+                _this.pickedSelectors = selectors;
+            });
+            return _this;
+        }
+        Object.defineProperty(SelectorsList.prototype, "pickedSelectors", {
+            get: function () {
+                return this._pickedSelectors;
+            },
+            set: function (selectors) {
+                if (selectors === void 0) { selectors = []; }
+                if (this._pickedSelectors === selectors)
+                    return;
+                this._pickedSelectors = selectors;
+                this.emit(LIST_CHANGED, selectors);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        SelectorsList.prototype._renderSelectors = function () {
+            var _this = this;
+            this.pickedSelectors.forEach(function (selector) {
+                var el = createElementFromDescriptor({
+                    text: selector.value,
+                    class: 'selector-value',
+                });
+                _this.element.appendChild(el);
+            });
+            this.renderedSelectors = this.pickedSelectors;
+        };
+        SelectorsList.prototype._clear = function () {
+            while (this.element.firstChild)
+                this.element.removeChild(this.element.firstChild);
+            this.renderedSelectors = null;
+        };
+        SelectorsList.prototype._addClickListener = function () {
+            var _this = this;
+            var onClick = function (event) {
+                removeFromUiRoot(_this.element);
+                if (event.target.parentElement === _this.element)
+                    _this.emit(SELECTOR_SELECTED, event.target.innerText);
+                listeners$3.removeInternalEventBeforeListener(window, ['click'], onClick);
+            };
+            listeners$3.addFirstInternalEventBeforeListener(window, ['click'], onClick);
+        };
+        SelectorsList.prototype.show = function (_a) {
+            var left = _a.left, bottom = _a.bottom, width = _a.width;
+            if (!this.pickedSelectors || this.pickedSelectors.length === 0)
+                return;
+            if (this.pickedSelectors !== this.renderedSelectors) {
+                this._clear();
+                this._renderSelectors();
+            }
+            var styles = {
+                left: left + 'px',
+                bottom: bottom + 'px',
+                width: width + 'px',
+            };
+            addToUiRoot(this.element);
+            setStyles(this.element, styles);
+            this._addClickListener();
+        };
+        SelectorsList.prototype.clear = function () {
+            this.pickedSelectors = null;
+        };
+        return SelectorsList;
+    }(serviceUtils$2.EventEmitter));
+    var selectorsList$1 = new SelectorsList();
+
+    var nativeMethods$a = hammerhead$1__default.nativeMethods;
+    var shadowUI$9 = hammerhead$1__default.shadowUI;
+    var eventUtils$4 = testCafeCore__default.eventUtils;
+    var ENABLED_CLASS = 'enabled';
+    var MATCH_INDICATOR_CLASSES = {
+        notFound: 'not-found',
+        invalid: 'invalid',
+        ok: 'ok',
+    };
+    var SelectorInputContainer = /** @class */ (function () {
+        function SelectorInputContainer() {
+            this._createElements();
+            this._addEventListeners();
+        }
+        Object.defineProperty(SelectorInputContainer.prototype, "value", {
+            get: function () {
+                return nativeMethods$a.inputValueGetter.call(this.input);
+            },
+            set: function (value) {
+                nativeMethods$a.inputValueSetter.call(this.input, value);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        SelectorInputContainer.prototype._createElements = function () {
+            this.element = createElementFromDescriptor(selectorInputContainer);
+            this.input = createElementFromDescriptor(selectorInput);
+            this.indicator = createElementFromDescriptor(matchIndicator);
+            this.expandButton = createElementFromDescriptor(expandSelectorsList);
+            this.element.appendChild(this.input);
+            this.element.appendChild(this.indicator);
+            this.element.appendChild(this.expandButton);
+        };
+        SelectorInputContainer.prototype._addEventListeners = function () {
+            var _this = this;
+            eventUtils$4.bind(this.expandButton, 'click', function () { return _this._expandSelectorsList(); });
+            eventUtils$4.bind(this.input, 'input', function () { return _this._onSelectorTyped(); });
+            eventUtils$4.bind(this.input, 'focus', function () { return _this._onFocusInput(); });
+            eventUtils$4.bind(this.input, 'blur', function () { return highlighter.stopHighlighting(); });
+            selectorsList$1.on(LIST_CHANGED, function (selectors) {
+                _this._updateExpandButton(selectors);
+            });
+            selectorsList$1.on(SELECTOR_SELECTED, function (value) {
+                _this._setSelectorInputValue({ value: value });
+            });
+            elementPicker.on(ELEMENT_PICKED, function (selectors) {
+                _this._setSelectorInputValue(selectors[0]);
+            });
+        };
+        SelectorInputContainer.prototype._setMatchIndicatorText = function (text) {
+            nativeMethods$a.nodeTextContentSetter.call(this.indicator, text);
+        };
+        SelectorInputContainer.prototype._setMatchIndicatorClass = function (value) {
+            for (var key in MATCH_INDICATOR_CLASSES)
+                shadowUI$9.removeClass(this.indicator, MATCH_INDICATOR_CLASSES[key]);
+            shadowUI$9.addClass(this.indicator, value);
+        };
+        SelectorInputContainer.prototype._indicateMatches = function (elements) {
+            if (elements === null) {
+                this._setMatchIndicatorText('Invalid Selector');
+                this._setMatchIndicatorClass(MATCH_INDICATOR_CLASSES.invalid);
+                return;
+            }
+            if (elements.length === 0) {
+                this._setMatchIndicatorText('No Matching Elements');
+                this._setMatchIndicatorClass(MATCH_INDICATOR_CLASSES.notFound);
+                return;
+            }
+            this._setMatchIndicatorText("Found: ".concat(elements.length));
+            this._setMatchIndicatorClass(MATCH_INDICATOR_CLASSES.ok);
+        };
+        SelectorInputContainer.prototype._highlightElements = function (elements) {
+            for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) {
+                var element = elements_1[_i];
+                highlighter.highlight(element);
+            }
+        };
+        SelectorInputContainer.prototype._setSelectorInputValue = function (selector) {
+            this.value = selector.value;
+            this.input.focus();
+        };
+        SelectorInputContainer.prototype._expandSelectorsList = function () {
+            var _a = this.element.getBoundingClientRect(), left = _a.left, top = _a.top, width = _a.width;
+            var clientHeight = document.documentElement.clientHeight;
+            var result = {
+                left: left,
+                width: width,
+                bottom: clientHeight - top + 1,
+            };
+            selectorsList$1.show(result);
+        };
+        SelectorInputContainer.prototype._updateExpandButton = function (selectors) {
+            if (selectors && selectors.length)
+                shadowUI$9.addClass(this.expandButton, ENABLED_CLASS);
+            else
+                shadowUI$9.removeClass(this.expandButton, ENABLED_CLASS);
+        };
+        SelectorInputContainer.prototype._onSelectorTyped = function () {
+            selectorsList$1.clear();
+            this._onFocusInput();
+        };
+        SelectorInputContainer.prototype._onFocusInput = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var elements;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            highlighter.stopHighlighting();
+                            if (!this.value) {
+                                this._indicateMatches([]);
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, getElementsBySelector(this.value)];
+                        case 1:
+                            elements = _a.sent();
+                            this._indicateMatches(elements);
+                            this._highlightElements(elements);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return SelectorInputContainer;
+    }());
+
+    function copy(value) {
+        var element = createElementFromDescriptor(auxiliaryCopyInput);
+        addToUiRoot(element);
+        // eslint-disable-next-line no-restricted-properties
+        element.value = value;
+        element.select();
+        document.execCommand('copy');
+        removeFromUiRoot(element);
+    }
+
+    var nativeMethods$b = hammerhead$1__default.nativeMethods;
+    var eventUtils$5 = testCafeCore__default.eventUtils;
+    var ANIMATION_TIMEOUT = 1200;
+    var VALUES = {
+        copy: 'Copy',
+        copied: 'Copied!',
+    };
+    var CopyButton = /** @class */ (function () {
+        function CopyButton(sourceElement) {
+            var _this = this;
+            this.element = createElementFromDescriptor(copyButton);
+            this.sourceElement = sourceElement;
+            eventUtils$5.bind(this.element, 'click', function () { return _this._copySelector(); });
+        }
+        CopyButton.prototype._copySelector = function () {
+            // eslint-disable-next-line no-restricted-properties
+            copy(this.sourceElement.value);
+            this._animate();
+        };
+        CopyButton.prototype._animate = function () {
+            var _this = this;
+            this._changeAppearance(VALUES.copied, 'bold');
+            nativeMethods$b.setTimeout.call(window, function () { return _this._resetAppearance(); }, ANIMATION_TIMEOUT);
+        };
+        CopyButton.prototype._resetAppearance = function () {
+            this._changeAppearance(VALUES.copy, '');
+        };
+        CopyButton.prototype._changeAppearance = function (value, fontWeight) {
+            nativeMethods$b.inputValueSetter.call(this.element, value);
+            setStyles(this.element, { fontWeight: fontWeight });
+        };
+        return CopyButton;
+    }());
+
+    var SelectorInspectorPanel = /** @class */ (function () {
+        function SelectorInspectorPanel() {
+            this.elementPicker = elementPicker;
+            this.element = createElementFromDescriptor(panel);
+            var pickButton = new PickButton();
+            var selectorInputContainer = new SelectorInputContainer();
+            var copyButton = new CopyButton(selectorInputContainer);
+            this.element.appendChild(pickButton.element);
+            this.element.appendChild(selectorInputContainer.element);
+            this.element.appendChild(copyButton.element);
+        }
+        SelectorInspectorPanel.prototype.show = function () {
+            if (!this.element.parentElement)
+                uiRoot.insertFirstChildToPanelsContainer(this.element);
+            setStyles(this.element, { display: 'flex' });
+        };
+        SelectorInspectorPanel.prototype.hide = function () {
+            setStyles(this.element, { display: 'none' });
+        };
+        return SelectorInspectorPanel;
+    }());
+
+    var Promise$2 = hammerhead$1__default.Promise;
+    var messageSandbox$3 = hammerhead$1__default.eventSandbox.message;
     var sendRequestToFrame$1 = testCafeCore__default.sendRequestToFrame;
     var HIDE_REQUEST_CMD = 'ui|hide|request';
     var HIDE_RESPONSE_CMD = 'ui|hide|response';
@@ -1399,6 +4580,7 @@ window['%hammerhead%'].utils.removeInjectedScript();
     exports$1.ProgressPanel = ProgressPanel;
     exports$1.StatusBar = StatusBar;
     exports$1.IframeStatusBar = IframeStatusBar;
+    exports$1.SelectorInspectorPanel = SelectorInspectorPanel;
     exports$1.hide = function (hideTopRoot) {
         if (hideTopRoot)
             return sendRequestToFrame$1({ cmd: HIDE_REQUEST_CMD }, HIDE_RESPONSE_CMD, window.top);
@@ -1413,11 +4595,11 @@ window['%hammerhead%'].utils.removeInjectedScript();
     };
     exports$1.showScreenshotMark = function (url) { return screenshotMark.show(url); };
     exports$1.hideScreenshotMark = function () { return screenshotMark.hide(); };
-    var nativeMethods$5 = hammerhead__default.nativeMethods;
-    var evalIframeScript = hammerhead__default.EVENTS.evalIframeScript;
-    nativeMethods$5.objectDefineProperty(window, '%testCafeUI%', { configurable: true, value: exports$1 });
+    var nativeMethods$c = hammerhead$1__default.nativeMethods;
+    var evalIframeScript = hammerhead$1__default.EVENTS.evalIframeScript;
+    nativeMethods$c.objectDefineProperty(window, '%testCafeUI%', { configurable: true, value: exports$1 });
     // eslint-disable-next-line no-undef
-    hammerhead__default.on(evalIframeScript, function (e) { return initTestCafeUI(nativeMethods$5.contentWindowGetter.call(e.iframe), true); });
+    hammerhead$1__default.on(evalIframeScript, function (e) { return initTestCafeUI(nativeMethods$c.contentWindowGetter.call(e.iframe), true); });
 
 }(window['%hammerhead%'], window['%testCafeCore%'], window['%hammerhead%'].Promise));