text: // NOTE: We should have the capability to initialize scripts with different contexts.
  // This is required for iframes without the src attribute because Hammerhead does not
  // inject scripts into such iframes. So, we wrap all scripts in initialization functions.
  (function () {
      function initTestCafeClientDrivers(window, isIFrameWithoutSrc) {
          var document = window.document;
  
          // This file was generated by modules-webmake (modules for web) project.
  // See: https://github.com/medikoo/modules-webmake
  
  (function (modules) {
  	'use strict';
  
  	var resolve, getRequire, wmRequire, notFoundError, findFile
  	  , extensions = {".js":[],".json":[],".css":[],".html":[]}
  	  , envRequire = typeof require === 'function' ? require : null;
  
  	notFoundError = function (path) {
  		var error = new Error("Could not find module '" + path + "'");
  		error.code = 'MODULE_NOT_FOUND';
  		return error;
  	};
  	findFile = function (scope, name, extName) {
  		var i, ext;
  		if (typeof scope[name + extName] === 'function') return name + extName;
  		for (i = 0; (ext = extensions[extName][i]); ++i) {
  			if (typeof scope[name + ext] === 'function') return name + ext;
  		}
  		return null;
  	};
  	resolve = function (scope, tree, path, fullPath, state, id) {
  		var name, dir, exports, module, fn, found, ext;
  		path = path.split(/[\\/]/);
  		name = path.pop();
  		if ((name === '.') || (name === '..')) {
  			path.push(name);
  			name = '';
  		}
  		while ((dir = path.shift()) != null) {
  			if (!dir || (dir === '.')) continue;
  			if (dir === '..') {
  				scope = tree.pop();
  				id = id.slice(0, id.lastIndexOf('/'));
  			} else {
  				tree.push(scope);
  				scope = scope[dir];
  				id += '/' + dir;
  			}
  			if (!scope) throw notFoundError(fullPath);
  		}
  		if (name && (typeof scope[name] !== 'function')) {
  			found = findFile(scope, name, '.js');
  			if (!found) found = findFile(scope, name, '.json');
  			if (!found) found = findFile(scope, name, '.css');
  			if (!found) found = findFile(scope, name, '.html');
  			if (found) {
  				name = found;
  			} else if ((state !== 2) && (typeof scope[name] === 'object')) {
  				tree.push(scope);
  				scope = scope[name];
  				id += '/' + name;
  				name = '';
  			}
  		}
  		if (!name) {
  			if ((state !== 1) && scope[':mainpath:']) {
  				return resolve(scope, tree, scope[':mainpath:'], fullPath, 1, id);
  			}
  			return resolve(scope, tree, 'index', fullPath, 2, id);
  		}
  		fn = scope[name];
  		if (!fn) throw notFoundError(fullPath);
  		if (fn.hasOwnProperty('module')) return fn.module.exports;
  		exports = {};
  		fn.module = module = { exports: exports, id: id + '/' + name };
  		fn.call(exports, exports, module, getRequire(scope, tree, id));
  		return module.exports;
  	};
  	wmRequire = function (scope, tree, fullPath, id) {
  		var name, path = fullPath, t = fullPath.charAt(0), state = 0;
  		if (t === '/') {
  			path = path.slice(1);
  			scope = modules['/'];
  			if (!scope) {
  				if (envRequire) return envRequire(fullPath);
  				throw notFoundError(fullPath);
  			}
  			id = '/';
  			tree = [];
  		} else if (t !== '.') {
  			name = path.split('/', 1)[0];
  			scope = modules[name];
  			if (!scope) {
  				if (envRequire) return envRequire(fullPath);
  				throw notFoundError(fullPath);
  			}
  			id = name;
  			tree = [];
  			path = path.slice(name.length + 1);
  			if (!path) {
  				path = scope[':mainpath:'];
  				if (path) {
  					state = 1;
  				} else {
  					path = 'index';
  					state = 2;
  				}
  			}
  		}
  		return resolve(scope, tree, path, fullPath, state, id);
  	};
  	getRequire = function (scope, tree, id) {
  		return function (path) {
  			return wmRequire(scope, [].concat(tree), path, id);
  		};
  	};
  	return getRequire(modules, [], '');
  })({
  	"replicator": {
  		":mainpath:": "index.js",
  		"index.js": function (exports, module, require) {
  			
  
  			// 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 ARRAY_BUFFER_SUPPORTED = typeof ArrayBuffer === 'function';
  			var MAP_SUPPORTED = typeof Map === 'function';
  			var SET_SUPPORTED = typeof Set === 'function';
  
  			var TYPED_ARRAY_CTORS = ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'];
  
  			// Saved proto functions
  			var arrSlice = Array.prototype.slice;
  
  			// Default serializer
  			var JSONSerializer = {
  			    serialize: function serialize(val) {
  			        return JSON.stringify(val);
  			    },
  
  			    deserialize: function deserialize(val) {
  			        return JSON.parse(val);
  			    }
  			};
  
  			// EncodingTransformer
  			var EncodingTransformer = function EncodingTransformer(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 DecodingTransformer(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 get() {
  			            if (val === void 0) val = references[refIdx];
  
  			            return val;
  			        },
  
  			        set: function set(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 shouldTransform(type, val) {
  			        return type === 'number' && isNaN(val);
  			    },
  
  			    toSerializable: function toSerializable() {
  			        return '';
  			    },
  
  			    fromSerializable: function fromSerializable() {
  			        return NaN;
  			    }
  			}, {
  			    type: '[[undefined]]',
  
  			    shouldTransform: function shouldTransform(type) {
  			        return type === 'undefined';
  			    },
  
  			    toSerializable: function toSerializable() {
  			        return '';
  			    },
  
  			    fromSerializable: function fromSerializable() {
  			        return void 0;
  			    }
  			}, {
  			    type: '[[Date]]',
  
  			    shouldTransform: function shouldTransform(type, val) {
  			        return val instanceof Date;
  			    },
  
  			    toSerializable: function toSerializable(date) {
  			        return date.getTime();
  			    },
  
  			    fromSerializable: function fromSerializable(val) {
  			        var date = new Date();
  
  			        date.setTime(val);
  			        return date;
  			    }
  			}, {
  			    type: '[[RegExp]]',
  
  			    shouldTransform: function shouldTransform(type, val) {
  			        return val instanceof RegExp;
  			    },
  
  			    toSerializable: function toSerializable(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 fromSerializable(val) {
  			        return new RegExp(val.src, val.flags);
  			    }
  			}, {
  			    type: '[[Error]]',
  
  			    shouldTransform: function shouldTransform(type, val) {
  			        return val instanceof Error;
  			    },
  
  			    toSerializable: function toSerializable(err) {
  			        return {
  			            name: err.name,
  			            message: err.message,
  			            stack: err.stack
  			        };
  			    },
  
  			    fromSerializable: function fromSerializable(val) {
  			        var Ctor = GLOBAL[val.name] || Error;
  			        var err = new Ctor(val.message);
  
  			        err.stack = val.stack;
  			        return err;
  			    }
  			}, {
  			    type: '[[ArrayBuffer]]',
  
  			    shouldTransform: function shouldTransform(type, val) {
  			        return ARRAY_BUFFER_SUPPORTED && val instanceof ArrayBuffer;
  			    },
  
  			    toSerializable: function toSerializable(buffer) {
  			        var view = new Int8Array(buffer);
  
  			        return arrSlice.call(view);
  			    },
  
  			    fromSerializable: function fromSerializable(val) {
  			        if (ARRAY_BUFFER_SUPPORTED) {
  			            var buffer = new ArrayBuffer(val.length);
  			            var view = new Int8Array(buffer);
  
  			            view.set(val);
  
  			            return buffer;
  			        }
  
  			        return val;
  			    }
  			}, {
  			    type: '[[TypedArray]]',
  
  			    shouldTransform: function shouldTransform(type, val) {
  			        for (var i = 0; i < TYPED_ARRAY_CTORS.length; i++) {
  			            var ctorName = TYPED_ARRAY_CTORS[i];
  
  			            if (typeof GLOBAL[ctorName] === 'function' && val instanceof GLOBAL[ctorName]) return true;
  			        }
  
  			        return false;
  			    },
  
  			    toSerializable: function toSerializable(arr) {
  			        return {
  			            ctorName: arr.constructor.name,
  			            arr: arrSlice.call(arr)
  			        };
  			    },
  
  			    fromSerializable: function fromSerializable(val) {
  			        return typeof GLOBAL[val.ctorName] === 'function' ? new GLOBAL[val.ctorName](val.arr) : val.arr;
  			    }
  			}, {
  			    type: '[[Map]]',
  
  			    shouldTransform: function shouldTransform(type, val) {
  			        return MAP_SUPPORTED && val instanceof Map;
  			    },
  
  			    toSerializable: function toSerializable(map) {
  			        var flattenedKVArr = [];
  
  			        map.forEach(function (val, key) {
  			            flattenedKVArr.push(key);
  			            flattenedKVArr.push(val);
  			        });
  
  			        return flattenedKVArr;
  			    },
  
  			    fromSerializable: function fromSerializable(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 shouldTransform(type, val) {
  			        return SET_SUPPORTED && val instanceof Set;
  			    },
  
  			    toSerializable: function toSerializable(set) {
  			        var arr = [];
  
  			        set.forEach(function (val) {
  			            arr.push(val);
  			        });
  
  			        return arr;
  			    },
  
  			    fromSerializable: function fromSerializable(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();
  			};
  		}
  	},
  	"testcafe-release": {
  		"src": {
  			"client": {
  				"driver": {
  					"command-executors": {
  						"browser-manipulation": {
  							"ensure-crop-options.js": function (exports, module, require) {
  								
  
  								exports.__esModule = true;
  								exports.default = ensureCropOptions;
  
  								var _testcafeCore = require('../../deps/testcafe-core');
  
  								var _testcafeAutomation = require('../../deps/testcafe-automation');
  
  								var _limitNumber = require('../../../../utils/limit-number');
  
  								var _limitNumber2 = _interopRequireDefault(_limitNumber);
  
  								var _testRun = require('../../../../errors/test-run');
  
  								function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  								function determineDimensionBounds(bounds, maximum) {
  								    var hasMin = typeof bounds.min === 'number';
  								    var hasMax = typeof bounds.max === 'number';
  								    var hasLength = typeof bounds.length === 'number';
  
  								    if (hasLength) bounds.length = (0, _limitNumber2.default)(bounds.length, 0, maximum);
  
  								    if (hasMin && bounds.min < 0) bounds.min += maximum;
  
  								    if (hasMax && bounds.max < 0) bounds.max += maximum;
  
  								    if (!hasMin) bounds.min = hasMax && hasLength ? bounds.max - bounds.length : 0;
  
  								    if (!hasMax) bounds.max = hasLength ? bounds.min + bounds.length : maximum;
  
  								    bounds.min = (0, _limitNumber2.default)(bounds.min, 0, maximum);
  								    bounds.max = (0, _limitNumber2.default)(bounds.max, 0, maximum);
  								    bounds.length = bounds.max - bounds.min;
  
  								    return bounds;
  								}
  
  								function determineScrollPoint(cropStart, cropEnd, viewportBound) {
  								    return Math.round(cropStart + (0, _limitNumber2.default)(cropEnd - cropStart, 0, viewportBound) / 2);
  								}
  
  								function ensureCropOptions(element, options) {
  								    var elementRectangle = element.getBoundingClientRect();
  
  								    var elementBounds = {
  								        left: elementRectangle.left,
  								        right: elementRectangle.right,
  								        top: elementRectangle.top,
  								        bottom: elementRectangle.bottom
  								    };
  
  								    var elementMargin = _testcafeCore.styleUtils.getElementMargin(element);
  								    var elementPadding = _testcafeCore.styleUtils.getElementPadding(element);
  								    var elementBordersWidth = _testcafeCore.styleUtils.getBordersWidth(element);
  
  								    options.originOffset = { x: 0, y: 0 };
  
  								    var scrollRight = elementBounds.left + element.scrollWidth + elementBordersWidth.left + elementBordersWidth.right;
  								    var scrollBottom = elementBounds.top + element.scrollHeight + elementBordersWidth.top + elementBordersWidth.bottom;
  
  								    elementBounds.right = Math.max(elementBounds.right, scrollRight);
  								    elementBounds.bottom = Math.max(elementBounds.bottom, scrollBottom);
  
  								    if (!options.includeBorders || !options.includePaddings) {
  								        options.originOffset.x += elementBordersWidth.left;
  								        options.originOffset.y += elementBordersWidth.top;
  
  								        elementBounds.left += elementBordersWidth.left;
  								        elementBounds.top += elementBordersWidth.top;
  								        elementBounds.right -= elementBordersWidth.right;
  								        elementBounds.bottom -= elementBordersWidth.bottom;
  
  								        if (!options.includePaddings) {
  								            options.originOffset.x += elementPadding.left;
  								            options.originOffset.y += elementPadding.top;
  
  								            elementBounds.left += elementPadding.left;
  								            elementBounds.top += elementPadding.top;
  								            elementBounds.right -= elementPadding.right;
  								            elementBounds.bottom -= elementPadding.bottom;
  								        }
  								    } else if (options.includeMargins) {
  								        options.originOffset.x -= elementMargin.left;
  								        options.originOffset.y -= elementMargin.top;
  
  								        elementBounds.left -= elementMargin.left;
  								        elementBounds.top -= elementMargin.top;
  								        elementBounds.right += elementMargin.right;
  								        elementBounds.bottom += elementMargin.bottom;
  								    }
  
  								    elementBounds.width = elementBounds.right - elementBounds.left;
  								    elementBounds.height = elementBounds.bottom - elementBounds.top;
  
  								    var horizontalCropBounds = determineDimensionBounds({ min: options.crop.left, max: options.crop.right, length: options.crop.width }, elementBounds.width);
  								    var verticalCropBounds = determineDimensionBounds({ min: options.crop.top, max: options.crop.bottom, length: options.crop.height }, elementBounds.height);
  
  								    options.crop.left = horizontalCropBounds.min;
  								    options.crop.right = horizontalCropBounds.max;
  								    options.crop.width = horizontalCropBounds.length;
  
  								    options.crop.top = verticalCropBounds.min;
  								    options.crop.bottom = verticalCropBounds.max;
  								    options.crop.height = verticalCropBounds.length;
  
  								    if (options.crop.width <= 0 || options.crop.height <= 0) throw new _testRun.InvalidElementScreenshotDimensionsError(options.crop.width, options.crop.height);
  
  								    var viewportDimensions = _testcafeCore.styleUtils.getViewportDimensions();
  
  								    if (elementBounds.width > viewportDimensions.width || elementBounds.height > viewportDimensions.height) options.scrollToCenter = true;
  
  								    var hasScrollTargetX = typeof options.scrollTargetX === 'number';
  								    var hasScrollTargetY = typeof options.scrollTargetY === 'number';
  
  								    if (!hasScrollTargetX) options.scrollTargetX = determineScrollPoint(options.crop.left, options.crop.right, viewportDimensions.width);
  
  								    if (!hasScrollTargetY) options.scrollTargetY = determineScrollPoint(options.crop.top, options.crop.bottom, viewportDimensions.height);
  
  								    var _getOffsetOptions = (0, _testcafeAutomation.getOffsetOptions)(element, options.scrollTargetX, options.scrollTargetY),
  								        offsetX = _getOffsetOptions.offsetX,
  								        offsetY = _getOffsetOptions.offsetY;
  
  								    options.scrollTargetX = offsetX;
  								    options.scrollTargetY = offsetY;
  
  								    var isScrollTargetXValid = !hasScrollTargetX || options.scrollTargetX >= options.crop.left && options.scrollTargetX <= options.crop.right;
  								    var isScrollTargetYValid = !hasScrollTargetY || options.scrollTargetY >= options.crop.top && options.scrollTargetY <= options.crop.bottom;
  
  								    if (!isScrollTargetXValid || !isScrollTargetYValid) throw new _testRun.ActionInvalidScrollTargetError(isScrollTargetXValid, isScrollTargetYValid);
  								}
  								module.exports = exports['default'];
  							},
  							"index.js": function (exports, module, require) {
  								
  
  								exports.__esModule = true;
  
  								exports.default = function (command, globalSelectorTimeout, statusBar) {
  								    var manipulationExecutor = new ManipulationExecutor(command, globalSelectorTimeout, statusBar);
  
  								    return manipulationExecutor.execute();
  								};
  
  								var _hammerhead = require('../../deps/hammerhead');
  
  								var _testcafeCore = require('../../deps/testcafe-core');
  
  								var _testcafeAutomation = require('../../deps/testcafe-automation');
  
  								var _testcafeUi = require('../../deps/testcafe-ui');
  
  								var _status = require('../../status');
  
  								var _status2 = _interopRequireDefault(_status);
  
  								var _ensureCropOptions = require('./ensure-crop-options');
  
  								var _ensureCropOptions2 = _interopRequireDefault(_ensureCropOptions);
  
  								var _ensureElements = require('../../utils/ensure-elements');
  
  								var _runWithBarriers2 = require('../../utils/run-with-barriers');
  
  								var _runWithBarriers3 = _interopRequireDefault(_runWithBarriers2);
  
  								var _clientMessages = require('../../../../test-run/client-messages');
  
  								var _clientMessages2 = _interopRequireDefault(_clientMessages);
  
  								var _type = require('../../../../test-run/commands/type');
  
  								var _type2 = _interopRequireDefault(_type);
  
  								var _options = require('../../../../test-run/commands/options');
  
  								function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  								function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  								var messageSandbox = _hammerhead.eventSandbox.message;
  
  								var HIDING_UI_RELAYOUT_DELAY = 500;
  								var POSSIBLE_RESIZE_ERROR_DELAY = 200;
  
  								var MANIPULATION_REQUEST_CMD = 'driver|browser-manipulation|request';
  								var MANIPULATION_RESPONSE_CMD = 'driver|browser-manipulation|response';
  
  								// Setup cross-iframe interaction
  								messageSandbox.on(messageSandbox.SERVICE_MSG_RECEIVED_EVENT, function (e) {
  								    if (e.message.cmd === MANIPULATION_REQUEST_CMD) {
  								        var element = _testcafeCore.domUtils.findIframeByWindow(e.source);
  
  								        var _e$message = e.message,
  								            command = _e$message.command,
  								            cropDimensions = _e$message.cropDimensions;
  
  
  								        if (cropDimensions) command.options = new _options.ElementScreenshotOptions({ crop: cropDimensions, includePaddings: false });
  
  								        var manipulation = new ManipulationExecutor(command);
  
  								        manipulation.element = element;
  
  								        manipulation.execute().then(function (result) {
  								            return messageSandbox.sendServiceMsg({ cmd: MANIPULATION_RESPONSE_CMD, result: result }, e.source);
  								        });
  								    }
  								});
  
  								var ManipulationExecutor = function () {
  								    function ManipulationExecutor(command, globalSelectorTimeout, statusBar) {
  								        _classCallCheck(this, ManipulationExecutor);
  
  								        this.command = command;
  								        this.globalSelectorTimeout = globalSelectorTimeout;
  								        this.statusBar = statusBar;
  								        this.element = null;
  								    }
  
  								    ManipulationExecutor.prototype._getAbsoluteCropValues = function _getAbsoluteCropValues() {
  								        var _element$getBoundingC = this.element.getBoundingClientRect(),
  								            top = _element$getBoundingC.top,
  								            left = _element$getBoundingC.left;
  
  								        left += this.command.options.originOffset.x;
  								        top += this.command.options.originOffset.y;
  
  								        var right = left + this.command.options.crop.right;
  								        var bottom = top + this.command.options.crop.bottom;
  
  								        top += this.command.options.crop.top;
  								        left += this.command.options.crop.left;
  
  								        return { top: top, left: left, bottom: bottom, right: right };
  								    };
  
  								    ManipulationExecutor.prototype._createManipulationReadyMessage = function _createManipulationReadyMessage() {
  								        var dpr = window.devicePixelRatio || 1;
  
  								        var message = {
  								            cmd: _clientMessages2.default.readyForBrowserManipulation,
  
  								            pageDimensions: {
  								                dpr: dpr,
  								                innerWidth: window.innerWidth,
  								                innerHeight: window.innerHeight,
  								                documentWidth: document.documentElement.clientWidth,
  								                documentHeight: document.documentElement.clientHeight,
  								                bodyWidth: document.body.clientWidth,
  								                bodyHeight: document.body.clientHeight
  								            },
  
  								            disableResending: true
  								        };
  
  								        if (this.command.type === _type2.default.takeElementScreenshot) message.cropDimensions = this._getAbsoluteCropValues();
  
  								        return message;
  								    };
  
  								    ManipulationExecutor.prototype._runScrollBeforeScreenshot = function _runScrollBeforeScreenshot() {
  								        var _this = this;
  
  								        return _hammerhead.Promise.resolve().then(function () {
  								            if (_this.element || !_this.command.selector) return _hammerhead.Promise.resolve();
  
  								            var selectorTimeout = _this.command.selector.timeout;
  
  								            var specificSelectorTimeout = typeof selectorTimeout === 'number' ? selectorTimeout : _this.globalSelectorTimeout;
  
  								            _this.statusBar.showWaitingElementStatus(specificSelectorTimeout);
  
  								            return (0, _ensureElements.ensureElements)([(0, _ensureElements.createElementDescriptor)(_this.command.selector)], _this.globalSelectorTimeout).then(function (elements) {
  								                _this.statusBar.hideWaitingElementStatus();
  
  								                _this.element = elements[0];
  								            }).catch(function (error) {
  								                _this.statusBar.hideWaitingElementStatus();
  
  								                throw error;
  								            });
  								        }).then(function () {
  								            (0, _ensureCropOptions2.default)(_this.element, _this.command.options);
  
  								            var _command$options = _this.command.options,
  								                scrollTargetX = _command$options.scrollTargetX,
  								                scrollTargetY = _command$options.scrollTargetY,
  								                scrollToCenter = _command$options.scrollToCenter;
  
  
  								            var scrollAutomation = new _testcafeAutomation.Scroll(_this.element, new _options.ScrollOptions({
  								                offsetX: scrollTargetX,
  								                offsetY: scrollTargetY,
  								                scrollToCenter: scrollToCenter,
  								                skipParentFrames: true
  								            }));
  
  								            return scrollAutomation.run();
  								        });
  								    };
  
  								    ManipulationExecutor.prototype._hideUI = function _hideUI() {
  								        (0, _testcafeUi.hide)();
  
  								        if (this.command.markData) (0, _testcafeUi.showScreenshotMark)(this.command.markData);
  
  								        return (0, _testcafeCore.delay)(HIDING_UI_RELAYOUT_DELAY);
  								    };
  
  								    ManipulationExecutor.prototype._showUI = function _showUI() {
  								        if (this.command.markData) (0, _testcafeUi.hideScreenshotMark)();
  
  								        (0, _testcafeUi.show)();
  								    };
  
  								    ManipulationExecutor.prototype._requestManipulation = function _requestManipulation() {
  								        if (window.top === window) return _hammerhead.transport.queuedAsyncServiceMsg(this._createManipulationReadyMessage());
  
  								        var cropDimensions = this._getAbsoluteCropValues();
  
  								        var iframeRequestPromise = (0, _testcafeCore.sendRequestToFrame)({
  								            cmd: MANIPULATION_REQUEST_CMD,
  								            command: this.command,
  								            cropDimensions: cropDimensions
  								        }, MANIPULATION_RESPONSE_CMD, window.parent);
  
  								        return iframeRequestPromise.then(function (message) {
  								            if (!message.result) return { result: null };
  
  								            var _message$result = message.result,
  								                result = _message$result.result,
  								                executionError = _message$result.executionError;
  
  
  								            if (executionError) throw executionError;
  
  								            return { result: result };
  								        });
  								    };
  
  								    ManipulationExecutor.prototype._runManipulation = function _runManipulation() {
  								        var _this2 = this;
  
  								        var manipulationResult = null;
  
  								        return _hammerhead.Promise.resolve().then(function () {
  								            if (_this2.command.type !== _type2.default.takeElementScreenshot) return _hammerhead.Promise.resolve();
  
  								            _testcafeCore.scrollController.stopPropagation();
  
  								            return _this2._runScrollBeforeScreenshot();
  								        }).then(function () {
  								            if (window.top === window) return _this2._hideUI();
  
  								            return _hammerhead.Promise.resolve();
  								        }).then(function () {
  								            return _this2._requestManipulation();
  								        }).then(function (_ref) {
  								            var result = _ref.result,
  								                error = _ref.error;
  
  								            if (error) throw error;
  
  								            _testcafeCore.scrollController.enablePropagation();
  
  								            manipulationResult = result;
  
  								            if (window.top === window) _this2._showUI();
  
  								            return (0, _testcafeCore.delay)(POSSIBLE_RESIZE_ERROR_DELAY);
  								        }).then(function () {
  								            return new _status2.default({ isCommandResult: true, result: manipulationResult });
  								        }).catch(function (err) {
  								            _testcafeCore.scrollController.enablePropagation();
  
  								            return new _status2.default({ isCommandResult: true, executionError: err });
  								        });
  								    };
  
  								    ManipulationExecutor.prototype.execute = function execute() {
  								        var _this3 = this;
  
  								        var _runWithBarriers = (0, _runWithBarriers3.default)(function () {
  								            return _this3._runManipulation();
  								        }),
  								            barriersPromise = _runWithBarriers.barriersPromise;
  
  								        return barriersPromise;
  								    };
  
  								    return ManipulationExecutor;
  								}();
  
  								module.exports = exports['default'];
  							}
  						},
  						"client-functions": {
  							"client-function-executor.js": function (exports, module, require) {
  								
  
  								exports.__esModule = true;
  
  								var _hammerhead = require('../../deps/hammerhead');
  
  								var _status = require('../../status');
  
  								var _status2 = _interopRequireDefault(_status);
  
  								var _replicator = require('./replicator');
  
  								var _evalFunction = require('./eval-function');
  
  								var _evalFunction2 = _interopRequireDefault(_evalFunction);
  
  								var _testRun = require('../../../../errors/test-run');
  
  								function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  								function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  								var ClientFunctionExecutor = function () {
  								    function ClientFunctionExecutor(command) {
  								        _classCallCheck(this, ClientFunctionExecutor);
  
  								        this.command = command;
  								        this.replicator = this._createReplicator();
  								        this.dependencies = this.replicator.decode(this.command.dependencies);
  
  								        this.fn = (0, _evalFunction2.default)(this.command.fnCode, this.dependencies);
  								    }
  
  								    ClientFunctionExecutor.prototype.getResult = function getResult() {
  								        var _this = this;
  
  								        return _hammerhead.Promise.resolve().then(function () {
  								            var args = _this.replicator.decode(_this.command.args);
  
  								            return _this._executeFn(args);
  								        }).catch(function (err) {
  								            if (!err.isTestCafeError) err = new _testRun.UncaughtErrorInClientFunctionCode(_this.command.instantiationCallsiteName, err);
  
  								            throw err;
  								        });
  								    };
  
  								    ClientFunctionExecutor.prototype.getResultDriverStatus = function getResultDriverStatus() {
  								        var _this2 = this;
  
  								        return this.getResult().then(function (result) {
  								            return new _status2.default({
  								                isCommandResult: true,
  								                result: _this2.replicator.encode(result)
  								            });
  								        }).catch(function (err) {
  								            return new _status2.default({
  								                isCommandResult: true,
  								                executionError: err
  								            });
  								        });
  								    };
  
  								    //Overridable methods
  
  
  								    ClientFunctionExecutor.prototype._createReplicator = function _createReplicator() {
  								        return (0, _replicator.createReplicator)([new _replicator.ClientFunctionNodeTransform(this.command.instantiationCallsiteName), new _replicator.FunctionTransform()]);
  								    };
  
  								    ClientFunctionExecutor.prototype._executeFn = function _executeFn(args) {
  								        return this.fn.apply(window, args);
  								    };
  
  								    return ClientFunctionExecutor;
  								}();
  
  								exports.default = ClientFunctionExecutor;
  								module.exports = exports['default'];
  							},
  							"eval-function.js": function (exports, module, require) {
  								
  
  								exports.__esModule = true;
  								exports.default = evalFunction;
  
  								var _hammerhead = require('../../deps/hammerhead');
  
  								var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  								function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  								// NOTE: expose Promise to the function code
  								/* eslint-disable @typescript-eslint/no-unused-vars */
  								var Promise = _hammerhead2.default.Promise;
  								/* eslint-enable @typescript-eslint/no-unused-vars */
  
  								// 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.
  								/* eslint-disable @typescript-eslint/no-unused-vars */
  								function evalFunction(fnCode, __dependencies$) {
  								    // NOTE: `eval` in strict mode will not override context variables
  								    'use strict';
  
  								    /* eslint-disable no-eval */
  
  								    return eval(fnCode);
  								    /* eslint-enable no-eval */
  								}
  								/* eslint-enable @typescript-eslint/no-unused-vars */
  
  								module.exports = exports['default'];
  							},
  							"replicator.js": function (exports, module, require) {
  								
  
  								exports.__esModule = true;
  								exports.ClientFunctionNodeTransform = exports.SelectorNodeTransform = exports.FunctionTransform = undefined;
  								exports.createReplicator = createReplicator;
  
  								var _replicator = require('replicator');
  
  								var _replicator2 = _interopRequireDefault(_replicator);
  
  								var _evalFunction = require('./eval-function');
  
  								var _evalFunction2 = _interopRequireDefault(_evalFunction);
  
  								var _nodeSnapshots = require('./selector-executor/node-snapshots');
  
  								var _testRun = require('../../../../errors/test-run');
  
  								var _hammerhead = require('../../deps/hammerhead');
  
  								var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  								function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  								function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  								// NOTE: save original ctors because they may be overwritten by page code
  								var Node = window.Node;
  								var identity = function identity(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 = new _replicator2.default({
  								        serialize: identity,
  								        deserialize: identity
  								    });
  
  								    return replicator.addTransforms(transforms);
  								}
  
  								var FunctionTransform = exports.FunctionTransform = function () {
  								    function FunctionTransform() {
  								        _classCallCheck(this, FunctionTransform);
  
  								        this.type = 'Function';
  								    }
  
  								    FunctionTransform.prototype.shouldTransform = function shouldTransform(type) {
  								        return type === 'function';
  								    };
  
  								    FunctionTransform.prototype.toSerializable = function toSerializable() {
  								        return '';
  								    };
  
  								    FunctionTransform.prototype.fromSerializable = function fromSerializable(_ref) {
  								        var fnCode = _ref.fnCode,
  								            dependencies = _ref.dependencies;
  
  								        return (0, _evalFunction2.default)(fnCode, dependencies);
  								    };
  
  								    return FunctionTransform;
  								}();
  
  								var SelectorNodeTransform = exports.SelectorNodeTransform = function () {
  								    function SelectorNodeTransform(customDOMProperties) {
  								        _classCallCheck(this, SelectorNodeTransform);
  
  								        this.type = 'Node';
  								        this.customDOMProperties = customDOMProperties || {};
  								    }
  
  								    SelectorNodeTransform.prototype._extend = function _extend(snapshot, node) {
  								        var _this = this;
  
  								        _hammerhead2.default.nativeMethods.objectKeys.call(window.Object, this.customDOMProperties).forEach(function (prop) {
  								            try {
  								                snapshot[prop] = _this.customDOMProperties[prop](node);
  								            } catch (err) {
  								                throw new _testRun.UncaughtErrorInCustomDOMPropertyCode(_this.instantiationCallsiteName, err, prop);
  								            }
  								        });
  								    };
  
  								    SelectorNodeTransform.prototype.shouldTransform = function shouldTransform(type, val) {
  								        return val instanceof Node;
  								    };
  
  								    SelectorNodeTransform.prototype.toSerializable = function toSerializable(node) {
  								        var snapshot = node.nodeType === 1 ? new _nodeSnapshots.ElementSnapshot(node) : new _nodeSnapshots.NodeSnapshot(node);
  
  								        this._extend(snapshot, node);
  
  								        return snapshot;
  								    };
  
  								    return SelectorNodeTransform;
  								}();
  
  								var ClientFunctionNodeTransform = exports.ClientFunctionNodeTransform = function () {
  								    function ClientFunctionNodeTransform(instantiationCallsiteName) {
  								        _classCallCheck(this, ClientFunctionNodeTransform);
  
  								        this.type = 'Node';
  								        this.instantiationCallsiteName = instantiationCallsiteName;
  								    }
  
  								    ClientFunctionNodeTransform.prototype.shouldTransform = function shouldTransform(type, val) {
  								        if (val instanceof Node) throw new _testRun.DomNodeClientFunctionResultError(this.instantiationCallsiteName);
  								    };
  
  								    return ClientFunctionNodeTransform;
  								}();
  							},
  							"selector-executor": {
  								"filter.js": function (exports, module, require) {
  									
  
  									var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  									var _FILTER_ERROR_TO_API_;
  
  									var _testRun = require('../../../../../errors/test-run');
  
  									var _elementUtils = require('../../../utils/element-utils');
  
  									var _testcafeCore = require('../../../deps/testcafe-core');
  
  									var _testcafeCore2 = _interopRequireDefault(_testcafeCore);
  
  									var _hammerhead = require('../../../deps/hammerhead');
  
  									var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  									function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  									function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  									var arrayUtils = _testcafeCore2.default.arrayUtils;
  									var typeUtils = _hammerhead2.default.utils.types;
  									var nativeMethods = _hammerhead2.default.nativeMethods;
  
  									var SELECTOR_FILTER_ERROR = {
  									    filterVisible: 1,
  									    filterHidden: 2,
  									    nth: 3
  									};
  
  									var FILTER_ERROR_TO_API_RE = (_FILTER_ERROR_TO_API_ = {}, _FILTER_ERROR_TO_API_[SELECTOR_FILTER_ERROR.filterVisible] = /^\.filterVisible\(\)$/, _FILTER_ERROR_TO_API_[SELECTOR_FILTER_ERROR.filterHidden] = /^\.filterHidden\(\)$/, _FILTER_ERROR_TO_API_[SELECTOR_FILTER_ERROR.nth] = /^\.nth\(\d+\)$/, _FILTER_ERROR_TO_API_);
  
  									var SelectorFilter = function () {
  									    function SelectorFilter() {
  									        _classCallCheck(this, SelectorFilter);
  
  									        this.err = null;
  									    }
  
  									    SelectorFilter.prototype.filter = function filter(node, options, apiInfo) {
  									        var filtered = arrayUtils.filter(node, _elementUtils.exists);
  
  									        if (options.filterVisible) {
  									            filtered = filtered.filter(_elementUtils.visible);
  
  									            this.assertFilterError(filtered, apiInfo, SELECTOR_FILTER_ERROR.filterVisible);
  									        }
  
  									        if (options.filterHidden) {
  									            filtered = filtered.filter(function (n) {
  									                return !(0, _elementUtils.visible)(n);
  									            });
  
  									            this.assertFilterError(filtered, apiInfo, SELECTOR_FILTER_ERROR.filterHidden);
  									        }
  
  									        if (options.counterMode) {
  									            if (options.index !== null) filtered = this.getNodeByIndex(filtered, options.index) ? 1 : 0;else filtered = filtered.length;
  									        } else {
  									            if (options.collectionMode) {
  									                if (options.index !== null) {
  									                    var nodeOnIndex = this.getNodeByIndex(filtered, options.index);
  
  									                    filtered = nodeOnIndex ? [nodeOnIndex] : [];
  									                }
  									            } else filtered = this.getNodeByIndex(filtered, options.index || 0);
  
  									            if (typeof options.index === 'number') this.assertFilterError(filtered, apiInfo, SELECTOR_FILTER_ERROR.nth);
  									        }
  
  									        return filtered;
  									    };
  
  									    SelectorFilter.prototype.cast = function cast(node) {
  									        var result = null;
  
  									        if (typeUtils.isNullOrUndefined(node)) result = [];else if (node instanceof Node) result = [node];else if ((0, _elementUtils.IsNodeCollection)(node)) result = node;else throw new _testRun.InvalidSelectorResultError();
  
  									        return result;
  									    };
  
  									    SelectorFilter.prototype.assertFilterError = function assertFilterError(filtered, apiInfo, filterError) {
  									        if (!filtered || filtered.length === 0) this.error = this.getErrorItem(apiInfo, filterError);
  									    };
  
  									    SelectorFilter.prototype.getErrorItem = function getErrorItem(_ref, err) {
  									        var apiFnChain = _ref.apiFnChain,
  									            apiFnID = _ref.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.prototype.getNodeByIndex = function getNodeByIndex(collection, index) {
  									        return index < 0 ? collection[collection.length + index] : collection[index];
  									    };
  
  									    _createClass(SelectorFilter, [{
  									        key: 'error',
  									        get: function get() {
  									            return this.err;
  									        },
  									        set: function set(message) {
  									            if (this.err === null) this.err = message;
  									        }
  									    }]);
  
  									    return SelectorFilter;
  									}();
  
  									// Selector filter
  
  
  									nativeMethods.objectDefineProperty.call(window, window, '%testCafeSelectorFilter%', {
  									    value: new SelectorFilter(),
  									    configurable: true
  									});
  								},
  								"index.js": function (exports, module, require) {
  									
  
  									exports.__esModule = true;
  
  									var _hammerhead = require('../../../deps/hammerhead');
  
  									var _testcafeCore = require('../../../deps/testcafe-core');
  
  									var _clientFunctionExecutor = require('../client-function-executor');
  
  									var _clientFunctionExecutor2 = _interopRequireDefault(_clientFunctionExecutor);
  
  									var _elementUtils = require('../../../utils/element-utils');
  
  									var _replicator = require('../replicator');
  
  									require('./filter');
  
  									function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  									function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  									function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  									function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  									var CHECK_ELEMENT_DELAY = 200;
  
  									var SelectorExecutor = function (_ClientFunctionExecut) {
  									    _inherits(SelectorExecutor, _ClientFunctionExecut);
  
  									    function SelectorExecutor(command, globalTimeout, startTime, createNotFoundError, createIsInvisibleError) {
  									        _classCallCheck(this, SelectorExecutor);
  
  									        var _this = _possibleConstructorReturn(this, _ClientFunctionExecut.call(this, command));
  
  									        _this.createNotFoundError = createNotFoundError;
  									        _this.createIsInvisibleError = createIsInvisibleError;
  									        _this.timeout = typeof command.timeout === 'number' ? command.timeout : globalTimeout;
  									        _this.counterMode = _this.dependencies.filterOptions.counterMode;
  
  									        if (startTime) {
  									            var elapsed = new Date() - startTime;
  
  									            _this.timeout = Math.max(_this.timeout - elapsed, 0);
  									        }
  
  									        var customDOMProperties = _this.dependencies && _this.dependencies.customDOMProperties;
  
  									        _this.replicator.addTransforms([new _replicator.SelectorNodeTransform(customDOMProperties)]);
  									        return _this;
  									    }
  
  									    SelectorExecutor.prototype._createReplicator = function _createReplicator() {
  									        return (0, _replicator.createReplicator)([new _replicator.FunctionTransform()]);
  									    };
  
  									    SelectorExecutor.prototype._getTimeoutErrorParams = function _getTimeoutErrorParams() {
  									        var apiFnIndex = window['%testCafeSelectorFilter%'].error;
  									        var apiFnChain = this.command.apiFnChain;
  
  									        if (typeof apiFnIndex !== 'undefined') return { apiFnIndex: apiFnIndex, apiFnChain: apiFnChain };
  
  									        return null;
  									    };
  
  									    SelectorExecutor.prototype._validateElement = function _validateElement(args, startTime) {
  									        var _this2 = this;
  
  									        return _hammerhead.Promise.resolve().then(function () {
  									            return _this2.fn.apply(window, args);
  									        }).then(function (el) {
  									            var isElementExists = (0, _elementUtils.exists)(el);
  									            var isElementVisible = !_this2.command.visibilityCheck || (0, _elementUtils.visible)(el);
  									            var createTimeoutError = !isElementExists ? _this2.createNotFoundError : _this2.createIsInvisibleError;
  									            var isTimeout = new Date() - startTime >= _this2.timeout;
  
  									            if (isElementExists && isElementVisible) return el;
  
  									            if (!isTimeout) return (0, _testcafeCore.delay)(CHECK_ELEMENT_DELAY).then(function () {
  									                return _this2._validateElement(args, startTime);
  									            });
  
  									            if (createTimeoutError) throw createTimeoutError(_this2._getTimeoutErrorParams());
  
  									            return null;
  									        });
  									    };
  
  									    SelectorExecutor.prototype._executeFn = function _executeFn(args) {
  									        if (this.counterMode) return _ClientFunctionExecut.prototype._executeFn.call(this, args);
  
  									        var startTime = new Date();
  									        var error = null;
  									        var element = null;
  
  									        return this._validateElement(args, startTime).catch(function (err) {
  									            error = err;
  									        }).then(function (el) {
  									            if (error) throw error;
  
  									            element = el;
  									        }).then(function () {
  									            return element;
  									        });
  									    };
  
  									    return SelectorExecutor;
  									}(_clientFunctionExecutor2.default);
  
  									exports.default = SelectorExecutor;
  									module.exports = exports['default'];
  								},
  								"node-snapshots.js": function (exports, module, require) {
  									
  
  									exports.__esModule = true;
  									exports.ElementSnapshot = exports.NodeSnapshot = undefined;
  
  									var _testcafeCore = require('../../../deps/testcafe-core');
  
  									var _snapshotProperties = require('../../../../../client-functions/selectors/snapshot-properties');
  
  									function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  									function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  									function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  									// Node
  									var nodeSnapshotPropertyInitializers = {
  									    // eslint-disable-next-line no-restricted-properties
  									    textContent: function textContent(node) {
  									        return node.textContent;
  									    },
  									    childNodeCount: function childNodeCount(node) {
  									        return node.childNodes.length;
  									    },
  									    hasChildNodes: function hasChildNodes(node) {
  									        return !!nodeSnapshotPropertyInitializers.childNodeCount(node);
  									    },
  
  									    childElementCount: function childElementCount(node) {
  									        /*eslint-disable no-restricted-properties*/
  									        var children = node.children;
  
  									        if (children) return children.length;
  
  									        // NOTE: IE doesn't have `children` for non-element nodes =/
  									        var childElementCount = 0;
  									        var childNodeCount = node.childNodes.length;
  									        /*eslint-enable no-restricted-properties*/
  
  									        for (var i = 0; i < childNodeCount; i++) {
  									            if (node.childNodes[i].nodeType === 1) childElementCount++;
  									        }
  
  									        return childElementCount;
  									    },
  
  									    /*eslint-disable no-restricted-properties*/
  									    hasChildElements: function hasChildElements(node) {
  									        return !!nodeSnapshotPropertyInitializers.childElementCount(node);
  									    }
  									    /*eslint-enable no-restricted-properties*/
  									};
  
  									var NodeSnapshot = exports.NodeSnapshot = function () {
  									    function NodeSnapshot(node) {
  									        _classCallCheck(this, NodeSnapshot);
  
  									        this._initializeProperties(node, _snapshotProperties.NODE_SNAPSHOT_PROPERTIES, nodeSnapshotPropertyInitializers);
  									    }
  
  									    NodeSnapshot.prototype._initializeProperties = function _initializeProperties(node, properties, initializers) {
  									        for (var i = 0; i < properties.length; i++) {
  									            var property = properties[i];
  									            var initializer = initializers[property];
  
  									            this[property] = initializer ? initializer(node) : node[property];
  									        }
  									    };
  
  									    return NodeSnapshot;
  									}();
  
  									// Element
  
  
  									var elementSnapshotPropertyInitializers = {
  									    tagName: function tagName(element) {
  									        return element.tagName.toLowerCase();
  									    },
  									    visible: _testcafeCore.positionUtils.isElementVisible,
  									    focused: function focused(element) {
  									        return _testcafeCore.domUtils.getActiveElement() === element;
  									    },
  
  									    attributes: function attributes(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 boundingClientRect(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 classNames(element) {
  									        var className = element.className;
  
  									        className = typeof className.animVal === 'string' ? className.animVal : className;
  
  									        return className.replace(/^\s+|\s+$/g, '').split(/\s+/g);
  									    },
  
  									    style: function style(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 innerText(element) {
  									        return element.innerText;
  									    }
  									};
  
  									var ElementSnapshot = exports.ElementSnapshot = function (_NodeSnapshot) {
  									    _inherits(ElementSnapshot, _NodeSnapshot);
  
  									    function ElementSnapshot(element) {
  									        _classCallCheck(this, ElementSnapshot);
  
  									        var _this = _possibleConstructorReturn(this, _NodeSnapshot.call(this, element));
  
  									        _this._initializeProperties(element, _snapshotProperties.ELEMENT_SNAPSHOT_PROPERTIES, elementSnapshotPropertyInitializers);
  									        return _this;
  									    }
  
  									    return ElementSnapshot;
  									}(NodeSnapshot);
  								}
  							}
  						},
  						"execute-action.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.default = executeAction;
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _testcafeCore = require('../deps/testcafe-core');
  
  							var _testcafeAutomation = require('../deps/testcafe-automation');
  
  							var _status = require('../status');
  
  							var _status2 = _interopRequireDefault(_status);
  
  							var _runWithBarriers2 = require('../utils/run-with-barriers');
  
  							var _runWithBarriers3 = _interopRequireDefault(_runWithBarriers2);
  
  							var _ensureElements = require('../utils/ensure-elements');
  
  							var _testRun = require('../../../errors/test-run');
  
  							var _type = require('../../../test-run/commands/type');
  
  							var _type2 = _interopRequireDefault(_type);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  							// Ensure command element properties
  							function ensureElementEditable(element) {
  							    if (!_testcafeCore.domUtils.isEditableElement(element)) throw new _testRun.ActionElementNonEditableError();
  							}
  
  							function ensureTextAreaElement(element) {
  							    if (!_testcafeCore.domUtils.isTextAreaElement(element)) throw new _testRun.ActionElementNotTextAreaError();
  							}
  
  							function ensureContentEditableElement(element, argumentTitle) {
  							    if (!_testcafeCore.domUtils.isContentEditableElement(element)) throw new _testRun.ActionElementNonContentEditableError(argumentTitle);
  							}
  
  							function ensureRootContainer(elements) {
  							    // NOTE: We should find a common element for the nodes to perform the select action
  							    if (!_testcafeCore.contentEditable.getNearestCommonAncestor(elements[0], elements[1])) throw new _testRun.ActionRootContainerNotFoundError();
  
  							    return elements;
  							}
  
  							function ensureFileInput(element) {
  							    if (!_testcafeCore.domUtils.isFileInput(element)) throw new _testRun.ActionElementIsNotFileInputError();
  							}
  
  							function ensureOffsetOptions(element, options) {
  							    var _getOffsetOptions = (0, _testcafeAutomation.getOffsetOptions)(element, options.offsetX, options.offsetY),
  							        offsetX = _getOffsetOptions.offsetX,
  							        offsetY = _getOffsetOptions.offsetY;
  
  							    options.offsetX = offsetX;
  							    options.offsetY = offsetY;
  							}
  
  							var MAX_DELAY_AFTER_EXECUTION = 2000;
  							var CHECK_ELEMENT_IN_AUTOMATIONS_INTERVAL = 250;
  
  							var ActionExecutor = function () {
  							    function ActionExecutor(command, globalSelectorTimeout, statusBar, testSpeed) {
  							        _classCallCheck(this, ActionExecutor);
  
  							        this.command = command;
  							        this.globalSelectorTimeout = globalSelectorTimeout;
  							        this.statusBar = statusBar;
  							        this.testSpeed = testSpeed;
  
  							        this.elements = [];
  							        this.ensureElementsPromise = null;
  							        this.ensureElementsStartTime = null;
  
  							        this.executionStartTime = null;
  							        this.executionStartedHandler = null;
  							        this.commandSelectorTimeout = null;
  							    }
  
  							    ActionExecutor.prototype._getSpecificTimeout = function _getSpecificTimeout() {
  							        var hasSpecificTimeout = this.command.selector && typeof this.command.selector.timeout === 'number';
  
  							        return hasSpecificTimeout ? this.command.selector.timeout : this.globalSelectorTimeout;
  							    };
  
  							    ActionExecutor.prototype._delayAfterExecution = function _delayAfterExecution() {
  							        if (!this.command.options || this.command.options.speed === 1) return _hammerhead.Promise.resolve();
  
  							        return (0, _testcafeCore.delay)((1 - this.command.options.speed) * MAX_DELAY_AFTER_EXECUTION);
  							    };
  
  							    ActionExecutor.prototype._isExecutionTimeoutExpired = function _isExecutionTimeoutExpired() {
  							        return Date.now() - this.executionStartTime >= this.commandSelectorTimeout;
  							    };
  
  							    ActionExecutor.prototype._ensureCommandArguments = function _ensureCommandArguments() {
  							        if (this.command.type === _type2.default.pressKey) {
  							            var parsedKeySequence = (0, _testcafeCore.parseKeySequence)(this.command.keys);
  
  							            if (parsedKeySequence.error) throw new _testRun.ActionIncorrectKeysError('keys');
  							        }
  							    };
  
  							    ActionExecutor.prototype._ensureCommandElements = function _ensureCommandElements() {
  							        var _this = this;
  
  							        var elementDescriptors = [];
  
  							        if (this.command.selector) elementDescriptors.push((0, _ensureElements.createElementDescriptor)(this.command.selector));
  
  							        if (this.command.type === _type2.default.dragToElement) elementDescriptors.push((0, _ensureElements.createAdditionalElementDescriptor)(this.command.destinationSelector, 'destinationSelector'));else if (this.command.type === _type2.default.selectEditableContent) {
  							            elementDescriptors.push((0, _ensureElements.createAdditionalElementDescriptor)(this.command.startSelector, 'startSelector'));
  							            elementDescriptors.push((0, _ensureElements.createAdditionalElementDescriptor)(this.command.endSelector || this.command.startSelector, 'endSelector'));
  							        }
  
  							        return (0, _ensureElements.ensureElements)(elementDescriptors, this.globalSelectorTimeout).then(function (elements) {
  							            _this.elements = elements;
  							        });
  							    };
  
  							    ActionExecutor.prototype._ensureCommandElementsProperties = function _ensureCommandElementsProperties() {
  							        if (this.command.type === _type2.default.selectText) ensureElementEditable(this.elements[0]);else if (this.command.type === _type2.default.selectTextAreaContent) ensureTextAreaElement(this.elements[0]);else if (this.command.type === _type2.default.selectEditableContent) {
  							            ensureContentEditableElement(this.elements[0], 'startSelector');
  							            ensureContentEditableElement(this.elements[1], 'endSelector');
  							            ensureRootContainer(this.elements);
  							        } else if (this.command.type === _type2.default.setFilesToUpload || this.command.type === _type2.default.clearUpload) ensureFileInput(this.elements[0]);
  							    };
  
  							    ActionExecutor.prototype._ensureCommandOptions = function _ensureCommandOptions() {
  							        if (this.elements.length && this.command.options && 'offsetX' in this.command.options && 'offsetY' in this.command.options) ensureOffsetOptions(this.elements[0], this.command.options);
  							    };
  
  							    ActionExecutor.prototype._createAutomation = function _createAutomation() {
  							        var selectArgs = null;
  
  							        switch (this.command.type) {
  							            case _type2.default.click:
  							                if (/option|optgroup/.test(_testcafeCore.domUtils.getTagName(this.elements[0]))) return new _testcafeAutomation.SelectChildClick(this.elements[0], this.command.options);
  
  							                return new _testcafeAutomation.Click(this.elements[0], this.command.options);
  
  							            case _type2.default.rightClick:
  							                return new _testcafeAutomation.RClick(this.elements[0], this.command.options);
  
  							            case _type2.default.doubleClick:
  							                return new _testcafeAutomation.DblClick(this.elements[0], this.command.options);
  
  							            case _type2.default.hover:
  							                return new _testcafeAutomation.Hover(this.elements[0], this.command.options);
  
  							            case _type2.default.drag:
  							                return new _testcafeAutomation.DragToOffset(this.elements[0], this.command.dragOffsetX, this.command.dragOffsetY, this.command.options);
  
  							            case _type2.default.dragToElement:
  							                return new _testcafeAutomation.DragToElement(this.elements[0], this.elements[1], this.command.options);
  
  							            case _type2.default.typeText:
  							                // eslint-disable-next-line no-restricted-properties
  							                return new _testcafeAutomation.Type(this.elements[0], this.command.text, this.command.options);
  
  							            case _type2.default.selectText:
  							            case _type2.default.selectTextAreaContent:
  							                selectArgs = (0, _testcafeAutomation.calculateSelectTextArguments)(this.elements[0], this.command);
  
  							                return new _testcafeAutomation.SelectText(this.elements[0], selectArgs.startPos, selectArgs.endPos, this.command.options);
  
  							            case _type2.default.selectEditableContent:
  							                return new _testcafeAutomation.SelectEditableContent(this.elements[0], this.elements[1], this.command.options);
  
  							            case _type2.default.pressKey:
  							                return new _testcafeAutomation.Press((0, _testcafeCore.parseKeySequence)(this.command.keys).combinations, this.command.options);
  
  							            case _type2.default.setFilesToUpload:
  							                return new _testcafeAutomation.Upload(this.elements[0], this.command.filePath, function (filePaths) {
  							                    return new _testRun.ActionCannotFindFileToUploadError(filePaths);
  							                });
  
  							            case _type2.default.clearUpload:
  							                return new _testcafeAutomation.Upload(this.elements[0]);
  							        }
  
  							        return null;
  							    };
  
  							    ActionExecutor.prototype._runAction = function _runAction(strictElementCheck) {
  							        var _this2 = this;
  
  							        return this._ensureCommandElements().then(function () {
  							            return _this2._ensureCommandElementsProperties();
  							        }).then(function () {
  							            _this2._ensureCommandOptions();
  
  							            var automation = _this2._createAutomation();
  
  							            if (automation.TARGET_ELEMENT_FOUND_EVENT) {
  							                automation.on(automation.TARGET_ELEMENT_FOUND_EVENT, function () {
  							                    _this2.statusBar.hideWaitingElementStatus(true);
  							                    _this2.executionStartedHandler();
  							                });
  							            } else {
  							                _this2.statusBar.hideWaitingElementStatus(true);
  							                _this2.executionStartedHandler();
  							            }
  
  							            return automation.run(strictElementCheck);
  							        });
  							    };
  
  							    ActionExecutor.prototype._runRecursively = function _runRecursively() {
  							        var _this3 = this;
  
  							        var actionFinished = false;
  							        var strictElementCheck = true;
  
  							        return _testcafeCore.promiseUtils.whilst(function () {
  							            return !actionFinished;
  							        }, function () {
  							            return _this3._runAction(strictElementCheck).then(function () {
  							                actionFinished = true;
  							            }).catch(function (err) {
  							                if (_this3._isExecutionTimeoutExpired()) {
  							                    if (err.message === _testcafeAutomation.ERROR_TYPES.foundElementIsNotTarget) {
  							                        // If we can't get a target element via elementFromPoint but it's
  							                        // visible we click on the point where the element is located.
  							                        strictElementCheck = false;
  
  							                        return _hammerhead.Promise.resolve();
  							                    }
  
  							                    throw err.message === _testcafeAutomation.ERROR_TYPES.elementIsInvisibleError ? new _testRun.ActionElementIsInvisibleError() : err;
  							                }
  
  							                return (0, _testcafeCore.delay)(CHECK_ELEMENT_IN_AUTOMATIONS_INTERVAL);
  							            });
  							        });
  							    };
  
  							    ActionExecutor.prototype.execute = function execute() {
  							        var _this4 = this;
  
  							        if (this.command.options && !this.command.options.speed) this.command.options.speed = this.testSpeed;
  
  							        var startPromise = new _hammerhead.Promise(function (resolve) {
  							            _this4.executionStartedHandler = resolve;
  							        });
  
  							        var completionPromise = new _hammerhead.Promise(function (resolve) {
  							            _this4.executionStartTime = new Date();
  
  							            try {
  							                _this4._ensureCommandArguments();
  							            } catch (err) {
  							                resolve(new _status2.default({ isCommandResult: true, executionError: err }));
  							                return;
  							            }
  
  							            _this4.commandSelectorTimeout = _this4._getSpecificTimeout();
  
  							            _this4.statusBar.showWaitingElementStatus(_this4.commandSelectorTimeout);
  
  							            var _runWithBarriers = (0, _runWithBarriers3.default)(function () {
  							                return _this4._runRecursively();
  							            }),
  							                actionPromise = _runWithBarriers.actionPromise,
  							                barriersPromise = _runWithBarriers.barriersPromise;
  
  							            actionPromise.then(function () {
  							                return _hammerhead.Promise.all([_this4._delayAfterExecution(), barriersPromise]);
  							            }).then(function () {
  							                return resolve(new _status2.default({ isCommandResult: true }));
  							            }).catch(function (err) {
  							                return _this4.statusBar.hideWaitingElementStatus(false).then(function () {
  							                    return resolve(new _status2.default({ isCommandResult: true, executionError: err }));
  							                });
  							            });
  							        });
  
  							        return { startPromise: startPromise, completionPromise: completionPromise };
  							    };
  
  							    return ActionExecutor;
  							}();
  
  							function executeAction(command, globalSelectorTimeout, statusBar, testSpeed) {
  							    var actionExecutor = new ActionExecutor(command, globalSelectorTimeout, statusBar, testSpeed);
  
  							    return actionExecutor.execute();
  							}
  							module.exports = exports['default'];
  						},
  						"execute-navigate-to.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.default = executeNavigateTo;
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  							var _testcafeCore = require('../deps/testcafe-core');
  
  							var _status = require('../status');
  
  							var _status2 = _interopRequireDefault(_status);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							var createNativeXHR = _hammerhead2.default.createNativeXHR,
  							    utils = _hammerhead2.default.utils;
  							function executeNavigateTo(command) {
  							    var navigationUrl = utils.url.getNavigationUrl(command.url, window);
  
  							    var ensurePagePromise = _hammerhead2.default.Promise.resolve();
  
  							    if (navigationUrl && _testcafeCore.browser.isRetryingTestPagesEnabled()) ensurePagePromise = _testcafeCore.browser.fetchPageToCache(navigationUrl, createNativeXHR);
  
  							    return ensurePagePromise.then(function () {
  							        var requestBarrier = new _testcafeCore.RequestBarrier();
  
  							        _hammerhead2.default.navigateTo(command.url, command.forceReload);
  
  							        return _hammerhead2.default.Promise.all([requestBarrier.wait(), _testcafeCore.pageUnloadBarrier.wait()]);
  							    }).then(function () {
  							        return new _status2.default({ isCommandResult: true });
  							    }).catch(function (err) {
  							        return new _status2.default({ isCommandResult: true, executionError: err });
  							    });
  							}
  							module.exports = exports['default'];
  						},
  						"execute-selector.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.getResult = getResult;
  							exports.getResultDriverStatus = getResultDriverStatus;
  
  							var _selectorExecutor = require('./client-functions/selector-executor');
  
  							var _selectorExecutor2 = _interopRequireDefault(_selectorExecutor);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							function getResult(command, globalTimeout, startTime, createNotFoundError, createIsInvisibleError, statusBar) {
  							    var selectorExecutor = new _selectorExecutor2.default(command, globalTimeout, startTime, createNotFoundError, createIsInvisibleError);
  
  							    statusBar.showWaitingElementStatus(selectorExecutor.timeout);
  
  							    return selectorExecutor.getResult().then(function (el) {
  							        return statusBar.hideWaitingElementStatus(!!el).then(function () {
  							            return el;
  							        });
  							    }).catch(function (err) {
  							        return statusBar.hideWaitingElementStatus(false).then(function () {
  							            throw err;
  							        });
  							    });
  							}
  
  							function getResultDriverStatus(command, globalTimeout, startTime, createNotFoundError, createIsInvisibleError, statusBar) {
  							    var selectorExecutor = new _selectorExecutor2.default(command, globalTimeout, startTime, createNotFoundError, createIsInvisibleError);
  
  							    statusBar.showWaitingElementStatus(selectorExecutor.timeout);
  
  							    return selectorExecutor.getResultDriverStatus().then(function (status) {
  							        return statusBar.hideWaitingElementStatus(!!status.result).then(function () {
  							            return status;
  							        });
  							    });
  							}
  						}
  					},
  					"deps": {
  						"hammerhead.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.default = window['%hammerhead%'];
  							module.exports = exports['default'];
  						},
  						"testcafe-automation.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.default = window['%testCafeAutomation%'];
  							module.exports = exports['default'];
  						},
  						"testcafe-core.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.default = window['%testCafeCore%'];
  							module.exports = exports['default'];
  						},
  						"testcafe-ui.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.default = window['%testCafeUI%'];
  							module.exports = exports['default'];
  						}
  					},
  					"driver-link": {
  						"child.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  
  							var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _testcafeCore = require('../deps/testcafe-core');
  
  							var _testRun = require('../../../errors/test-run');
  
  							var _sendMessageToDriver = require('./send-message-to-driver');
  
  							var _sendMessageToDriver2 = _interopRequireDefault(_sendMessageToDriver);
  
  							var _messages = require('./messages');
  
  							var _status = require('../status');
  
  							var _status2 = _interopRequireDefault(_status);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  							var CHECK_IFRAME_EXISTENCE_INTERVAL = 1000;
  							var CHECK_IFRAME_VISIBLE_INTERVAL = 200;
  							var WAIT_IFRAME_RESPONSE_DELAY = 500;
  
  							var ChildDriverLink = function () {
  							    function ChildDriverLink(driverWindow, driverId) {
  							        _classCallCheck(this, ChildDriverLink);
  
  							        this.driverWindow = driverWindow;
  							        this.driverIframe = _testcafeCore.domUtils.findIframeByWindow(driverWindow);
  							        this.driverId = driverId;
  							        this.iframeAvailabilityTimeout = 0;
  							    }
  
  							    ChildDriverLink.prototype._ensureIframe = function _ensureIframe() {
  							        var _this = this;
  
  							        if (!_testcafeCore.domUtils.isElementInDocument(this.driverIframe)) return _hammerhead.Promise.reject(new _testRun.CurrentIframeNotFoundError());
  
  							        return (0, _testcafeCore.waitFor)(function () {
  							            return _testcafeCore.positionUtils.isElementVisible(_this.driverIframe) ? _this.driverIframe : null;
  							        }, CHECK_IFRAME_VISIBLE_INTERVAL, this.iframeAvailabilityTimeout).catch(function () {
  							            throw new _testRun.CurrentIframeIsInvisibleError();
  							        });
  							    };
  
  							    ChildDriverLink.prototype._waitForIframeRemovedOrHidden = function _waitForIframeRemovedOrHidden() {
  							        var _this2 = this;
  
  							        // NOTE: If an iframe was removed or became hidden while a
  							        // command was being executed, we consider this command finished.
  							        return new _hammerhead.Promise(function (resolve) {
  							            _this2.checkIframeInterval = _hammerhead.nativeMethods.setInterval.call(window, function () {
  							                _this2._ensureIframe().catch(function () {
  							                    // NOTE: wait for possible delayed iframe message
  							                    return (0, _testcafeCore.delay)(WAIT_IFRAME_RESPONSE_DELAY).then(function () {
  							                        return resolve(new _status2.default({ isCommandResult: true }));
  							                    });
  							                });
  							            }, CHECK_IFRAME_EXISTENCE_INTERVAL);
  							        });
  							    };
  
  							    ChildDriverLink.prototype._waitForCommandResult = function _waitForCommandResult() {
  							        var _this3 = this;
  
  							        var onMessage = null;
  
  							        var waitForResultMessage = function waitForResultMessage() {
  							            return new _hammerhead.Promise(function (resolve) {
  							                onMessage = function onMessage(e) {
  							                    if (e.message.type === _messages.TYPE.commandExecuted) resolve(e.message.driverStatus);
  							                };
  
  							                _hammerhead.eventSandbox.message.on(_hammerhead.eventSandbox.message.SERVICE_MSG_RECEIVED_EVENT, onMessage);
  							            });
  							        };
  
  							        return _hammerhead.Promise.race([this._waitForIframeRemovedOrHidden(), waitForResultMessage()]).then(function (status) {
  							            _hammerhead.eventSandbox.message.off(_hammerhead.eventSandbox.message.SERVICE_MSG_RECEIVED_EVENT, onMessage);
  							            _hammerhead.nativeMethods.clearInterval.call(window, _this3.checkIframeInterval);
  
  							            return status;
  							        });
  							    };
  
  							    ChildDriverLink.prototype.confirmConnectionEstablished = function confirmConnectionEstablished(requestMsgId) {
  							        var msg = new _messages.ConfirmationMessage(requestMsgId, { id: this.driverId });
  
  							        _hammerhead.eventSandbox.message.sendServiceMsg(msg, this.driverWindow);
  							    };
  
  							    ChildDriverLink.prototype.executeCommand = function executeCommand(command, testSpeed) {
  							        var _this4 = this;
  
  							        // NOTE:  We should check if the iframe is visible and exists before executing the next
  							        // command, because the iframe might be hidden or removed since the previous command.
  							        return this._ensureIframe().then(function () {
  							            var msg = new _messages.ExecuteCommandMessage(command, testSpeed);
  
  							            return _hammerhead.Promise.all([(0, _sendMessageToDriver2.default)(msg, _this4.driverWindow, _this4.iframeAvailabilityTimeout, _testRun.CurrentIframeIsNotLoadedError), _this4._waitForCommandResult()]);
  							        }).then(function (result) {
  							            return result[1];
  							        });
  							    };
  
  							    _createClass(ChildDriverLink, [{
  							        key: 'availabilityTimeout',
  							        set: function set(val) {
  							            this.iframeAvailabilityTimeout = val;
  							        }
  							    }]);
  
  							    return ChildDriverLink;
  							}();
  
  							exports.default = ChildDriverLink;
  							module.exports = exports['default'];
  						},
  						"messages.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.SetNativeDialogHandlerMessage = exports.ConfirmationMessage = exports.ExecuteCommandMessage = exports.CommandExecutedMessage = exports.EstablishConnectionMessage = exports.TYPE = undefined;
  
  							var _generateId = require('../generate-id');
  
  							var _generateId2 = _interopRequireDefault(_generateId);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  							function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  							function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  							var TYPE = exports.TYPE = {
  							    establishConnection: 'driver|establish-connection',
  							    commandExecuted: 'driver|command-executed',
  							    executeCommand: 'driver|execute-command',
  							    confirmation: 'driver|confirmation',
  							    setNativeDialogHandler: 'driver|set-native-dialog-handler'
  							};
  
  							var InterDriverMessage = function InterDriverMessage(type) {
  							    _classCallCheck(this, InterDriverMessage);
  
  							    this.type = type;
  							    this.id = (0, _generateId2.default)();
  							};
  
  							var EstablishConnectionMessage = exports.EstablishConnectionMessage = function (_InterDriverMessage) {
  							    _inherits(EstablishConnectionMessage, _InterDriverMessage);
  
  							    function EstablishConnectionMessage() {
  							        _classCallCheck(this, EstablishConnectionMessage);
  
  							        return _possibleConstructorReturn(this, _InterDriverMessage.call(this, TYPE.establishConnection));
  							    }
  
  							    return EstablishConnectionMessage;
  							}(InterDriverMessage);
  
  							var CommandExecutedMessage = exports.CommandExecutedMessage = function (_InterDriverMessage2) {
  							    _inherits(CommandExecutedMessage, _InterDriverMessage2);
  
  							    function CommandExecutedMessage(driverStatus) {
  							        _classCallCheck(this, CommandExecutedMessage);
  
  							        var _this2 = _possibleConstructorReturn(this, _InterDriverMessage2.call(this, TYPE.commandExecuted));
  
  							        _this2.driverStatus = driverStatus;
  							        return _this2;
  							    }
  
  							    return CommandExecutedMessage;
  							}(InterDriverMessage);
  
  							var ExecuteCommandMessage = exports.ExecuteCommandMessage = function (_InterDriverMessage3) {
  							    _inherits(ExecuteCommandMessage, _InterDriverMessage3);
  
  							    function ExecuteCommandMessage(command, testSpeed) {
  							        _classCallCheck(this, ExecuteCommandMessage);
  
  							        var _this3 = _possibleConstructorReturn(this, _InterDriverMessage3.call(this, TYPE.executeCommand));
  
  							        _this3.command = command;
  							        _this3.testSpeed = testSpeed;
  							        return _this3;
  							    }
  
  							    return ExecuteCommandMessage;
  							}(InterDriverMessage);
  
  							var ConfirmationMessage = exports.ConfirmationMessage = function (_InterDriverMessage4) {
  							    _inherits(ConfirmationMessage, _InterDriverMessage4);
  
  							    function ConfirmationMessage(requestMessageId, result) {
  							        _classCallCheck(this, ConfirmationMessage);
  
  							        var _this4 = _possibleConstructorReturn(this, _InterDriverMessage4.call(this, TYPE.confirmation));
  
  							        _this4.requestMessageId = requestMessageId;
  							        _this4.result = result;
  							        return _this4;
  							    }
  
  							    return ConfirmationMessage;
  							}(InterDriverMessage);
  
  							var SetNativeDialogHandlerMessage = exports.SetNativeDialogHandlerMessage = function (_InterDriverMessage5) {
  							    _inherits(SetNativeDialogHandlerMessage, _InterDriverMessage5);
  
  							    function SetNativeDialogHandlerMessage(dialogHandler) {
  							        _classCallCheck(this, SetNativeDialogHandlerMessage);
  
  							        var _this5 = _possibleConstructorReturn(this, _InterDriverMessage5.call(this, TYPE.setNativeDialogHandler));
  
  							        _this5.dialogHandler = dialogHandler;
  							        return _this5;
  							    }
  
  							    return SetNativeDialogHandlerMessage;
  							}(InterDriverMessage);
  						},
  						"parent.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _messages = require('./messages');
  
  							var _testRun = require('../../../errors/test-run');
  
  							var _sendMessageToDriver = require('./send-message-to-driver');
  
  							var _sendMessageToDriver2 = _interopRequireDefault(_sendMessageToDriver);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  							var WAIT_FOR_PARENT_DRIVER_RESPONSE_TIMEOUT = 5000;
  
  							var ParentDriverLink = function () {
  							    function ParentDriverLink(parentDriverWindow) {
  							        _classCallCheck(this, ParentDriverLink);
  
  							        this.driverWindow = parentDriverWindow;
  							    }
  
  							    ParentDriverLink.prototype.establishConnection = function establishConnection() {
  							        var msg = new _messages.EstablishConnectionMessage();
  
  							        return (0, _sendMessageToDriver2.default)(msg, this.driverWindow, WAIT_FOR_PARENT_DRIVER_RESPONSE_TIMEOUT, _testRun.CurrentIframeIsNotLoadedError).then(function (response) {
  							            return response.result.id;
  							        });
  							    };
  
  							    ParentDriverLink.prototype.confirmMessageReceived = function confirmMessageReceived(requestMsgId) {
  							        var msg = new _messages.ConfirmationMessage(requestMsgId);
  
  							        _hammerhead.eventSandbox.message.sendServiceMsg(msg, this.driverWindow);
  							    };
  
  							    ParentDriverLink.prototype.onCommandExecuted = function onCommandExecuted(status) {
  							        var msg = new _messages.CommandExecutedMessage(status);
  
  							        _hammerhead.eventSandbox.message.sendServiceMsg(msg, this.driverWindow);
  							    };
  
  							    return ParentDriverLink;
  							}();
  
  							exports.default = ParentDriverLink;
  							module.exports = exports['default'];
  						},
  						"send-message-to-driver.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.default = sendMessageToDriver;
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _testcafeCore = require('../deps/testcafe-core');
  
  							var _messages = require('./messages');
  
  							var MIN_RESPONSE_WAITING_TIMEOUT = 2500;
  							var RESEND_MESSAGE_INTERVAL = 1000;
  
  							function sendMessageToDriver(msg, driverWindow, timeout, NotLoadedErrorCtor) {
  							    var sendMsgInterval = null;
  							    var sendMsgTimeout = null;
  							    var onResponse = null;
  
  							    timeout = Math.max(timeout || 0, MIN_RESPONSE_WAITING_TIMEOUT);
  
  							    var sendAndWaitForResponse = function sendAndWaitForResponse() {
  							        return new _hammerhead.Promise(function (resolve) {
  							            onResponse = function onResponse(e) {
  							                if (e.message.type === _messages.TYPE.confirmation && e.message.requestMessageId === msg.id) resolve(e.message);
  							            };
  
  							            _hammerhead.eventSandbox.message.on(_hammerhead.eventSandbox.message.SERVICE_MSG_RECEIVED_EVENT, onResponse);
  
  							            sendMsgInterval = _hammerhead.nativeMethods.setInterval.call(window, function () {
  							                return _hammerhead.eventSandbox.message.sendServiceMsg(msg, driverWindow);
  							            }, RESEND_MESSAGE_INTERVAL);
  							            _hammerhead.eventSandbox.message.sendServiceMsg(msg, driverWindow);
  							        });
  							    };
  
  							    return _hammerhead.Promise.race([(0, _testcafeCore.delay)(timeout), sendAndWaitForResponse()]).then(function (response) {
  							        _hammerhead.nativeMethods.clearInterval.call(window, sendMsgInterval);
  							        _hammerhead.nativeMethods.clearTimeout.call(window, sendMsgTimeout);
  							        _hammerhead.eventSandbox.message.off(_hammerhead.eventSandbox.message.SERVICE_MSG_RECEIVED_EVENT, onResponse);
  
  							        if (!response) throw new NotLoadedErrorCtor();
  
  							        return response;
  							    });
  							}
  							module.exports = exports['default'];
  						}
  					},
  					"driver.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  
  						var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  						var _hammerhead = require('./deps/hammerhead');
  
  						var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  						var _testcafeCore = require('./deps/testcafe-core');
  
  						var _browserConnectionTimeouts = require('../../utils/browser-connection-timeouts');
  
  						var _testcafeUi = require('./deps/testcafe-ui');
  
  						var _clientMessages = require('../../test-run/client-messages');
  
  						var _clientMessages2 = _interopRequireDefault(_clientMessages);
  
  						var _type = require('../../test-run/commands/type');
  
  						var _type2 = _interopRequireDefault(_type);
  
  						var _utils = require('../../test-run/commands/utils');
  
  						var _testRun = require('../../errors/test-run');
  
  						var _browserConsoleMessages = require('../../test-run/browser-console-messages');
  
  						var _browserConsoleMessages2 = _interopRequireDefault(_browserConsoleMessages);
  
  						var _nativeDialogTracker = require('./native-dialog-tracker');
  
  						var _nativeDialogTracker2 = _interopRequireDefault(_nativeDialogTracker);
  
  						var _messages = require('./driver-link/messages');
  
  						var _storage = require('./storage');
  
  						var _storage2 = _interopRequireDefault(_storage);
  
  						var _status = require('./status');
  
  						var _status2 = _interopRequireDefault(_status);
  
  						var _generateId = require('./generate-id');
  
  						var _generateId2 = _interopRequireDefault(_generateId);
  
  						var _child = require('./driver-link/child');
  
  						var _child2 = _interopRequireDefault(_child);
  
  						var _executeAction = require('./command-executors/execute-action');
  
  						var _executeAction2 = _interopRequireDefault(_executeAction);
  
  						var _browserManipulation = require('./command-executors/browser-manipulation');
  
  						var _browserManipulation2 = _interopRequireDefault(_browserManipulation);
  
  						var _executeNavigateTo = require('./command-executors/execute-navigate-to');
  
  						var _executeNavigateTo2 = _interopRequireDefault(_executeNavigateTo);
  
  						var _executeSelector = require('./command-executors/execute-selector');
  
  						var _clientFunctionExecutor = require('./command-executors/client-functions/client-function-executor');
  
  						var _clientFunctionExecutor2 = _interopRequireDefault(_clientFunctionExecutor);
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  						var transport = _hammerhead2.default.transport;
  						var Promise = _hammerhead2.default.Promise;
  						var messageSandbox = _hammerhead2.default.eventSandbox.message;
  						var storages = _hammerhead2.default.storages;
  						var nativeMethods = _hammerhead2.default.nativeMethods;
  						var DateCtor = nativeMethods.date;
  
  						var TEST_DONE_SENT_FLAG = 'testcafe|driver|test-done-sent-flag';
  						var PENDING_STATUS = 'testcafe|driver|pending-status';
  						var EXECUTING_CLIENT_FUNCTION_DESCRIPTOR = 'testcafe|driver|executing-client-function-descriptor';
  						var SELECTOR_EXECUTION_START_TIME = 'testcafe|driver|selector-execution-start-time';
  						var PENDING_PAGE_ERROR = 'testcafe|driver|pending-page-error';
  						var ACTIVE_IFRAME_SELECTOR = 'testcafe|driver|active-iframe-selector';
  						var TEST_SPEED = 'testcafe|driver|test-speed';
  						var ASSERTION_RETRIES_TIMEOUT = 'testcafe|driver|assertion-retries-timeout';
  						var ASSERTION_RETRIES_START_TIME = 'testcafe|driver|assertion-retries-start-time';
  						var CONSOLE_MESSAGES = 'testcafe|driver|console-messages';
  
  						var ACTION_IFRAME_ERROR_CTORS = {
  						    NotLoadedError: _testRun.ActionIframeIsNotLoadedError,
  						    NotFoundError: _testRun.ActionElementNotFoundError,
  						    IsInvisibleError: _testRun.ActionElementIsInvisibleError
  						};
  
  						var CURRENT_IFRAME_ERROR_CTORS = {
  						    NotLoadedError: _testRun.CurrentIframeIsNotLoadedError,
  						    NotFoundError: _testRun.CurrentIframeNotFoundError,
  						    IsInvisibleError: _testRun.CurrentIframeIsInvisibleError
  						};
  
  						var Driver = function () {
  						    function Driver(testRunId, communicationUrls, runInfo, options) {
  						        var _this = this;
  
  						        _classCallCheck(this, Driver);
  
  						        this.COMMAND_EXECUTING_FLAG = 'testcafe|driver|command-executing-flag';
  						        this.EXECUTING_IN_IFRAME_FLAG = 'testcafe|driver|executing-in-iframe-flag';
  
  						        this.testRunId = testRunId;
  						        this.heartbeatUrl = communicationUrls.heartbeat;
  						        this.browserStatusUrl = communicationUrls.status;
  						        this.browserStatusDoneUrl = communicationUrls.statusDone;
  						        this.userAgent = runInfo.userAgent;
  						        this.fixtureName = runInfo.fixtureName;
  						        this.testName = runInfo.testName;
  						        this.selectorTimeout = options.selectorTimeout;
  						        this.pageLoadTimeout = options.pageLoadTimeout;
  						        this.initialSpeed = options.speed;
  						        this.skipJsErrors = options.skipJsErrors;
  						        this.dialogHandler = options.dialogHandler;
  
  						        this.customCommandHandlers = {};
  
  						        this.contextStorage = null;
  						        this.nativeDialogsTracker = null;
  
  						        this.childDriverLinks = [];
  						        this.activeChildDriverLink = null;
  
  						        this.statusBar = null;
  
  						        if (options.retryTestPages) _testcafeCore.browser.enableRetryingTestPages();
  
  						        this.pageInitialRequestBarrier = new _testcafeCore.RequestBarrier();
  
  						        this.readyPromise = _testcafeCore.eventUtils.documentReady(this.pageLoadTimeout).then(function () {
  						            return _this.pageInitialRequestBarrier.wait(true);
  						        });
  
  						        this._initChildDriverListening();
  
  						        _testcafeCore.pageUnloadBarrier.init();
  						        (0, _testcafeCore.preventRealEvents)();
  
  						        _hammerhead2.default.on(_hammerhead2.default.EVENTS.uncaughtJsError, function (err) {
  						            return _this._onJsError(err);
  						        });
  						        _hammerhead2.default.on(_hammerhead2.default.EVENTS.unhandledRejection, function (err) {
  						            return _this._onJsError(err);
  						        });
  						        _hammerhead2.default.on(_hammerhead2.default.EVENTS.consoleMethCalled, function (e) {
  						            return _this._onConsoleMessage(e);
  						        });
  						        _hammerhead2.default.on(_hammerhead2.default.EVENTS.beforeFormSubmit, function (e) {
  						            return _this._onFormSubmit(e);
  						        });
  
  						        this.setCustomCommandHandlers(_type2.default.unlockPage, function () {
  						            return _this._unlockPageAfterTestIsDone();
  						        });
  						    }
  
  						    // Error handling
  						    Driver.prototype._onJsError = function _onJsError(err) {
  						        // NOTE: we should not send any message to the server if we've
  						        // sent the 'test-done' message but haven't got the response.
  						        if (this.skipJsErrors || this.contextStorage.getItem(TEST_DONE_SENT_FLAG)) return Promise.resolve();
  
  						        var error = new _testRun.UncaughtErrorOnPage(err.stack, err.pageUrl);
  
  						        if (!this.contextStorage.getItem(PENDING_PAGE_ERROR)) this.contextStorage.setItem(PENDING_PAGE_ERROR, error);
  
  						        return null;
  						    };
  
  						    Driver.prototype._unlockPageAfterTestIsDone = function _unlockPageAfterTestIsDone() {
  						        (0, _testcafeCore.disableRealEventsPreventing)();
  
  						        return Promise.resolve();
  						    };
  
  						    Driver.prototype._failIfClientCodeExecutionIsInterrupted = function _failIfClientCodeExecutionIsInterrupted() {
  						        // NOTE: ClientFunction should be used primarily for observation. We raise
  						        // an error if the page was reloaded during ClientFunction execution.
  						        var executingClientFnDescriptor = this.contextStorage.getItem(EXECUTING_CLIENT_FUNCTION_DESCRIPTOR);
  
  						        if (executingClientFnDescriptor) {
  						            this._onReady(new _status2.default({
  						                isCommandResult: true,
  						                executionError: new _testRun.ClientFunctionExecutionInterruptionError(executingClientFnDescriptor.instantiationCallsiteName)
  						            }));
  
  						            return true;
  						        }
  
  						        return false;
  						    };
  
  						    Driver.prototype.onCustomClientScriptError = function onCustomClientScriptError(err, moduleName) {
  						        var error = moduleName ? new _testRun.UncaughtErrorInCustomClientScriptLoadedFromModule(err, moduleName) : new _testRun.UncaughtErrorInCustomClientScriptCode(err);
  
  						        if (!this.contextStorage.getItem(PENDING_PAGE_ERROR)) this.contextStorage.setItem(PENDING_PAGE_ERROR, error);
  						    };
  
  						    // HACK: For https://github.com/DevExpress/testcafe/issues/3560
  						    // We have to cancel every form submit after a test is done
  						    // to prevent requests to a closed session
  
  
  						    Driver.prototype._onFormSubmit = function _onFormSubmit(e) {
  						        if (this.contextStorage.getItem(TEST_DONE_SENT_FLAG)) e.preventSubmit = true;
  						    };
  
  						    // Console messages
  
  
  						    Driver.prototype._onConsoleMessage = function _onConsoleMessage(_ref) {
  						        var meth = _ref.meth,
  						            line = _ref.line;
  
  						        var messages = this.consoleMessages;
  
  						        messages.addMessage(meth, line);
  
  						        this.consoleMessages = messages;
  						    };
  
  						    // Status
  
  
  						    Driver.prototype._addPendingErrorToStatus = function _addPendingErrorToStatus(status) {
  						        var pendingPageError = this.contextStorage.getItem(PENDING_PAGE_ERROR);
  
  						        if (pendingPageError) {
  						            this.contextStorage.setItem(PENDING_PAGE_ERROR, null);
  						            status.pageError = pendingPageError;
  						        }
  						    };
  
  						    Driver.prototype._addUnexpectedDialogErrorToStatus = function _addUnexpectedDialogErrorToStatus(status) {
  						        var dialogError = this.nativeDialogsTracker.getUnexpectedDialogError();
  
  						        status.pageError = status.pageError || dialogError;
  						    };
  
  						    Driver.prototype._addConsoleMessagesToStatus = function _addConsoleMessagesToStatus(status) {
  						        status.consoleMessages = this.consoleMessages;
  						        this.consoleMessages = null;
  						    };
  
  						    Driver.prototype._sendStatusRequest = function _sendStatusRequest(status) {
  						        var statusRequestOptions = {
  						            cmd: _clientMessages2.default.ready,
  						            status: status,
  						            disableResending: true,
  						            allowRejecting: true
  						        };
  
  						        var requestAttempt = function requestAttempt() {
  						            return (0, _testcafeCore.getTimeLimitedPromise)(transport.asyncServiceMsg(statusRequestOptions), _browserConnectionTimeouts.SEND_STATUS_REQUEST_TIME_LIMIT);
  						        };
  						        var retryRequest = function retryRequest() {
  						            return (0, _testcafeCore.delay)(_browserConnectionTimeouts.SEND_STATUS_REQUEST_RETRY_DELAY).then(requestAttempt);
  						        };
  
  						        var statusPromise = requestAttempt();
  
  						        for (var i = 0; i < _browserConnectionTimeouts.SEND_STATUS_REQUEST_RETRY_COUNT; i++) {
  						            statusPromise = statusPromise.catch(retryRequest);
  						        }return statusPromise;
  						    };
  
  						    Driver.prototype._sendStatus = function _sendStatus(status) {
  						        var _this2 = this;
  
  						        // NOTE: We should not modify the status if it is resent after
  						        // the page load because the server has cached the response
  						        if (!status.resent) {
  						            this._addPendingErrorToStatus(status);
  						            this._addUnexpectedDialogErrorToStatus(status);
  						            this._addConsoleMessagesToStatus(status);
  						        }
  
  						        this.contextStorage.setItem(PENDING_STATUS, status);
  
  						        var readyCommandResponse = null;
  
  						        // NOTE: postpone status sending if the page is unloading
  						        return _testcafeCore.pageUnloadBarrier.wait(0).then(function () {
  						            return _this2._sendStatusRequest(status);
  						        })
  						        //NOTE: do not execute the next command if the page is unloading
  						        .then(function (res) {
  						            readyCommandResponse = res;
  
  						            return _testcafeCore.pageUnloadBarrier.wait(0);
  						        }).then(function () {
  						            _this2.contextStorage.setItem(PENDING_STATUS, null);
  
  						            return readyCommandResponse;
  						        });
  						    };
  
  						    // Iframes interaction
  
  
  						    Driver.prototype._initChildDriverListening = function _initChildDriverListening() {
  						        var _this3 = this;
  
  						        messageSandbox.on(messageSandbox.SERVICE_MSG_RECEIVED_EVENT, function (e) {
  						            var msg = e.message;
  						            var iframeWindow = e.source;
  
  						            if (msg.type === _messages.TYPE.establishConnection) {
  						                var childDriverLink = _this3._getChildDriverLinkByWindow(iframeWindow);
  
  						                if (!childDriverLink) {
  						                    var driverId = _this3.testRunId + '-' + (0, _generateId2.default)();
  
  						                    childDriverLink = new _child2.default(iframeWindow, driverId);
  						                    _this3.childDriverLinks.push(childDriverLink);
  						                }
  
  						                childDriverLink.confirmConnectionEstablished(msg.id);
  						            }
  						        });
  						    };
  
  						    Driver.prototype._getChildDriverLinkByWindow = function _getChildDriverLinkByWindow(driverWindow) {
  						        return this.childDriverLinks.filter(function (link) {
  						            return link.driverWindow === driverWindow;
  						        })[0];
  						    };
  
  						    Driver.prototype._runInActiveIframe = function _runInActiveIframe(command) {
  						        var _this4 = this;
  
  						        var runningChain = Promise.resolve();
  						        var activeIframeSelector = this.contextStorage.getItem(ACTIVE_IFRAME_SELECTOR);
  
  						        // NOTE: if the page was reloaded we restore the active child driver link via the iframe selector
  						        if (!this.activeChildDriverLink && activeIframeSelector) runningChain = this._switchToIframe(activeIframeSelector, CURRENT_IFRAME_ERROR_CTORS);
  
  						        runningChain.then(function () {
  						            _this4.contextStorage.setItem(_this4.EXECUTING_IN_IFRAME_FLAG, true);
  
  						            return _this4.activeChildDriverLink.executeCommand(command, _this4.speed);
  						        }).then(function (status) {
  						            return _this4._onCommandExecutedInIframe(status);
  						        }).catch(function (err) {
  						            return _this4._onCommandExecutedInIframe(new _status2.default({
  						                isCommandResult: true,
  						                executionError: err
  						            }));
  						        });
  						    };
  
  						    Driver.prototype._onCommandExecutedInIframe = function _onCommandExecutedInIframe(status) {
  						        this.contextStorage.setItem(this.EXECUTING_IN_IFRAME_FLAG, false);
  						        this._onReady(status);
  						    };
  
  						    Driver.prototype._ensureChildDriverLink = function _ensureChildDriverLink(iframeWindow, ErrorCtor, selectorTimeout) {
  						        var _this5 = this;
  
  						        // NOTE: a child driver should establish connection with the parent when it's loaded.
  						        // Here we are waiting while the appropriate child driver do this if it didn't do yet.
  						        return (0, _testcafeCore.waitFor)(function () {
  						            return _this5._getChildDriverLinkByWindow(iframeWindow);
  						        }, _browserConnectionTimeouts.CHECK_IFRAME_DRIVER_LINK_DELAY, selectorTimeout).catch(function () {
  						            throw new ErrorCtor();
  						        });
  						    };
  
  						    Driver.prototype._switchToIframe = function _switchToIframe(selector, iframeErrorCtors) {
  						        var _this6 = this;
  
  						        var hasSpecificTimeout = typeof selector.timeout === 'number';
  						        var commandSelectorTimeout = hasSpecificTimeout ? selector.timeout : this.selectorTimeout;
  
  						        return (0, _executeSelector.getResult)(selector, commandSelectorTimeout, null, function (fn) {
  						            return new iframeErrorCtors.NotFoundError(fn);
  						        }, function () {
  						            return new iframeErrorCtors.IsInvisibleError();
  						        }, this.statusBar).then(function (iframe) {
  						            if (!_testcafeCore.domUtils.isIframeElement(iframe)) throw new _testRun.ActionElementNotIframeError();
  
  						            return _this6._ensureChildDriverLink(nativeMethods.contentWindowGetter.call(iframe), iframeErrorCtors.NotLoadedError, commandSelectorTimeout);
  						        }).then(function (childDriverLink) {
  						            childDriverLink.availabilityTimeout = commandSelectorTimeout;
  						            _this6.activeChildDriverLink = childDriverLink;
  						            _this6.contextStorage.setItem(ACTIVE_IFRAME_SELECTOR, selector);
  						        });
  						    };
  
  						    Driver.prototype._switchToMainWindow = function _switchToMainWindow(command) {
  						        if (this.activeChildDriverLink) this.activeChildDriverLink.executeCommand(command);
  
  						        this.contextStorage.setItem(ACTIVE_IFRAME_SELECTOR, null);
  						        this.activeChildDriverLink = null;
  						    };
  
  						    Driver.prototype._setNativeDialogHandlerInIframes = function _setNativeDialogHandlerInIframes(dialogHandler) {
  						        var msg = new _messages.SetNativeDialogHandlerMessage(dialogHandler);
  
  						        for (var i = 0; i < this.childDriverLinks.length; i++) {
  						            messageSandbox.sendServiceMsg(msg, this.childDriverLinks[i].driverWindow);
  						        }
  						    };
  
  						    // Commands handling
  
  
  						    Driver.prototype._onActionCommand = function _onActionCommand(command) {
  						        var _this7 = this;
  
  						        var _executeActionCommand = (0, _executeAction2.default)(command, this.selectorTimeout, this.statusBar, this.speed),
  						            startPromise = _executeActionCommand.startPromise,
  						            completionPromise = _executeActionCommand.completionPromise;
  
  						        startPromise.then(function () {
  						            return _this7.contextStorage.setItem(_this7.COMMAND_EXECUTING_FLAG, true);
  						        });
  
  						        completionPromise.then(function (driverStatus) {
  						            _this7.contextStorage.setItem(_this7.COMMAND_EXECUTING_FLAG, false);
  
  						            return _this7._onReady(driverStatus);
  						        });
  						    };
  
  						    Driver.prototype._onSetNativeDialogHandlerCommand = function _onSetNativeDialogHandlerCommand(command) {
  						        this.nativeDialogsTracker.setHandler(command.dialogHandler);
  						        this._setNativeDialogHandlerInIframes(command.dialogHandler);
  
  						        this._onReady(new _status2.default({ isCommandResult: true }));
  						    };
  
  						    Driver.prototype._onGetNativeDialogHistoryCommand = function _onGetNativeDialogHistoryCommand() {
  						        this._onReady(new _status2.default({
  						            isCommandResult: true,
  						            result: this.nativeDialogsTracker.appearedDialogs
  						        }));
  						    };
  
  						    Driver.prototype._onGetBrowserConsoleMessagesCommand = function _onGetBrowserConsoleMessagesCommand() {
  						        this._onReady(new _status2.default({ isCommandResult: true }));
  						    };
  
  						    Driver.prototype._onNavigateToCommand = function _onNavigateToCommand(command) {
  						        var _this8 = this;
  
  						        this.contextStorage.setItem(this.COMMAND_EXECUTING_FLAG, true);
  
  						        (0, _executeNavigateTo2.default)(command).then(function (driverStatus) {
  						            _this8.contextStorage.setItem(_this8.COMMAND_EXECUTING_FLAG, false);
  
  						            return _this8._onReady(driverStatus);
  						        });
  						    };
  
  						    Driver.prototype._onExecuteClientFunctionCommand = function _onExecuteClientFunctionCommand(command) {
  						        var _this9 = this;
  
  						        this.contextStorage.setItem(EXECUTING_CLIENT_FUNCTION_DESCRIPTOR, { instantiationCallsiteName: command.instantiationCallsiteName });
  
  						        var executor = new _clientFunctionExecutor2.default(command);
  
  						        executor.getResultDriverStatus().then(function (driverStatus) {
  						            _this9.contextStorage.setItem(EXECUTING_CLIENT_FUNCTION_DESCRIPTOR, null);
  						            _this9._onReady(driverStatus);
  						        });
  						    };
  
  						    Driver.prototype._onExecuteSelectorCommand = function _onExecuteSelectorCommand(command) {
  						        var _this10 = this;
  
  						        var startTime = this.contextStorage.getItem(SELECTOR_EXECUTION_START_TIME) || new DateCtor();
  						        var elementNotFoundOrNotVisible = function elementNotFoundOrNotVisible(fn) {
  						            return new _testRun.CannotObtainInfoForElementSpecifiedBySelectorError(null, fn);
  						        };
  						        var createError = command.needError ? elementNotFoundOrNotVisible : null;
  
  						        (0, _executeSelector.getResultDriverStatus)(command, this.selectorTimeout, startTime, createError, createError, this.statusBar).then(function (driverStatus) {
  						            _this10.contextStorage.setItem(SELECTOR_EXECUTION_START_TIME, null);
  						            _this10._onReady(driverStatus);
  						        });
  						    };
  
  						    Driver.prototype._onSwitchToMainWindowCommand = function _onSwitchToMainWindowCommand(command) {
  						        this._switchToMainWindow(command);
  
  						        this._onReady(new _status2.default({ isCommandResult: true }));
  						    };
  
  						    Driver.prototype._onSwitchToIframeCommand = function _onSwitchToIframeCommand(command) {
  						        var _this11 = this;
  
  						        this._switchToIframe(command.selector, ACTION_IFRAME_ERROR_CTORS).then(function () {
  						            return _this11._onReady(new _status2.default({ isCommandResult: true }));
  						        }).catch(function (err) {
  						            return _this11._onReady(new _status2.default({
  						                isCommandResult: true,
  						                executionError: err
  						            }));
  						        });
  						    };
  
  						    Driver.prototype._onBrowserManipulationCommand = function _onBrowserManipulationCommand(command) {
  						        var _this12 = this;
  
  						        this.contextStorage.setItem(this.COMMAND_EXECUTING_FLAG, true);
  
  						        (0, _browserManipulation2.default)(command, this.selectorTimeout, this.statusBar).then(function (driverStatus) {
  						            _this12.contextStorage.setItem(_this12.COMMAND_EXECUTING_FLAG, false);
  						            return _this12._onReady(driverStatus);
  						        });
  						    };
  
  						    Driver.prototype._onSetBreakpointCommand = function _onSetBreakpointCommand(isTestError) {
  						        var _this13 = this;
  
  						        this.statusBar.showDebuggingStatus(isTestError).then(function (stopAfterNextAction) {
  						            return _this13._onReady(new _status2.default({
  						                isCommandResult: true,
  						                result: stopAfterNextAction
  						            }));
  						        });
  						    };
  
  						    Driver.prototype._onSetTestSpeedCommand = function _onSetTestSpeedCommand(command) {
  						        this.speed = command.speed;
  						        this._onReady(new _status2.default({ isCommandResult: true }));
  						    };
  
  						    Driver.prototype._onShowAssertionRetriesStatusCommand = function _onShowAssertionRetriesStatusCommand(command) {
  						        this.contextStorage.setItem(ASSERTION_RETRIES_TIMEOUT, command.timeout);
  						        this.contextStorage.setItem(ASSERTION_RETRIES_START_TIME, Date.now());
  
  						        this.statusBar.showWaitingAssertionRetriesStatus(command.timeout);
  						        this._onReady(new _status2.default({ isCommandResult: true }));
  						    };
  
  						    Driver.prototype._onHideAssertionRetriesStatusCommand = function _onHideAssertionRetriesStatusCommand(command) {
  						        var _this14 = this;
  
  						        this.contextStorage.setItem(ASSERTION_RETRIES_TIMEOUT, null);
  						        this.contextStorage.setItem(ASSERTION_RETRIES_START_TIME, null);
  
  						        this.statusBar.hideWaitingAssertionRetriesStatus(command.success).then(function () {
  						            return _this14._onReady(new _status2.default({ isCommandResult: true }));
  						        });
  						    };
  
  						    Driver.prototype._checkStatus = function _checkStatus() {
  						        var _this15 = this;
  
  						        return _testcafeCore.browser.checkStatus(this.browserStatusDoneUrl, _hammerhead2.default.createNativeXHR, { manualRedirect: true }).then(function (_ref2) {
  						            var command = _ref2.command,
  						                redirecting = _ref2.redirecting;
  
  						            var isSessionChange = redirecting && command.url.indexOf(_this15.testRunId) < 0;
  
  						            if (isSessionChange) {
  						                storages.clear();
  						                storages.lock();
  						            } else _this15.contextStorage.setItem(TEST_DONE_SENT_FLAG, false);
  
  						            if (redirecting) _testcafeCore.browser.redirect(command);else _this15._onReady({ isCommandResult: false });
  						        }).catch(function () {
  						            return (0, _testcafeCore.delay)(_browserConnectionTimeouts.CHECK_STATUS_RETRY_DELAY);
  						        });
  						    };
  
  						    Driver.prototype._onCustomCommand = function _onCustomCommand(command) {
  						        var _this16 = this;
  
  						        var handler = this.customCommandHandlers[command.type].handler;
  
  						        handler(command).then(function (result) {
  						            _this16._onReady(new _status2.default({ isCommandResult: true, result: result }));
  						        });
  						    };
  
  						    Driver.prototype._onTestDone = function _onTestDone(status) {
  						        var _this17 = this;
  
  						        this.contextStorage.setItem(TEST_DONE_SENT_FLAG, true);
  
  						        this._sendStatus(status).then(function () {
  						            return _this17._checkStatus();
  						        });
  						    };
  
  						    Driver.prototype._onBackupStoragesCommand = function _onBackupStoragesCommand() {
  						        this._onReady(new _status2.default({
  						            isCommandResult: true,
  						            result: storages.backup()
  						        }));
  						    };
  
  						    // Routing
  
  
  						    Driver.prototype._onReady = function _onReady(status) {
  						        var _this18 = this;
  
  						        this._sendStatus(status).then(function (command) {
  						            if (command) _this18._onCommand(command);
  
  						            // NOTE: the driver gets an empty response if TestRun doesn't get a new command within 2 minutes
  						            else _this18._onReady(new _status2.default());
  						        });
  						    };
  
  						    Driver.prototype._executeCommand = function _executeCommand(command) {
  						        if (this.customCommandHandlers[command.type]) this._onCustomCommand(command);else if (command.type === _type2.default.testDone) this._onTestDone(new _status2.default({ isCommandResult: true }));else if (command.type === _type2.default.setBreakpoint) this._onSetBreakpointCommand(command.isTestError);else if (command.type === _type2.default.switchToMainWindow) this._onSwitchToMainWindowCommand(command);else if (command.type === _type2.default.switchToIframe) this._onSwitchToIframeCommand(command);else if ((0, _utils.isBrowserManipulationCommand)(command)) this._onBrowserManipulationCommand(command);else if (command.type === _type2.default.executeClientFunction) this._onExecuteClientFunctionCommand(command);else if (command.type === _type2.default.executeSelector) this._onExecuteSelectorCommand(command);else if (command.type === _type2.default.navigateTo) this._onNavigateToCommand(command);else if (command.type === _type2.default.setNativeDialogHandler) this._onSetNativeDialogHandlerCommand(command);else if (command.type === _type2.default.getNativeDialogHistory) this._onGetNativeDialogHistoryCommand(command);else if (command.type === _type2.default.getBrowserConsoleMessages) this._onGetBrowserConsoleMessagesCommand(command);else if (command.type === _type2.default.setTestSpeed) this._onSetTestSpeedCommand(command);else if (command.type === _type2.default.showAssertionRetriesStatus) this._onShowAssertionRetriesStatusCommand(command);else if (command.type === _type2.default.hideAssertionRetriesStatus) this._onHideAssertionRetriesStatusCommand(command);else if (command.type === _type2.default.backupStorages) this._onBackupStoragesCommand();else this._onActionCommand(command);
  						    };
  
  						    Driver.prototype._isExecutableInTopWindowOnly = function _isExecutableInTopWindowOnly(command) {
  						        if ((0, _utils.isExecutableInTopWindowOnly)(command)) return true;
  
  						        var customCommandHandler = this.customCommandHandlers[command.type];
  
  						        return customCommandHandler && customCommandHandler.isExecutableInTopWindowOnly;
  						    };
  
  						    Driver.prototype._onCommand = function _onCommand(command) {
  						        var _this19 = this;
  
  						        // NOTE: the driver sends status to the server as soon as it's created,
  						        // but it should wait until the page is loaded before executing a command.
  						        this.readyPromise.then(function () {
  						            // NOTE: we should not execute a command if we already have a pending page error and this command is
  						            // rejectable by page errors. In this case, we immediately send status with this error to the server.
  						            var isCommandRejectableByError = (0, _utils.isCommandRejectableByPageError)(command);
  						            var pendingPageError = _this19.contextStorage.getItem(PENDING_PAGE_ERROR);
  
  						            if (pendingPageError && isCommandRejectableByError) {
  						                _this19._onReady(new _status2.default({ isCommandResult: true }));
  						                return;
  						            }
  
  						            // NOTE: we should execute a command in an iframe if the current execution context belongs to
  						            // this iframe and the command is not one of those that can be executed only in the top window.
  						            var isThereActiveIframe = _this19.activeChildDriverLink || _this19.contextStorage.getItem(ACTIVE_IFRAME_SELECTOR);
  
  						            if (!_this19._isExecutableInTopWindowOnly(command) && isThereActiveIframe) {
  						                _this19._runInActiveIframe(command);
  						                return;
  						            }
  
  						            _this19._executeCommand(command);
  						        });
  						    };
  
  						    // API
  
  
  						    Driver.prototype.setCustomCommandHandlers = function setCustomCommandHandlers(command, handler, executeInTopWindowOnly) {
  						        this.customCommandHandlers[command] = {
  						            isExecutableInTopWindowOnly: executeInTopWindowOnly,
  						            handler: handler
  						        };
  						    };
  
  						    Driver.prototype.start = function start() {
  						        var _this20 = this;
  
  						        this.contextStorage = new _storage2.default(window, this.testRunId);
  						        this.nativeDialogsTracker = new _nativeDialogTracker2.default(this.contextStorage, this.dialogHandler);
  
  						        if (!this.speed) this.speed = this.initialSpeed;
  
  						        _testcafeCore.browser.startHeartbeat(this.heartbeatUrl, _hammerhead2.default.createNativeXHR);
  
  						        this.statusBar = new _testcafeUi.StatusBar(this.userAgent, this.fixtureName, this.testName);
  
  						        this.statusBar.on(this.statusBar.UNLOCK_PAGE_BTN_CLICK, _testcafeCore.disableRealEventsPreventing);
  
  						        this.readyPromise.then(function () {
  						            _this20.statusBar.hidePageLoadingStatus();
  
  						            var assertionRetriesTimeout = _this20.contextStorage.getItem(ASSERTION_RETRIES_TIMEOUT);
  
  						            if (assertionRetriesTimeout) {
  						                var startTime = _this20.contextStorage.getItem(ASSERTION_RETRIES_START_TIME);
  						                var timeLeft = assertionRetriesTimeout - (new Date() - startTime);
  
  						                if (timeLeft > 0) _this20.statusBar.showWaitingAssertionRetriesStatus(assertionRetriesTimeout, startTime);
  						            }
  						        });
  
  						        var pendingStatus = this.contextStorage.getItem(PENDING_STATUS);
  
  						        if (pendingStatus) pendingStatus.resent = true;
  
  						        // NOTE: we should not send any message to the server if we've
  						        // sent the 'test-done' message but haven't got the response.
  						        if (this.contextStorage.getItem(TEST_DONE_SENT_FLAG)) {
  						            if (pendingStatus) this._onTestDone(pendingStatus);else this._checkStatus();
  
  						            return;
  						        }
  
  						        if (this._failIfClientCodeExecutionIsInterrupted()) return;
  
  						        var inCommandExecution = this.contextStorage.getItem(this.COMMAND_EXECUTING_FLAG) || this.contextStorage.getItem(this.EXECUTING_IN_IFRAME_FLAG);
  
  						        var status = pendingStatus || new _status2.default({ isCommandResult: inCommandExecution });
  
  						        this.contextStorage.setItem(this.COMMAND_EXECUTING_FLAG, false);
  						        this.contextStorage.setItem(this.EXECUTING_IN_IFRAME_FLAG, false);
  
  						        this._onReady(status);
  						    };
  
  						    _createClass(Driver, [{
  						        key: 'speed',
  						        set: function set(val) {
  						            this.contextStorage.setItem(TEST_SPEED, val);
  						        },
  						        get: function get() {
  						            return this.contextStorage.getItem(TEST_SPEED);
  						        }
  						    }, {
  						        key: 'consoleMessages',
  						        get: function get() {
  						            return new _browserConsoleMessages2.default(this.contextStorage.getItem(CONSOLE_MESSAGES));
  						        },
  						        set: function set(messages) {
  						            return this.contextStorage.setItem(CONSOLE_MESSAGES, messages ? messages.getCopy() : null);
  						        }
  						    }]);
  
  						    return Driver;
  						}();
  
  						exports.default = Driver;
  						module.exports = exports['default'];
  					},
  					"embedding-utils.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  
  						var _nodeSnapshots = require('./command-executors/client-functions/selector-executor/node-snapshots');
  
  						var _selectorExecutor = require('./command-executors/client-functions/selector-executor');
  
  						var _selectorExecutor2 = _interopRequireDefault(_selectorExecutor);
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						exports.default = {
  						    NodeSnapshot: _nodeSnapshots.NodeSnapshot,
  						    ElementSnapshot: _nodeSnapshots.ElementSnapshot,
  						    SelectorExecutor: _selectorExecutor2.default
  						};
  						module.exports = exports['default'];
  					},
  					"generate-id.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  
  						exports.default = function () {
  						    if (typeof _hammerhead.nativeMethods.performanceNow === 'function') return _hammerhead.nativeMethods.performanceNow().toString();
  
  						    return (_hammerhead.nativeMethods.dateNow() + Math.random()).toString();
  						};
  
  						var _hammerhead = require('./deps/hammerhead');
  
  						module.exports = exports['default'];
  					},
  					"iframe-driver.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  
  						var _hammerhead = require('./deps/hammerhead');
  
  						var _testcafeCore = require('./deps/testcafe-core');
  
  						var _testcafeUi = require('./deps/testcafe-ui');
  
  						var _driver = require('./driver');
  
  						var _driver2 = _interopRequireDefault(_driver);
  
  						var _storage = require('./storage');
  
  						var _storage2 = _interopRequireDefault(_storage);
  
  						var _status = require('./status');
  
  						var _status2 = _interopRequireDefault(_status);
  
  						var _parent = require('./driver-link/parent');
  
  						var _parent2 = _interopRequireDefault(_parent);
  
  						var _messages = require('./driver-link/messages');
  
  						var _iframe = require('./native-dialog-tracker/iframe');
  
  						var _iframe2 = _interopRequireDefault(_iframe);
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  						function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  						function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  						var IframeDriver = function (_Driver) {
  						    _inherits(IframeDriver, _Driver);
  
  						    function IframeDriver(testRunId, options) {
  						        _classCallCheck(this, IframeDriver);
  
  						        var _this = _possibleConstructorReturn(this, _Driver.call(this, testRunId, {}, {}, options));
  
  						        _this.lastParentDriverMessageId = null;
  						        _this.parentDriverLink = new _parent2.default(window.parent);
  						        _this._initParentDriverListening();
  						        return _this;
  						    }
  
  						    // Errors handling
  
  
  						    IframeDriver.prototype._onJsError = function _onJsError() {
  						        // NOTE: do nothing because hammerhead sends js error to the top window directly
  						    };
  
  						    IframeDriver.prototype._onConsoleMessage = function _onConsoleMessage() {}
  						    // NOTE: do nothing because hammerhead sends console messages to the top window directly
  
  
  						    // Messaging between drivers
  						    ;
  
  						    IframeDriver.prototype._initParentDriverListening = function _initParentDriverListening() {
  						        var _this2 = this;
  
  						        _hammerhead.eventSandbox.message.on(_hammerhead.eventSandbox.message.SERVICE_MSG_RECEIVED_EVENT, function (e) {
  						            var msg = e.message;
  
  						            _testcafeCore.pageUnloadBarrier.wait(0).then(function () {
  						                // NOTE: the parent driver repeats commands sent to a child driver if it doesn't get a confirmation
  						                // from the child in time. However, confirmations sent by child drivers may be delayed when the browser
  						                // is heavily loaded. That's why the child driver should ignore repeated messages from its parent.
  						                if (msg.type === _messages.TYPE.executeCommand) {
  						                    if (_this2.lastParentDriverMessageId === msg.id) return;
  
  						                    _this2.lastParentDriverMessageId = msg.id;
  
  						                    _this2.readyPromise.then(function () {
  						                        _this2.speed = msg.testSpeed;
  
  						                        _this2.parentDriverLink.confirmMessageReceived(msg.id);
  						                        _this2._onCommand(msg.command);
  						                    });
  						                }
  
  						                if (msg.type === _messages.TYPE.setNativeDialogHandler) {
  						                    _this2.nativeDialogsTracker.setHandler(msg.dialogHandler);
  						                    _this2._setNativeDialogHandlerInIframes(msg.dialogHandler);
  						                }
  						            });
  						        });
  						    };
  
  						    // Commands handling
  
  
  						    IframeDriver.prototype._onSwitchToMainWindowCommand = function _onSwitchToMainWindowCommand(command) {
  						        this._switchToMainWindow(command);
  						    };
  
  						    // Routing
  
  
  						    IframeDriver.prototype._onReady = function _onReady(status) {
  						        this.parentDriverLink.onCommandExecuted(status);
  						    };
  
  						    // API
  
  
  						    IframeDriver.prototype.start = function start() {
  						        var _this3 = this;
  
  						        this.nativeDialogsTracker = new _iframe2.default(this.dialogHandler);
  						        this.statusBar = new _testcafeUi.IframeStatusBar();
  
  						        var initializePromise = this.parentDriverLink.establishConnection().then(function (id) {
  						            _this3.contextStorage = new _storage2.default(window, id);
  
  						            if (_this3._failIfClientCodeExecutionIsInterrupted()) return;
  
  						            var inCommandExecution = _this3.contextStorage.getItem(_this3.COMMAND_EXECUTING_FLAG) || _this3.contextStorage.getItem(_this3.EXECUTING_IN_IFRAME_FLAG);
  
  						            if (inCommandExecution) {
  						                _this3.contextStorage.setItem(_this3.COMMAND_EXECUTING_FLAG, false);
  						                _this3.contextStorage.setItem(_this3.EXECUTING_IN_IFRAME_FLAG, false);
  						                _this3._onReady(new _status2.default({ isCommandResult: true }));
  						            }
  						        });
  
  						        this.readyPromise = _hammerhead.Promise.all([this.readyPromise, initializePromise]);
  						    };
  
  						    return IframeDriver;
  						}(_driver2.default);
  
  						exports.default = IframeDriver;
  						module.exports = exports['default'];
  					},
  					"index.js": function (exports, module, require) {
  						
  
  						var _hammerhead = require('./deps/hammerhead');
  
  						var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  						var _driver = require('./driver');
  
  						var _driver2 = _interopRequireDefault(_driver);
  
  						var _iframeDriver = require('./iframe-driver');
  
  						var _iframeDriver2 = _interopRequireDefault(_iframeDriver);
  
  						var _scriptExecutionBarrier = require('./script-execution-barrier');
  
  						var _scriptExecutionBarrier2 = _interopRequireDefault(_scriptExecutionBarrier);
  
  						var _embeddingUtils = require('./embedding-utils');
  
  						var _embeddingUtils2 = _interopRequireDefault(_embeddingUtils);
  
  						var _internalProperties = require('./internal-properties');
  
  						var _internalProperties2 = _interopRequireDefault(_internalProperties);
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						var nativeMethods = _hammerhead2.default.nativeMethods;
  						var evalIframeScript = _hammerhead2.default.EVENTS.evalIframeScript;
  
  						nativeMethods.objectDefineProperty(window, _internalProperties2.default.testCafeDriver, { configurable: true, value: _driver2.default });
  						nativeMethods.objectDefineProperty(window, _internalProperties2.default.testCafeIframeDriver, { configurable: true, value: _iframeDriver2.default });
  						nativeMethods.objectDefineProperty(window, _internalProperties2.default.scriptExecutionBarrier, {
  						    configurable: true,
  						    value: _scriptExecutionBarrier2.default
  						});
  						nativeMethods.objectDefineProperty(window, _internalProperties2.default.testCafeEmbeddingUtils, { configurable: true, value: _embeddingUtils2.default });
  
  						// eslint-disable-next-line no-undef
  						_hammerhead2.default.on(evalIframeScript, function (e) {
  						    return initTestCafeClientDrivers(nativeMethods.contentWindowGetter.call(e.iframe), true);
  						});
  					},
  					"internal-properties.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  						exports.default = {
  						    testCafeDriver: '%testCafeDriver%',
  						    testCafeIframeDriver: '%testCafeIframeDriver%',
  						    scriptExecutionBarrier: '%ScriptExecutionBarrier%',
  						    testCafeEmbeddingUtils: '%testCafeEmbeddingUtils%',
  						    testCafeDriverInstance: '%testCafeDriverInstance%'
  						};
  						module.exports = exports['default'];
  					},
  					"native-dialog-tracker": {
  						"iframe.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  							var _messages = require('./messages');
  
  							var _messages2 = _interopRequireDefault(_messages);
  
  							var _index = require('./index');
  
  							var _index2 = _interopRequireDefault(_index);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  							function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  							function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  							var messageSandbox = _hammerhead2.default.eventSandbox.message;
  
  							var IframeNativeDialogTracker = function (_NativeDialogTracker) {
  							    _inherits(IframeNativeDialogTracker, _NativeDialogTracker);
  
  							    function IframeNativeDialogTracker(dialogHandler) {
  							        _classCallCheck(this, IframeNativeDialogTracker);
  
  							        return _possibleConstructorReturn(this, _NativeDialogTracker.call(this, null, dialogHandler));
  							    }
  
  							    IframeNativeDialogTracker.prototype._defaultDialogHandler = function _defaultDialogHandler(type) {
  							        messageSandbox.sendServiceMsg({
  							            type: _messages2.default.unexpectedDialog,
  							            dialogType: type,
  							            url: _index2.default._getPageUrl()
  							        }, window.top);
  							    };
  
  							    IframeNativeDialogTracker.prototype._addAppearedDialogs = function _addAppearedDialogs(type, text) {
  							        messageSandbox.sendServiceMsg({
  							            type: _messages2.default.appearedDialog,
  							            dialogType: type,
  							            text: text,
  							            url: _index2.default._getPageUrl()
  							        }, window.top);
  							    };
  
  							    IframeNativeDialogTracker.prototype._onHandlerError = function _onHandlerError(type, message) {
  							        messageSandbox.sendServiceMsg({
  							            type: _messages2.default.handlerError,
  							            dialogType: type,
  							            message: message,
  							            url: _index2.default._getPageUrl()
  							        }, window.top);
  							    };
  
  							    return IframeNativeDialogTracker;
  							}(_index2.default);
  
  							exports.default = IframeNativeDialogTracker;
  							module.exports = exports['default'];
  						},
  						"index.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  
  							var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  							var _testRun = require('../../../errors/test-run');
  
  							var _clientFunctionExecutor = require('../command-executors/client-functions/client-function-executor');
  
  							var _clientFunctionExecutor2 = _interopRequireDefault(_clientFunctionExecutor);
  
  							var _messages = require('./messages');
  
  							var _messages2 = _interopRequireDefault(_messages);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  							var messageSandbox = _hammerhead2.default.eventSandbox.message;
  							var processScript = _hammerhead2.default.processScript;
  							var nativeMethods = _hammerhead2.default.nativeMethods;
  
  							var APPEARED_DIALOGS = 'testcafe|native-dialog-tracker|appeared-dialogs';
  							var UNEXPECTED_DIALOG = 'testcafe|native-dialog-tracker|unexpected-dialog';
  							var ERROR_IN_HANDLER = 'testcafe|native-dialog-tracker|error-in-handler';
  							var GETTING_PAGE_URL_PROCESSED_SCRIPT = processScript('window.location.href');
  
  							var NativeDialogTracker = function () {
  							    function NativeDialogTracker(contextStorage, dialogHandler) {
  							        _classCallCheck(this, NativeDialogTracker);
  
  							        this.contextStorage = contextStorage;
  							        this.dialogHandler = dialogHandler;
  
  							        this._init();
  							        this._initListening();
  
  							        if (this.dialogHandler) this.setHandler(dialogHandler);
  							    }
  
  							    NativeDialogTracker._getPageUrl = function _getPageUrl() {
  							        return nativeMethods.eval(GETTING_PAGE_URL_PROCESSED_SCRIPT);
  							    };
  
  							    NativeDialogTracker.prototype._initListening = function _initListening() {
  							        var _this = this;
  
  							        messageSandbox.on(messageSandbox.SERVICE_MSG_RECEIVED_EVENT, function (e) {
  							            var msg = e.message;
  
  							            if (msg.type === _messages2.default.appearedDialog)
  							                // eslint-disable-next-line no-restricted-properties
  							                _this._addAppearedDialogs(msg.dialogType, msg.text, msg.url);else if (msg.type === _messages2.default.unexpectedDialog && !_this.unexpectedDialog) _this.unexpectedDialog = { type: msg.dialogType, url: msg.url };else if (msg.type === _messages2.default.handlerError && !_this.handlerError) _this._onHandlerError(msg.dialogType, msg.message, msg.url);
  							        });
  							    };
  
  							    NativeDialogTracker.prototype._init = function _init() {
  							        var _this2 = this;
  
  							        _hammerhead2.default.on(_hammerhead2.default.EVENTS.beforeUnload, function (e) {
  							            if (e.prevented && !e.isFakeIEEvent) {
  							                if (_this2.dialogHandler) {
  							                    var handler = _this2._createDialogHandler('beforeunload');
  
  							                    handler(e.returnValue || '');
  							                } else _this2._defaultDialogHandler('beforeunload');
  							            }
  
  							            // NOTE: we should save changes that could be made via 'shift' and 'push' methods.
  							            if (_this2.contextStorage) _this2.contextStorage.save();
  							        });
  
  							        window.alert = function () {
  							            return _this2._defaultDialogHandler('alert');
  							        };
  							        window.confirm = function () {
  							            return _this2._defaultDialogHandler('confirm');
  							        };
  							        window.prompt = function () {
  							            return _this2._defaultDialogHandler('prompt');
  							        };
  							    };
  
  							    NativeDialogTracker.prototype._createDialogHandler = function _createDialogHandler(type) {
  							        var _this3 = this;
  
  							        return function (text) {
  							            var url = NativeDialogTracker._getPageUrl();
  
  							            _this3._addAppearedDialogs(type, text, url);
  
  							            var executor = new _clientFunctionExecutor2.default(_this3.dialogHandler);
  							            var result = null;
  
  							            try {
  							                result = executor.fn.apply(window, [type, text, url]);
  							            } catch (err) {
  							                _this3._onHandlerError(type, err.message || String(err), url);
  							            }
  
  							            return result;
  							        };
  							    };
  
  							    // Overridable methods
  
  
  							    NativeDialogTracker.prototype._defaultDialogHandler = function _defaultDialogHandler(type) {
  							        var url = NativeDialogTracker._getPageUrl();
  
  							        this.unexpectedDialog = this.unexpectedDialog || { type: type, url: url };
  							    };
  
  							    NativeDialogTracker.prototype._addAppearedDialogs = function _addAppearedDialogs(type, text, url) {
  							        this.appearedDialogs.splice(0, 0, { type: type, text: text, url: url });
  							    };
  
  							    NativeDialogTracker.prototype._onHandlerError = function _onHandlerError(type, message, url) {
  							        this.handlerError = this.handlerError || { type: type, message: message, url: url };
  							    };
  
  							    // API
  
  
  							    NativeDialogTracker.prototype.setHandler = function setHandler(dialogHandler) {
  							        var _this4 = this;
  
  							        this.dialogHandler = dialogHandler;
  
  							        ['alert', 'confirm', 'prompt'].forEach(function (dialogType) {
  							            window[dialogType] = _this4.dialogHandler ? _this4._createDialogHandler(dialogType) : function () {
  							                return _this4._defaultDialogHandler(dialogType);
  							            };
  							        });
  							    };
  
  							    NativeDialogTracker.prototype.getUnexpectedDialogError = function getUnexpectedDialogError() {
  							        var unexpectedDialog = this.unexpectedDialog;
  							        var handlerError = this.handlerError;
  
  							        this.unexpectedDialog = null;
  							        this.handlerError = null;
  
  							        if (unexpectedDialog) return new _testRun.NativeDialogNotHandledError(unexpectedDialog.type, unexpectedDialog.url);
  
  							        if (handlerError) return new _testRun.UncaughtErrorInNativeDialogHandler(handlerError.type, handlerError.message, handlerError.url);
  
  							        return null;
  							    };
  
  							    _createClass(NativeDialogTracker, [{
  							        key: 'appearedDialogs',
  							        get: function get() {
  							            var dialogs = this.contextStorage.getItem(APPEARED_DIALOGS);
  
  							            if (!dialogs) {
  							                dialogs = [];
  							                this.appearedDialogs = dialogs;
  							            }
  
  							            return dialogs;
  							        },
  							        set: function set(dialog) {
  							            this.contextStorage.setItem(APPEARED_DIALOGS, dialog);
  							        }
  							    }, {
  							        key: 'unexpectedDialog',
  							        get: function get() {
  							            return this.contextStorage.getItem(UNEXPECTED_DIALOG);
  							        },
  							        set: function set(dialog) {
  							            this.contextStorage.setItem(UNEXPECTED_DIALOG, dialog);
  							        }
  							    }, {
  							        key: 'handlerError',
  							        get: function get() {
  							            return this.contextStorage.getItem(ERROR_IN_HANDLER);
  							        },
  							        set: function set(dialog) {
  							            this.contextStorage.setItem(ERROR_IN_HANDLER, dialog);
  							        }
  							    }]);
  
  							    return NativeDialogTracker;
  							}();
  
  							exports.default = NativeDialogTracker;
  							module.exports = exports['default'];
  						},
  						"messages.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.default = {
  							    appearedDialog: 'appeared-dialog',
  							    unexpectedDialog: 'unexpected-dialog',
  							    handlerError: 'handler-error'
  							};
  							module.exports = exports['default'];
  						}
  					},
  					"script-execution-barrier.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  
  						var _hammerhead = require('./deps/hammerhead');
  
  						var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  						var _testcafeCore = require('./deps/testcafe-core');
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  						var Promise = _hammerhead2.default.Promise;
  						var nativeMethods = _hammerhead2.default.nativeMethods;
  
  						var WAIT_FOR_NEW_SCRIPTS_DELAY = 25;
  
  						var ScriptExecutionBarrier = function () {
  						    function ScriptExecutionBarrier() {
  						        var _this = this;
  
  						        _classCallCheck(this, ScriptExecutionBarrier);
  
  						        this.watchdog = null;
  
  						        this.SCRIPT_LOADING_TIMEOUT = 2000;
  						        this.BARRIER_TIMEOUT = 3000;
  
  						        this.scriptsCount = 0;
  						        this.resolveWaitingPromise = null;
  
  						        this.scriptElementAddedHandler = function (e) {
  						            return _this._onScriptElementAdded(e.el);
  						        };
  
  						        _hammerhead2.default.on(_hammerhead2.default.EVENTS.scriptElementAdded, this.scriptElementAddedHandler);
  						    }
  
  						    ScriptExecutionBarrier.prototype._onScriptElementAdded = function _onScriptElementAdded(el) {
  						        var _this2 = this;
  
  						        var scriptSrc = nativeMethods.scriptSrcGetter.call(el);
  
  						        if (scriptSrc === void 0 || scriptSrc === '') return;
  
  						        this.scriptsCount++;
  
  						        var loadingTimeout = null;
  
  						        var done = function done() {
  						            nativeMethods.removeEventListener.call(el, 'load', done);
  						            nativeMethods.removeEventListener.call(el, 'error', done);
  
  						            nativeMethods.clearTimeout.call(window, loadingTimeout);
  
  						            _this2._onScriptLoadedOrFailed();
  						        };
  
  						        nativeMethods.addEventListener.call(el, 'load', done);
  						        nativeMethods.addEventListener.call(el, 'error', done);
  
  						        loadingTimeout = nativeMethods.setTimeout.call(window, done, this.SCRIPT_LOADING_TIMEOUT);
  						    };
  
  						    ScriptExecutionBarrier.prototype._onScriptLoadedOrFailed = function _onScriptLoadedOrFailed() {
  						        var _this3 = this;
  
  						        this.scriptsCount--;
  
  						        if (this.scriptsCount) return;
  
  						        (0, _testcafeCore.delay)(WAIT_FOR_NEW_SCRIPTS_DELAY).then(function () {
  						            if (!_this3.resolveWaitingPromise) return;
  
  						            if (!_this3.scriptsCount) _this3.resolveWaitingPromise();
  						        });
  						    };
  
  						    ScriptExecutionBarrier.prototype.wait = function wait() {
  						        var _this4 = this;
  
  						        return new Promise(function (resolve) {
  						            var done = function done() {
  						                nativeMethods.clearTimeout.call(window, _this4.watchdog);
  						                _hammerhead2.default.off(_hammerhead2.default.EVENTS.scriptElementAdded, _this4.scriptElementAddedHandler);
  
  						                _this4.watchdog = null;
  						                _this4.resolveWaitingPromise = null;
  
  						                resolve();
  						            };
  
  						            if (!_this4.scriptsCount) done();else {
  						                _this4.watchdog = nativeMethods.setTimeout.call(window, function () {
  						                    return done();
  						                }, _this4.BARRIER_TIMEOUT);
  						                _this4.resolveWaitingPromise = function () {
  						                    return done();
  						                };
  						            }
  						        });
  						    };
  
  						    return ScriptExecutionBarrier;
  						}();
  
  						exports.default = ScriptExecutionBarrier;
  						module.exports = exports['default'];
  					},
  					"status.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  
  						var _assignable = require('../../utils/assignable');
  
  						var _assignable2 = _interopRequireDefault(_assignable);
  
  						var _generateId = require('./generate-id');
  
  						var _generateId2 = _interopRequireDefault(_generateId);
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  						function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  						function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  						var DriverStatus = function (_Assignable) {
  						    _inherits(DriverStatus, _Assignable);
  
  						    function DriverStatus(obj) {
  						        _classCallCheck(this, DriverStatus);
  
  						        var _this = _possibleConstructorReturn(this, _Assignable.call(this, obj));
  
  						        _this.id = (0, _generateId2.default)();
  						        _this.isCommandResult = false;
  						        _this.executionError = null;
  						        _this.pageError = null;
  						        _this.resent = false;
  						        _this.result = null;
  						        _this.consoleMessages = null;
  
  						        _this._assignFrom(obj, true);
  						        return _this;
  						    }
  
  						    DriverStatus.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return [{ name: 'isCommandResult' }, { name: 'executionError' }, { name: 'pageError' }, { name: 'result' }, { name: 'consoleMessages' }];
  						    };
  
  						    return DriverStatus;
  						}(_assignable2.default);
  
  						exports.default = DriverStatus;
  						module.exports = exports['default'];
  					},
  					"storage.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  
  						var _hammerhead = require('./deps/hammerhead');
  
  						var _hammerhead2 = _interopRequireDefault(_hammerhead);
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  						var JSON = _hammerhead2.default.json;
  						var nativeMethods = _hammerhead2.default.nativeMethods;
  
  						var STORAGE_KEY_PREFIX = 'testcafe|driver|';
  
  						var Storage = function () {
  						    function Storage(window, testRunId) {
  						        _classCallCheck(this, Storage);
  
  						        this.storage = nativeMethods.winSessionStorageGetter.call(window);
  						        this.storageKey = STORAGE_KEY_PREFIX + testRunId;
  						        this.data = {};
  
  						        this._loadFromStorage();
  						    }
  
  						    Storage.prototype._loadFromStorage = function _loadFromStorage() {
  						        var savedData = this.storage.getItem(this.storageKey);
  
  						        if (savedData) {
  						            this.data = JSON.parse(savedData);
  						            this.storage.removeItem(this.storageKey);
  						        }
  						    };
  
  						    Storage.prototype.save = function save() {
  						        this.storage.setItem(this.storageKey, JSON.stringify(this.data));
  						    };
  
  						    Storage.prototype.setItem = function setItem(prop, value) {
  						        this.data[prop] = value;
  						        this.save();
  						    };
  
  						    Storage.prototype.getItem = function getItem(prop) {
  						        return this.data[prop];
  						    };
  
  						    Storage.prototype.dispose = function dispose() {
  						        this.storage.removeItem(this.storageKey);
  						    };
  
  						    return Storage;
  						}();
  
  						exports.default = Storage;
  						module.exports = exports['default'];
  					},
  					"utils": {
  						"element-utils.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.exists = exists;
  							exports.visible = visible;
  							exports.IsNodeCollection = IsNodeCollection;
  
  							var _testcafeCore = require('../deps/testcafe-core');
  
  							var _testcafeUi = require('../deps/testcafe-ui');
  
  							// NOTE: save original ctors and methods because they may be overwritten by page code
  							var isArray = Array.isArray;
  							var Node = window.Node;
  							var HTMLCollection = window.HTMLCollection;
  							var NodeList = window.NodeList;
  
  							function exists(el) {
  							    return !!el;
  							}
  
  							function visible(el) {
  							    if (!_testcafeCore.domUtils.isDomElement(el) && !_testcafeCore.domUtils.isTextNode(el)) return false;
  
  							    if (_testcafeCore.domUtils.isOptionElement(el) || _testcafeCore.domUtils.getTagName(el) === 'optgroup') return _testcafeUi.selectElement.isOptionElementVisible(el);
  
  							    return _testcafeCore.positionUtils.isElementVisible(el);
  							}
  
  							function IsNodeCollection(obj) {
  							    return obj instanceof HTMLCollection || obj instanceof NodeList || isArrayOfNodes(obj);
  							}
  
  							function isArrayOfNodes(obj) {
  							    if (!isArray(obj)) return false;
  
  							    for (var i = 0; i < obj.length; i++) {
  							        if (!(obj[i] instanceof Node)) return false;
  							    }
  
  							    return true;
  							}
  						},
  						"ensure-elements.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.ensureElements = ensureElements;
  							exports.createElementDescriptor = createElementDescriptor;
  							exports.createAdditionalElementDescriptor = createAdditionalElementDescriptor;
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _testcafeCore = require('../deps/testcafe-core');
  
  							var _selectorExecutor = require('../command-executors/client-functions/selector-executor');
  
  							var _selectorExecutor2 = _interopRequireDefault(_selectorExecutor);
  
  							var _testRun = require('../../../errors/test-run');
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  							var ElementsRetriever = function () {
  							    function ElementsRetriever(elementDescriptors, globalSelectorTimeout) {
  							        var _this = this;
  
  							        _classCallCheck(this, ElementsRetriever);
  
  							        this.elements = [];
  							        this.globalSelectorTimeout = globalSelectorTimeout;
  							        this.ensureElementsPromise = _hammerhead.Promise.resolve();
  							        this.ensureElementsStartTime = new Date();
  
  							        elementDescriptors.forEach(function (descriptor) {
  							            return _this._ensureElement(descriptor);
  							        });
  							    }
  
  							    ElementsRetriever.prototype._ensureElement = function _ensureElement(_ref) {
  							        var _this2 = this;
  
  							        var selector = _ref.selector,
  							            createNotFoundError = _ref.createNotFoundError,
  							            createIsInvisibleError = _ref.createIsInvisibleError,
  							            createHasWrongNodeTypeError = _ref.createHasWrongNodeTypeError;
  
  							        this.ensureElementsPromise = this.ensureElementsPromise.then(function () {
  							            var selectorExecutor = new _selectorExecutor2.default(selector, _this2.globalSelectorTimeout, _this2.ensureElementsStartTime, createNotFoundError, createIsInvisibleError);
  
  							            return selectorExecutor.getResult();
  							        }).then(function (el) {
  							            if (!_testcafeCore.domUtils.isDomElement(el)) throw createHasWrongNodeTypeError(_testcafeCore.NODE_TYPE_DESCRIPTIONS[el.nodeType]);
  
  							            _this2.elements.push(el);
  							        });
  							    };
  
  							    ElementsRetriever.prototype.getElements = function getElements() {
  							        var _this3 = this;
  
  							        return this.ensureElementsPromise.then(function () {
  							            return _this3.elements;
  							        });
  							    };
  
  							    return ElementsRetriever;
  							}();
  
  							function ensureElements(elementDescriptors, globalSelectorTimeout) {
  							    var elementsRetriever = new ElementsRetriever(elementDescriptors, globalSelectorTimeout);
  
  							    return elementsRetriever.getElements();
  							}
  
  							function createElementDescriptor(selector) {
  							    return {
  							        selector: selector,
  							        createNotFoundError: function createNotFoundError(fn) {
  							            return new _testRun.ActionElementNotFoundError(fn);
  							        },
  							        createIsInvisibleError: function createIsInvisibleError() {
  							            return new _testRun.ActionElementIsInvisibleError();
  							        },
  							        createHasWrongNodeTypeError: function createHasWrongNodeTypeError(nodeDescription) {
  							            return new _testRun.ActionSelectorMatchesWrongNodeTypeError(nodeDescription);
  							        }
  							    };
  							}
  
  							function createAdditionalElementDescriptor(selector, elementName) {
  							    return {
  							        selector: selector,
  							        createNotFoundError: function createNotFoundError(fn) {
  							            return new _testRun.ActionAdditionalElementNotFoundError(elementName, fn);
  							        },
  							        createIsInvisibleError: function createIsInvisibleError() {
  							            return new _testRun.ActionAdditionalElementIsInvisibleError(elementName);
  							        },
  							        createHasWrongNodeTypeError: function createHasWrongNodeTypeError(nodeDescription) {
  							            return new _testRun.ActionAdditionalSelectorMatchesWrongNodeTypeError(elementName, nodeDescription);
  							        }
  							    };
  							}
  						},
  						"run-with-barriers.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  
  							exports.default = function (action) {
  							    var requestBarrier = new _testcafeCore.RequestBarrier();
  							    var scriptExecutionBarrier = new _scriptExecutionBarrier2.default();
  
  							    _testcafeCore.pageUnloadBarrier.watchForPageNavigationTriggers();
  
  							    var actionResult = null;
  
  							    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
  							        args[_key - 1] = arguments[_key];
  							    }
  
  							    var actionPromise = action.apply(undefined, args);
  
  							    var barriersPromise = actionPromise.then(function (result) {
  							        actionResult = result;
  
  							        return _hammerhead.Promise.all([
  							        // NOTE: script can be added by xhr-request, so we should run
  							        // script execution barrier waiting after request barrier resolved
  							        requestBarrier.wait().then(function () {
  							            return scriptExecutionBarrier.wait();
  							        }), _testcafeCore.pageUnloadBarrier.wait()]);
  							    }).then(function () {
  							        return actionResult;
  							    });
  
  							    return { actionPromise: actionPromise, barriersPromise: barriersPromise };
  							};
  
  							var _hammerhead = require('../deps/hammerhead');
  
  							var _testcafeCore = require('../deps/testcafe-core');
  
  							var _scriptExecutionBarrier = require('../script-execution-barrier');
  
  							var _scriptExecutionBarrier2 = _interopRequireDefault(_scriptExecutionBarrier);
  
  							function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  							module.exports = exports['default'];
  						}
  					}
  				}
  			},
  			"client-functions": {
  				"selectors": {
  					"snapshot-properties.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  						// -------------------------------------------------------------
  						// 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 = exports.NODE_SNAPSHOT_PROPERTIES = ['nodeType', 'textContent', 'childNodeCount', 'hasChildNodes', 'childElementCount', 'hasChildElements'];
  
  						var ELEMENT_SNAPSHOT_PROPERTIES = exports.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 SNAPSHOT_PROPERTIES = exports.SNAPSHOT_PROPERTIES = NODE_SNAPSHOT_PROPERTIES.concat(ELEMENT_SNAPSHOT_PROPERTIES);
  					}
  				}
  			},
  			"errors": {
  				"test-run": {
  					"index.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  						exports.RequestHookNotImplementedMethodError = exports.RequestHookUnhandledError = exports.SetNativeDialogHandlerCodeWrongTypeError = exports.UncaughtErrorInNativeDialogHandler = exports.NativeDialogNotHandledError = exports.CurrentIframeIsInvisibleError = exports.CurrentIframeNotFoundError = exports.CurrentIframeIsNotLoadedError = exports.ActionIframeIsNotLoadedError = exports.ActionElementNotIframeError = exports.RoleSwitchInRoleInitializerError = exports.ForbiddenCharactersInScreenshotPathError = exports.InvalidElementScreenshotDimensionsError = exports.WindowDimensionsOverflowError = exports.ExecuteAsyncExpressionError = exports.ActionInvalidScrollTargetError = exports.ActionElementIsNotFileInputError = exports.ActionCannotFindFileToUploadError = exports.ActionIncorrectKeysError = exports.ActionRootContainerNotFoundError = exports.ActionElementNonContentEditableError = exports.ActionElementNotTextAreaError = exports.ActionElementNonEditableError = exports.ActionAdditionalSelectorMatchesWrongNodeTypeError = exports.ActionAdditionalElementIsInvisibleError = exports.ActionAdditionalElementNotFoundError = exports.ActionSelectorMatchesWrongNodeTypeError = exports.ActionElementIsInvisibleError = exports.ActionElementNotFoundError = exports.ActionSelectorError = exports.ActionUnsupportedDeviceTypeError = exports.SetTestSpeedArgumentError = exports.ActionStringArrayElementError = exports.ActionStringOrStringArrayArgumentError = exports.ActionPositiveIntegerArgumentError = exports.ActionRoleArgumentError = exports.ActionIntegerArgumentError = exports.ActionNullableStringArgumentError = exports.ActionStringArgumentError = exports.ActionOptionsTypeError = exports.ActionSpeedOptionError = exports.ActionBooleanArgumentError = exports.ActionBooleanOptionError = exports.ActionPositiveIntegerOptionError = exports.ActionIntegerOptionError = exports.AssertionUnawaitedPromiseError = exports.AssertionWithoutMethodCallError = exports.AssertionExecutableArgumentError = exports.ExternalAssertionLibraryError = exports.UncaughtErrorInCustomClientScriptLoadedFromModule = exports.UncaughtErrorInCustomClientScriptCode = exports.UncaughtExceptionError = exports.UnhandledPromiseRejectionError = exports.UncaughtErrorInCustomDOMPropertyCode = exports.UncaughtErrorInClientFunctionCode = exports.UncaughtNonErrorObjectInTestCode = exports.UncaughtErrorInTestCode = exports.UncaughtErrorOnPage = exports.PageLoadError = exports.CannotObtainInfoForElementSpecifiedBySelectorError = exports.InvalidSelectorResultError = exports.DomNodeClientFunctionResultError = exports.ClientFunctionExecutionInterruptionError = exports.MissingAwaitError = undefined;
  
  						var _types = require('../types');
  
  						function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  						function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  						function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // -------------------------------------------------------------
  						// WARNING: this file is used by both the client and the server.
  						// Do not use any browser or node-specific API!
  						// -------------------------------------------------------------
  
  
  						// Base
  						//--------------------------------------------------------------------
  						var TestRunErrorBase = function TestRunErrorBase(code) {
  						    _classCallCheck(this, TestRunErrorBase);
  
  						    this.code = code;
  						    this.isTestCafeError = true;
  						    this.callsite = null;
  						};
  
  						var ActionOptionErrorBase = function (_TestRunErrorBase) {
  						    _inherits(ActionOptionErrorBase, _TestRunErrorBase);
  
  						    function ActionOptionErrorBase(code, optionName, actualValue) {
  						        _classCallCheck(this, ActionOptionErrorBase);
  
  						        var _this = _possibleConstructorReturn(this, _TestRunErrorBase.call(this, code));
  
  						        _this.optionName = optionName;
  						        _this.actualValue = actualValue;
  						        return _this;
  						    }
  
  						    return ActionOptionErrorBase;
  						}(TestRunErrorBase);
  
  						var ActionArgumentErrorBase = function (_TestRunErrorBase2) {
  						    _inherits(ActionArgumentErrorBase, _TestRunErrorBase2);
  
  						    function ActionArgumentErrorBase(code, argumentName, actualValue) {
  						        _classCallCheck(this, ActionArgumentErrorBase);
  
  						        var _this2 = _possibleConstructorReturn(this, _TestRunErrorBase2.call(this, code));
  
  						        _this2.argumentName = argumentName;
  						        _this2.actualValue = actualValue;
  						        return _this2;
  						    }
  
  						    return ActionArgumentErrorBase;
  						}(TestRunErrorBase);
  
  						// Synchronization errors
  						//--------------------------------------------------------------------
  
  
  						var MissingAwaitError = exports.MissingAwaitError = function (_TestRunErrorBase3) {
  						    _inherits(MissingAwaitError, _TestRunErrorBase3);
  
  						    function MissingAwaitError(callsite) {
  						        _classCallCheck(this, MissingAwaitError);
  
  						        var _this3 = _possibleConstructorReturn(this, _TestRunErrorBase3.call(this, _types.TEST_RUN_ERRORS.missingAwaitError));
  
  						        _this3.callsite = callsite;
  						        return _this3;
  						    }
  
  						    return MissingAwaitError;
  						}(TestRunErrorBase);
  
  						// Client function errors
  						//--------------------------------------------------------------------
  
  
  						var ClientFunctionExecutionInterruptionError = exports.ClientFunctionExecutionInterruptionError = function (_TestRunErrorBase4) {
  						    _inherits(ClientFunctionExecutionInterruptionError, _TestRunErrorBase4);
  
  						    function ClientFunctionExecutionInterruptionError(instantiationCallsiteName) {
  						        _classCallCheck(this, ClientFunctionExecutionInterruptionError);
  
  						        var _this4 = _possibleConstructorReturn(this, _TestRunErrorBase4.call(this, _types.TEST_RUN_ERRORS.clientFunctionExecutionInterruptionError));
  
  						        _this4.instantiationCallsiteName = instantiationCallsiteName;
  						        return _this4;
  						    }
  
  						    return ClientFunctionExecutionInterruptionError;
  						}(TestRunErrorBase);
  
  						var DomNodeClientFunctionResultError = exports.DomNodeClientFunctionResultError = function (_TestRunErrorBase5) {
  						    _inherits(DomNodeClientFunctionResultError, _TestRunErrorBase5);
  
  						    function DomNodeClientFunctionResultError(instantiationCallsiteName) {
  						        _classCallCheck(this, DomNodeClientFunctionResultError);
  
  						        var _this5 = _possibleConstructorReturn(this, _TestRunErrorBase5.call(this, _types.TEST_RUN_ERRORS.domNodeClientFunctionResultError));
  
  						        _this5.instantiationCallsiteName = instantiationCallsiteName;
  						        return _this5;
  						    }
  
  						    return DomNodeClientFunctionResultError;
  						}(TestRunErrorBase);
  
  						// Selector errors
  						//--------------------------------------------------------------------
  
  
  						var SelectorErrorBase = function (_TestRunErrorBase6) {
  						    _inherits(SelectorErrorBase, _TestRunErrorBase6);
  
  						    function SelectorErrorBase(code, _ref) {
  						        var apiFnChain = _ref.apiFnChain,
  						            apiFnIndex = _ref.apiFnIndex;
  
  						        _classCallCheck(this, SelectorErrorBase);
  
  						        var _this6 = _possibleConstructorReturn(this, _TestRunErrorBase6.call(this, code));
  
  						        _this6.apiFnChain = apiFnChain;
  						        _this6.apiFnIndex = apiFnIndex;
  						        return _this6;
  						    }
  
  						    return SelectorErrorBase;
  						}(TestRunErrorBase);
  
  						var InvalidSelectorResultError = exports.InvalidSelectorResultError = function (_TestRunErrorBase7) {
  						    _inherits(InvalidSelectorResultError, _TestRunErrorBase7);
  
  						    function InvalidSelectorResultError() {
  						        _classCallCheck(this, InvalidSelectorResultError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase7.call(this, _types.TEST_RUN_ERRORS.invalidSelectorResultError));
  						    }
  
  						    return InvalidSelectorResultError;
  						}(TestRunErrorBase);
  
  						var CannotObtainInfoForElementSpecifiedBySelectorError = exports.CannotObtainInfoForElementSpecifiedBySelectorError = function (_SelectorErrorBase) {
  						    _inherits(CannotObtainInfoForElementSpecifiedBySelectorError, _SelectorErrorBase);
  
  						    function CannotObtainInfoForElementSpecifiedBySelectorError(callsite, apiFnArgs) {
  						        _classCallCheck(this, CannotObtainInfoForElementSpecifiedBySelectorError);
  
  						        var _this8 = _possibleConstructorReturn(this, _SelectorErrorBase.call(this, _types.TEST_RUN_ERRORS.cannotObtainInfoForElementSpecifiedBySelectorError, apiFnArgs));
  
  						        _this8.callsite = callsite;
  						        return _this8;
  						    }
  
  						    return CannotObtainInfoForElementSpecifiedBySelectorError;
  						}(SelectorErrorBase);
  
  						// Page errors
  						//--------------------------------------------------------------------
  
  
  						var PageLoadError = exports.PageLoadError = function (_TestRunErrorBase8) {
  						    _inherits(PageLoadError, _TestRunErrorBase8);
  
  						    function PageLoadError(errMsg, url) {
  						        _classCallCheck(this, PageLoadError);
  
  						        var _this9 = _possibleConstructorReturn(this, _TestRunErrorBase8.call(this, _types.TEST_RUN_ERRORS.pageLoadError));
  
  						        _this9.url = url;
  						        _this9.errMsg = errMsg;
  						        return _this9;
  						    }
  
  						    return PageLoadError;
  						}(TestRunErrorBase);
  
  						// Uncaught errors
  						//--------------------------------------------------------------------
  
  
  						var UncaughtErrorOnPage = exports.UncaughtErrorOnPage = function (_TestRunErrorBase9) {
  						    _inherits(UncaughtErrorOnPage, _TestRunErrorBase9);
  
  						    function UncaughtErrorOnPage(errStack, pageDestUrl) {
  						        _classCallCheck(this, UncaughtErrorOnPage);
  
  						        var _this10 = _possibleConstructorReturn(this, _TestRunErrorBase9.call(this, _types.TEST_RUN_ERRORS.uncaughtErrorOnPage));
  
  						        _this10.errStack = errStack;
  						        _this10.pageDestUrl = pageDestUrl;
  						        return _this10;
  						    }
  
  						    return UncaughtErrorOnPage;
  						}(TestRunErrorBase);
  
  						var UncaughtErrorInTestCode = exports.UncaughtErrorInTestCode = function (_TestRunErrorBase10) {
  						    _inherits(UncaughtErrorInTestCode, _TestRunErrorBase10);
  
  						    function UncaughtErrorInTestCode(err, callsite) {
  						        _classCallCheck(this, UncaughtErrorInTestCode);
  
  						        var _this11 = _possibleConstructorReturn(this, _TestRunErrorBase10.call(this, _types.TEST_RUN_ERRORS.uncaughtErrorInTestCode));
  
  						        _this11.errMsg = String(err.rawMessage || err);
  						        _this11.callsite = err.callsite || callsite;
  						        _this11.originError = err;
  						        return _this11;
  						    }
  
  						    return UncaughtErrorInTestCode;
  						}(TestRunErrorBase);
  
  						var UncaughtNonErrorObjectInTestCode = exports.UncaughtNonErrorObjectInTestCode = function (_TestRunErrorBase11) {
  						    _inherits(UncaughtNonErrorObjectInTestCode, _TestRunErrorBase11);
  
  						    function UncaughtNonErrorObjectInTestCode(obj) {
  						        _classCallCheck(this, UncaughtNonErrorObjectInTestCode);
  
  						        var _this12 = _possibleConstructorReturn(this, _TestRunErrorBase11.call(this, _types.TEST_RUN_ERRORS.uncaughtNonErrorObjectInTestCode));
  
  						        _this12.objType = typeof obj;
  						        _this12.objStr = String(obj);
  						        return _this12;
  						    }
  
  						    return UncaughtNonErrorObjectInTestCode;
  						}(TestRunErrorBase);
  
  						var UncaughtErrorInClientFunctionCode = exports.UncaughtErrorInClientFunctionCode = function (_TestRunErrorBase12) {
  						    _inherits(UncaughtErrorInClientFunctionCode, _TestRunErrorBase12);
  
  						    function UncaughtErrorInClientFunctionCode(instantiationCallsiteName, err) {
  						        _classCallCheck(this, UncaughtErrorInClientFunctionCode);
  
  						        var _this13 = _possibleConstructorReturn(this, _TestRunErrorBase12.call(this, _types.TEST_RUN_ERRORS.uncaughtErrorInClientFunctionCode));
  
  						        _this13.errMsg = String(err);
  						        _this13.instantiationCallsiteName = instantiationCallsiteName;
  						        return _this13;
  						    }
  
  						    return UncaughtErrorInClientFunctionCode;
  						}(TestRunErrorBase);
  
  						var UncaughtErrorInCustomDOMPropertyCode = exports.UncaughtErrorInCustomDOMPropertyCode = function (_TestRunErrorBase13) {
  						    _inherits(UncaughtErrorInCustomDOMPropertyCode, _TestRunErrorBase13);
  
  						    function UncaughtErrorInCustomDOMPropertyCode(instantiationCallsiteName, err, prop) {
  						        _classCallCheck(this, UncaughtErrorInCustomDOMPropertyCode);
  
  						        var _this14 = _possibleConstructorReturn(this, _TestRunErrorBase13.call(this, _types.TEST_RUN_ERRORS.uncaughtErrorInCustomDOMPropertyCode, err, prop));
  
  						        _this14.errMsg = String(err);
  						        _this14.property = prop;
  						        _this14.instantiationCallsiteName = instantiationCallsiteName;
  						        return _this14;
  						    }
  
  						    return UncaughtErrorInCustomDOMPropertyCode;
  						}(TestRunErrorBase);
  
  						var UnhandledPromiseRejectionError = exports.UnhandledPromiseRejectionError = function (_TestRunErrorBase14) {
  						    _inherits(UnhandledPromiseRejectionError, _TestRunErrorBase14);
  
  						    function UnhandledPromiseRejectionError(err) {
  						        _classCallCheck(this, UnhandledPromiseRejectionError);
  
  						        var _this15 = _possibleConstructorReturn(this, _TestRunErrorBase14.call(this, _types.TEST_RUN_ERRORS.unhandledPromiseRejection));
  
  						        _this15.errMsg = String(err);
  						        return _this15;
  						    }
  
  						    return UnhandledPromiseRejectionError;
  						}(TestRunErrorBase);
  
  						var UncaughtExceptionError = exports.UncaughtExceptionError = function (_TestRunErrorBase15) {
  						    _inherits(UncaughtExceptionError, _TestRunErrorBase15);
  
  						    function UncaughtExceptionError(err) {
  						        _classCallCheck(this, UncaughtExceptionError);
  
  						        var _this16 = _possibleConstructorReturn(this, _TestRunErrorBase15.call(this, _types.TEST_RUN_ERRORS.uncaughtException));
  
  						        _this16.errMsg = String(err);
  						        return _this16;
  						    }
  
  						    return UncaughtExceptionError;
  						}(TestRunErrorBase);
  
  						var UncaughtErrorInCustomClientScriptCode = exports.UncaughtErrorInCustomClientScriptCode = function (_TestRunErrorBase16) {
  						    _inherits(UncaughtErrorInCustomClientScriptCode, _TestRunErrorBase16);
  
  						    function UncaughtErrorInCustomClientScriptCode(err) {
  						        _classCallCheck(this, UncaughtErrorInCustomClientScriptCode);
  
  						        var _this17 = _possibleConstructorReturn(this, _TestRunErrorBase16.call(this, _types.TEST_RUN_ERRORS.uncaughtErrorInCustomClientScriptCode));
  
  						        _this17.errMsg = String(err);
  						        return _this17;
  						    }
  
  						    return UncaughtErrorInCustomClientScriptCode;
  						}(TestRunErrorBase);
  
  						var UncaughtErrorInCustomClientScriptLoadedFromModule = exports.UncaughtErrorInCustomClientScriptLoadedFromModule = function (_TestRunErrorBase17) {
  						    _inherits(UncaughtErrorInCustomClientScriptLoadedFromModule, _TestRunErrorBase17);
  
  						    function UncaughtErrorInCustomClientScriptLoadedFromModule(err, moduleName) {
  						        _classCallCheck(this, UncaughtErrorInCustomClientScriptLoadedFromModule);
  
  						        var _this18 = _possibleConstructorReturn(this, _TestRunErrorBase17.call(this, _types.TEST_RUN_ERRORS.uncaughtErrorInCustomClientScriptCodeLoadedFromModule));
  
  						        _this18.errMsg = String(err);
  						        _this18.moduleName = moduleName;
  						        return _this18;
  						    }
  
  						    return UncaughtErrorInCustomClientScriptLoadedFromModule;
  						}(TestRunErrorBase);
  
  						// Assertion errors
  						//--------------------------------------------------------------------
  
  
  						var ExternalAssertionLibraryError = exports.ExternalAssertionLibraryError = function (_TestRunErrorBase18) {
  						    _inherits(ExternalAssertionLibraryError, _TestRunErrorBase18);
  
  						    function ExternalAssertionLibraryError(err, callsite) {
  						        _classCallCheck(this, ExternalAssertionLibraryError);
  
  						        var _this19 = _possibleConstructorReturn(this, _TestRunErrorBase18.call(this, _types.TEST_RUN_ERRORS.externalAssertionLibraryError));
  
  						        _this19.errMsg = String(err);
  						        _this19.callsite = callsite;
  						        return _this19;
  						    }
  
  						    return ExternalAssertionLibraryError;
  						}(TestRunErrorBase);
  
  						var AssertionExecutableArgumentError = exports.AssertionExecutableArgumentError = function (_ActionArgumentErrorB) {
  						    _inherits(AssertionExecutableArgumentError, _ActionArgumentErrorB);
  
  						    function AssertionExecutableArgumentError(argumentName, argumentValue, err, isAPIError) {
  						        _classCallCheck(this, AssertionExecutableArgumentError);
  
  						        var _this20 = _possibleConstructorReturn(this, _ActionArgumentErrorB.call(this, _types.TEST_RUN_ERRORS.assertionExecutableArgumentError, argumentName, argumentValue));
  
  						        _this20.errMsg = isAPIError ? err.rawMessage : err.message;
  						        _this20.originError = err;
  						        return _this20;
  						    }
  
  						    return AssertionExecutableArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var AssertionWithoutMethodCallError = exports.AssertionWithoutMethodCallError = function (_TestRunErrorBase19) {
  						    _inherits(AssertionWithoutMethodCallError, _TestRunErrorBase19);
  
  						    function AssertionWithoutMethodCallError(callsite) {
  						        _classCallCheck(this, AssertionWithoutMethodCallError);
  
  						        var _this21 = _possibleConstructorReturn(this, _TestRunErrorBase19.call(this, _types.TEST_RUN_ERRORS.assertionWithoutMethodCallError));
  
  						        _this21.callsite = callsite;
  						        return _this21;
  						    }
  
  						    return AssertionWithoutMethodCallError;
  						}(TestRunErrorBase);
  
  						var AssertionUnawaitedPromiseError = exports.AssertionUnawaitedPromiseError = function (_TestRunErrorBase20) {
  						    _inherits(AssertionUnawaitedPromiseError, _TestRunErrorBase20);
  
  						    function AssertionUnawaitedPromiseError(callsite) {
  						        _classCallCheck(this, AssertionUnawaitedPromiseError);
  
  						        var _this22 = _possibleConstructorReturn(this, _TestRunErrorBase20.call(this, _types.TEST_RUN_ERRORS.assertionUnawaitedPromiseError));
  
  						        _this22.callsite = callsite;
  						        return _this22;
  						    }
  
  						    return AssertionUnawaitedPromiseError;
  						}(TestRunErrorBase);
  
  						// Action parameters errors
  						//--------------------------------------------------------------------
  						// Options errors
  
  
  						var ActionIntegerOptionError = exports.ActionIntegerOptionError = function (_ActionOptionErrorBas) {
  						    _inherits(ActionIntegerOptionError, _ActionOptionErrorBas);
  
  						    function ActionIntegerOptionError(optionName, actualValue) {
  						        _classCallCheck(this, ActionIntegerOptionError);
  
  						        return _possibleConstructorReturn(this, _ActionOptionErrorBas.call(this, _types.TEST_RUN_ERRORS.actionIntegerOptionError, optionName, actualValue));
  						    }
  
  						    return ActionIntegerOptionError;
  						}(ActionOptionErrorBase);
  
  						var ActionPositiveIntegerOptionError = exports.ActionPositiveIntegerOptionError = function (_ActionOptionErrorBas2) {
  						    _inherits(ActionPositiveIntegerOptionError, _ActionOptionErrorBas2);
  
  						    function ActionPositiveIntegerOptionError(optionName, actualValue) {
  						        _classCallCheck(this, ActionPositiveIntegerOptionError);
  
  						        return _possibleConstructorReturn(this, _ActionOptionErrorBas2.call(this, _types.TEST_RUN_ERRORS.actionPositiveIntegerOptionError, optionName, actualValue));
  						    }
  
  						    return ActionPositiveIntegerOptionError;
  						}(ActionOptionErrorBase);
  
  						var ActionBooleanOptionError = exports.ActionBooleanOptionError = function (_ActionOptionErrorBas3) {
  						    _inherits(ActionBooleanOptionError, _ActionOptionErrorBas3);
  
  						    function ActionBooleanOptionError(optionName, actualValue) {
  						        _classCallCheck(this, ActionBooleanOptionError);
  
  						        return _possibleConstructorReturn(this, _ActionOptionErrorBas3.call(this, _types.TEST_RUN_ERRORS.actionBooleanOptionError, optionName, actualValue));
  						    }
  
  						    return ActionBooleanOptionError;
  						}(ActionOptionErrorBase);
  
  						var ActionBooleanArgumentError = exports.ActionBooleanArgumentError = function (_ActionArgumentErrorB2) {
  						    _inherits(ActionBooleanArgumentError, _ActionArgumentErrorB2);
  
  						    function ActionBooleanArgumentError(argumentName, actualValue) {
  						        _classCallCheck(this, ActionBooleanArgumentError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB2.call(this, _types.TEST_RUN_ERRORS.actionBooleanArgumentError, argumentName, actualValue));
  						    }
  
  						    return ActionBooleanArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var ActionSpeedOptionError = exports.ActionSpeedOptionError = function (_ActionOptionErrorBas4) {
  						    _inherits(ActionSpeedOptionError, _ActionOptionErrorBas4);
  
  						    function ActionSpeedOptionError(optionName, actualValue) {
  						        _classCallCheck(this, ActionSpeedOptionError);
  
  						        return _possibleConstructorReturn(this, _ActionOptionErrorBas4.call(this, _types.TEST_RUN_ERRORS.actionSpeedOptionError, optionName, actualValue));
  						    }
  
  						    return ActionSpeedOptionError;
  						}(ActionOptionErrorBase);
  
  						var ActionOptionsTypeError = exports.ActionOptionsTypeError = function (_TestRunErrorBase21) {
  						    _inherits(ActionOptionsTypeError, _TestRunErrorBase21);
  
  						    function ActionOptionsTypeError(actualType) {
  						        _classCallCheck(this, ActionOptionsTypeError);
  
  						        var _this28 = _possibleConstructorReturn(this, _TestRunErrorBase21.call(this, _types.TEST_RUN_ERRORS.actionOptionsTypeError));
  
  						        _this28.actualType = actualType;
  						        return _this28;
  						    }
  
  						    return ActionOptionsTypeError;
  						}(TestRunErrorBase);
  
  						// Arguments errors
  
  
  						var ActionStringArgumentError = exports.ActionStringArgumentError = function (_ActionArgumentErrorB3) {
  						    _inherits(ActionStringArgumentError, _ActionArgumentErrorB3);
  
  						    function ActionStringArgumentError(argumentName, actualValue) {
  						        _classCallCheck(this, ActionStringArgumentError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB3.call(this, _types.TEST_RUN_ERRORS.actionStringArgumentError, argumentName, actualValue));
  						    }
  
  						    return ActionStringArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var ActionNullableStringArgumentError = exports.ActionNullableStringArgumentError = function (_ActionArgumentErrorB4) {
  						    _inherits(ActionNullableStringArgumentError, _ActionArgumentErrorB4);
  
  						    function ActionNullableStringArgumentError(argumentName, actualValue) {
  						        _classCallCheck(this, ActionNullableStringArgumentError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB4.call(this, _types.TEST_RUN_ERRORS.actionNullableStringArgumentError, argumentName, actualValue));
  						    }
  
  						    return ActionNullableStringArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var ActionIntegerArgumentError = exports.ActionIntegerArgumentError = function (_ActionArgumentErrorB5) {
  						    _inherits(ActionIntegerArgumentError, _ActionArgumentErrorB5);
  
  						    function ActionIntegerArgumentError(argumentName, actualValue) {
  						        _classCallCheck(this, ActionIntegerArgumentError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB5.call(this, _types.TEST_RUN_ERRORS.actionIntegerArgumentError, argumentName, actualValue));
  						    }
  
  						    return ActionIntegerArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var ActionRoleArgumentError = exports.ActionRoleArgumentError = function (_ActionArgumentErrorB6) {
  						    _inherits(ActionRoleArgumentError, _ActionArgumentErrorB6);
  
  						    function ActionRoleArgumentError(argumentName, actualValue) {
  						        _classCallCheck(this, ActionRoleArgumentError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB6.call(this, _types.TEST_RUN_ERRORS.actionRoleArgumentError, argumentName, actualValue));
  						    }
  
  						    return ActionRoleArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var ActionPositiveIntegerArgumentError = exports.ActionPositiveIntegerArgumentError = function (_ActionArgumentErrorB7) {
  						    _inherits(ActionPositiveIntegerArgumentError, _ActionArgumentErrorB7);
  
  						    function ActionPositiveIntegerArgumentError(argumentName, actualValue) {
  						        _classCallCheck(this, ActionPositiveIntegerArgumentError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB7.call(this, _types.TEST_RUN_ERRORS.actionPositiveIntegerArgumentError, argumentName, actualValue));
  						    }
  
  						    return ActionPositiveIntegerArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var ActionStringOrStringArrayArgumentError = exports.ActionStringOrStringArrayArgumentError = function (_ActionArgumentErrorB8) {
  						    _inherits(ActionStringOrStringArrayArgumentError, _ActionArgumentErrorB8);
  
  						    function ActionStringOrStringArrayArgumentError(argumentName, actualValue) {
  						        _classCallCheck(this, ActionStringOrStringArrayArgumentError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB8.call(this, _types.TEST_RUN_ERRORS.actionStringOrStringArrayArgumentError, argumentName, actualValue));
  						    }
  
  						    return ActionStringOrStringArrayArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var ActionStringArrayElementError = exports.ActionStringArrayElementError = function (_ActionArgumentErrorB9) {
  						    _inherits(ActionStringArrayElementError, _ActionArgumentErrorB9);
  
  						    function ActionStringArrayElementError(argumentName, actualValue, elementIndex) {
  						        _classCallCheck(this, ActionStringArrayElementError);
  
  						        var _this35 = _possibleConstructorReturn(this, _ActionArgumentErrorB9.call(this, _types.TEST_RUN_ERRORS.actionStringArrayElementError, argumentName, actualValue));
  
  						        _this35.elementIndex = elementIndex;
  						        return _this35;
  						    }
  
  						    return ActionStringArrayElementError;
  						}(ActionArgumentErrorBase);
  
  						var SetTestSpeedArgumentError = exports.SetTestSpeedArgumentError = function (_ActionArgumentErrorB10) {
  						    _inherits(SetTestSpeedArgumentError, _ActionArgumentErrorB10);
  
  						    function SetTestSpeedArgumentError(argumentName, actualValue) {
  						        _classCallCheck(this, SetTestSpeedArgumentError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB10.call(this, _types.TEST_RUN_ERRORS.setTestSpeedArgumentError, argumentName, actualValue));
  						    }
  
  						    return SetTestSpeedArgumentError;
  						}(ActionArgumentErrorBase);
  
  						var ActionUnsupportedDeviceTypeError = exports.ActionUnsupportedDeviceTypeError = function (_ActionArgumentErrorB11) {
  						    _inherits(ActionUnsupportedDeviceTypeError, _ActionArgumentErrorB11);
  
  						    function ActionUnsupportedDeviceTypeError(argumentName, argumentValue) {
  						        _classCallCheck(this, ActionUnsupportedDeviceTypeError);
  
  						        return _possibleConstructorReturn(this, _ActionArgumentErrorB11.call(this, _types.TEST_RUN_ERRORS.actionUnsupportedDeviceTypeError, argumentName, argumentValue));
  						    }
  
  						    return ActionUnsupportedDeviceTypeError;
  						}(ActionArgumentErrorBase);
  
  						// Selector errors
  
  
  						var ActionSelectorError = exports.ActionSelectorError = function (_TestRunErrorBase22) {
  						    _inherits(ActionSelectorError, _TestRunErrorBase22);
  
  						    function ActionSelectorError(selectorName, err, isAPIError) {
  						        _classCallCheck(this, ActionSelectorError);
  
  						        var _this38 = _possibleConstructorReturn(this, _TestRunErrorBase22.call(this, _types.TEST_RUN_ERRORS.actionSelectorError));
  
  						        _this38.selectorName = selectorName;
  						        _this38.errMsg = isAPIError ? err.rawMessage : err.message;
  						        _this38.originError = err;
  						        return _this38;
  						    }
  
  						    return ActionSelectorError;
  						}(TestRunErrorBase);
  
  						// Action execution errors
  						//--------------------------------------------------------------------
  
  
  						var ActionElementNotFoundError = exports.ActionElementNotFoundError = function (_SelectorErrorBase2) {
  						    _inherits(ActionElementNotFoundError, _SelectorErrorBase2);
  
  						    function ActionElementNotFoundError(apiFnArgs) {
  						        _classCallCheck(this, ActionElementNotFoundError);
  
  						        return _possibleConstructorReturn(this, _SelectorErrorBase2.call(this, _types.TEST_RUN_ERRORS.actionElementNotFoundError, apiFnArgs));
  						    }
  
  						    return ActionElementNotFoundError;
  						}(SelectorErrorBase);
  
  						var ActionElementIsInvisibleError = exports.ActionElementIsInvisibleError = function (_TestRunErrorBase23) {
  						    _inherits(ActionElementIsInvisibleError, _TestRunErrorBase23);
  
  						    function ActionElementIsInvisibleError() {
  						        _classCallCheck(this, ActionElementIsInvisibleError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase23.call(this, _types.TEST_RUN_ERRORS.actionElementIsInvisibleError));
  						    }
  
  						    return ActionElementIsInvisibleError;
  						}(TestRunErrorBase);
  
  						var ActionSelectorMatchesWrongNodeTypeError = exports.ActionSelectorMatchesWrongNodeTypeError = function (_TestRunErrorBase24) {
  						    _inherits(ActionSelectorMatchesWrongNodeTypeError, _TestRunErrorBase24);
  
  						    function ActionSelectorMatchesWrongNodeTypeError(nodeDescription) {
  						        _classCallCheck(this, ActionSelectorMatchesWrongNodeTypeError);
  
  						        var _this41 = _possibleConstructorReturn(this, _TestRunErrorBase24.call(this, _types.TEST_RUN_ERRORS.actionSelectorMatchesWrongNodeTypeError));
  
  						        _this41.nodeDescription = nodeDescription;
  						        return _this41;
  						    }
  
  						    return ActionSelectorMatchesWrongNodeTypeError;
  						}(TestRunErrorBase);
  
  						var ActionAdditionalElementNotFoundError = exports.ActionAdditionalElementNotFoundError = function (_SelectorErrorBase3) {
  						    _inherits(ActionAdditionalElementNotFoundError, _SelectorErrorBase3);
  
  						    function ActionAdditionalElementNotFoundError(argumentName, apiFnArgs) {
  						        _classCallCheck(this, ActionAdditionalElementNotFoundError);
  
  						        var _this42 = _possibleConstructorReturn(this, _SelectorErrorBase3.call(this, _types.TEST_RUN_ERRORS.actionAdditionalElementNotFoundError, apiFnArgs));
  
  						        _this42.argumentName = argumentName;
  						        return _this42;
  						    }
  
  						    return ActionAdditionalElementNotFoundError;
  						}(SelectorErrorBase);
  
  						var ActionAdditionalElementIsInvisibleError = exports.ActionAdditionalElementIsInvisibleError = function (_TestRunErrorBase25) {
  						    _inherits(ActionAdditionalElementIsInvisibleError, _TestRunErrorBase25);
  
  						    function ActionAdditionalElementIsInvisibleError(argumentName) {
  						        _classCallCheck(this, ActionAdditionalElementIsInvisibleError);
  
  						        var _this43 = _possibleConstructorReturn(this, _TestRunErrorBase25.call(this, _types.TEST_RUN_ERRORS.actionAdditionalElementIsInvisibleError));
  
  						        _this43.argumentName = argumentName;
  						        return _this43;
  						    }
  
  						    return ActionAdditionalElementIsInvisibleError;
  						}(TestRunErrorBase);
  
  						var ActionAdditionalSelectorMatchesWrongNodeTypeError = exports.ActionAdditionalSelectorMatchesWrongNodeTypeError = function (_TestRunErrorBase26) {
  						    _inherits(ActionAdditionalSelectorMatchesWrongNodeTypeError, _TestRunErrorBase26);
  
  						    function ActionAdditionalSelectorMatchesWrongNodeTypeError(argumentName, nodeDescription) {
  						        _classCallCheck(this, ActionAdditionalSelectorMatchesWrongNodeTypeError);
  
  						        var _this44 = _possibleConstructorReturn(this, _TestRunErrorBase26.call(this, _types.TEST_RUN_ERRORS.actionAdditionalSelectorMatchesWrongNodeTypeError));
  
  						        _this44.argumentName = argumentName;
  						        _this44.nodeDescription = nodeDescription;
  						        return _this44;
  						    }
  
  						    return ActionAdditionalSelectorMatchesWrongNodeTypeError;
  						}(TestRunErrorBase);
  
  						var ActionElementNonEditableError = exports.ActionElementNonEditableError = function (_TestRunErrorBase27) {
  						    _inherits(ActionElementNonEditableError, _TestRunErrorBase27);
  
  						    function ActionElementNonEditableError() {
  						        _classCallCheck(this, ActionElementNonEditableError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase27.call(this, _types.TEST_RUN_ERRORS.actionElementNonEditableError));
  						    }
  
  						    return ActionElementNonEditableError;
  						}(TestRunErrorBase);
  
  						var ActionElementNotTextAreaError = exports.ActionElementNotTextAreaError = function (_TestRunErrorBase28) {
  						    _inherits(ActionElementNotTextAreaError, _TestRunErrorBase28);
  
  						    function ActionElementNotTextAreaError() {
  						        _classCallCheck(this, ActionElementNotTextAreaError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase28.call(this, _types.TEST_RUN_ERRORS.actionElementNotTextAreaError));
  						    }
  
  						    return ActionElementNotTextAreaError;
  						}(TestRunErrorBase);
  
  						var ActionElementNonContentEditableError = exports.ActionElementNonContentEditableError = function (_TestRunErrorBase29) {
  						    _inherits(ActionElementNonContentEditableError, _TestRunErrorBase29);
  
  						    function ActionElementNonContentEditableError(argumentName) {
  						        _classCallCheck(this, ActionElementNonContentEditableError);
  
  						        var _this47 = _possibleConstructorReturn(this, _TestRunErrorBase29.call(this, _types.TEST_RUN_ERRORS.actionElementNonContentEditableError));
  
  						        _this47.argumentName = argumentName;
  						        return _this47;
  						    }
  
  						    return ActionElementNonContentEditableError;
  						}(TestRunErrorBase);
  
  						var ActionRootContainerNotFoundError = exports.ActionRootContainerNotFoundError = function (_TestRunErrorBase30) {
  						    _inherits(ActionRootContainerNotFoundError, _TestRunErrorBase30);
  
  						    function ActionRootContainerNotFoundError() {
  						        _classCallCheck(this, ActionRootContainerNotFoundError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase30.call(this, _types.TEST_RUN_ERRORS.actionRootContainerNotFoundError));
  						    }
  
  						    return ActionRootContainerNotFoundError;
  						}(TestRunErrorBase);
  
  						var ActionIncorrectKeysError = exports.ActionIncorrectKeysError = function (_TestRunErrorBase31) {
  						    _inherits(ActionIncorrectKeysError, _TestRunErrorBase31);
  
  						    function ActionIncorrectKeysError(argumentName) {
  						        _classCallCheck(this, ActionIncorrectKeysError);
  
  						        var _this49 = _possibleConstructorReturn(this, _TestRunErrorBase31.call(this, _types.TEST_RUN_ERRORS.actionIncorrectKeysError));
  
  						        _this49.argumentName = argumentName;
  						        return _this49;
  						    }
  
  						    return ActionIncorrectKeysError;
  						}(TestRunErrorBase);
  
  						var ActionCannotFindFileToUploadError = exports.ActionCannotFindFileToUploadError = function (_TestRunErrorBase32) {
  						    _inherits(ActionCannotFindFileToUploadError, _TestRunErrorBase32);
  
  						    function ActionCannotFindFileToUploadError(filePaths) {
  						        _classCallCheck(this, ActionCannotFindFileToUploadError);
  
  						        var _this50 = _possibleConstructorReturn(this, _TestRunErrorBase32.call(this, _types.TEST_RUN_ERRORS.actionCannotFindFileToUploadError));
  
  						        _this50.filePaths = filePaths;
  						        return _this50;
  						    }
  
  						    return ActionCannotFindFileToUploadError;
  						}(TestRunErrorBase);
  
  						var ActionElementIsNotFileInputError = exports.ActionElementIsNotFileInputError = function (_TestRunErrorBase33) {
  						    _inherits(ActionElementIsNotFileInputError, _TestRunErrorBase33);
  
  						    function ActionElementIsNotFileInputError() {
  						        _classCallCheck(this, ActionElementIsNotFileInputError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase33.call(this, _types.TEST_RUN_ERRORS.actionElementIsNotFileInputError));
  						    }
  
  						    return ActionElementIsNotFileInputError;
  						}(TestRunErrorBase);
  
  						var ActionInvalidScrollTargetError = exports.ActionInvalidScrollTargetError = function (_TestRunErrorBase34) {
  						    _inherits(ActionInvalidScrollTargetError, _TestRunErrorBase34);
  
  						    function ActionInvalidScrollTargetError(scrollTargetXValid, scrollTargetYValid) {
  						        _classCallCheck(this, ActionInvalidScrollTargetError);
  
  						        var _this52 = _possibleConstructorReturn(this, _TestRunErrorBase34.call(this, _types.TEST_RUN_ERRORS.actionInvalidScrollTargetError));
  
  						        if (!scrollTargetXValid) {
  						            if (!scrollTargetYValid) _this52.properties = 'scrollTargetX and scrollTargetY properties';else _this52.properties = 'scrollTargetX property';
  						        } else _this52.properties = 'scrollTargetY property';
  						        return _this52;
  						    }
  
  						    return ActionInvalidScrollTargetError;
  						}(TestRunErrorBase);
  
  						var ExecuteAsyncExpressionError = exports.ExecuteAsyncExpressionError = function (_TestRunErrorBase35) {
  						    _inherits(ExecuteAsyncExpressionError, _TestRunErrorBase35);
  
  						    function ExecuteAsyncExpressionError(err, expression, line, column, callsite) {
  						        _classCallCheck(this, ExecuteAsyncExpressionError);
  
  						        var _this53 = _possibleConstructorReturn(this, _TestRunErrorBase35.call(this, _types.TEST_RUN_ERRORS.executeAsyncExpressionError));
  
  						        _this53.errMsg = err.message;
  						        _this53.callsite = callsite;
  						        _this53.errStack = err.stack;
  						        _this53.expression = expression;
  						        _this53.line = line;
  						        _this53.column = column;
  						        return _this53;
  						    }
  
  						    return ExecuteAsyncExpressionError;
  						}(TestRunErrorBase);
  
  						var WindowDimensionsOverflowError = exports.WindowDimensionsOverflowError = function (_TestRunErrorBase36) {
  						    _inherits(WindowDimensionsOverflowError, _TestRunErrorBase36);
  
  						    function WindowDimensionsOverflowError(callsite) {
  						        _classCallCheck(this, WindowDimensionsOverflowError);
  
  						        var _this54 = _possibleConstructorReturn(this, _TestRunErrorBase36.call(this, _types.TEST_RUN_ERRORS.windowDimensionsOverflowError));
  
  						        _this54.callsite = callsite;
  						        return _this54;
  						    }
  
  						    return WindowDimensionsOverflowError;
  						}(TestRunErrorBase);
  
  						var InvalidElementScreenshotDimensionsError = exports.InvalidElementScreenshotDimensionsError = function (_TestRunErrorBase37) {
  						    _inherits(InvalidElementScreenshotDimensionsError, _TestRunErrorBase37);
  
  						    function InvalidElementScreenshotDimensionsError(width, height) {
  						        _classCallCheck(this, InvalidElementScreenshotDimensionsError);
  
  						        var _this55 = _possibleConstructorReturn(this, _TestRunErrorBase37.call(this, _types.TEST_RUN_ERRORS.invalidElementScreenshotDimensionsError));
  
  						        var widthIsInvalid = width <= 0;
  						        var heightIsInvalid = height <= 0;
  
  						        if (widthIsInvalid) {
  						            if (heightIsInvalid) {
  						                _this55.verb = 'are';
  						                _this55.dimensions = 'width and height';
  						            } else {
  						                _this55.verb = 'is';
  						                _this55.dimensions = 'width';
  						            }
  						        } else {
  						            _this55.verb = 'is';
  						            _this55.dimensions = 'height';
  						        }
  						        return _this55;
  						    }
  
  						    return InvalidElementScreenshotDimensionsError;
  						}(TestRunErrorBase);
  
  						var ForbiddenCharactersInScreenshotPathError = exports.ForbiddenCharactersInScreenshotPathError = function (_TestRunErrorBase38) {
  						    _inherits(ForbiddenCharactersInScreenshotPathError, _TestRunErrorBase38);
  
  						    function ForbiddenCharactersInScreenshotPathError(screenshotPath, forbiddenCharsList) {
  						        _classCallCheck(this, ForbiddenCharactersInScreenshotPathError);
  
  						        var _this56 = _possibleConstructorReturn(this, _TestRunErrorBase38.call(this, _types.TEST_RUN_ERRORS.forbiddenCharactersInScreenshotPathError));
  
  						        _this56.screenshotPath = screenshotPath;
  						        _this56.forbiddenCharsList = forbiddenCharsList;
  						        return _this56;
  						    }
  
  						    return ForbiddenCharactersInScreenshotPathError;
  						}(TestRunErrorBase);
  
  						var RoleSwitchInRoleInitializerError = exports.RoleSwitchInRoleInitializerError = function (_TestRunErrorBase39) {
  						    _inherits(RoleSwitchInRoleInitializerError, _TestRunErrorBase39);
  
  						    function RoleSwitchInRoleInitializerError(callsite) {
  						        _classCallCheck(this, RoleSwitchInRoleInitializerError);
  
  						        var _this57 = _possibleConstructorReturn(this, _TestRunErrorBase39.call(this, _types.TEST_RUN_ERRORS.roleSwitchInRoleInitializerError));
  
  						        _this57.callsite = callsite;
  						        return _this57;
  						    }
  
  						    return RoleSwitchInRoleInitializerError;
  						}(TestRunErrorBase);
  
  						// Iframe errors
  
  
  						var ActionElementNotIframeError = exports.ActionElementNotIframeError = function (_TestRunErrorBase40) {
  						    _inherits(ActionElementNotIframeError, _TestRunErrorBase40);
  
  						    function ActionElementNotIframeError() {
  						        _classCallCheck(this, ActionElementNotIframeError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase40.call(this, _types.TEST_RUN_ERRORS.actionElementNotIframeError));
  						    }
  
  						    return ActionElementNotIframeError;
  						}(TestRunErrorBase);
  
  						var ActionIframeIsNotLoadedError = exports.ActionIframeIsNotLoadedError = function (_TestRunErrorBase41) {
  						    _inherits(ActionIframeIsNotLoadedError, _TestRunErrorBase41);
  
  						    function ActionIframeIsNotLoadedError() {
  						        _classCallCheck(this, ActionIframeIsNotLoadedError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase41.call(this, _types.TEST_RUN_ERRORS.actionIframeIsNotLoadedError));
  						    }
  
  						    return ActionIframeIsNotLoadedError;
  						}(TestRunErrorBase);
  
  						var CurrentIframeIsNotLoadedError = exports.CurrentIframeIsNotLoadedError = function (_TestRunErrorBase42) {
  						    _inherits(CurrentIframeIsNotLoadedError, _TestRunErrorBase42);
  
  						    function CurrentIframeIsNotLoadedError() {
  						        _classCallCheck(this, CurrentIframeIsNotLoadedError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase42.call(this, _types.TEST_RUN_ERRORS.currentIframeIsNotLoadedError));
  						    }
  
  						    return CurrentIframeIsNotLoadedError;
  						}(TestRunErrorBase);
  
  						var CurrentIframeNotFoundError = exports.CurrentIframeNotFoundError = function (_TestRunErrorBase43) {
  						    _inherits(CurrentIframeNotFoundError, _TestRunErrorBase43);
  
  						    function CurrentIframeNotFoundError() {
  						        _classCallCheck(this, CurrentIframeNotFoundError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase43.call(this, _types.TEST_RUN_ERRORS.currentIframeNotFoundError));
  						    }
  
  						    return CurrentIframeNotFoundError;
  						}(TestRunErrorBase);
  
  						var CurrentIframeIsInvisibleError = exports.CurrentIframeIsInvisibleError = function (_TestRunErrorBase44) {
  						    _inherits(CurrentIframeIsInvisibleError, _TestRunErrorBase44);
  
  						    function CurrentIframeIsInvisibleError() {
  						        _classCallCheck(this, CurrentIframeIsInvisibleError);
  
  						        return _possibleConstructorReturn(this, _TestRunErrorBase44.call(this, _types.TEST_RUN_ERRORS.currentIframeIsInvisibleError));
  						    }
  
  						    return CurrentIframeIsInvisibleError;
  						}(TestRunErrorBase);
  
  						// Native dialog errors
  
  
  						var NativeDialogNotHandledError = exports.NativeDialogNotHandledError = function (_TestRunErrorBase45) {
  						    _inherits(NativeDialogNotHandledError, _TestRunErrorBase45);
  
  						    function NativeDialogNotHandledError(dialogType, url) {
  						        _classCallCheck(this, NativeDialogNotHandledError);
  
  						        var _this63 = _possibleConstructorReturn(this, _TestRunErrorBase45.call(this, _types.TEST_RUN_ERRORS.nativeDialogNotHandledError));
  
  						        _this63.dialogType = dialogType;
  						        _this63.pageUrl = url;
  						        return _this63;
  						    }
  
  						    return NativeDialogNotHandledError;
  						}(TestRunErrorBase);
  
  						var UncaughtErrorInNativeDialogHandler = exports.UncaughtErrorInNativeDialogHandler = function (_TestRunErrorBase46) {
  						    _inherits(UncaughtErrorInNativeDialogHandler, _TestRunErrorBase46);
  
  						    function UncaughtErrorInNativeDialogHandler(dialogType, errMsg, url) {
  						        _classCallCheck(this, UncaughtErrorInNativeDialogHandler);
  
  						        var _this64 = _possibleConstructorReturn(this, _TestRunErrorBase46.call(this, _types.TEST_RUN_ERRORS.uncaughtErrorInNativeDialogHandler));
  
  						        _this64.dialogType = dialogType;
  						        _this64.errMsg = errMsg;
  						        _this64.pageUrl = url;
  						        return _this64;
  						    }
  
  						    return UncaughtErrorInNativeDialogHandler;
  						}(TestRunErrorBase);
  
  						var SetNativeDialogHandlerCodeWrongTypeError = exports.SetNativeDialogHandlerCodeWrongTypeError = function (_TestRunErrorBase47) {
  						    _inherits(SetNativeDialogHandlerCodeWrongTypeError, _TestRunErrorBase47);
  
  						    function SetNativeDialogHandlerCodeWrongTypeError(actualType) {
  						        _classCallCheck(this, SetNativeDialogHandlerCodeWrongTypeError);
  
  						        var _this65 = _possibleConstructorReturn(this, _TestRunErrorBase47.call(this, _types.TEST_RUN_ERRORS.setNativeDialogHandlerCodeWrongTypeError));
  
  						        _this65.actualType = actualType;
  						        return _this65;
  						    }
  
  						    return SetNativeDialogHandlerCodeWrongTypeError;
  						}(TestRunErrorBase);
  
  						var RequestHookUnhandledError = exports.RequestHookUnhandledError = function (_TestRunErrorBase48) {
  						    _inherits(RequestHookUnhandledError, _TestRunErrorBase48);
  
  						    function RequestHookUnhandledError(err, hookClassName, methodName) {
  						        _classCallCheck(this, RequestHookUnhandledError);
  
  						        var _this66 = _possibleConstructorReturn(this, _TestRunErrorBase48.call(this, _types.TEST_RUN_ERRORS.requestHookUnhandledError));
  
  						        _this66.errMsg = String(err);
  						        _this66.hookClassName = hookClassName;
  						        _this66.methodName = methodName;
  						        return _this66;
  						    }
  
  						    return RequestHookUnhandledError;
  						}(TestRunErrorBase);
  
  						var RequestHookNotImplementedMethodError = exports.RequestHookNotImplementedMethodError = function (_TestRunErrorBase49) {
  						    _inherits(RequestHookNotImplementedMethodError, _TestRunErrorBase49);
  
  						    function RequestHookNotImplementedMethodError(methodName, hookClassName) {
  						        _classCallCheck(this, RequestHookNotImplementedMethodError);
  
  						        var _this67 = _possibleConstructorReturn(this, _TestRunErrorBase49.call(this, _types.TEST_RUN_ERRORS.requestHookNotImplementedError));
  
  						        _this67.methodName = methodName;
  						        _this67.hookClassName = hookClassName;
  						        return _this67;
  						    }
  
  						    return RequestHookNotImplementedMethodError;
  						}(TestRunErrorBase);
  					}
  				},
  				"types.js": function (exports, module, require) {
  					
  
  					exports.__esModule = true;
  					// -------------------------------------------------------------
  					// 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 = exports.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',
  					    executeAsyncExpressionError: 'E66'
  					};
  
  					var RUNTIME_ERRORS = exports.RUNTIME_ERRORS = {
  					    cannotCreateMultipleLiveModeRunners: 'E1000',
  					    cannotRunLiveModeRunnerMultipleTimes: 'E1001',
  					    browserDisconnected: 'E1002',
  					    cannotRunAgainstDisconnectedBrowsers: 'E1003',
  					    cannotEstablishBrowserConnection: 'E1004',
  					    cannotFindBrowser: 'E1005',
  					    browserProviderNotFound: 'E1006',
  					    browserNotSet: 'E1007',
  					    testSourcesNotSet: 'E1008',
  					    noTestsToRun: 'E1009',
  					    cannotFindReporterForAlias: 'E1010',
  					    multipleStdoutReporters: 'E1011',
  					    optionValueIsNotValidRegExp: 'E1012',
  					    optionValueIsNotValidKeyValue: 'E1013',
  					    invalidSpeedValue: 'E1014',
  					    invalidConcurrencyFactor: 'E1015',
  					    cannotDivideRemotesCountByConcurrency: 'E1016',
  					    portsOptionRequiresTwoNumbers: 'E1017',
  					    portIsNotFree: 'E1018',
  					    invalidHostname: 'E1019',
  					    cannotFindSpecifiedTestSource: 'E1020',
  					    clientFunctionCodeIsNotAFunction: 'E1021',
  					    selectorInitializedWithWrongType: 'E1022',
  					    clientFunctionCannotResolveTestRun: 'E1023',
  					    regeneratorInClientFunctionCode: 'E1024',
  					    invalidClientFunctionTestRunBinding: 'E1025',
  					    invalidValueType: 'E1026',
  					    unsupportedUrlProtocol: 'E1027',
  					    testControllerProxyCannotResolveTestRun: 'E1028',
  					    timeLimitedPromiseTimeoutExpired: 'E1029',
  					    cannotUseScreenshotPathPatternWithoutBaseScreenshotPathSpecified: 'E1030',
  					    cannotSetVideoOptionsWithoutBaseVideoPathSpecified: 'E1031',
  					    multipleAPIMethodCallForbidden: 'E1032',
  					    invalidReporterOutput: 'E1033',
  					    cannotReadSSLCertFile: 'E1034',
  					    cannotPrepareTestsDueToError: 'E1035',
  					    cannotParseRawFile: 'E1036',
  					    testedAppFailedWithError: 'E1037',
  					    unableToOpenBrowser: 'E1038',
  					    requestHookConfigureAPIError: 'E1039',
  					    forbiddenCharatersInScreenshotPath: 'E1040',
  					    cannotFindFFMPEG: 'E1041',
  					    compositeArgumentsError: 'E1042',
  					    cannotFindTypescriptConfigurationFile: 'E1043',
  					    clientScriptInitializerIsNotSpecified: 'E1044',
  					    clientScriptBasePathIsNotSpecified: 'E1045',
  					    clientScriptInitializerMultipleContentSources: 'E1046',
  					    cannotLoadClientScriptFromPath: 'E1047',
  					    clientScriptModuleEntryPointPathCalculationError: 'E1048'
  					};
  				}
  			},
  			"test-run": {
  				"browser-console-messages.js": function (exports, module, require) {
  					
  
  					exports.__esModule = true;
  
  					var _assignable = require('../utils/assignable');
  
  					var _assignable2 = _interopRequireDefault(_assignable);
  
  					function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  					function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  					function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  					function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // -------------------------------------------------------------
  					// WARNING: this file is used by both the client and the server.
  					// Do not use any browser or node-specific API!
  					// -------------------------------------------------------------
  
  
  					var BrowserConsoleMessages = function (_Assignable) {
  					    _inherits(BrowserConsoleMessages, _Assignable);
  
  					    function BrowserConsoleMessages(obj) {
  					        _classCallCheck(this, BrowserConsoleMessages);
  
  					        var _this = _possibleConstructorReturn(this, _Assignable.call(this));
  
  					        _this.log = [];
  					        _this.info = [];
  					        _this.warn = [];
  					        _this.error = [];
  
  					        _this._assignFrom(obj);
  					        return _this;
  					    }
  
  					    BrowserConsoleMessages.prototype._getAssignableProperties = function _getAssignableProperties() {
  					        return [{ name: 'log' }, { name: 'info' }, { name: 'warn' }, { name: 'error' }];
  					    };
  
  					    BrowserConsoleMessages.prototype.concat = function concat(consoleMessages) {
  					        this.log = this.log.concat(consoleMessages.log);
  					        this.info = this.info.concat(consoleMessages.info);
  					        this.warn = this.warn.concat(consoleMessages.warn);
  					        this.error = this.error.concat(consoleMessages.error);
  					    };
  
  					    BrowserConsoleMessages.prototype.addMessage = function addMessage(type, msg) {
  					        this[type].push(msg);
  					    };
  
  					    BrowserConsoleMessages.prototype.getCopy = function getCopy() {
  					        var copy = {};
  					        var properties = this._getAssignableProperties();
  
  					        for (var _i2 = 0, _length2 = properties.length; _i2 < _length2; _i2++) {
  					            var property = properties[_i2];
  					            copy[property.name] = this[property.name].slice();
  					        }
  
  					        return copy;
  					    };
  
  					    return BrowserConsoleMessages;
  					}(_assignable2.default);
  
  					exports.default = BrowserConsoleMessages;
  					module.exports = exports['default'];
  				},
  				"client-messages.js": function (exports, module, require) {
  					
  
  					exports.__esModule = true;
  					exports.default = {
  					    ready: 'ready',
  					    readyForBrowserManipulation: 'ready-for-browser-manipulation',
  					    waitForFileDownload: 'wait-for-file-download'
  					};
  					module.exports = exports['default'];
  				},
  				"commands": {
  					"options.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  						exports.AssertionOptions = exports.ResizeToFitDeviceOptions = exports.DragToElementOptions = exports.TypeOptions = exports.MoveOptions = exports.ClickOptions = exports.MouseOptions = exports.ElementScreenshotOptions = exports.ScrollOptions = exports.OffsetOptions = exports.ActionOptions = exports.speedOption = exports.booleanOption = exports.positiveIntegerOption = exports.integerOption = undefined;
  
  						var _assignable = require('../../utils/assignable');
  
  						var _assignable2 = _interopRequireDefault(_assignable);
  
  						var _factories = require('./validations/factories');
  
  						var _testRun = require('../../errors/test-run');
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  						function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  						function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // -------------------------------------------------------------
  						// WARNING: this file is used by both the client and the server.
  						// Do not use any browser or node-specific API!
  						// -------------------------------------------------------------
  
  						var integerOption = exports.integerOption = (0, _factories.createIntegerValidator)(_testRun.ActionIntegerOptionError);
  						var positiveIntegerOption = exports.positiveIntegerOption = (0, _factories.createPositiveIntegerValidator)(_testRun.ActionPositiveIntegerOptionError);
  						var booleanOption = exports.booleanOption = (0, _factories.createBooleanValidator)(_testRun.ActionBooleanOptionError);
  						var speedOption = exports.speedOption = (0, _factories.createSpeedValidator)(_testRun.ActionSpeedOptionError);
  
  						// Acitons
  
  						var ActionOptions = exports.ActionOptions = function (_Assignable) {
  						    _inherits(ActionOptions, _Assignable);
  
  						    function ActionOptions(obj, validate) {
  						        _classCallCheck(this, ActionOptions);
  
  						        var _this = _possibleConstructorReturn(this, _Assignable.call(this));
  
  						        _this.speed = null;
  
  						        _this._assignFrom(obj, validate);
  						        return _this;
  						    }
  
  						    ActionOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return [{ name: 'speed', type: speedOption }];
  						    };
  
  						    return ActionOptions;
  						}(_assignable2.default);
  
  						// Offset
  
  
  						var OffsetOptions = exports.OffsetOptions = function (_ActionOptions) {
  						    _inherits(OffsetOptions, _ActionOptions);
  
  						    function OffsetOptions(obj, validate) {
  						        _classCallCheck(this, OffsetOptions);
  
  						        var _this2 = _possibleConstructorReturn(this, _ActionOptions.call(this));
  
  						        _this2.offsetX = null;
  						        _this2.offsetY = null;
  
  						        _this2._assignFrom(obj, validate);
  						        return _this2;
  						    }
  
  						    OffsetOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return _ActionOptions.prototype._getAssignableProperties.call(this).concat([{ name: 'offsetX', type: integerOption }, { name: 'offsetY', type: integerOption }]);
  						    };
  
  						    return OffsetOptions;
  						}(ActionOptions);
  
  						var ScrollOptions = exports.ScrollOptions = function (_OffsetOptions) {
  						    _inherits(ScrollOptions, _OffsetOptions);
  
  						    function ScrollOptions(obj, validate) {
  						        _classCallCheck(this, ScrollOptions);
  
  						        var _this3 = _possibleConstructorReturn(this, _OffsetOptions.call(this));
  
  						        _this3.scrollToCenter = false;
  						        _this3.skipParentFrames = false;
  
  						        _this3._assignFrom(obj, validate);
  						        return _this3;
  						    }
  
  						    ScrollOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return _OffsetOptions.prototype._getAssignableProperties.call(this).concat([{ name: 'scrollToCenter', type: booleanOption }, { name: 'skipParentFrames', type: booleanOption }]);
  						    };
  
  						    return ScrollOptions;
  						}(OffsetOptions);
  
  						// Element Screenshot
  
  
  						var ElementScreenshotOptions = exports.ElementScreenshotOptions = function (_ActionOptions2) {
  						    _inherits(ElementScreenshotOptions, _ActionOptions2);
  
  						    function ElementScreenshotOptions(obj, validate) {
  						        _classCallCheck(this, ElementScreenshotOptions);
  
  						        var _this4 = _possibleConstructorReturn(this, _ActionOptions2.call(this));
  
  						        _this4.scrollTargetX = null;
  						        _this4.scrollTargetY = null;
  						        _this4.includeMargins = false;
  						        _this4.includeBorders = true;
  						        _this4.includePaddings = true;
  
  						        _this4.crop = {
  						            left: null,
  						            right: null,
  						            top: null,
  						            bottom: null
  						        };
  
  						        _this4._assignFrom(obj, validate);
  						        return _this4;
  						    }
  
  						    ElementScreenshotOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return _ActionOptions2.prototype._getAssignableProperties.call(this).concat([{ name: 'scrollTargetX', type: integerOption }, { name: 'scrollTargetY', type: integerOption }, { name: 'crop.left', type: integerOption }, { name: 'crop.right', type: integerOption }, { name: 'crop.top', type: integerOption }, { name: 'crop.bottom', type: integerOption }, { name: 'includeMargins', type: booleanOption }, { name: 'includeBorders', type: booleanOption }, { name: 'includePaddings', type: booleanOption }]);
  						    };
  
  						    return ElementScreenshotOptions;
  						}(ActionOptions);
  
  						// Mouse
  
  
  						var MouseOptions = exports.MouseOptions = function (_OffsetOptions2) {
  						    _inherits(MouseOptions, _OffsetOptions2);
  
  						    function MouseOptions(obj, validate) {
  						        _classCallCheck(this, MouseOptions);
  
  						        var _this5 = _possibleConstructorReturn(this, _OffsetOptions2.call(this));
  
  						        _this5.modifiers = {
  						            ctrl: false,
  						            alt: false,
  						            shift: false,
  						            meta: false
  						        };
  
  						        _this5._assignFrom(obj, validate);
  						        return _this5;
  						    }
  
  						    MouseOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return _OffsetOptions2.prototype._getAssignableProperties.call(this).concat([{ name: 'modifiers.ctrl', type: booleanOption }, { name: 'modifiers.alt', type: booleanOption }, { name: 'modifiers.shift', type: booleanOption }, { name: 'modifiers.meta', type: booleanOption }]);
  						    };
  
  						    return MouseOptions;
  						}(OffsetOptions);
  
  						// Click
  
  
  						var ClickOptions = exports.ClickOptions = function (_MouseOptions) {
  						    _inherits(ClickOptions, _MouseOptions);
  
  						    function ClickOptions(obj, validate) {
  						        _classCallCheck(this, ClickOptions);
  
  						        var _this6 = _possibleConstructorReturn(this, _MouseOptions.call(this));
  
  						        _this6.caretPos = null;
  
  						        _this6._assignFrom(obj, validate);
  						        return _this6;
  						    }
  
  						    ClickOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return _MouseOptions.prototype._getAssignableProperties.call(this).concat([{ name: 'caretPos', type: positiveIntegerOption }]);
  						    };
  
  						    return ClickOptions;
  						}(MouseOptions);
  
  						// Move
  
  
  						var MoveOptions = exports.MoveOptions = function (_MouseOptions2) {
  						    _inherits(MoveOptions, _MouseOptions2);
  
  						    function MoveOptions(obj, validate) {
  						        _classCallCheck(this, MoveOptions);
  
  						        var _this7 = _possibleConstructorReturn(this, _MouseOptions2.call(this));
  
  						        _this7.speed = null;
  						        _this7.minMovingTime = null;
  						        _this7.holdLeftButton = false;
  						        _this7.skipScrolling = false;
  						        _this7.skipDefaultDragBehavior = false;
  
  						        _this7._assignFrom(obj, validate);
  						        return _this7;
  						    }
  
  						    MoveOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return _MouseOptions2.prototype._getAssignableProperties.call(this).concat([{ name: 'speed' }, { name: 'minMovingTime' }, { name: 'holdLeftButton' }, { name: 'skipScrolling', type: booleanOption }, { name: 'skipDefaultDragBehavior', type: booleanOption }]);
  						    };
  
  						    return MoveOptions;
  						}(MouseOptions);
  
  						// Type
  
  
  						var TypeOptions = exports.TypeOptions = function (_ClickOptions) {
  						    _inherits(TypeOptions, _ClickOptions);
  
  						    function TypeOptions(obj, validate) {
  						        _classCallCheck(this, TypeOptions);
  
  						        var _this8 = _possibleConstructorReturn(this, _ClickOptions.call(this));
  
  						        _this8.replace = false;
  						        _this8.paste = false;
  
  						        _this8._assignFrom(obj, validate);
  						        return _this8;
  						    }
  
  						    TypeOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return _ClickOptions.prototype._getAssignableProperties.call(this).concat([{ name: 'replace', type: booleanOption }, { name: 'paste', type: booleanOption }]);
  						    };
  
  						    return TypeOptions;
  						}(ClickOptions);
  
  						// DragToElement
  
  
  						var DragToElementOptions = exports.DragToElementOptions = function (_MouseOptions3) {
  						    _inherits(DragToElementOptions, _MouseOptions3);
  
  						    function DragToElementOptions(obj, validate) {
  						        _classCallCheck(this, DragToElementOptions);
  
  						        var _this9 = _possibleConstructorReturn(this, _MouseOptions3.call(this, obj, validate));
  
  						        _this9.destinationOffsetX = null;
  						        _this9.destinationOffsetY = null;
  
  						        _this9._assignFrom(obj, validate);
  						        return _this9;
  						    }
  
  						    DragToElementOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return _MouseOptions3.prototype._getAssignableProperties.call(this).concat([{ name: 'destinationOffsetX', type: integerOption }, { name: 'destinationOffsetY', type: integerOption }]);
  						    };
  
  						    return DragToElementOptions;
  						}(MouseOptions);
  
  						//ResizeToFitDevice
  
  
  						var ResizeToFitDeviceOptions = exports.ResizeToFitDeviceOptions = function (_Assignable2) {
  						    _inherits(ResizeToFitDeviceOptions, _Assignable2);
  
  						    function ResizeToFitDeviceOptions(obj, validate) {
  						        _classCallCheck(this, ResizeToFitDeviceOptions);
  
  						        var _this10 = _possibleConstructorReturn(this, _Assignable2.call(this));
  
  						        _this10.portraitOrientation = false;
  
  						        _this10._assignFrom(obj, validate);
  						        return _this10;
  						    }
  
  						    ResizeToFitDeviceOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return [{ name: 'portraitOrientation', type: booleanOption }];
  						    };
  
  						    return ResizeToFitDeviceOptions;
  						}(_assignable2.default);
  
  						//Assertion
  
  
  						var AssertionOptions = exports.AssertionOptions = function (_Assignable3) {
  						    _inherits(AssertionOptions, _Assignable3);
  
  						    function AssertionOptions(obj, validate) {
  						        _classCallCheck(this, AssertionOptions);
  
  						        var _this11 = _possibleConstructorReturn(this, _Assignable3.call(this));
  
  						        _this11.timeout = void 0;
  						        _this11.allowUnawaitedPromise = false;
  
  						        _this11._assignFrom(obj, validate);
  						        return _this11;
  						    }
  
  						    AssertionOptions.prototype._getAssignableProperties = function _getAssignableProperties() {
  						        return [{ name: 'timeout', type: positiveIntegerOption }, { name: 'allowUnawaitedPromise', type: booleanOption }];
  						    };
  
  						    return AssertionOptions;
  						}(_assignable2.default);
  					},
  					"type.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  						// -------------------------------------------------------------
  						// WARNING: this file is used by both the client and the server.
  						// Do not use any browser or node-specific API!
  						// -------------------------------------------------------------
  
  						exports.default = {
  						    click: 'click',
  						    rightClick: 'right-click',
  						    doubleClick: 'double-click',
  						    drag: 'drag',
  						    dragToElement: 'drag-to-element',
  						    hover: 'hover',
  						    typeText: 'type-text',
  						    selectText: 'select-text',
  						    selectTextAreaContent: 'select-text-area-content',
  						    selectEditableContent: 'select-editable-content',
  						    pressKey: 'press-key',
  						    wait: 'wait',
  						    navigateTo: 'navigate-to',
  						    setFilesToUpload: 'set-files-to-upload',
  						    clearUpload: 'clear-upload',
  						    executeClientFunction: 'execute-client-function',
  						    executeSelector: 'execute-selector',
  						    takeScreenshot: 'take-screenshot',
  						    takeElementScreenshot: 'take-element-screenshot',
  						    takeScreenshotOnFail: 'take-screenshot-on-fail',
  						    prepareBrowserManipulation: 'prepare-browser-manipulation',
  						    showAssertionRetriesStatus: 'show-assertion-retries-status',
  						    hideAssertionRetriesStatus: 'hide-assertion-retries-status',
  						    setBreakpoint: 'set-breakpoint',
  						    resizeWindow: 'resize-window',
  						    resizeWindowToFitDevice: 'resize-window-to-fit-device',
  						    maximizeWindow: 'maximize-window',
  						    switchToIframe: 'switch-to-iframe',
  						    switchToMainWindow: 'switch-to-main-window',
  						    setNativeDialogHandler: 'set-native-dialog-handler',
  						    getNativeDialogHistory: 'get-native-dialog-history',
  						    getBrowserConsoleMessages: 'get-browser-console-messages',
  						    setTestSpeed: 'set-test-speed',
  						    setPageLoadTimeout: 'set-page-load-timeout',
  						    debug: 'debug',
  						    assertion: 'assertion',
  						    useRole: 'useRole',
  						    testDone: 'test-done',
  						    backupStorages: 'backup-storages',
  						    executeExpression: 'execute-expression',
  						    executeAsyncExpression: 'execute-async-expression',
  						    unlockPage: 'unlock-page'
  						};
  						module.exports = exports['default'];
  					},
  					"utils.js": function (exports, module, require) {
  						
  
  						exports.__esModule = true;
  						exports.isCommandRejectableByPageError = isCommandRejectableByPageError;
  						exports.canSetDebuggerBreakpointBeforeCommand = canSetDebuggerBreakpointBeforeCommand;
  						exports.isScreenshotCommand = isScreenshotCommand;
  						exports.isResizeWindowCommand = isResizeWindowCommand;
  						exports.isBrowserManipulationCommand = isBrowserManipulationCommand;
  						exports.isServiceCommand = isServiceCommand;
  						exports.isExecutableInTopWindowOnly = isExecutableInTopWindowOnly;
  						exports.isJSExpression = isJSExpression;
  						exports.isExecutableOnClientCommand = isExecutableOnClientCommand;
  
  						var _type = require('./type');
  
  						var _type2 = _interopRequireDefault(_type);
  
  						function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  						var RAW_API_JS_EXPRESSION_TYPE = 'js-expr'; // -------------------------------------------------------------
  						// WARNING: this file is used by both the client and the server.
  						// Do not use any browser or node-specific API!
  						// -------------------------------------------------------------
  						function isCommandRejectableByPageError(command) {
  						    return !isObservationCommand(command) && !isBrowserManipulationCommand(command) && !isServiceCommand(command) || isResizeWindowCommand(command) && !isWindowSwitchingCommand(command);
  						}
  
  						function isClientFunctionCommand(command) {
  						    return command.type === _type2.default.executeClientFunction || command.type === _type2.default.executeSelector;
  						}
  
  						function isObservationCommand(command) {
  						    return isClientFunctionCommand(command) || command.type === _type2.default.wait || command.type === _type2.default.assertion || command.type === _type2.default.executeExpression;
  						}
  
  						function isWindowSwitchingCommand(command) {
  						    return command.type === _type2.default.switchToIframe || command.type === _type2.default.switchToMainWindow;
  						}
  
  						function canSetDebuggerBreakpointBeforeCommand(command) {
  						    return command.type !== _type2.default.debug && !isClientFunctionCommand(command) && !isServiceCommand(command);
  						}
  
  						function isScreenshotCommand(command) {
  						    return command.type === _type2.default.takeScreenshot || command.type === _type2.default.takeElementScreenshot || command.type === _type2.default.takeScreenshotOnFail;
  						}
  
  						function isResizeWindowCommand(command) {
  						    return command.type === _type2.default.resizeWindow || command.type === _type2.default.resizeWindowToFitDevice || command.type === _type2.default.maximizeWindow;
  						}
  
  						function isBrowserManipulationCommand(command) {
  						    return isScreenshotCommand(command) || isResizeWindowCommand(command);
  						}
  
  						function isServiceCommand(command) {
  						    return command.type === _type2.default.testDone || command.type === _type2.default.showAssertionRetriesStatus || command.type === _type2.default.hideAssertionRetriesStatus || command.type === _type2.default.setBreakpoint || command.type === _type2.default.takeScreenshotOnFail;
  						}
  
  						function isExecutableInTopWindowOnly(command) {
  						    return command.type === _type2.default.testDone || command.type === _type2.default.switchToMainWindow || command.type === _type2.default.setNativeDialogHandler || command.type === _type2.default.getNativeDialogHistory || command.type === _type2.default.setTestSpeed || command.type === _type2.default.showAssertionRetriesStatus || command.type === _type2.default.hideAssertionRetriesStatus || command.type === _type2.default.setBreakpoint || isBrowserManipulationCommand(command) && command.type !== _type2.default.takeElementScreenshot;
  						}
  
  						function isJSExpression(val) {
  						    return val !== null && typeof val === 'object' && val.type === RAW_API_JS_EXPRESSION_TYPE && typeof val.value === 'string';
  						}
  
  						function isExecutableOnClientCommand(command) {
  						    return command.type !== _type2.default.wait && command.type !== _type2.default.setPageLoadTimeout && command.type !== _type2.default.debug && command.type !== _type2.default.useRole && command.type !== _type2.default.assertion && command.type !== _type2.default.executeExpression && command.type !== _type2.default.executeAsyncExpression;
  						}
  					},
  					"validations": {
  						"factories.js": function (exports, module, require) {
  							
  
  							exports.__esModule = true;
  							exports.createIntegerValidator = createIntegerValidator;
  							exports.createPositiveIntegerValidator = createPositiveIntegerValidator;
  							exports.createBooleanValidator = createBooleanValidator;
  							exports.createSpeedValidator = createSpeedValidator;
  							// -------------------------------------------------------------
  							// WARNING: this file is used by both the client and the server.
  							// Do not use any browser or node-specific API!
  							// -------------------------------------------------------------
  
  							function createIntegerValidator(ErrorCtor) {
  							    return function (name, val) {
  							        var valType = typeof val;
  
  							        if (valType !== 'number') throw new ErrorCtor(name, valType);
  
  							        var isInteger = !isNaN(val) && isFinite(val) && val === Math.floor(val);
  
  							        if (!isInteger) throw new ErrorCtor(name, val);
  							    };
  							}
  
  							function createPositiveIntegerValidator(ErrorCtor) {
  							    var integerValidator = createIntegerValidator(ErrorCtor);
  
  							    return function (name, val) {
  							        integerValidator(name, val);
  
  							        if (val < 0) throw new ErrorCtor(name, val);
  							    };
  							}
  
  							function createBooleanValidator(ErrorCtor) {
  							    return function (name, val) {
  							        var valType = typeof val;
  
  							        if (valType !== 'boolean') throw new ErrorCtor(name, valType);
  							    };
  							}
  
  							function createSpeedValidator(ErrorCtor) {
  							    return function (name, val) {
  							        var valType = typeof val;
  
  							        if (valType !== 'number') throw new ErrorCtor(name, valType);
  
  							        if (isNaN(val) || val < 0.01 || val > 1) throw new ErrorCtor(name, val);
  							    };
  							}
  						}
  					}
  				}
  			},
  			"utils": {
  				"assignable.js": function (exports, module, require) {
  					
  
  					exports.__esModule = true;
  
  					function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  					// -------------------------------------------------------------
  					// WARNING: this file is used by both the client and the server.
  					// Do not use any browser or node-specific API!
  					// -------------------------------------------------------------
  
  					var Assignable = function () {
  					    function Assignable() {
  					        _classCallCheck(this, Assignable);
  					    }
  
  					    Assignable.prototype._getAssignableProperties = function _getAssignableProperties() {
  					        throw new Error('Not implemented');
  					    };
  
  					    Assignable.prototype._assignFrom = function _assignFrom(obj, validate) {
  					        var initOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  
  					        if (!obj) return;
  
  					        var props = this._getAssignableProperties();
  
  					        for (var i = 0; i < props.length; i++) {
  					            var _props$i = props[i],
  					                name = _props$i.name,
  					                type = _props$i.type,
  					                required = _props$i.required,
  					                init = _props$i.init,
  					                defaultValue = _props$i.defaultValue;
  
  
  					            var path = name.split('.');
  					            var lastIdx = path.length - 1;
  					            var last = path[lastIdx];
  					            var srcObj = obj;
  					            var destObj = this;
  
  					            for (var j = 0; j < lastIdx && srcObj && destObj; j++) {
  					                srcObj = srcObj[path[j]];
  					                destObj = destObj[path[j]];
  					            }
  
  					            if (destObj && 'defaultValue' in props[i]) destObj[name] = defaultValue;
  
  					            if (srcObj && destObj) {
  					                var srcVal = srcObj[last];
  
  					                if (srcVal !== void 0 || required) {
  					                    if (validate && type) type(name, srcVal);
  
  					                    destObj[last] = init ? init(name, srcVal, initOptions) : srcVal;
  					                }
  					            }
  					        }
  					    };
  
  					    return Assignable;
  					}();
  
  					exports.default = Assignable;
  					module.exports = exports['default'];
  				},
  				"browser-connection-timeouts.js": function (exports, module, require) {
  					
  
  					exports.__esModule = true;
  					// -------------------------------------------------------------
  					// WARNING: this file is used by both the client and the server.
  					// Do not use any browser or node-specific API!
  					// -------------------------------------------------------------
  
  					var HEARTBEAT_TIMEOUT = exports.HEARTBEAT_TIMEOUT = 2 * 60 * 1000;
  					var BROWSER_RESTART_TIMEOUT = exports.BROWSER_RESTART_TIMEOUT = 60 * 1000;
  
  					var HEARTBEAT_INTERVAL = exports.HEARTBEAT_INTERVAL = 2 * 1000;
  
  					var CHECK_IFRAME_DRIVER_LINK_DELAY = exports.CHECK_IFRAME_DRIVER_LINK_DELAY = 500;
  					var SEND_STATUS_REQUEST_TIME_LIMIT = exports.SEND_STATUS_REQUEST_TIME_LIMIT = 5000;
  					var SEND_STATUS_REQUEST_RETRY_DELAY = exports.SEND_STATUS_REQUEST_RETRY_DELAY = 300;
  					var SEND_STATUS_REQUEST_RETRY_COUNT = exports.SEND_STATUS_REQUEST_RETRY_COUNT = Math.floor(HEARTBEAT_TIMEOUT / SEND_STATUS_REQUEST_RETRY_DELAY - 1);
  					var CHECK_STATUS_RETRY_DELAY = exports.CHECK_STATUS_RETRY_DELAY = 1000;
  				},
  				"limit-number.js": function (exports, module, require) {
  					
  
  					exports.__esModule = true;
  
  					exports.default = function (value, min, max) {
  					    return Math.min(Math.max(min, value), max);
  					};
  
  					module.exports = exports["default"]; // -------------------------------------------------------------
  					// WARNING: this file is used by both the client and the server.
  					// Do not use any browser or node-specific API!
  					// -------------------------------------------------------------
  				}
  			}
  		}
  	}
  })("testcafe-release/src/client/driver/index");
  
      }
  
      initTestCafeClientDrivers(window);
  })();
  