(function () {

    /******************************************************************************
    Copyright (c) Microsoft Corporation.

    Permission to use, copy, modify, and/or distribute this software for any
    purpose with or without fee is hereby granted.

    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
    PERFORMANCE OF THIS SOFTWARE.
    ***************************************************************************** */
    /* global Reflect, Promise */

    var extendStatics = function(d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    function __spreadArray(to, from, pack) {
        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
            if (ar || !(i in from)) {
                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
                ar[i] = from[i];
            }
        }
        return to.concat(ar || Array.prototype.slice.call(from));
    }

    // -------------------------------------------------------------
    // WARNING: this file is used by both the client and the server.
    // Do not use any browser or node-specific API!
    // -------------------------------------------------------------
    // NOTE: Some websites override the String.prototype.trim method. When we use this function
    // in our scripts, we expect it to have the default behavior. Therefore, in order to protect
    // ourselves from spoofing, we must use our own implementation. Also, we cannot use the
    // String.prototype.trim method because on the client-side it is the same in the top window and
    // an iframe window. The client code may override this method in the top window before the
    // iframe is initialized, so that the iframe will lose access to the native method.
    function trim (str) {
        return typeof str === 'string' ? str.replace(/(^\s+)|(\s+$)/g, '') : str;
    }

    // -------------------------------------------------------------
    var URL_RE = /^\s*([\w-]+?:)?(?:\/\/(?:([^/]+)@)?(([^/%?;#: ]*)(?::(\d+))?))?(.*?)\s*$/;
    var PROTOCOL_RE = /^([\w-]+?:)(\/\/|[^\\/]|$)/;
    var PATH_AFTER_HOST_RE = /^\/([^/]+?)\/([\S\s]+)$/;
    var FILE_RE = /^file:/i;
    var SHORT_ORIGIN_RE = /^http(s)?:\/\//;
    var IS_SECURE_ORIGIN_RE = /^s\*/;
    var SUPPORTED_PROTOCOL_RE = /^(?:https?|file):/i;
    var HASH_RE = /^#/;
    var REQUEST_DESCRIPTOR_VALUES_SEPARATOR = '!';
    var REQUEST_DESCRIPTOR_SESSION_INFO_VALUES_SEPARATOR = '*';
    var TRAILING_SLASH_RE = /\/$/;
    var SPECIAL_BLANK_PAGE = 'about:blank';
    var SPECIAL_ERROR_PAGE = 'about:error';
    var SPECIAL_PAGES = [SPECIAL_BLANK_PAGE, SPECIAL_ERROR_PAGE];
    var HTTP_DEFAULT_PORT = '80';
    var HTTPS_DEFAULT_PORT = '443';
    var Credentials;
    (function (Credentials) {
        Credentials[Credentials["include"] = 0] = "include";
        Credentials[Credentials["sameOrigin"] = 1] = "sameOrigin";
        Credentials[Credentials["omit"] = 2] = "omit";
        Credentials[Credentials["unknown"] = 3] = "unknown";
    })(Credentials || (Credentials = {})); // eslint-disable-line no-shadow
    var SPECIAL_PAGE_DEST_RESOURCE_INFO = {
        protocol: 'about:',
        host: '',
        hostname: '',
        port: '',
        partAfterHost: '',
    };
    var RESOURCE_TYPES = [
        { name: 'isIframe', flag: 'i' },
        { name: 'isForm', flag: 'f' },
        { name: 'isScript', flag: 's' },
        { name: 'isEventSource', flag: 'e' },
        { name: 'isHtmlImport', flag: 'h' },
        { name: 'isWebSocket', flag: 'w' },
        { name: 'isServiceWorker', flag: 'c' },
        { name: 'isAjax', flag: 'a' },
        { name: 'isObject', flag: 'o' },
    ];
    function parseResourceType(resourceType) {
        var parsedResourceType = {};
        if (!resourceType)
            return parsedResourceType;
        for (var _i = 0, RESOURCE_TYPES_1 = RESOURCE_TYPES; _i < RESOURCE_TYPES_1.length; _i++) {
            var _a = RESOURCE_TYPES_1[_i], name_1 = _a.name, flag = _a.flag;
            if (resourceType.indexOf(flag) > -1)
                parsedResourceType[name_1] = true;
        }
        return parsedResourceType;
    }
    function getResourceTypeString(parsedResourceType) {
        if (!parsedResourceType)
            return null;
        var resourceType = '';
        for (var _i = 0, RESOURCE_TYPES_2 = RESOURCE_TYPES; _i < RESOURCE_TYPES_2.length; _i++) {
            var _a = RESOURCE_TYPES_2[_i], name_2 = _a.name, flag = _a.flag;
            if (parsedResourceType[name_2])
                resourceType += flag;
        }
        return resourceType || null;
    }
    function makeShortOrigin(origin) {
        return origin === 'null' ? '' : origin.replace(SHORT_ORIGIN_RE, function (_, secure) { return secure ? 's*' : ''; });
    }
    function restoreShortOrigin(origin) {
        if (!origin)
            return 'null';
        return IS_SECURE_ORIGIN_RE.test(origin) ? origin.replace(IS_SECURE_ORIGIN_RE, 'https://') : 'http://' + origin;
    }
    function sameOriginCheck$1(location, checkedUrl) {
        if (!checkedUrl)
            return true;
        var parsedCheckedUrl = parseUrl$1(checkedUrl);
        var isRelative = !parsedCheckedUrl.host;
        if (isRelative)
            return true;
        var parsedLocation = parseUrl$1(location);
        var parsedProxyLocation = parseProxyUrl$1(location);
        if (parsedCheckedUrl.host === parsedLocation.host && parsedCheckedUrl.protocol === parsedLocation.protocol)
            return true;
        var parsedDestUrl = parsedProxyLocation ? parsedProxyLocation.destResourceInfo : parsedLocation;
        if (!parsedDestUrl)
            return false;
        var isSameProtocol = !parsedCheckedUrl.protocol || parsedCheckedUrl.protocol === parsedDestUrl.protocol;
        var portsEq = !parsedDestUrl.port && !parsedCheckedUrl.port ||
            parsedDestUrl.port && parsedDestUrl.port.toString() === parsedCheckedUrl.port;
        return isSameProtocol && !!portsEq && parsedDestUrl.hostname === parsedCheckedUrl.hostname;
    }
    // NOTE: Convert the destination protocol and hostname to the lower case. (GH-1)
    function convertHostToLowerCase(url) {
        var parsedUrl = parseUrl$1(url);
        parsedUrl.protocol = parsedUrl.protocol && parsedUrl.protocol.toLowerCase();
        parsedUrl.host = parsedUrl.host && parsedUrl.host.toLowerCase();
        return formatUrl(parsedUrl);
    }
    function getURLString(url) {
        // TODO: fix it
        // eslint-disable-next-line no-undef
        if (url === null && /iPad|iPhone/i.test(window.navigator.userAgent))
            return '';
        return String(url).replace(/[\n\t]/g, '');
    }
    function getProxyUrl$1(url, opts) {
        var sessionInfo = [opts.sessionId];
        if (opts.windowId)
            sessionInfo.push(opts.windowId);
        var params = [sessionInfo.join(REQUEST_DESCRIPTOR_SESSION_INFO_VALUES_SEPARATOR)];
        if (opts.resourceType)
            params.push(opts.resourceType);
        if (opts.charset)
            params.push(opts.charset.toLowerCase());
        if (typeof opts.credentials === 'number')
            params.push(opts.credentials.toString());
        if (opts.reqOrigin)
            params.push(encodeURIComponent(makeShortOrigin(opts.reqOrigin)));
        var descriptor = params.join(REQUEST_DESCRIPTOR_VALUES_SEPARATOR);
        var proxyProtocol = opts.proxyProtocol || 'http:';
        return "".concat(proxyProtocol, "//").concat(opts.proxyHostname, ":").concat(opts.proxyPort, "/").concat(descriptor, "/").concat(convertHostToLowerCase(url));
    }
    function getDomain(parsed) {
        if (parsed.protocol === 'file:')
            return 'null';
        return formatUrl({
            protocol: parsed.protocol,
            host: parsed.host,
            hostname: parsed.hostname,
            port: String(parsed.port || ''),
        });
    }
    function parseRequestDescriptor(desc) {
        var _a = desc.split(REQUEST_DESCRIPTOR_VALUES_SEPARATOR), sessionInfo = _a[0], resourceType = _a[1], resourceData = _a.slice(2);
        if (!sessionInfo)
            return null;
        var _b = sessionInfo.split(REQUEST_DESCRIPTOR_SESSION_INFO_VALUES_SEPARATOR), sessionId = _b[0], windowId = _b[1];
        var parsedDesc = { sessionId: sessionId, resourceType: resourceType || null };
        if (windowId)
            parsedDesc.windowId = windowId;
        if (resourceType && resourceData.length) {
            var parsedResourceType = parseResourceType(resourceType);
            if (parsedResourceType.isScript || parsedResourceType.isServiceWorker)
                parsedDesc.charset = resourceData[0];
            else if (parsedResourceType.isWebSocket)
                parsedDesc.reqOrigin = decodeURIComponent(restoreShortOrigin(resourceData[0]));
            else if (parsedResourceType.isIframe && resourceData[0])
                parsedDesc.reqOrigin = decodeURIComponent(restoreShortOrigin(resourceData[0]));
            else if (parsedResourceType.isAjax) {
                parsedDesc.credentials = parseInt(resourceData[0], 10);
                if (resourceData.length === 2)
                    parsedDesc.reqOrigin = decodeURIComponent(restoreShortOrigin(resourceData[1]));
            }
        }
        return parsedDesc;
    }
    function parseProxyUrl$1(proxyUrl) {
        // TODO: Remove it.
        var parsedUrl = parseUrl$1(proxyUrl);
        if (!parsedUrl.partAfterHost)
            return null;
        var match = parsedUrl.partAfterHost.match(PATH_AFTER_HOST_RE);
        if (!match)
            return null;
        var parsedDesc = parseRequestDescriptor(match[1]);
        // NOTE: We should have, at least, the job uid and the owner token.
        if (!parsedDesc)
            return null;
        var destUrl = match[2];
        // Browser can redirect to a special page with hash (GH-1671)
        var destUrlWithoutHash = destUrl.replace(/#[\S\s]*$/, '');
        if (!isSpecialPage$1(destUrlWithoutHash) && !SUPPORTED_PROTOCOL_RE.test(destUrl))
            return null;
        var destResourceInfo;
        if (isSpecialPage$1(destUrlWithoutHash))
            destResourceInfo = SPECIAL_PAGE_DEST_RESOURCE_INFO;
        else {
            destUrl = omitDefaultPort(destUrl);
            destResourceInfo = parseUrl$1(destUrl);
        }
        return {
            destUrl: destUrl,
            destResourceInfo: destResourceInfo,
            partAfterHost: parsedUrl.partAfterHost,
            proxy: {
                hostname: parsedUrl.hostname || '',
                port: parsedUrl.port || '',
            },
            sessionId: parsedDesc.sessionId,
            resourceType: parsedDesc.resourceType,
            charset: parsedDesc.charset,
            reqOrigin: parsedDesc.reqOrigin,
            windowId: parsedDesc.windowId,
            credentials: parsedDesc.credentials,
        };
    }
    function parseUrl$1(url) {
        url = processSpecialChars(url);
        if (!url)
            return {};
        var urlMatch = url.match(URL_RE);
        return urlMatch ? {
            protocol: urlMatch[1],
            auth: urlMatch[2],
            host: urlMatch[3],
            hostname: urlMatch[4],
            port: urlMatch[5],
            partAfterHost: urlMatch[6],
        } : {};
    }
    function isSupportedProtocol$1(url) {
        url = trim(url || '');
        var isHash = HASH_RE.test(url);
        if (isHash)
            return false;
        var protocol = url.match(PROTOCOL_RE);
        if (!protocol)
            return true;
        return SUPPORTED_PROTOCOL_RE.test(protocol[0]);
    }
    function resolveUrlAsDest$1(url, getProxyUrlMeth, isUrlsSet) {
        if (isUrlsSet === void 0) { isUrlsSet = false; }
        if (isUrlsSet)
            return handleUrlsSet(resolveUrlAsDest$1, url, getProxyUrlMeth);
        getProxyUrlMeth = getProxyUrlMeth || getProxyUrl$1;
        if (isSupportedProtocol$1(url)) {
            var proxyUrl = getProxyUrlMeth(url);
            var parsedProxyUrl = parseProxyUrl$1(proxyUrl);
            return parsedProxyUrl ? formatUrl(parsedProxyUrl.destResourceInfo) : url;
        }
        return url;
    }
    function formatUrl(parsedUrl) {
        // NOTE: the URL is relative.
        if (parsedUrl.protocol !== 'file:' && parsedUrl.protocol !== 'about:' &&
            !parsedUrl.host && (!parsedUrl.hostname || !parsedUrl.port))
            return parsedUrl.partAfterHost || '';
        var url = parsedUrl.protocol || '';
        if (parsedUrl.protocol !== 'about:')
            url += '//';
        if (parsedUrl.auth)
            url += parsedUrl.auth + '@';
        if (parsedUrl.host)
            url += parsedUrl.host;
        else if (parsedUrl.hostname) {
            url += parsedUrl.hostname;
            if (parsedUrl.port)
                url += ':' + parsedUrl.port;
        }
        if (parsedUrl.partAfterHost)
            url += parsedUrl.partAfterHost;
        return url;
    }
    function handleUrlsSet(handler, url) {
        var args = [];
        for (var _i = 2; _i < arguments.length; _i++) {
            args[_i - 2] = arguments[_i];
        }
        var resourceUrls = url.split(',');
        var replacedUrls = [];
        for (var _a = 0, resourceUrls_1 = resourceUrls; _a < resourceUrls_1.length; _a++) {
            var fullUrlStr = resourceUrls_1[_a];
            var _b = fullUrlStr.replace(/ +/g, ' ').trim().split(' '), urlStr = _b[0], postUrlStr = _b[1];
            if (urlStr) {
                var replacedUrl = handler.apply(void 0, __spreadArray([urlStr], args, false));
                replacedUrls.push(replacedUrl + (postUrlStr ? " ".concat(postUrlStr) : ''));
            }
        }
        return replacedUrls.join(',');
    }
    function correctMultipleSlashes(url, pageProtocol) {
        if (pageProtocol === void 0) { pageProtocol = ''; }
        // NOTE: Remove unnecessary slashes from the beginning of the url and after scheme.
        // For example:
        // "//////example.com" -> "//example.com" (scheme-less HTTP(S) URL)
        // "////home/testcafe/documents" -> "///home/testcafe/documents" (scheme-less unix file URL)
        // "http:///example.com" -> "http://example.com"
        //
        // And add missing slashes after the file scheme.
        // "file://C:/document.txt" -> "file:///C:/document.txt"
        if (url.match(FILE_RE) || pageProtocol.match(FILE_RE)) {
            return url
                .replace(/^(file:)?\/+(\/\/\/.*$)/i, '$1$2')
                .replace(/^(file:)?\/*([A-Za-z]):/i, '$1///$2:');
        }
        return url.replace(/^(https?:)?\/+(\/\/.*$)/i, '$1$2');
    }
    function processSpecialChars(url) {
        return correctMultipleSlashes(getURLString(url));
    }
    function ensureTrailingSlash(srcUrl, processedUrl) {
        if (!isValidUrl(processedUrl))
            return processedUrl;
        var srcUrlEndsWithTrailingSlash = TRAILING_SLASH_RE.test(srcUrl);
        var processedUrlEndsWithTrailingSlash = TRAILING_SLASH_RE.test(processedUrl);
        if (srcUrlEndsWithTrailingSlash && !processedUrlEndsWithTrailingSlash)
            processedUrl += '/';
        else if (srcUrl && !srcUrlEndsWithTrailingSlash && processedUrlEndsWithTrailingSlash)
            processedUrl = processedUrl.replace(TRAILING_SLASH_RE, '');
        return processedUrl;
    }
    function isSpecialPage$1(url) {
        return SPECIAL_PAGES.indexOf(url) !== -1;
    }
    function isValidPort(port) {
        var parsedPort = parseInt(port, 10);
        return parsedPort > 0 && parsedPort <= 65535;
    }
    function isValidUrl(url) {
        var parsedUrl = parseUrl$1(url);
        return parsedUrl.protocol === 'file:' || parsedUrl.protocol === 'about:' ||
            !!parsedUrl.hostname && (!parsedUrl.port || isValidPort(parsedUrl.port));
    }
    function omitDefaultPort(url) {
        // NOTE: If you request an url containing default port
        // then browser remove this one itself.
        var parsedUrl = parseUrl$1(url);
        var hasDefaultPort = parsedUrl.protocol === 'https:' && parsedUrl.port === HTTPS_DEFAULT_PORT ||
            parsedUrl.protocol === 'http:' && parsedUrl.port === HTTP_DEFAULT_PORT;
        if (hasDefaultPort) {
            parsedUrl.host = parsedUrl.hostname;
            parsedUrl.port = '';
            return formatUrl(parsedUrl);
        }
        return url;
    }

    // -------------------------------------------------------------
    // WARNING: this file is used by both the client and the server.
    // Do not use any browser or node-specific API!
    // -------------------------------------------------------------
    var INTERNAL_PROPS = {
        processDomMethodName: 'hammerhead|process-dom-method',
        processedContext: 'hammerhead|processed-context',
        documentWasCleaned: 'hammerhead|document-was-cleaned',
        documentCharset: 'hammerhead|document-charset',
        iframeNativeMethods: 'hammerhead|iframe-native-methods',
        hammerhead: '%hammerhead%',
        selection: 'hammerhead|selection',
        shadowUIElement: 'hammerhead|shadow-ui-element',
        forceProxySrcForImage: 'hammerhead|image|force-proxy-src-flag',
        skipNextLoadEventForImage: 'hammerhead|image|skip-next-load-event-flag',
        cachedImage: 'hammerhead|image|cached-image',
        sandboxIsReattached: 'hammerhead|sandbox-is-reattached',
        nativeStrRepresentation: 'hammerhead|native-string-representation',
        currentBaseUrl: 'hammerhead|current-base-url',
    };

    // -------------------------------------------------------------
    // WARNING: this file is used by both the client and the server.
    // Do not use any browser or node-specific API!
    // -------------------------------------------------------------
    var INTERNAL_ATTRS = {
        storedAttrPostfix: '-hammerhead-stored-value',
        hoverPseudoClass: 'data-hammerhead-hovered',
        focusPseudoClass: 'data-hammerhead-focused',
        uploadInfoHiddenInputName: 'hammerhead|upload-info-hidden-input-name',
    };

    var isInWorker = typeof window === 'undefined' && typeof self === 'object';
    var global$1 = (isInWorker ? self : window);
    var globalContextInfo = {
        isInWorker: isInWorker,
        global: global$1,
        isServiceWorker: isInWorker && !global$1.XMLHttpRequest,
    };

    function replaceNativeAccessor(descriptor, accessorName, newAccessor) {
        if (newAccessor && descriptor[accessorName]) {
            var stringifiedNativeAccessor_1 = descriptor[accessorName].toString();
            newAccessor.toString = function () { return stringifiedNativeAccessor_1; };
        }
        descriptor[accessorName] = newAccessor;
    }
    function createOverriddenDescriptor(obj, prop, _a) {
        var getter = _a.getter, setter = _a.setter, value = _a.value;
        var descriptor = nativeMethods.objectGetOwnPropertyDescriptor(obj, prop);
        if ((getter || setter) && value)
            throw new Error('Cannot both specify accessors and a value or writable attribute.');
        if (!descriptor)
            return void 0;
        if (value) {
            if (!nativeMethods.objectHasOwnProperty.call(descriptor, 'writable')) {
                descriptor.writable = !!descriptor.set;
                delete descriptor.get;
                delete descriptor.set;
            }
            descriptor.value = value; // eslint-disable-line no-restricted-properties
        }
        else {
            if (nativeMethods.objectHasOwnProperty.call(descriptor, 'writable')) {
                delete descriptor.value; // eslint-disable-line no-restricted-properties
                delete descriptor.writable;
            }
            if (getter !== null)
                replaceNativeAccessor(descriptor, 'get', getter);
            if (setter !== null)
                replaceNativeAccessor(descriptor, 'set', setter);
        }
        return descriptor;
    }
    function overrideDescriptor(obj, prop, propertyAccessors) {
        if (!obj)
            return;
        var descriptor = createOverriddenDescriptor(obj, prop, propertyAccessors);
        if (descriptor)
            nativeMethods.objectDefineProperty(obj, prop, descriptor);
        else
            overrideDescriptor(nativeMethods.objectGetPrototypeOf(obj), prop, propertyAccessors);
    }
    function overrideFunctionName(fn, name) {
        var nameDescriptor = nativeMethods.objectGetOwnPropertyDescriptor(fn, 'name');
        if (!nameDescriptor)
            return;
        nameDescriptor.value = name; // eslint-disable-line no-restricted-properties
        nativeMethods.objectDefineProperty(fn, 'name', nameDescriptor);
    }
    function overrideToString(nativeFnWrapper, nativeFn) {
        nativeMethods.objectDefineProperty(nativeFnWrapper, INTERNAL_PROPS.nativeStrRepresentation, {
            value: nativeMethods.Function.prototype.toString.call(nativeFn),
            configurable: true,
        });
    }
    // TODO: this function should not be used outside this file
    // for now it's used to flag cases in which we assign our wrapper to a native function when it is missing
    function overrideStringRepresentation(nativeFnWrapper, nativeFn) {
        overrideFunctionName(nativeFnWrapper, nativeFn.name);
        overrideToString(nativeFnWrapper, nativeFn);
    }
    function isNativeFunction(fn) {
        return !nativeMethods.objectHasOwnProperty.call(fn, INTERNAL_PROPS.nativeStrRepresentation);
    }
    function overrideFunction(obj, fnName, wrapper) {
        var fn = obj[fnName];
        if (isNativeFunction(fn)) {
            overrideStringRepresentation(wrapper, fn);
            obj[fnName] = wrapper;
        }
    }
    function overrideConstructor(obj, fnName, wrapper, overrideProtoConstructor) {
        if (overrideProtoConstructor === void 0) { overrideProtoConstructor = false; }
        var nativePrototype = obj[fnName]['prototype'];
        overrideFunction(obj, fnName, wrapper);
        // NOTE: restore native prototype (to make `instanceof` work as expected)
        wrapper.prototype = nativePrototype;
        // NOTE: we need to override the `constructor` property of a prototype
        // because sometimes native constructor can be retrieved from it
        if (overrideProtoConstructor)
            nativePrototype.constructor = wrapper;
    }

    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

    function createCommonjsModule(fn) {
      var module = { exports: {} };
    	return fn(module, module.exports), module.exports;
    }

    /*!
     * Bowser - a browser detector
     * https://github.com/ded/bowser
     * MIT License | (c) Dustin Diaz 2015
     */

    var bowser = createCommonjsModule(function (module) {
    !function (root, name, definition) {
      if (module.exports) module.exports = definition();
      else root[name] = definition();
    }(commonjsGlobal, 'bowser', function () {
      /**
        * See useragents.js for examples of navigator.userAgent
        */

      var t = true;

      function detect(ua) {

        function getFirstMatch(regex) {
          var match = ua.match(regex);
          return (match && match.length > 1 && match[1]) || '';
        }

        function getSecondMatch(regex) {
          var match = ua.match(regex);
          return (match && match.length > 1 && match[2]) || '';
        }

        var iosdevice = getFirstMatch(/(ipod|iphone|ipad)/i).toLowerCase()
          , likeAndroid = /like android/i.test(ua)
          , android = !likeAndroid && /android/i.test(ua)
          , nexusMobile = /nexus\s*[0-6]\s*/i.test(ua)
          , nexusTablet = !nexusMobile && /nexus\s*[0-9]+/i.test(ua)
          , chromeos = /CrOS/.test(ua)
          , silk = /silk/i.test(ua)
          , sailfish = /sailfish/i.test(ua)
          , tizen = /tizen/i.test(ua)
          , webos = /(web|hpw)os/i.test(ua)
          , windowsphone = /windows phone/i.test(ua)
          ; /SamsungBrowser/i.test(ua)
          ; var windows = !windowsphone && /windows/i.test(ua)
          , mac = !iosdevice && !silk && /macintosh/i.test(ua)
          , linux = !android && !sailfish && !tizen && !webos && /linux/i.test(ua)
          , edgeVersion = getFirstMatch(/edge\/(\d+(\.\d+)?)/i)
          , versionIdentifier = getFirstMatch(/version\/(\d+(\.\d+)?)/i)
          , tablet = /tablet/i.test(ua)
          , mobile = !tablet && /[^-]mobi/i.test(ua)
          , xbox = /xbox/i.test(ua)
          , result;

        if (/opera/i.test(ua)) {
          //  an old Opera
          result = {
            name: 'Opera'
          , opera: t
          , version: versionIdentifier || getFirstMatch(/(?:opera|opr|opios)[\s\/](\d+(\.\d+)?)/i)
          };
        } else if (/opr|opios/i.test(ua)) {
          // a new Opera
          result = {
            name: 'Opera'
            , opera: t
            , version: getFirstMatch(/(?:opr|opios)[\s\/](\d+(\.\d+)?)/i) || versionIdentifier
          };
        }
        else if (/SamsungBrowser/i.test(ua)) {
          result = {
            name: 'Samsung Internet for Android'
            , samsungBrowser: t
            , version: versionIdentifier || getFirstMatch(/(?:SamsungBrowser)[\s\/](\d+(\.\d+)?)/i)
          };
        }
        else if (/coast/i.test(ua)) {
          result = {
            name: 'Opera Coast'
            , coast: t
            , version: versionIdentifier || getFirstMatch(/(?:coast)[\s\/](\d+(\.\d+)?)/i)
          };
        }
        else if (/yabrowser/i.test(ua)) {
          result = {
            name: 'Yandex Browser'
          , yandexbrowser: t
          , version: versionIdentifier || getFirstMatch(/(?:yabrowser)[\s\/](\d+(\.\d+)?)/i)
          };
        }
        else if (/ucbrowser/i.test(ua)) {
          result = {
              name: 'UC Browser'
            , ucbrowser: t
            , version: getFirstMatch(/(?:ucbrowser)[\s\/](\d+(?:\.\d+)+)/i)
          };
        }
        else if (/mxios/i.test(ua)) {
          result = {
            name: 'Maxthon'
            , maxthon: t
            , version: getFirstMatch(/(?:mxios)[\s\/](\d+(?:\.\d+)+)/i)
          };
        }
        else if (/epiphany/i.test(ua)) {
          result = {
            name: 'Epiphany'
            , epiphany: t
            , version: getFirstMatch(/(?:epiphany)[\s\/](\d+(?:\.\d+)+)/i)
          };
        }
        else if (/puffin/i.test(ua)) {
          result = {
            name: 'Puffin'
            , puffin: t
            , version: getFirstMatch(/(?:puffin)[\s\/](\d+(?:\.\d+)?)/i)
          };
        }
        else if (/sleipnir/i.test(ua)) {
          result = {
            name: 'Sleipnir'
            , sleipnir: t
            , version: getFirstMatch(/(?:sleipnir)[\s\/](\d+(?:\.\d+)+)/i)
          };
        }
        else if (/k-meleon/i.test(ua)) {
          result = {
            name: 'K-Meleon'
            , kMeleon: t
            , version: getFirstMatch(/(?:k-meleon)[\s\/](\d+(?:\.\d+)+)/i)
          };
        }
        else if (windowsphone) {
          result = {
            name: 'Windows Phone'
          , windowsphone: t
          };
          if (edgeVersion) {
            result.msedge = t;
            result.version = edgeVersion;
          }
          else {
            result.msie = t;
            result.version = getFirstMatch(/iemobile\/(\d+(\.\d+)?)/i);
          }
        }
        else if (/msie|trident/i.test(ua)) {
          result = {
            name: 'Internet Explorer'
          , msie: t
          , version: getFirstMatch(/(?:msie |rv:)(\d+(\.\d+)?)/i)
          };
        } else if (chromeos) {
          result = {
            name: 'Chrome'
          , chromeos: t
          , chromeBook: t
          , chrome: t
          , version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
          };
        } else if (/chrome.+? edge/i.test(ua)) {
          result = {
            name: 'Microsoft Edge'
          , msedge: t
          , version: edgeVersion
          };
        }
        else if (/vivaldi/i.test(ua)) {
          result = {
            name: 'Vivaldi'
            , vivaldi: t
            , version: getFirstMatch(/vivaldi\/(\d+(\.\d+)?)/i) || versionIdentifier
          };
        }
        else if (sailfish) {
          result = {
            name: 'Sailfish'
          , sailfish: t
          , version: getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i)
          };
        }
        else if (/seamonkey\//i.test(ua)) {
          result = {
            name: 'SeaMonkey'
          , seamonkey: t
          , version: getFirstMatch(/seamonkey\/(\d+(\.\d+)?)/i)
          };
        }
        else if (/firefox|iceweasel|fxios/i.test(ua)) {
          result = {
            name: 'Firefox'
          , firefox: t
          , version: getFirstMatch(/(?:firefox|iceweasel|fxios)[ \/](\d+(\.\d+)?)/i)
          };
          if (/\((mobile|tablet);[^\)]*rv:[\d\.]+\)/i.test(ua)) {
            result.firefoxos = t;
          }
        }
        else if (silk) {
          result =  {
            name: 'Amazon Silk'
          , silk: t
          , version : getFirstMatch(/silk\/(\d+(\.\d+)?)/i)
          };
        }
        else if (/phantom/i.test(ua)) {
          result = {
            name: 'PhantomJS'
          , phantom: t
          , version: getFirstMatch(/phantomjs\/(\d+(\.\d+)?)/i)
          };
        }
        else if (/slimerjs/i.test(ua)) {
          result = {
            name: 'SlimerJS'
            , slimer: t
            , version: getFirstMatch(/slimerjs\/(\d+(\.\d+)?)/i)
          };
        }
        else if (/blackberry|\bbb\d+/i.test(ua) || /rim\stablet/i.test(ua)) {
          result = {
            name: 'BlackBerry'
          , blackberry: t
          , version: versionIdentifier || getFirstMatch(/blackberry[\d]+\/(\d+(\.\d+)?)/i)
          };
        }
        else if (webos) {
          result = {
            name: 'WebOS'
          , webos: t
          , version: versionIdentifier || getFirstMatch(/w(?:eb)?osbrowser\/(\d+(\.\d+)?)/i)
          };
          /touchpad\//i.test(ua) && (result.touchpad = t);
        }
        else if (/bada/i.test(ua)) {
          result = {
            name: 'Bada'
          , bada: t
          , version: getFirstMatch(/dolfin\/(\d+(\.\d+)?)/i)
          };
        }
        else if (tizen) {
          result = {
            name: 'Tizen'
          , tizen: t
          , version: getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.\d+)?)/i) || versionIdentifier
          };
        }
        else if (/qupzilla/i.test(ua)) {
          result = {
            name: 'QupZilla'
            , qupzilla: t
            , version: getFirstMatch(/(?:qupzilla)[\s\/](\d+(?:\.\d+)+)/i) || versionIdentifier
          };
        }
        else if (/chromium/i.test(ua)) {
          result = {
            name: 'Chromium'
            , chromium: t
            , version: getFirstMatch(/(?:chromium)[\s\/](\d+(?:\.\d+)?)/i) || versionIdentifier
          };
        }
        else if (/chrome|crios|crmo/i.test(ua)) {
          result = {
            name: 'Chrome'
            , chrome: t
            , version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
          };
        }
        else if (android) {
          result = {
            name: 'Android'
            , version: versionIdentifier
          };
        }
        else if (/safari|applewebkit/i.test(ua)) {
          result = {
            name: 'Safari'
          , safari: t
          };
          if (versionIdentifier) {
            result.version = versionIdentifier;
          }
        }
        else if (iosdevice) {
          result = {
            name : iosdevice == 'iphone' ? 'iPhone' : iosdevice == 'ipad' ? 'iPad' : 'iPod'
          };
          // WTF: version is not part of user agent in web apps
          if (versionIdentifier) {
            result.version = versionIdentifier;
          }
        }
        else if(/googlebot/i.test(ua)) {
          result = {
            name: 'Googlebot'
          , googlebot: t
          , version: getFirstMatch(/googlebot\/(\d+(\.\d+))/i) || versionIdentifier
          };
        }
        else {
          result = {
            name: getFirstMatch(/^(.*)\/(.*) /),
            version: getSecondMatch(/^(.*)\/(.*) /)
         };
       }

        // set webkit or gecko flag for browsers based on these engines
        if (!result.msedge && /(apple)?webkit/i.test(ua)) {
          if (/(apple)?webkit\/537\.36/i.test(ua)) {
            result.name = result.name || "Blink";
            result.blink = t;
          } else {
            result.name = result.name || "Webkit";
            result.webkit = t;
          }
          if (!result.version && versionIdentifier) {
            result.version = versionIdentifier;
          }
        } else if (!result.opera && /gecko\//i.test(ua)) {
          result.name = result.name || "Gecko";
          result.gecko = t;
          result.version = result.version || getFirstMatch(/gecko\/(\d+(\.\d+)?)/i);
        }

        // set OS flags for platforms that have multiple browsers
        if (!result.windowsphone && !result.msedge && (android || result.silk)) {
          result.android = t;
        } else if (!result.windowsphone && !result.msedge && iosdevice) {
          result[iosdevice] = t;
          result.ios = t;
        } else if (mac) {
          result.mac = t;
        } else if (xbox) {
          result.xbox = t;
        } else if (windows) {
          result.windows = t;
        } else if (linux) {
          result.linux = t;
        }

        // OS version extraction
        var osVersion = '';
        if (result.windowsphone) {
          osVersion = getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i);
        } else if (iosdevice) {
          osVersion = getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i);
          osVersion = osVersion.replace(/[_\s]/g, '.');
        } else if (android) {
          osVersion = getFirstMatch(/android[ \/-](\d+(\.\d+)*)/i);
        } else if (result.webos) {
          osVersion = getFirstMatch(/(?:web|hpw)os\/(\d+(\.\d+)*)/i);
        } else if (result.blackberry) {
          osVersion = getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i);
        } else if (result.bada) {
          osVersion = getFirstMatch(/bada\/(\d+(\.\d+)*)/i);
        } else if (result.tizen) {
          osVersion = getFirstMatch(/tizen[\/\s](\d+(\.\d+)*)/i);
        }
        if (osVersion) {
          result.osversion = osVersion;
        }

        // device type extraction
        var osMajorVersion = osVersion.split('.')[0];
        if (
             tablet
          || nexusTablet
          || iosdevice == 'ipad'
          || (android && (osMajorVersion == 3 || (osMajorVersion >= 4 && !mobile)))
          || result.silk
        ) {
          result.tablet = t;
        } else if (
             mobile
          || iosdevice == 'iphone'
          || iosdevice == 'ipod'
          || android
          || nexusMobile
          || result.blackberry
          || result.webos
          || result.bada
        ) {
          result.mobile = t;
        }

        // Graded Browser Support
        // http://developer.yahoo.com/yui/articles/gbs
        if (result.msedge ||
            (result.msie && result.version >= 10) ||
            (result.yandexbrowser && result.version >= 15) ||
    		    (result.vivaldi && result.version >= 1.0) ||
            (result.chrome && result.version >= 20) ||
            (result.samsungBrowser && result.version >= 4) ||
            (result.firefox && result.version >= 20.0) ||
            (result.safari && result.version >= 6) ||
            (result.opera && result.version >= 10.0) ||
            (result.ios && result.osversion && result.osversion.split(".")[0] >= 6) ||
            (result.blackberry && result.version >= 10.1)
            || (result.chromium && result.version >= 20)
            ) {
          result.a = t;
        }
        else if ((result.msie && result.version < 10) ||
            (result.chrome && result.version < 20) ||
            (result.firefox && result.version < 20.0) ||
            (result.safari && result.version < 6) ||
            (result.opera && result.version < 10.0) ||
            (result.ios && result.osversion && result.osversion.split(".")[0] < 6)
            || (result.chromium && result.version < 20)
            ) {
          result.c = t;
        } else result.x = t;

        return result
      }

      var bowser = detect(typeof navigator !== 'undefined' ? navigator.userAgent || '' : '');

      bowser.test = function (browserList) {
        for (var i = 0; i < browserList.length; ++i) {
          var browserItem = browserList[i];
          if (typeof browserItem=== 'string') {
            if (browserItem in bowser) {
              return true;
            }
          }
        }
        return false;
      };

      /**
       * Get version precisions count
       *
       * @example
       *   getVersionPrecision("1.10.3") // 3
       *
       * @param  {string} version
       * @return {number}
       */
      function getVersionPrecision(version) {
        return version.split(".").length;
      }

      /**
       * Array::map polyfill
       *
       * @param  {Array} arr
       * @param  {Function} iterator
       * @return {Array}
       */
      function map(arr, iterator) {
        var result = [], i;
        if (Array.prototype.map) {
          return Array.prototype.map.call(arr, iterator);
        }
        for (i = 0; i < arr.length; i++) {
          result.push(iterator(arr[i]));
        }
        return result;
      }

      /**
       * Calculate browser version weight
       *
       * @example
       *   compareVersions(['1.10.2.1',  '1.8.2.1.90'])    // 1
       *   compareVersions(['1.010.2.1', '1.09.2.1.90']);  // 1
       *   compareVersions(['1.10.2.1',  '1.10.2.1']);     // 0
       *   compareVersions(['1.10.2.1',  '1.0800.2']);     // -1
       *
       * @param  {Array<String>} versions versions to compare
       * @return {Number} comparison result
       */
      function compareVersions(versions) {
        // 1) get common precision for both versions, for example for "10.0" and "9" it should be 2
        var precision = Math.max(getVersionPrecision(versions[0]), getVersionPrecision(versions[1]));
        var chunks = map(versions, function (version) {
          var delta = precision - getVersionPrecision(version);

          // 2) "9" -> "9.0" (for precision = 2)
          version = version + new Array(delta + 1).join(".0");

          // 3) "9.0" -> ["000000000"", "000000009"]
          return map(version.split("."), function (chunk) {
            return new Array(20 - chunk.length).join("0") + chunk;
          }).reverse();
        });

        // iterate in reverse order by reversed chunks array
        while (--precision >= 0) {
          // 4) compare: "000000009" > "000000010" = false (but "9" > "10" = true)
          if (chunks[0][precision] > chunks[1][precision]) {
            return 1;
          }
          else if (chunks[0][precision] === chunks[1][precision]) {
            if (precision === 0) {
              // all version chunks are same
              return 0;
            }
          }
          else {
            return -1;
          }
        }
      }

      /**
       * Check if browser is unsupported
       *
       * @example
       *   bowser.isUnsupportedBrowser({
       *     msie: "10",
       *     firefox: "23",
       *     chrome: "29",
       *     safari: "5.1",
       *     opera: "16",
       *     phantom: "534"
       *   });
       *
       * @param  {Object}  minVersions map of minimal version to browser
       * @param  {Boolean} [strictMode = false] flag to return false if browser wasn't found in map
       * @param  {String}  [ua] user agent string
       * @return {Boolean}
       */
      function isUnsupportedBrowser(minVersions, strictMode, ua) {
        var _bowser = bowser;

        // make strictMode param optional with ua param usage
        if (typeof strictMode === 'string') {
          ua = strictMode;
          strictMode = void(0);
        }

        if (strictMode === void(0)) {
          strictMode = false;
        }
        if (ua) {
          _bowser = detect(ua);
        }

        var version = "" + _bowser.version;
        for (var browser in minVersions) {
          if (minVersions.hasOwnProperty(browser)) {
            if (_bowser[browser]) {
              if (typeof minVersions[browser] !== 'string') {
                throw new Error('Browser version in the minVersion map should be a string: ' + browser + ': ' + String(minVersions));
              }

              // browser version and min supported version.
              return compareVersions([version, minVersions[browser]]) < 0;
            }
          }
        }

        return strictMode; // not found
      }

      /**
       * Check if browser is supported
       *
       * @param  {Object} minVersions map of minimal version to browser
       * @param  {Boolean} [strictMode = false] flag to return false if browser wasn't found in map
       * @param  {String}  [ua] user agent string
       * @return {Boolean}
       */
      function check(minVersions, strictMode, ua) {
        return !isUnsupportedBrowser(minVersions, strictMode, ua);
      }

      bowser.isUnsupportedBrowser = isUnsupportedBrowser;
      bowser.compareVersions = compareVersions;
      bowser.check = check;

      /*
       * Set our detect method to the main bowser object so we can
       * reuse it to test other user agents.
       * This is needed to implement future tests.
       */
      bowser._detect = detect;

      return bowser
    });
    });

    var userAgent = navigator.userAgent.toLowerCase();
    //@ts-ignore
    var info = bowser._detect(userAgent);
    var webkitVersionMatch = userAgent.match(/applewebkit\/(\d+(:?\.\d+)*)/);
    //Helper
    //@ts-ignore
    bowser.compareVersions;
    //Platforms
    !!info.mac;
    !!info.android;
    !!info.ios;
    !!info.mobile;
    !!info.tablet;
    //Browsers
    parseInt(info.version, 10);
    info.version;
    webkitVersionMatch && webkitVersionMatch[1] || '';
    var isIE = !!(info.msie || info.msedge);
    !!info.firefox;
    !!info.msedge;
    !!info.chrome;
    var isSafari = !!info.safari;
    !!(info.webkit || info.blink);
    /electron/g.test(userAgent);

    function isFunction(val) {
        return typeof val === 'function';
    }

    /*global Document, Window */
    var NATIVE_CODE_RE = /\[native code]/;
    var NativeMethods = /** @class */ (function () {
        function NativeMethods(doc, win) {
            win = win || globalContextInfo.global;
            this.refreshWindowMeths(win, globalContextInfo.isInWorker);
            this.refreshWorkerMeths(win);
            if (globalContextInfo.isInWorker)
                return;
            this.refreshDocumentMeths(doc, win);
            this.refreshElementMeths(doc, win);
        }
        NativeMethods._getDocumentPropOwnerName = function (docPrototype, propName) {
            return docPrototype.hasOwnProperty(propName) ? 'Document' : 'HTMLDocument'; // eslint-disable-line no-prototype-builtins
        };
        NativeMethods.prototype.getStoragesPropsOwner = function (win) {
            return this.isStoragePropsLocatedInProto ? win.Window.prototype : win;
        };
        NativeMethods.prototype.refreshWorkerMeths = function (scope /* WorkerGlobalScope */) {
            this.importScripts = scope.importScripts;
        };
        NativeMethods.prototype.refreshDocumentMeths = function (doc, win) {
            doc = doc || document;
            win = win || window;
            var docPrototype = win.Document.prototype;
            // Dom
            this.createDocumentFragment = docPrototype.createDocumentFragment;
            this.createElement = docPrototype.createElement;
            this.createElementNS = docPrototype.createElementNS;
            this.createTextNode = docPrototype.createTextNode;
            this.documentOpenPropOwnerName = NativeMethods._getDocumentPropOwnerName(docPrototype, 'open');
            this.documentClosePropOwnerName = NativeMethods._getDocumentPropOwnerName(docPrototype, 'close');
            this.documentWritePropOwnerName = NativeMethods._getDocumentPropOwnerName(docPrototype, 'write');
            this.documentWriteLnPropOwnerName = NativeMethods._getDocumentPropOwnerName(docPrototype, 'writeln');
            this.documentOpen = win[this.documentOpenPropOwnerName].prototype.open;
            this.documentClose = win[this.documentClosePropOwnerName].prototype.close;
            this.documentWrite = win[this.documentWritePropOwnerName].prototype.write;
            this.documentWriteLn = win[this.documentWriteLnPropOwnerName].prototype.writeln;
            this.elementFromPoint = docPrototype.elementFromPoint;
            this.caretRangeFromPoint = docPrototype.caretRangeFromPoint;
            // @ts-ignore Experimental method in Firefox
            this.caretPositionFromPoint = docPrototype.caretPositionFromPoint;
            this.getElementById = docPrototype.getElementById;
            this.getElementsByClassName = docPrototype.getElementsByClassName;
            this.getElementsByName = docPrototype.getElementsByName;
            this.getElementsByTagName = docPrototype.getElementsByTagName;
            this.querySelector = docPrototype.querySelector;
            this.querySelectorAll = docPrototype.querySelectorAll;
            this.createHTMLDocument = win.DOMImplementation.prototype.createHTMLDocument;
            // @ts-ignore
            if (doc.registerElement) {
                // @ts-ignore
                this.registerElement = docPrototype.registerElement;
            }
            // Event
            // NOTE: IE11 has no EventTarget so we should save "Event" methods separately
            if (!win.EventTarget) {
                this.documentAddEventListener = docPrototype.addEventListener;
                this.documentRemoveEventListener = docPrototype.removeEventListener;
            }
            this.documentCreateEvent = docPrototype.createEvent;
            // @ts-ignore Deprecated
            this.documentCreateTouch = docPrototype.createTouch;
            // @ts-ignore Deprecated
            this.documentCreateTouchList = docPrototype.createTouchList;
            // getters/setters
            this.documentCookiePropOwnerName = NativeMethods._getDocumentPropOwnerName(docPrototype, 'cookie');
            var documentCookieDescriptor = win.Object.getOwnPropertyDescriptor(win[this.documentCookiePropOwnerName].prototype, 'cookie');
            // TODO: remove this condition after the GH-1649 fix
            if (!this.isNativeCode(documentCookieDescriptor.get) ||
                !this.isNativeCode(documentCookieDescriptor.get.toString)) {
                try {
                    var parentNativeMethods = win.parent['%hammerhead%'].nativeMethods;
                    documentCookieDescriptor.get = parentNativeMethods.documentCookieGetter;
                    documentCookieDescriptor.set = parentNativeMethods.documentCookieSetter;
                }
                catch (_a) { } // eslint-disable-line no-empty
            }
            this.documentReferrerGetter = win.Object.getOwnPropertyDescriptor(docPrototype, 'referrer').get;
            this.documentStyleSheetsGetter = win.Object.getOwnPropertyDescriptor(docPrototype, 'styleSheets').get;
            this.documentActiveElementGetter = win.Object.getOwnPropertyDescriptor(docPrototype, 'activeElement').get;
            this.documentCookieGetter = documentCookieDescriptor.get;
            this.documentCookieSetter = documentCookieDescriptor.set;
            var documentDocumentURIDescriptor = win.Object.getOwnPropertyDescriptor(docPrototype, 'documentURI');
            if (documentDocumentURIDescriptor)
                this.documentDocumentURIGetter = documentDocumentURIDescriptor.get;
            var documentTitleDescriptor = win.Object.getOwnPropertyDescriptor(docPrototype, 'title');
            this.documentTitleGetter = documentTitleDescriptor.get;
            this.documentTitleSetter = documentTitleDescriptor.set;
        };
        NativeMethods.prototype.refreshElementMeths = function (doc, win) {
            var _this = this;
            win = win || window;
            var createElement = (function (tagName) { return _this.createElement.call(doc || document, tagName); });
            var nativeElement = createElement('div');
            var createTextNode = function (data) { return _this.createTextNode.call(doc || document, data); };
            var textNode = createTextNode('text');
            // Dom
            this.appendChild = win.Node.prototype.appendChild;
            this.append = win.Element.prototype.append;
            this.prepend = win.Element.prototype.prepend;
            this.after = win.Element.prototype.after;
            this.attachShadow = win.Element.prototype.attachShadow;
            this.replaceChild = nativeElement.replaceChild;
            this.cloneNode = nativeElement.cloneNode;
            this.elementGetElementsByClassName = nativeElement.getElementsByClassName;
            this.elementGetElementsByTagName = nativeElement.getElementsByTagName;
            this.elementQuerySelector = nativeElement.querySelector;
            this.elementQuerySelectorAll = nativeElement.querySelectorAll;
            this.getAttribute = nativeElement.getAttribute;
            this.getAttributeNS = nativeElement.getAttributeNS;
            this.getAttributeNode = nativeElement.getAttributeNode;
            this.getAttributeNodeNS = nativeElement.getAttributeNodeNS;
            this.insertBefore = nativeElement.insertBefore;
            this.insertCell = createElement('tr').insertCell;
            this.insertTableRow = createElement('table').insertRow;
            this.insertTBodyRow = createElement('tbody').insertRow;
            this.removeAttribute = nativeElement.removeAttribute;
            this.removeAttributeNS = nativeElement.removeAttributeNS;
            this.removeAttributeNode = nativeElement.removeAttributeNode;
            this.removeChild = win.Node.prototype.removeChild;
            this.remove = win.Element.prototype.remove;
            this.elementReplaceWith = win.Element.prototype.replaceWith;
            this.setAttribute = nativeElement.setAttribute;
            this.setAttributeNS = nativeElement.setAttributeNS;
            this.hasAttribute = nativeElement.hasAttribute;
            this.hasAttributeNS = nativeElement.hasAttributeNS;
            this.hasAttributes = nativeElement.hasAttributes;
            this.anchorToString = win.HTMLAnchorElement.prototype.toString;
            this.matches = nativeElement.matches || nativeElement.msMatchesSelector;
            this.closest = nativeElement.closest;
            // NOTE: The 'insertAdjacent...' methods is located in HTMLElement prototype in IE11 only
            this.insertAdjacentMethodsOwner = win.Element.prototype.hasOwnProperty('insertAdjacentElement') // eslint-disable-line no-prototype-builtins
                ? win.Element.prototype
                : win.HTMLElement.prototype;
            this.insertAdjacentElement = this.insertAdjacentMethodsOwner.insertAdjacentElement;
            this.insertAdjacentHTML = this.insertAdjacentMethodsOwner.insertAdjacentHTML;
            this.insertAdjacentText = this.insertAdjacentMethodsOwner.insertAdjacentText;
            // Text node
            this.appendData = textNode.appendData;
            // TODO: remove this condition after the GH-1649 fix
            if (!this.isNativeCode(this.elementGetElementsByTagName)) {
                try {
                    var parentNativeMethods = win.parent['%hammerhead%'].nativeMethods;
                    this.elementGetElementsByTagName = parentNativeMethods.elementGetElementsByTagName;
                }
                // eslint-disable-next-line no-empty
                catch (e) {
                }
            }
            // Event
            if (win.EventTarget) {
                this.addEventListener = win.EventTarget.prototype.addEventListener;
                this.removeEventListener = win.EventTarget.prototype.removeEventListener;
                this.dispatchEvent = win.EventTarget.prototype.dispatchEvent;
            }
            // NOTE: IE11 has no EventTarget
            else {
                this.addEventListener = nativeElement.addEventListener;
                this.removeEventListener = nativeElement.removeEventListener;
                this.dispatchEvent = nativeElement.dispatchEvent;
            }
            this.blur = nativeElement.blur;
            this.click = nativeElement.click;
            this.focus = nativeElement.focus;
            // @ts-ignore
            this.select = window.TextRange ? createElement('body').createTextRange().select : null;
            this.setSelectionRange = createElement('input').setSelectionRange;
            this.textAreaSetSelectionRange = createElement('textarea').setSelectionRange;
            this.svgFocus = win.SVGElement ? win.SVGElement.prototype.focus : this.focus;
            this.svgBlur = win.SVGElement ? win.SVGElement.prototype.blur : this.blur;
            // Style
            // NOTE: The 'style' descriptor is located in the Element.prototype in the Safari on IOS
            this.htmlElementStylePropOwnerName = win.Element.prototype.hasOwnProperty('style') ? 'Element' : 'HTMLElement'; // eslint-disable-line no-prototype-builtins
            var htmlElementStyleDescriptor = win.Object.getOwnPropertyDescriptor(win[this.htmlElementStylePropOwnerName].prototype, 'style');
            this.htmlElementStyleGetter = htmlElementStyleDescriptor.get;
            // NOTE: IE does not allow to set a style property
            if (htmlElementStyleDescriptor.set)
                this.htmlElementStyleSetter = htmlElementStyleDescriptor.set;
            var styleCssTextDescriptor = win.Object.getOwnPropertyDescriptor(win.CSSStyleDeclaration.prototype, 'cssText');
            this.styleCssTextGetter = styleCssTextDescriptor.get;
            this.styleCssTextSetter = styleCssTextDescriptor.set;
        };
        NativeMethods.prototype._refreshGettersAndSetters = function (win, isInWorker) {
            if (isInWorker === void 0) { isInWorker = false; }
            win = win || window;
            var winProto = win.constructor.prototype;
            // NOTE: Event properties is located in window prototype only in IE11
            this.isEventPropsLocatedInProto = winProto.hasOwnProperty('onerror'); // eslint-disable-line no-prototype-builtins
            var eventPropsOwner = this.isEventPropsLocatedInProto ? winProto : win;
            var winOnBeforeUnloadDescriptor = win.Object.getOwnPropertyDescriptor(eventPropsOwner, 'onbeforeunload');
            var winOnUnloadDescriptor = win.Object.getOwnPropertyDescriptor(eventPropsOwner, 'onunload');
            var winOnPageHideDescriptor = win.Object.getOwnPropertyDescriptor(eventPropsOwner, 'onpagehide');
            var winOnMessageDescriptor = win.Object.getOwnPropertyDescriptor(eventPropsOwner, 'onmessage');
            var winOnErrorDescriptor = win.Object.getOwnPropertyDescriptor(eventPropsOwner, 'onerror');
            var winOnHashChangeDescriptor = win.Object.getOwnPropertyDescriptor(eventPropsOwner, 'onhashchange');
            this.winOnBeforeUnloadSetter = winOnBeforeUnloadDescriptor && winOnBeforeUnloadDescriptor.set;
            this.winOnUnloadSetter = winOnUnloadDescriptor && winOnUnloadDescriptor.set;
            this.winOnPageHideSetter = winOnPageHideDescriptor && winOnPageHideDescriptor.set;
            this.winOnMessageSetter = winOnMessageDescriptor && winOnMessageDescriptor.set;
            this.winOnErrorSetter = winOnErrorDescriptor && winOnErrorDescriptor.set;
            this.winOnHashChangeSetter = winOnHashChangeDescriptor && winOnHashChangeDescriptor.set;
            var winOnUnhandledRejectionDescriptor = win.Object.getOwnPropertyDescriptor(eventPropsOwner, 'onunhandledrejection');
            if (winOnUnhandledRejectionDescriptor)
                this.winOnUnhandledRejectionSetter = winOnUnhandledRejectionDescriptor.set;
            // Getters
            if (win.WebSocket) {
                var urlPropDescriptor = win.Object.getOwnPropertyDescriptor(win.WebSocket.prototype, 'url');
                if (urlPropDescriptor && urlPropDescriptor.get && urlPropDescriptor.configurable)
                    this.webSocketUrlGetter = urlPropDescriptor.get;
            }
            this.messageEventOriginGetter = win.Object.getOwnPropertyDescriptor(win.MessageEvent.prototype, 'origin').get;
            // NOTE: At present we proxy only the PerformanceNavigationTiming.
            // Another types of the PerformanceEntry will be fixed later
            // https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry
            if (win.PerformanceNavigationTiming)
                this.performanceEntryNameGetter = win.Object.getOwnPropertyDescriptor(win.PerformanceEntry.prototype, 'name').get;
            var dataPropDescriptor = win.Object.getOwnPropertyDescriptor(win.MessageEvent.prototype, 'data');
            // NOTE: This condition is used for the Android 6.0 browser
            if (dataPropDescriptor)
                this.messageEventDataGetter = dataPropDescriptor.get;
            if (win.fetch) {
                this.responseStatusGetter = win.Object.getOwnPropertyDescriptor(win.Response.prototype, 'status').get;
                this.responseTypeGetter = win.Object.getOwnPropertyDescriptor(win.Response.prototype, 'type').get;
                this.responseUrlGetter = win.Object.getOwnPropertyDescriptor(win.Response.prototype, 'url').get;
                this.requestUrlGetter = win.Object.getOwnPropertyDescriptor(win.Request.prototype, 'url').get;
                this.requestReferrerGetter = win.Object.getOwnPropertyDescriptor(win.Request.prototype, 'referrer').get;
            }
            if (win.XMLHttpRequest) {
                var xhrResponseURLDescriptor = win.Object.getOwnPropertyDescriptor(win.XMLHttpRequest.prototype, 'responseURL');
                // NOTE: IE doesn't support the 'responseURL' property
                if (xhrResponseURLDescriptor)
                    this.xhrResponseURLGetter = xhrResponseURLDescriptor.get;
            }
            // eslint-disable-next-line no-restricted-properties
            if (win.Window) {
                // NOTE: The 'localStorage' and 'sessionStorage' properties is located in window prototype only in IE11
                this.isStoragePropsLocatedInProto = win.Window.prototype.hasOwnProperty('localStorage'); // eslint-disable-line no-prototype-builtins
                var storagesPropsOwner = this.getStoragesPropsOwner(win);
                this.winLocalStorageGetter = win.Object.getOwnPropertyDescriptor(storagesPropsOwner, 'localStorage').get;
                this.winSessionStorageGetter = win.Object.getOwnPropertyDescriptor(storagesPropsOwner, 'sessionStorage').get;
            }
            if (isInWorker)
                return;
            this.storageGetItem = win.Storage.prototype.getItem;
            this.storageSetItem = win.Storage.prototype.setItem;
            this.storageRemoveItem = win.Storage.prototype.removeItem;
            this.storageClear = win.Storage.prototype.clear;
            this.storageKey = win.Storage.prototype.key;
            this.storageLengthGetter = win.Object.getOwnPropertyDescriptor(win.Storage.prototype, 'length');
            var objectDataDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLObjectElement.prototype, 'data');
            var inputTypeDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'type');
            var inputValueDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'value');
            var inputDisabledDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'disabled');
            var inputRequiredDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'required');
            var textAreaValueDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLTextAreaElement.prototype, 'value');
            var imageSrcDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLImageElement.prototype, 'src');
            var imageSrcsetDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLImageElement.prototype, 'srcset');
            var scriptSrcDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLScriptElement.prototype, 'src');
            var scriptIntegrityDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLScriptElement.prototype, 'integrity');
            var embedSrcDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLEmbedElement.prototype, 'src');
            var sourceSrcDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLSourceElement.prototype, 'src');
            var mediaSrcDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLMediaElement.prototype, 'src');
            var inputSrcDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'src');
            var frameSrcDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLFrameElement.prototype, 'src');
            var iframeSrcDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLIFrameElement.prototype, 'src');
            var anchorHrefDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'href');
            var linkHrefDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLLinkElement.prototype, 'href');
            var linkIntegrityDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLLinkElement.prototype, 'integrity');
            var linkRelDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLLinkElement.prototype, 'rel');
            var linkAsDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLLinkElement.prototype, 'as');
            var areaHrefDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAreaElement.prototype, 'href');
            var baseHrefDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLBaseElement.prototype, 'href');
            var anchorHostDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'host');
            var anchorHostnameDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'hostname');
            var anchorPathnameDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'pathname');
            var anchorPortDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'port');
            var anchorProtocolDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'protocol');
            var anchorSearchDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'search');
            var anchorTargetDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'target');
            var formTargetDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLFormElement.prototype, 'target');
            var areaTargetDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAreaElement.prototype, 'target');
            var baseTargetDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLBaseElement.prototype, 'target');
            var inputFormTargetDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'formTarget');
            var buttonFormTargetDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLButtonElement.prototype, 'formTarget');
            var svgImageHrefDescriptor = win.Object.getOwnPropertyDescriptor(win.SVGImageElement.prototype, 'href');
            var svgAnimStrAnimValDescriptor = win.Object.getOwnPropertyDescriptor(win.SVGAnimatedString.prototype, 'animVal');
            var svgAnimStrBaseValDescriptor = win.Object.getOwnPropertyDescriptor(win.SVGAnimatedString.prototype, 'baseVal');
            var inputAutocompleteDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'autocomplete');
            var formActionDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLFormElement.prototype, 'action');
            var inputFormActionDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'formAction');
            var buttonFormActionDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLButtonElement.prototype, 'formAction');
            var nodeTextContentDescriptor = win.Object.getOwnPropertyDescriptor(win.Node.prototype, 'textContent');
            var htmlElementInnerTextDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLElement.prototype, 'innerText');
            var scriptTextDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLScriptElement.prototype, 'text');
            var anchorTextDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'text');
            var titleElementTextDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLTitleElement.prototype, 'text');
            var iframeSandboxDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLIFrameElement.prototype, 'sandbox');
            var metaHttpEquivDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLMetaElement.prototype, 'httpEquiv');
            var windowOriginDescriptor = win.Object.getOwnPropertyDescriptor(win, 'origin');
            if (windowOriginDescriptor) {
                this.windowOriginGetter = windowOriginDescriptor.get;
                this.windowOriginSetter = windowOriginDescriptor.set;
            }
            // NOTE: We need 'disabled' property only for Chrome.
            // In Chrome it's located in HTMLInputElement.prototype
            // But in IE11 it's located in HTMLElement.prototype
            // So we need the null check
            if (inputDisabledDescriptor) {
                this.inputDisabledSetter = inputDisabledDescriptor.set;
                this.inputDisabledGetter = inputDisabledDescriptor.get;
            }
            // NOTE: Html properties is located in HTMLElement prototype in IE11 only
            this.elementHTMLPropOwnerName = win.Element.prototype.hasOwnProperty('innerHTML') ? 'Element' : 'HTMLElement'; // eslint-disable-line no-prototype-builtins
            var elementInnerHTMLDescriptor = win.Object.getOwnPropertyDescriptor(win[this.elementHTMLPropOwnerName].prototype, 'innerHTML');
            var elementOuterHTMLDescriptor = win.Object.getOwnPropertyDescriptor(win[this.elementHTMLPropOwnerName].prototype, 'outerHTML');
            // Setters
            this.objectDataSetter = objectDataDescriptor.set;
            this.inputTypeSetter = inputTypeDescriptor.set;
            this.inputValueSetter = inputValueDescriptor.set;
            this.inputRequiredSetter = inputRequiredDescriptor.set;
            this.textAreaValueSetter = textAreaValueDescriptor.set;
            this.imageSrcSetter = imageSrcDescriptor.set;
            this.scriptSrcSetter = scriptSrcDescriptor.set;
            this.embedSrcSetter = embedSrcDescriptor.set;
            this.sourceSrcSetter = sourceSrcDescriptor.set;
            this.mediaSrcSetter = mediaSrcDescriptor.set;
            this.inputSrcSetter = inputSrcDescriptor.set;
            this.frameSrcSetter = frameSrcDescriptor.set;
            this.iframeSrcSetter = iframeSrcDescriptor.set;
            this.anchorHrefSetter = anchorHrefDescriptor.set;
            this.linkHrefSetter = linkHrefDescriptor.set;
            this.linkRelSetter = linkRelDescriptor.set;
            this.linkAsSetter = linkAsDescriptor && linkAsDescriptor.set;
            this.areaHrefSetter = areaHrefDescriptor.set;
            this.baseHrefSetter = baseHrefDescriptor.set;
            this.anchorHostSetter = anchorHostDescriptor.set;
            this.anchorHostnameSetter = anchorHostnameDescriptor.set;
            this.anchorPathnameSetter = anchorPathnameDescriptor.set;
            this.anchorPortSetter = anchorPortDescriptor.set;
            this.anchorProtocolSetter = anchorProtocolDescriptor.set;
            this.anchorSearchSetter = anchorSearchDescriptor.set;
            this.anchorTargetSetter = anchorTargetDescriptor.set;
            this.formTargetSetter = formTargetDescriptor.set;
            this.areaTargetSetter = areaTargetDescriptor.set;
            this.baseTargetSetter = baseTargetDescriptor.set;
            this.inputFormTargetSetter = inputFormTargetDescriptor.set;
            this.buttonFormTargetSetter = buttonFormTargetDescriptor.set;
            this.svgAnimStrBaseValSetter = svgAnimStrBaseValDescriptor.set;
            this.inputAutocompleteSetter = inputAutocompleteDescriptor.set;
            this.formActionSetter = formActionDescriptor.set;
            this.inputFormActionSetter = inputFormActionDescriptor.set;
            this.buttonFormActionSetter = buttonFormActionDescriptor.set;
            this.iframeSandboxSetter = iframeSandboxDescriptor.set;
            this.metaHttpEquivSetter = metaHttpEquivDescriptor.set;
            this.htmlElementOnloadSetter = win.Object.getOwnPropertyDescriptor(win.HTMLElement.prototype, 'onload').set;
            this.nodeTextContentSetter = nodeTextContentDescriptor.set;
            this.htmlElementInnerTextSetter = htmlElementInnerTextDescriptor.set;
            this.scriptTextSetter = scriptTextDescriptor.set;
            this.anchorTextSetter = anchorTextDescriptor.set;
            this.elementInnerHTMLSetter = elementInnerHTMLDescriptor.set;
            this.elementOuterHTMLSetter = elementOuterHTMLDescriptor.set;
            // NOTE: Some browsers (for example, Edge, Internet Explorer 11, Safari) don't support the 'integrity' property.
            if (scriptIntegrityDescriptor && linkIntegrityDescriptor) {
                this.scriptIntegritySetter = scriptIntegrityDescriptor.set;
                this.linkIntegritySetter = linkIntegrityDescriptor.set;
            }
            this.titleElementTextSetter = titleElementTextDescriptor.set;
            // NOTE: the classList property is located in HTMLElement prototype in IE11
            this.elementClassListPropOwnerName = win.Element.prototype.hasOwnProperty('classList') ? 'Element' : 'HTMLElement'; // eslint-disable-line no-prototype-builtins
            this.elementClassListGetter = win.Object.getOwnPropertyDescriptor(win[this.elementClassListPropOwnerName].prototype, 'classList').get;
            this.htmlCollectionLengthGetter = win.Object.getOwnPropertyDescriptor(win.HTMLCollection.prototype, 'length').get;
            this.nodeListLengthGetter = win.Object.getOwnPropertyDescriptor(win.NodeList.prototype, 'length').get;
            this.elementChildElementCountGetter = win.Object.getOwnPropertyDescriptor(win.Element.prototype, 'childElementCount').get;
            this.inputFilesGetter = win.Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, 'files').get;
            this.styleSheetHrefGetter = win.Object.getOwnPropertyDescriptor(win.StyleSheet.prototype, 'href').get;
            this.objectDataGetter = objectDataDescriptor.get;
            this.inputTypeGetter = inputTypeDescriptor.get;
            this.inputValueGetter = inputValueDescriptor.get;
            this.inputRequiredGetter = inputRequiredDescriptor.get;
            this.textAreaValueGetter = textAreaValueDescriptor.get;
            this.imageSrcGetter = imageSrcDescriptor.get;
            this.scriptSrcGetter = scriptSrcDescriptor.get;
            this.embedSrcGetter = embedSrcDescriptor.get;
            this.sourceSrcGetter = sourceSrcDescriptor.get;
            this.mediaSrcGetter = mediaSrcDescriptor.get;
            this.inputSrcGetter = inputSrcDescriptor.get;
            this.frameSrcGetter = frameSrcDescriptor.get;
            this.iframeSrcGetter = iframeSrcDescriptor.get;
            this.anchorHrefGetter = anchorHrefDescriptor.get;
            this.linkHrefGetter = linkHrefDescriptor.get;
            this.linkRelGetter = linkRelDescriptor.get;
            this.areaHrefGetter = areaHrefDescriptor.get;
            this.baseHrefGetter = baseHrefDescriptor.get;
            this.anchorHostGetter = anchorHostDescriptor.get;
            this.anchorHostnameGetter = anchorHostnameDescriptor.get;
            this.anchorPathnameGetter = anchorPathnameDescriptor.get;
            this.anchorPortGetter = anchorPortDescriptor.get;
            this.anchorProtocolGetter = anchorProtocolDescriptor.get;
            this.anchorSearchGetter = anchorSearchDescriptor.get;
            this.anchorTargetGetter = anchorTargetDescriptor.get;
            this.formTargetGetter = formTargetDescriptor.get;
            this.areaTargetGetter = areaTargetDescriptor.get;
            this.baseTargetGetter = baseTargetDescriptor.get;
            this.inputFormTargetGetter = inputFormTargetDescriptor.get;
            this.buttonFormTargetGetter = buttonFormTargetDescriptor.get;
            this.svgImageHrefGetter = svgImageHrefDescriptor.get;
            this.svgAnimStrAnimValGetter = svgAnimStrAnimValDescriptor.get;
            this.svgAnimStrBaseValGetter = svgAnimStrBaseValDescriptor.get;
            this.inputAutocompleteGetter = inputAutocompleteDescriptor.get;
            this.formActionGetter = formActionDescriptor.get;
            this.inputFormActionGetter = inputFormActionDescriptor.get;
            this.buttonFormActionGetter = buttonFormActionDescriptor.get;
            this.iframeSandboxGetter = iframeSandboxDescriptor.get;
            this.metaHttpEquivGetter = metaHttpEquivDescriptor.get;
            this.contentWindowGetter = win.Object.getOwnPropertyDescriptor(win.HTMLIFrameElement.prototype, 'contentWindow').get;
            this.contentDocumentGetter = win.Object.getOwnPropertyDescriptor(win.HTMLIFrameElement.prototype, 'contentDocument').get;
            this.frameContentWindowGetter = win.Object.getOwnPropertyDescriptor(win.HTMLFrameElement.prototype, 'contentWindow').get;
            this.nodeTextContentGetter = nodeTextContentDescriptor.get;
            this.htmlElementInnerTextGetter = htmlElementInnerTextDescriptor.get;
            this.scriptTextGetter = scriptTextDescriptor.get;
            this.anchorTextGetter = anchorTextDescriptor.get;
            this.elementInnerHTMLGetter = elementInnerHTMLDescriptor.get;
            this.elementOuterHTMLGetter = elementOuterHTMLDescriptor.get;
            this.nodeFirstChildGetter = win.Object.getOwnPropertyDescriptor(win.Node.prototype, 'firstChild').get;
            this.nodeLastChildGetter = win.Object.getOwnPropertyDescriptor(win.Node.prototype, 'lastChild').get;
            this.nodeNextSiblingGetter = win.Object.getOwnPropertyDescriptor(win.Node.prototype, 'nextSibling').get;
            this.nodePrevSiblingGetter = win.Object.getOwnPropertyDescriptor(win.Node.prototype, 'previousSibling').get;
            this.nodeParentNodeGetter = win.Object.getOwnPropertyDescriptor(win.Node.prototype, 'parentNode').get;
            this.nodeChildNodesGetter = win.Object.getOwnPropertyDescriptor(win.Node.prototype, 'childNodes').get;
            this.elementFirstElementChildGetter = win.Object.getOwnPropertyDescriptor(win.Element.prototype, 'firstElementChild').get;
            this.elementLastElementChildGetter = win.Object.getOwnPropertyDescriptor(win.Element.prototype, 'lastElementChild').get;
            this.elementNextElementSiblingGetter = win.Object.getOwnPropertyDescriptor(win.Element.prototype, 'nextElementSibling').get;
            this.elementPrevElementSiblingGetter = win.Object.getOwnPropertyDescriptor(win.Element.prototype, 'previousElementSibling').get;
            // NOTE: Some browsers (for example, Edge, Internet Explorer 11, Safari) don't support the 'integrity' property.
            if (scriptIntegrityDescriptor && linkIntegrityDescriptor) {
                this.scriptIntegrityGetter = scriptIntegrityDescriptor.get;
                this.linkIntegrityGetter = linkIntegrityDescriptor.get;
            }
            // NOTE: In the Internet Explorer 11 the children property is located in HTMLElement.
            var childrenPropOwner = win.Element.prototype.hasOwnProperty('children') // eslint-disable-line no-prototype-builtins
                ? win.Element.prototype
                : win.HTMLElement.prototype;
            this.elementChildrenGetter = win.Object.getOwnPropertyDescriptor(childrenPropOwner, 'children').get;
            var anchorOriginDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLAnchorElement.prototype, 'origin');
            // NOTE: IE and Edge don't support origin property
            if (anchorOriginDescriptor)
                this.anchorOriginGetter = anchorOriginDescriptor.get;
            var iframeSrcdocDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLIFrameElement.prototype, 'srcdoc');
            // NOTE: IE11 doesn't support the 'srcdoc' property
            if (iframeSrcdocDescriptor) {
                this.iframeSrcdocGetter = iframeSrcdocDescriptor.get;
                this.iframeSrcdocSetter = iframeSrcdocDescriptor.set;
            }
            var cssStyleSheetHrefDescriptor = win.Object.getOwnPropertyDescriptor(win.CSSStyleSheet.prototype, 'href');
            // NOTE: IE11 doesn't support the 'href' property
            if (cssStyleSheetHrefDescriptor)
                this.cssStyleSheetHrefGetter = cssStyleSheetHrefDescriptor.get;
            var nodeBaseURIDescriptor = win.Object.getOwnPropertyDescriptor(win.Node.prototype, 'baseURI');
            // NOTE: IE11 doesn't support the 'baseURI' property
            if (nodeBaseURIDescriptor)
                this.nodeBaseURIGetter = nodeBaseURIDescriptor.get;
            // NOTE: The 'attributes' property is located in Node prototype in IE11 only
            this.elementAttributesPropOwnerName = win.Element.prototype.hasOwnProperty('attributes') ? 'Element' : 'Node'; // eslint-disable-line no-prototype-builtins
            this.elementAttributesGetter = win.Object.getOwnPropertyDescriptor(win[this.elementAttributesPropOwnerName].prototype, 'attributes').get;
            var htmlManifestDescriptor = win.Object.getOwnPropertyDescriptor(win.HTMLHtmlElement.prototype, 'manifest');
            // NOTE: Only the Safari browser supports the 'manifest' property
            if (htmlManifestDescriptor) {
                this.htmlManifestGetter = htmlManifestDescriptor.get;
                this.htmlManifestSetter = htmlManifestDescriptor.set;
            }
            // NOTE: IE11 doesn't support the 'srcset' property
            if (iframeSrcdocDescriptor) {
                this.imageSrcsetSetter = imageSrcsetDescriptor.set;
                this.imageSrcsetGetter = imageSrcsetDescriptor.get;
            }
            this.titleElementTextGetter = titleElementTextDescriptor.get;
            // MutationRecord
            this.mutationRecordNextSiblingGetter = win.Object.getOwnPropertyDescriptor(win.MutationRecord.prototype, 'nextSibling').get;
            this.mutationRecordPrevSiblingGetter = win.Object.getOwnPropertyDescriptor(win.MutationRecord.prototype, 'previousSibling').get;
        };
        NativeMethods.prototype.refreshWindowMeths = function (win, isInWorker) {
            if (isInWorker === void 0) { isInWorker = false; }
            win = win || window;
            var winProto = win.constructor.prototype;
            // Dom
            this.eval = win.eval;
            this.formSubmit = win.HTMLFormElement && win.HTMLFormElement.prototype.submit;
            this.documentFragmentQuerySelector = win.DocumentFragment && win.DocumentFragment.prototype.querySelector;
            this.documentFragmentQuerySelectorAll = win.DocumentFragment && win.DocumentFragment.prototype.querySelectorAll;
            this.preventDefault = win.Event.prototype.preventDefault;
            this.historyPushState = win.history && win.history.pushState;
            this.historyReplaceState = win.history && win.history.replaceState;
            this.postMessage = win.postMessage || winProto.postMessage;
            this.windowOpen = win.open || winProto.open;
            this.setTimeout = win.setTimeout || winProto.setTimeout;
            this.setInterval = win.setInterval || winProto.setInterval;
            this.clearTimeout = win.clearTimeout || winProto.clearTimeout;
            this.clearInterval = win.clearInterval || winProto.clearInterval;
            this.registerProtocolHandler = win.navigator.registerProtocolHandler;
            this.sendBeacon = win.Navigator && win.Navigator.prototype.sendBeacon;
            if (win.XMLHttpRequest) {
                // NOTE: IE11 has no EventTarget so we should save "Event" methods separately
                var xhrEventProto = (win.EventTarget || win.XMLHttpRequest).prototype;
                this.xhrAbort = win.XMLHttpRequest.prototype.abort;
                this.xhrOpen = win.XMLHttpRequest.prototype.open;
                this.xhrSend = win.XMLHttpRequest.prototype.send;
                this.xhrAddEventListener = xhrEventProto.addEventListener;
                this.xhrRemoveEventListener = xhrEventProto.removeEventListener;
                this.xhrDispatchEvent = xhrEventProto.dispatchEvent;
                this.xhrGetResponseHeader = win.XMLHttpRequest.prototype.getResponseHeader;
                this.xhrGetAllResponseHeaders = win.XMLHttpRequest.prototype.getAllResponseHeaders;
                this.xhrSetRequestHeader = win.XMLHttpRequest.prototype.setRequestHeader;
                this.xhrOverrideMimeType = win.XMLHttpRequest.prototype.overrideMimeType;
            }
            try {
                this.registerServiceWorker = win.navigator.serviceWorker.register;
                this.getRegistrationServiceWorker = win.navigator.serviceWorker.getRegistration;
            }
            catch (e) {
                this.registerServiceWorker = null;
                this.getRegistrationServiceWorker = null;
            }
            this.createContextualFragment = win.Range && win.Range.prototype.createContextualFragment;
            var nativePerformance = win.performance;
            if (nativePerformance) {
                // eslint-disable-next-line no-restricted-properties
                var nativePerformanceNow_1 = win.performance.now || win.Performance.prototype.now;
                this.performanceNow = function () {
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    return nativePerformanceNow_1.apply(nativePerformance, args);
                };
            }
            // Fetch
            this.fetch = win.fetch;
            this.Request = win.Request;
            if (win.Headers) {
                this.Headers = win.Headers;
                this.headersSet = win.Headers.prototype.set;
                this.headersGet = win.Headers.prototype.get;
                this.headersDelete = win.Headers.prototype.delete;
                this.headersEntries = win.Headers.prototype.entries;
                this.headersForEach = win.Headers.prototype.forEach;
                this.headersValues = win.Headers.prototype.values;
            }
            // Event
            this.windowAddEventListener = win.addEventListener || winProto.addEventListener;
            this.windowRemoveEventListener = win.removeEventListener || winProto.removeEventListener;
            this.windowDispatchEvent = win.dispatchEvent;
            this.WindowPointerEvent = win.PointerEvent || winProto.PointerEvent;
            this.WindowMSPointerEvent = win.MSPointerEvent || winProto.MSPointerEvent;
            this.WindowTouch = win.Touch || winProto.Touch;
            this.WindowTouchEvent = win.TouchEvent || winProto.TouchEvent;
            this.WindowKeyboardEvent = win.KeyboardEvent || winProto.KeyboardEvent;
            this.WindowFocusEvent = win.FocusEvent || winProto.FocusEvent;
            this.WindowTextEvent = win.TextEvent || winProto.TextEvent;
            this.WindowInputEvent = win.InputEvent || winProto.InputEvent;
            this.WindowMouseEvent = win.MouseEvent || winProto.MouseEvent;
            this.eventTargetGetter = win.Object.getOwnPropertyDescriptor(win.Event.prototype, 'target').get;
            this.canvasContextDrawImage = win.CanvasRenderingContext2D && win.CanvasRenderingContext2D.prototype.drawImage;
            // FormData
            this.formDataAppend = win.FormData && win.FormData.prototype.append;
            // DateTime
            this.date = win.Date;
            this.dateNow = win.Date.now; // eslint-disable-line no-restricted-properties
            // Math
            this.math = win.Math;
            this.mathRandom = win.Math.random;
            // Object
            this.objectToString = win.Object.prototype.toString;
            this.objectAssign = win.Object.assign;
            this.objectKeys = win.Object.keys;
            this.objectDefineProperty = win.Object.defineProperty;
            this.objectDefineProperties = win.Object.defineProperties;
            this.objectCreate = win.Object.create;
            this.objectIsExtensible = win.Object.isExtensible;
            this.objectIsFrozen = win.Object.isFrozen;
            this.objectGetOwnPropertyDescriptor = win.Object.getOwnPropertyDescriptor;
            this.objectHasOwnProperty = win.Object.hasOwnProperty;
            this.objectGetOwnPropertyNames = win.Object.getOwnPropertyNames;
            this.objectGetPrototypeOf = win.Object.getPrototypeOf;
            this.objectSetPrototypeOf = win.Object.setPrototypeOf;
            this.objectGetOwnPropertySymbols = win.Object.getOwnPropertySymbols;
            // Array
            this.arraySlice = win.Array.prototype.slice;
            this.arrayConcat = win.Array.prototype.concat;
            this.arrayFilter = win.Array.prototype.filter;
            this.arrayFind = win.Array.prototype.find;
            this.arrayMap = win.Array.prototype.map;
            this.arrayJoin = win.Array.prototype.join;
            this.arraySplice = win.Array.prototype.splice;
            this.arrayUnshift = win.Array.prototype.unshift;
            this.arrayForEach = win.Array.prototype.forEach;
            this.arrayIndexOf = win.Array.prototype.indexOf;
            this.arraySome = win.Array.prototype.some;
            this.arrayEvery = win.Array.prototype.every;
            this.arrayReverse = win.Array.prototype.reverse;
            this.arrayReduce = win.Array.prototype.reduce;
            this.arrayFrom = win.Array.from;
            this.isArray = win.Array.isArray;
            this.DOMParserParseFromString = win.DOMParser && win.DOMParser.prototype.parseFromString;
            this.arrayBufferIsView = win.ArrayBuffer.prototype.constructor.isView;
            // NOTE: this section relates to getting properties from DOM classes
            if (!isInWorker) {
                // DOMTokenList
                this.tokenListAdd = win.DOMTokenList.prototype.add;
                this.tokenListRemove = win.DOMTokenList.prototype.remove;
                this.tokenListReplace = win.DOMTokenList.prototype.replace;
                this.tokenListSupports = win.DOMTokenList.prototype.supports;
                this.tokenListToggle = win.DOMTokenList.prototype.toggle;
                this.tokenListContains = win.DOMTokenList.prototype.contains;
                var tokenListValueDescriptor = win.Object.getOwnPropertyDescriptor(win.DOMTokenList.prototype, 'value');
                // NOTE: IE11 doesn't support the 'value' property of the DOMTokenList interface
                if (tokenListValueDescriptor)
                    this.tokenListValueSetter = tokenListValueDescriptor.set;
                // Stylesheets
                this.styleGetPropertyValue = win.CSSStyleDeclaration.prototype.getPropertyValue;
                this.styleSetProperty = win.CSSStyleDeclaration.prototype.setProperty;
                this.styleRemoveProperty = win.CSSStyleDeclaration.prototype.removeProperty;
                this.styleInsertRule = win.CSSStyleSheet.prototype.insertRule;
                this.scrollTo = win.scrollTo;
            }
            if (win.Promise) {
                this.promiseThen = win.Promise.prototype.then;
                this.promiseReject = win.Promise.reject;
            }
            // Console
            this.console = win.console;
            if (this.console) {
                this.consoleMeths = {
                    log: win.console.log,
                    warn: win.console.warn,
                    error: win.console.error,
                    info: win.console.info,
                };
            }
            this.crypto = win.crypto || win.msCrypto;
            this.cryptoGetRandomValues = this.crypto && this.crypto.getRandomValues;
            this.refreshClasses(win);
            this._refreshGettersAndSetters(win, isInWorker);
        };
        NativeMethods.prototype.refreshClasses = function (win) {
            this.windowClass = win.Window;
            this.documentClass = win.Document;
            this.locationClass = win.Location;
            this.elementClass = win.Element;
            this.svgElementClass = win.SVGElement;
            this.Worker = win.Worker;
            this.MessageChannel = win.MessageChannel;
            this.Array = win.Array;
            this.ArrayBuffer = win.ArrayBuffer;
            this.Uint8Array = win.Uint8Array;
            this.Uint16Array = win.Uint16Array;
            this.Uint32Array = win.Uint32Array;
            this.DataView = win.DataView;
            this.Blob = win.Blob;
            this.XMLHttpRequest = win.XMLHttpRequest;
            this.Image = win.Image;
            this.Function = win.Function;
            this.functionToString = win.Function.prototype.toString;
            this.functionBind = win.Function.prototype.bind;
            this.Error = win.Error;
            this.FontFace = win.FontFace;
            this.StorageEvent = win.StorageEvent;
            this.MutationObserver = win.MutationObserver;
            this.EventSource = win.EventSource;
            this.Proxy = win.Proxy;
            this.WebSocket = win.WebSocket;
            this.HTMLCollection = win.HTMLCollection;
            this.NodeList = win.NodeList;
            this.Node = win.Node;
            this.URL = win.URL;
            this.DataTransfer = win.DataTransfer;
            this.DataTransferItemList = win.DataTransferItemList;
            this.DataTransferItem = win.DataTransferItem;
            this.FileList = win.FileList;
            // NOTE: non-IE11 case. window.File in IE11 is not constructable.
            if (win.File && isFunction(win.File))
                this.File = win.File;
        };
        NativeMethods.prototype.refreshElectronMeths = function (vmModule) {
            if (this.createScript && isNativeFunction(vmModule.createScript))
                return false;
            this.createScript = vmModule.createScript;
            this.runInDebugContext = vmModule.runInDebugContext;
            this.runInContext = vmModule.runInContext;
            this.runInNewContext = vmModule.runInNewContext;
            this.runInThisContext = vmModule.runInThisContext;
            return true;
        };
        NativeMethods._ensureDocumentMethodRestore = function (document, prototype, methodName, savedNativeMethod) {
            prototype[methodName] = savedNativeMethod;
            if (document[methodName] !== prototype[methodName])
                document[methodName] = savedNativeMethod;
        };
        NativeMethods.prototype.restoreDocumentMeths = function (window, document) {
            var docPrototype = window.Document.prototype;
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'createDocumentFragment', this.createDocumentFragment);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'createElement', this.createElement);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'createElementNS', this.createElementNS);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'elementFromPoint', this.elementFromPoint);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'caretRangeFromPoint', this.caretRangeFromPoint);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'caretPositionFromPoint', this.caretPositionFromPoint);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'getElementById', this.getElementById);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'getElementsByClassName', this.getElementsByClassName);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'getElementsByName', this.getElementsByName);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'getElementsByTagName', this.getElementsByTagName);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'querySelector', this.querySelector);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'querySelectorAll', this.querySelectorAll);
            // Event
            // NOTE: IE11 has no EventTarget
            if (!window.EventTarget) {
                NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'addEventListener', this.documentAddEventListener);
                NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'removeEventListener', this.documentRemoveEventListener);
            }
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'createEvent', this.documentCreateEvent);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'createTouch', this.documentCreateTouch);
            NativeMethods._ensureDocumentMethodRestore(document, docPrototype, 'createTouchList', this.documentCreateTouchList);
            NativeMethods._ensureDocumentMethodRestore(document, window[this.documentOpenPropOwnerName].prototype, 'open', this.documentOpen);
            NativeMethods._ensureDocumentMethodRestore(document, window[this.documentClosePropOwnerName].prototype, 'close', this.documentClose);
            NativeMethods._ensureDocumentMethodRestore(document, window[this.documentWritePropOwnerName].prototype, 'write', this.documentWrite);
            NativeMethods._ensureDocumentMethodRestore(document, window[this.documentWriteLnPropOwnerName].prototype, 'writeln', this.documentWriteLn);
        };
        NativeMethods.prototype.refreshIfNecessary = function (doc, win) {
            var _this = this;
            var tryToExecuteCode = function (func) {
                try {
                    return func();
                }
                catch (e) {
                    return true;
                }
            };
            var needToRefreshDocumentMethods = tryToExecuteCode(function () { return !doc.createElement || isNativeFunction(document.createElement); });
            var needToRefreshElementMethods = tryToExecuteCode(function () {
                var nativeElement = _this.createElement.call(doc, 'div');
                return isNativeFunction(nativeElement.getAttribute);
            });
            var needToRefreshWindowMethods = tryToExecuteCode(function () {
                _this.setTimeout.call(win, function () { return void 0; }, 0);
                return isNativeFunction(win.XMLHttpRequest.prototype.open);
            });
            // NOTE: T173709
            if (needToRefreshDocumentMethods)
                this.refreshDocumentMeths(doc, win);
            if (needToRefreshElementMethods)
                this.refreshElementMeths(doc, win);
            // NOTE: T239109
            if (needToRefreshWindowMethods)
                this.refreshWindowMeths(win);
        };
        NativeMethods.prototype.isNativeCode = function (fn) {
            return NATIVE_CODE_RE.test(this.functionToString.call(fn));
        };
        return NativeMethods;
    }());
    var nativeMethods = new NativeMethods();

    var instanceAndPrototypeToStringAreEqual = false;
    if (nativeMethods.createElement) {
        var form = nativeMethods.createElement.call(document, 'form');
        var elements = nativeMethods.getElementsByName.call(document, '');
        // NOTE: In some browsers, elements without the url attribute return the location url
        // when accessing this attribute directly. See form.action in Edge 25 as an example.
        nativeMethods.formActionGetter.call(form) === window.location.toString();
        // NOTE: In Chrome, toString(window) equals '[object Window]' and toString(Window.prototype) equals '[object Blob]',
        // this condition is also satisfied for Blob, Document, XMLHttpRequest, etc
        instanceAndPrototypeToStringAreEqual = nativeMethods.objectToString.call(window) ===
            nativeMethods.objectToString.call(Window.prototype);
        // NOTE: In the Edge 17, the getNamedItem method of attributes object is not enumerable
        !!nativeMethods.objectGetOwnPropertyDescriptor.call(window.Object, NamedNodeMap.prototype, 'getNamedItem');
        // Both IE and Edge return an HTMLCollection, not a NodeList
        // @ts-ignore
        nativeMethods.objectGetPrototypeOf.call(window.Object, elements) ===
            nativeMethods.HTMLCollection.prototype;
    }

    var WINDOW_IS_UNDEFINED = typeof window === 'undefined';
    WINDOW_IS_UNDEFINED ? '' : instanceToString(window);
    WINDOW_IS_UNDEFINED ? '' : instanceToString(nativeMethods.createElement.call(document, 'td'));
    var ELEMENT_NODE_TYPE = WINDOW_IS_UNDEFINED ? -1 : Node.ELEMENT_NODE;
    function instanceToString(instance) {
        if (!instanceAndPrototypeToStringAreEqual)
            return nativeMethods.objectToString.call(instance);
        return instance && typeof instance === 'object'
            ? nativeMethods.objectToString.call(nativeMethods.objectGetPrototypeOf(instance))
            : '';
    }
    function getIframeLocation(iframe) {
        var documentLocation = null;
        try {
            // eslint-disable-next-line no-restricted-properties
            documentLocation = nativeMethods.contentDocumentGetter.call(iframe).location.href;
        }
        catch (e) {
            documentLocation = null;
        }
        var srcLocation = nativeMethods.getAttribute.call(iframe, 'src' + INTERNAL_ATTRS.storedAttrPostfix) ||
            nativeMethods.getAttribute.call(iframe, 'src') || nativeMethods.iframeSrcGetter.call(iframe);
        var parsedProxyDocumentLocation = documentLocation && isSupportedProtocol(documentLocation) &&
            parseProxyUrl(documentLocation);
        var parsedProxySrcLocation = srcLocation && isSupportedProtocol(srcLocation) &&
            parseProxyUrl(srcLocation);
        return {
            documentLocation: parsedProxyDocumentLocation ? parsedProxyDocumentLocation.destUrl : documentLocation,
            srcLocation: parsedProxySrcLocation ? parsedProxySrcLocation.destUrl : srcLocation,
        };
    }
    function getFrameElement(win) {
        try {
            return win.frameElement;
        }
        catch (e) {
            return null;
        }
    }
    function findDocument(el) {
        if (el.documentElement)
            return el;
        if (el.ownerDocument && el.ownerDocument.defaultView)
            return el.ownerDocument;
        var parent = isElementNode(el) && nativeMethods.nodeParentNodeGetter.call(el);
        return parent ? findDocument(parent) : document;
    }
    var SHADOW_ROOT_PARENT_ELEMENT = 'hammerhead|element|shadow-root-parent';
    function getNodeShadowRootParent(el) {
        var parent = nativeMethods.nodeParentNodeGetter.call(el);
        while (parent && parent.nodeType !== Node.DOCUMENT_FRAGMENT_NODE)
            parent = nativeMethods.nodeParentNodeGetter.call(parent);
        return parent && parent[SHADOW_ROOT_PARENT_ELEMENT];
    }
    function isElementInDocument(el, currentDocument) {
        var doc = currentDocument || document;
        if (!doc.documentElement)
            return false;
        if (doc.documentElement.contains(el))
            return true;
        var shadowRootParent = getNodeShadowRootParent(el);
        return shadowRootParent ? isElementInDocument(shadowRootParent) : false;
    }
    function isIframeWithoutSrc(iframe) {
        var iframeLocation = getIframeLocation(iframe);
        var iframeSrcLocation = iframeLocation.srcLocation;
        var iframeDocumentLocation = iframeLocation.documentLocation;
        // NOTE: is a cross-domain iframe
        if (iframeDocumentLocation === null)
            return false;
        // NOTE: after 'document.write' or 'document.open' call for iframe with/without src
        // we will process it as iframe without src
        if (nativeMethods.contentWindowGetter.call(iframe)[INTERNAL_PROPS.documentWasCleaned])
            return true;
        var iframeDocumentLocationHaveSupportedProtocol = isSupportedProtocol(iframeDocumentLocation);
        // NOTE: When an iframe has an empty src attribute (<iframe src></iframe>) or has no src attribute (<iframe></iframe>),
        // the iframe.src property is not empty but has different values in different browsers.
        // Its document location is 'about:blank'. Therefore, we should check the src attribute.
        if (!iframeDocumentLocationHaveSupportedProtocol && !nativeMethods.getAttribute.call(iframe, 'src'))
            return true;
        // In Chrome, when an iframe with the src attribute is added to DOM,
        // its documentLocation is set to "about:blank" until the iframe has been loaded.
        // So, we should check srcLocation in this case.
        if (iframeSrcLocation && isSupportedProtocol(iframeSrcLocation))
            return false;
        return !iframeDocumentLocationHaveSupportedProtocol;
    }
    function isFetchHeaders(instance) {
        if (nativeMethods.Headers && instance instanceof nativeMethods.Headers)
            return true;
        return instance && instanceToString(instance) === '[object Headers]';
    }
    function isFetchRequest(instance) {
        if (nativeMethods.Request && instance instanceof nativeMethods.Request)
            return true;
        return instance && instanceToString(instance) === '[object Request]';
    }
    function isElementNode(node) {
        return node && node.nodeType === ELEMENT_NODE_TYPE;
    }

    var DOCUMENT_URL_RESOLVER = 'hammerhead|document-url-resolver';
    var urlResolver = {
        _createResolver: function (doc) {
            var htmlDocument = nativeMethods.createHTMLDocument.call(doc.implementation, 'title');
            var a = nativeMethods.createElement.call(htmlDocument, 'a');
            var base = nativeMethods.createElement.call(htmlDocument, 'base');
            nativeMethods.appendChild.call(htmlDocument.body, a);
            nativeMethods.appendChild.call(htmlDocument.head, base);
            return htmlDocument;
        },
        _getResolver: function (doc) {
            // NOTE: Once a document is recreated (document.open, document.write is called), nativeMethods will be refreshed.
            // If we call urlResolve.updateBase after this,
            // we will use native methods from an actual document.
            // However, a document that contains an element for url resolving is created using a previous version of nativeMethods.
            if (!doc[DOCUMENT_URL_RESOLVER]) {
                nativeMethods.objectDefineProperty(doc, DOCUMENT_URL_RESOLVER, {
                    value: this._createResolver(doc),
                    writable: true,
                });
            }
            return doc[DOCUMENT_URL_RESOLVER];
        },
        _isNestedIframeWithoutSrc: function (win) {
            if (!win || !win.parent || win.parent === win || win.parent.parent === win.parent)
                return false;
            var iframeElement = getFrameElement(window);
            return !!iframeElement && isIframeWithoutSrc(iframeElement);
        },
        init: function (doc) {
            this.updateBase(get(), doc);
        },
        getResolverElement: function (doc) {
            return nativeMethods.nodeFirstChildGetter.call(this._getResolver(doc).body);
        },
        resolve: function (url, doc) {
            var resolver = this.getResolverElement(doc);
            var href = null;
            if (url === null)
                nativeMethods.removeAttribute.call(resolver, 'href');
            else {
                nativeMethods.anchorHrefSetter.call(resolver, url);
                href = nativeMethods.anchorHrefGetter.call(resolver);
                // NOTE: It looks like a Chrome bug: in a nested iframe without src (when an iframe is placed into another
                // iframe) you cannot set a relative link href while the iframe loading is not completed. So, we'll do it with
                // the parent's urlResolver Safari demonstrates similar behavior, but urlResolver.href has a relative URL value.
                var needUseParentResolver = url && (!href || href.charAt(0) === '/') &&
                    this._isNestedIframeWithoutSrc(doc.defaultView);
                if (needUseParentResolver)
                    return this.resolve(url, window.parent.document);
            }
            return ensureTrailingSlash(url, href);
        },
        updateBase: function (url, doc) {
            if (this.proxyless)
                return;
            var resolverDocument = this._getResolver(doc);
            var baseElement = nativeMethods.elementGetElementsByTagName.call(resolverDocument.head, 'base')[0];
            url = url || get();
            /*eslint-disable no-restricted-properties*/
            var parsedUrl = parseUrl$1(url);
            var isRelativeUrl = parsedUrl.protocol !== 'file:' && parsedUrl.protocol !== 'about:' && !parsedUrl.host;
            var isProtocolRelativeUrl = /^\/\//.test(url) && !!parsedUrl.host;
            /*eslint-enable no-restricted-properties*/
            if (isRelativeUrl || isProtocolRelativeUrl) {
                var destinationLocation = get();
                this.updateBase(destinationLocation, doc);
                url = this.resolve(url, doc);
            }
            nativeMethods.setAttribute.call(baseElement, 'href', url);
        },
        getBaseUrl: function (doc) {
            var baseElement = nativeMethods.elementGetElementsByTagName.call(this._getResolver(doc).head, 'base')[0];
            return nativeMethods.getAttribute.call(baseElement, 'href');
        },
        changeUrlPart: function (url, nativePropSetter, value, doc) {
            var resolver = this.getResolverElement(doc);
            nativeMethods.anchorHrefSetter.call(resolver, url);
            nativePropSetter.call(resolver, value);
            return nativeMethods.anchorHrefGetter.call(resolver);
        },
        dispose: function (doc) {
            doc[DOCUMENT_URL_RESOLVER] = null;
        },
        get proxyless() {
            return this._proxyless;
        },
        set proxyless(value) {
            this._proxyless = value;
        },
    };

    var Settings = /** @class */ (function () {
        function Settings() {
            this._settings = {
                isFirstPageLoad: true,
                sessionId: '',
                forceProxySrcForImage: false,
                crossDomainProxyPort: '',
                referer: '',
                serviceMsgUrl: '',
                transportWorkerUrl: '',
                iframeTaskScriptTemplate: '',
                cookie: '',
                allowMultipleWindows: false,
                isRecordMode: false,
                windowId: '',
                proxyless: false,
                disableCrossDomain: false,
            };
        }
        Settings.prototype.set = function (value) {
            this._settings = value;
        };
        Settings.prototype.get = function () {
            return this._settings;
        };
        return Settings;
    }());
    var settings = new Settings();

    var forcedLocation = null;
    // NOTE: exposed only for tests
    function getLocation() {
        // NOTE: Used for testing. Unfortunately, we cannot override the 'getLocation' method in a test.
        if (forcedLocation)
            return forcedLocation;
        var frameElement = getFrameElement(globalContextInfo.global);
        // NOTE: Fallback to the owner page's URL if we are in an iframe without src.
        if (frameElement && isIframeWithoutSrc(frameElement))
            return settings.get().referer;
        return globalContextInfo.global.location.toString();
    }
    // NOTE: We need to be able to force the page location. During the test, Hammerhead should think that it is on the
    // proxied page, not in the test environment. Unfortunately, we cannot do it in any other way.
    function forceLocation(url) {
        forcedLocation = url;
    }
    function sameOriginCheck(location, checkedUrl) {
        if (checkedUrl)
            checkedUrl = resolveUrl(checkedUrl);
        return settings.get().disableCrossDomain || sameOriginCheck$1(location, checkedUrl);
    }
    function resolveUrl(url, doc) {
        var preProcessedUrl = getURLString(url);
        if (preProcessedUrl && preProcessedUrl.indexOf('//') === 0) {
            // eslint-disable-next-line no-restricted-properties
            var pageProtocol = getParsed().protocol;
            preProcessedUrl = pageProtocol + correctMultipleSlashes(preProcessedUrl, pageProtocol);
        }
        else
            preProcessedUrl = correctMultipleSlashes(preProcessedUrl);
        if (globalContextInfo.isInWorker) {
            if (self.location.protocol !== 'blob:') // eslint-disable-line no-restricted-properties
                return new nativeMethods.URL(preProcessedUrl, get()).href; // eslint-disable-line no-restricted-properties
            return String(url);
        }
        return urlResolver.resolve(preProcessedUrl, doc || document);
    }
    var get = function () {
        var location = getLocation();
        var parsedProxyUrl = parseProxyUrl$1(location);
        return parsedProxyUrl ? parsedProxyUrl.destUrl : location;
    };
    function parseLocationThroughAnchor(url) {
        var resolver = urlResolver.getResolverElement(document);
        // eslint-disable-next-line no-restricted-properties
        var destPort = parseUrl$1(url).port;
        // NOTE: IE browser adds the default port for the https protocol while resolving.
        nativeMethods.anchorHrefSetter.call(resolver, get());
        var hostname = nativeMethods.anchorHostnameGetter.call(resolver);
        var pathname = nativeMethods.anchorPathnameGetter.call(resolver);
        // NOTE: IE ignores the first '/' symbol in the pathname.
        if (pathname.charAt(0) !== '/')
            pathname = '/' + pathname;
        // TODO: Describe default ports logic.
        return {
            protocol: nativeMethods.anchorProtocolGetter.call(resolver),
            // NOTE: Remove the default port.
            port: destPort ? nativeMethods.anchorPortGetter.call(resolver) : '',
            hostname: hostname,
            // NOTE: Remove the default port from the host.
            host: destPort ? nativeMethods.anchorHostGetter.call(resolver) : hostname,
            pathname: pathname,
            hash: resolver.hash,
            search: nativeMethods.anchorSearchGetter.call(resolver),
        };
    }
    function parseLocationThroughURL(url) {
        var parsedUrl = new nativeMethods.URL(url);
        /* eslint-disable no-restricted-properties */
        return {
            protocol: parsedUrl.protocol,
            port: parsedUrl.port,
            hostname: parsedUrl.hostname,
            host: parsedUrl.host,
            pathname: parsedUrl.pathname,
            hash: parsedUrl.hash,
            search: parsedUrl.search,
        };
        /* eslint-enable no-restricted-properties */
    }
    function getParsed() {
        var dest = get();
        return globalContextInfo.isInWorker ? parseLocationThroughURL(dest) : parseLocationThroughAnchor(dest);
    }
    function getOriginHeader() {
        return getDomain(getParsed());
    }

    var SUPPORTED_WEB_SOCKET_PROTOCOL_RE = /^wss?:/i;
    // NOTE: The window.location equals 'about:blank' in iframes without src
    // therefore we need to find a window with src to get the proxy settings
    var DEFAULT_PROXY_SETTINGS = (function () {
        /*eslint-disable no-restricted-properties*/
        var locationWindow = globalContextInfo.isInWorker ? { location: parseUrl(self.location.origin), parent: null } : window;
        var proxyLocation = locationWindow.location;
        while (!proxyLocation.hostname) {
            // about:blank page in proxyless mode
            if (!globalContextInfo.isInWorker
                && locationWindow === locationWindow.top)
                break;
            locationWindow = locationWindow.parent;
            proxyLocation = locationWindow.location;
        }
        return {
            hostname: proxyLocation.hostname,
            port: proxyLocation.port.toString(),
            protocol: proxyLocation.protocol,
        };
        /*eslint-enable no-restricted-properties*/
    })();
    function getCharsetFromDocument(parsedResourceType) {
        if (!parsedResourceType.isScript && !parsedResourceType.isServiceWorker)
            return null;
        return self.document && document[INTERNAL_PROPS.documentCharset] || null;
    }
    var getProxyUrl = function (url, opts, proxyless) {
        if (opts === void 0) { opts = {}; }
        if (proxyless === void 0) { proxyless = false; }
        if (opts.isUrlsSet) {
            opts.isUrlsSet = false;
            return handleUrlsSet(getProxyUrl, String(url), opts, proxyless);
        }
        if (proxyless)
            return String(url);
        url = getURLString(url);
        var resourceType = opts && opts.resourceType;
        var parsedResourceType = parseResourceType(resourceType);
        if (!parsedResourceType.isWebSocket && !isSupportedProtocol(url) && !isSpecialPage(url))
            return url;
        // NOTE: Resolves relative URLs.
        var resolvedUrl = resolveUrl(url, opts && opts.doc);
        if (parsedResourceType.isWebSocket && !isValidWebSocketUrl(resolvedUrl) || !isValidUrl(resolvedUrl))
            return url;
        /*eslint-disable no-restricted-properties*/
        var proxyHostname = opts && opts.proxyHostname || DEFAULT_PROXY_SETTINGS.hostname;
        var proxyPort = opts && opts.proxyPort || DEFAULT_PROXY_SETTINGS.port;
        var proxyServerProtocol = opts && opts.proxyProtocol || DEFAULT_PROXY_SETTINGS.protocol;
        /*eslint-enable no-restricted-properties*/
        var proxyProtocol = parsedResourceType.isWebSocket
            ? proxyServerProtocol.replace('http', 'ws')
            : proxyServerProtocol;
        var sessionId = opts && opts.sessionId || settings.get().sessionId;
        var windowId = opts && opts.windowId || settings.get().windowId;
        var credentials = opts && opts.credentials;
        var charset = opts && opts.charset;
        var reqOrigin = opts && opts.reqOrigin;
        var crossDomainPort = getCrossDomainProxyPort(proxyPort);
        // NOTE: If the relative URL contains no slash (e.g. 'img123'), the resolver will keep
        // the original proxy information, so that we can return such URL as is.
        // TODO: Implement the isProxyURL function.
        var parsedProxyUrl = parseProxyUrl$1(resolvedUrl);
        /*eslint-disable no-restricted-properties*/
        var isValidProxyUrl = !!parsedProxyUrl && parsedProxyUrl.proxy.hostname === proxyHostname &&
            (parsedProxyUrl.proxy.port === proxyPort || parsedProxyUrl.proxy.port === crossDomainPort);
        /*eslint-enable no-restricted-properties*/
        if (isValidProxyUrl) {
            if (resourceType && parsedProxyUrl.resourceType === resourceType)
                return resolvedUrl;
            // NOTE: Need to change the proxy URL resource type.
            var destUrl = formatUrl(parsedProxyUrl.destResourceInfo);
            return getProxyUrl(destUrl, {
                proxyProtocol: proxyProtocol,
                proxyHostname: proxyHostname,
                proxyPort: proxyPort,
                sessionId: sessionId,
                resourceType: resourceType,
                charset: charset,
                reqOrigin: reqOrigin,
                credentials: credentials,
            });
        }
        var parsedUrl = parseUrl$1(resolvedUrl);
        if (!parsedUrl.protocol) // eslint-disable-line no-restricted-properties
            return url;
        charset = charset || getCharsetFromDocument(parsedResourceType);
        // NOTE: It seems that the relative URL had the leading slash or dots, so that the proxy info path part was
        // removed by the resolver and we have an origin URL with the incorrect host and protocol.
        /*eslint-disable no-restricted-properties*/
        if (parsedUrl.protocol === proxyServerProtocol && parsedUrl.hostname === proxyHostname &&
            parsedUrl.port === proxyPort) {
            var parsedDestLocation = getParsed();
            parsedUrl.protocol = parsedDestLocation.protocol;
            parsedUrl.host = parsedDestLocation.host;
            parsedUrl.hostname = parsedDestLocation.hostname;
            parsedUrl.port = parsedDestLocation.port || '';
            resolvedUrl = formatUrl(parsedUrl);
        }
        /*eslint-enable no-restricted-properties*/
        if (parsedResourceType.isWebSocket) {
            // eslint-disable-next-line no-restricted-properties
            parsedUrl.protocol = parsedUrl.protocol.replace('ws', 'http');
            resolvedUrl = formatUrl(parsedUrl);
            reqOrigin = reqOrigin || getOriginHeader();
        }
        if (parsedResourceType.isIframe && proxyPort === settings.get().crossDomainProxyPort)
            reqOrigin = reqOrigin || getOriginHeader();
        return getProxyUrl$1(resolvedUrl, {
            proxyProtocol: proxyProtocol,
            proxyHostname: proxyHostname,
            proxyPort: proxyPort,
            sessionId: sessionId,
            resourceType: resourceType,
            charset: charset,
            reqOrigin: reqOrigin,
            windowId: windowId,
            credentials: credentials,
        });
    };
    function getCrossDomainProxyPort(proxyPort) {
        return settings.get().crossDomainProxyPort === proxyPort
            // eslint-disable-next-line no-restricted-properties
            ? location.port.toString()
            : settings.get().crossDomainProxyPort;
    }
    var resolveUrlAsDest = function (url, isUrlsSet) {
        if (isUrlsSet === void 0) { isUrlsSet = false; }
        return resolveUrlAsDest$1(url, getProxyUrl, isUrlsSet);
    };
    var parseProxyUrl = function (proxyUrl) {
        return parseProxyUrl$1(proxyUrl);
    };
    function parseUrl(url) {
        return parseUrl$1(url);
    }
    function isValidWebSocketUrl(url) {
        var resolvedUrl = resolveUrlAsDest(url);
        return SUPPORTED_WEB_SOCKET_PROTOCOL_RE.test(resolvedUrl);
    }
    function isSupportedProtocol(url) {
        return isSupportedProtocol$1(url);
    }
    function isSpecialPage(url) {
        return isSpecialPage$1(url);
    }
    function stringifyResourceType(resourceType) {
        return getResourceTypeString(resourceType);
    }
    function getDestinationUrl(proxyUrl) {
        var parsedProxyUrl = parseProxyUrl(proxyUrl);
        return parsedProxyUrl ? parsedProxyUrl.destUrl : proxyUrl;
    }
    function getAjaxProxyUrl(url, credentials, proxyless) {
        if (proxyless === void 0) { proxyless = false; }
        if (proxyless)
            return String(url);
        var isCrossDomain = !sameOriginCheck(getLocation(), url);
        var opts = { resourceType: stringifyResourceType({ isAjax: true }), credentials: credentials };
        if (isCrossDomain) {
            opts.proxyPort = settings.get().crossDomainProxyPort;
            opts.reqOrigin = getOriginHeader();
        }
        return getProxyUrl(url, opts);
    }

    var EventEmitter = /** @class */ (function () {
        function EventEmitter() {
            this.eventsListeners = nativeMethods.objectCreate(null);
        }
        EventEmitter.prototype.emit = function (evt) {
            var args = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                args[_i - 1] = arguments[_i];
            }
            var listeners = this.eventsListeners[evt];
            if (!listeners)
                return;
            var index = 0;
            while (listeners[index]) {
                // HACK: For IE: after calling document.write, the IFrameSandbox event handler throws the
                // 'Can't execute code from a freed script' exception because the document has been
                // recreated.
                if (isIE) {
                    try {
                        listeners[index].toString();
                    }
                    catch (e) {
                        nativeMethods.arraySplice.call(listeners, index, 1);
                        continue;
                    }
                }
                listeners[index++].apply(this, args);
            }
        };
        EventEmitter.prototype.off = function (evt, listener) {
            var listeners = this.eventsListeners[evt];
            if (!listeners)
                return;
            this.eventsListeners[evt] = nativeMethods.arrayFilter.call(listeners, function (currentListener) { return currentListener !== listener; });
        };
        EventEmitter.prototype.on = function (evt, listener) {
            this.eventsListeners[evt] = this.eventsListeners[evt] || [];
            if (this.eventsListeners[evt].indexOf(listener) === -1)
                this.eventsListeners[evt].push(listener);
            return listener;
        };
        return EventEmitter;
    }());

    var SandboxBase = /** @class */ (function (_super) {
        __extends(SandboxBase, _super);
        function SandboxBase() {
            var _this = _super !== null && _super.apply(this, arguments) || this;
            _this.window = null;
            _this.nativeMethods = nativeMethods;
            _this.document = null;
            _this.proxyless = false;
            return _this;
        }
        // NOTE: The sandbox is deactivated when its window is removed from the DOM.
        SandboxBase.prototype.isDeactivated = function () {
            try {
                // NOTE: In IE11, a situation when the document is not active may occur.
                // eslint-disable-next-line no-unused-expressions
                this.document.body;
                if (this.window[INTERNAL_PROPS.hammerhead]) {
                    var frameElement_1 = getFrameElement(this.window);
                    return !!frameElement_1 && !isElementInDocument(frameElement_1, findDocument(frameElement_1));
                }
            }
            catch (e) { // eslint-disable-line no-empty
            }
            return true;
        };
        SandboxBase.prototype.attach = function (window, document) {
            this.window = window;
            this.document = document || window.document;
            this.proxyless = !!settings.get().proxyless;
        };
        return SandboxBase;
    }(EventEmitter));

    var SandboxBaseWithDelayedSettings = /** @class */ (function (_super) {
        __extends(SandboxBaseWithDelayedSettings, _super);
        function SandboxBaseWithDelayedSettings(_waitHammerheadSettings) {
            var _this = _super.call(this) || this;
            _this._waitHammerheadSettings = _waitHammerheadSettings;
            if (_waitHammerheadSettings) {
                _waitHammerheadSettings.then(function () {
                    _this._waitHammerheadSettings = null;
                });
            }
            return _this;
        }
        SandboxBaseWithDelayedSettings.prototype.gettingSettingInProgress = function () {
            return !!this._waitHammerheadSettings;
        };
        SandboxBaseWithDelayedSettings.prototype.delayUntilGetSettings = function (action) {
            return this._waitHammerheadSettings.then(action);
        };
        return SandboxBaseWithDelayedSettings;
    }(SandboxBase));

    // -------------------------------------------------------------
    // WARNING: this file is used by both the client and the server.
    // Do not use any browser or node-specific API!
    // -------------------------------------------------------------
    /* eslint hammerhead/proto-methods: 2 */
    var BUILTIN_HEADERS = {
        authorization: 'authorization',
        wwwAuthenticate: 'www-authenticate',
        proxyAuthorization: 'proxy-authorization',
        proxyAuthenticate: 'proxy-authenticate',
        host: 'host',
        referer: 'referer',
        origin: 'origin',
        contentLength: 'content-length',
        cookie: 'cookie',
        setCookie: 'set-cookie',
        ifModifiedSince: 'if-modified-since',
        ifNoneMatch: 'if-none-match',
        contentType: 'content-type',
        location: 'location',
        xFrameOptions: 'x-frame-options',
        sourceMap: 'sourcemap',
        referrerPolicy: 'referrer-policy',
        refresh: 'refresh',
        link: 'link',
        cacheControl: 'cache-control',
        pragma: 'pragma',
        eTag: 'etag',
        contentDisposition: 'content-disposition',
        accept: 'accept',
        contentEncoding: 'content-encoding',
        expires: 'expires',
        trailer: 'trailer',
        transferEncoding: 'transfer-encoding',
        serviceWorkerAllowed: 'service-worker-allowed',
        accessControlAllowOrigin: 'access-control-allow-origin',
        accessControlAllowCredentials: 'access-control-allow-credentials',
        contentSecurityPolicy: 'content-security-policy',
        contentSecurityPolicyReportOnly: 'content-security-policy-report-only',
        xContentSecurityPolicy: 'x-content-security-policy',
        xContentSecurityPolicyReportOnly: 'x-content-security-policy-report-only',
        xWebkitCsp: 'x-webkit-csp',
        isApiRequest: 'is-api-request',
        userAgent: 'user-agent',
    };

    // -------------------------------------------------------------
    var AUTHENTICATE_PREFIX = '~~~TestCafe added this prefix to hide the authentication dialog box~~~';
    var AUTHORIZATION_PREFIX = '~~~TestCafe added this prefix to control the authorization flow~~~';
    function hasAuthenticatePrefix(value) {
        return value.indexOf(AUTHENTICATE_PREFIX) > -1;
    }
    function removeAuthenticatePrefix(value) {
        return value.replace(AUTHENTICATE_PREFIX, '');
    }
    function isAuthenticateHeader(headerName) {
        var headerNameStr = String(headerName).toLowerCase();
        return headerNameStr === BUILTIN_HEADERS.wwwAuthenticate || headerNameStr === BUILTIN_HEADERS.proxyAuthenticate;
    }
    function addAuthorizationPrefix(value) {
        return AUTHORIZATION_PREFIX + value;
    }
    function hasAuthorizationPrefix(value) {
        return value.indexOf(AUTHORIZATION_PREFIX) > -1;
    }
    function removeAuthorizationPrefix(value) {
        return value.replace(AUTHORIZATION_PREFIX, '');
    }
    function isAuthorizationHeader(headerName) {
        var headerNameStr = String(headerName).toLowerCase();
        return headerNameStr === BUILTIN_HEADERS.authorization || headerNameStr === BUILTIN_HEADERS.proxyAuthorization;
    }

    var XHR_READY_STATES = ['UNSENT', 'OPENED', 'HEADERS_RECEIVED', 'LOADING', 'DONE'];
    var XhrSandbox = /** @class */ (function (_super) {
        __extends(XhrSandbox, _super);
        function XhrSandbox(_cookieSandbox, waitHammerheadSettings) {
            var _this = _super.call(this, waitHammerheadSettings) || this;
            _this._cookieSandbox = _cookieSandbox;
            _this.XHR_COMPLETED_EVENT = 'hammerhead|event|xhr-completed';
            _this.XHR_ERROR_EVENT = 'hammerhead|event|xhr-error';
            _this.BEFORE_XHR_SEND_EVENT = 'hammerhead|event|before-xhr-send';
            return _this;
        }
        XhrSandbox.setRequestOptions = function (req, withCredentials, args) {
            XhrSandbox.REQUESTS_OPTIONS.set(req, {
                withCredentials: withCredentials,
                openArgs: args,
                headers: [],
            });
        };
        XhrSandbox.createNativeXHR = function () {
            var xhr = new nativeMethods.XMLHttpRequest();
            xhr.open = nativeMethods.xhrOpen;
            xhr.abort = nativeMethods.xhrAbort;
            xhr.send = nativeMethods.xhrSend;
            xhr.addEventListener = nativeMethods.xhrAddEventListener || nativeMethods.addEventListener;
            xhr.removeEventListener = nativeMethods.xhrRemoveEventListener || nativeMethods.removeEventListener;
            xhr.setRequestHeader = nativeMethods.xhrSetRequestHeader;
            xhr.getResponseHeader = nativeMethods.xhrGetResponseHeader;
            xhr.getAllResponseHeaders = nativeMethods.xhrGetAllResponseHeaders;
            xhr.overrideMimeType = nativeMethods.xhrOverrideMimeType;
            xhr.dispatchEvent = nativeMethods.xhrDispatchEvent || nativeMethods.dispatchEvent;
            return xhr;
        };
        XhrSandbox.openNativeXhr = function (xhr, url, isAsync) {
            xhr.open('POST', url, isAsync);
            xhr.setRequestHeader(BUILTIN_HEADERS.cacheControl, 'no-cache, no-store, must-revalidate');
        };
        XhrSandbox._reopenXhr = function (xhr, reqOpts, proxyless) {
            var url = reqOpts.openArgs[1];
            var withCredentials = xhr.withCredentials;
            reqOpts.withCredentials = withCredentials;
            reqOpts.openArgs[1] = getAjaxProxyUrl(url, withCredentials ? Credentials.include : Credentials.sameOrigin, proxyless);
            nativeMethods.xhrOpen.apply(xhr, reqOpts.openArgs);
            reqOpts.openArgs[1] = url;
            for (var _i = 0, _a = reqOpts.headers; _i < _a.length; _i++) {
                var header = _a[_i];
                nativeMethods.xhrSetRequestHeader.apply(xhr, header);
            }
        };
        XhrSandbox.prototype.attach = function (window) {
            _super.prototype.attach.call(this, window);
            var xhrSandbox = this;
            var xmlHttpRequestProto = window.XMLHttpRequest.prototype;
            var emitXhrCompletedEvent = function () {
                var nativeRemoveEventListener = nativeMethods.xhrRemoveEventListener || nativeMethods.removeEventListener;
                xhrSandbox.emit(xhrSandbox.XHR_COMPLETED_EVENT, { xhr: this });
                nativeRemoveEventListener.call(this, 'loadend', emitXhrCompletedEvent);
            };
            var syncCookieWithClientIfNecessary = function () {
                if (this.readyState < this.HEADERS_RECEIVED)
                    return;
                var nativeRemoveEventListener = nativeMethods.xhrRemoveEventListener || nativeMethods.removeEventListener;
                xhrSandbox._cookieSandbox.syncCookie();
                nativeRemoveEventListener.call(this, 'readystatechange', syncCookieWithClientIfNecessary);
            };
            var xmlHttpRequestWrapper = function () {
                var nativeAddEventListener = nativeMethods.xhrAddEventListener || nativeMethods.addEventListener;
                var xhr = new nativeMethods.XMLHttpRequest();
                nativeAddEventListener.call(xhr, 'loadend', emitXhrCompletedEvent);
                nativeAddEventListener.call(xhr, 'readystatechange', syncCookieWithClientIfNecessary);
                return xhr;
            };
            for (var _i = 0, XHR_READY_STATES_1 = XHR_READY_STATES; _i < XHR_READY_STATES_1.length; _i++) {
                var readyState = XHR_READY_STATES_1[_i];
                nativeMethods.objectDefineProperty(xmlHttpRequestWrapper, readyState, nativeMethods.objectGetOwnPropertyDescriptor(nativeMethods.XMLHttpRequest, readyState));
            }
            // NOTE: We cannot just assign constructor property of the prototype of XMLHttpRequest starts from safari 9.0
            overrideConstructor(window, 'XMLHttpRequest', xmlHttpRequestWrapper);
            nativeMethods.objectDefineProperty(xmlHttpRequestProto, 'constructor', {
                value: xmlHttpRequestWrapper,
            });
            overrideFunction(xmlHttpRequestProto, 'abort', function () {
                var _this = this;
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                if (xhrSandbox.gettingSettingInProgress())
                    return void xhrSandbox.delayUntilGetSettings(function () { return _this.abort.apply(_this, args); });
                nativeMethods.xhrAbort.apply(this, args);
                xhrSandbox.emit(xhrSandbox.XHR_ERROR_EVENT, {
                    err: new Error('XHR aborted'),
                    xhr: this,
                });
            });
            // NOTE: Redirect all requests to the Hammerhead proxy and ensure that requests don't
            // violate Same Origin Policy.
            overrideFunction(xmlHttpRequestProto, 'open', function () {
                var _this = this;
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                var url = args[1];
                if (getProxyUrl(url, {}, xhrSandbox.proxyless) === url) {
                    XhrSandbox.setRequestOptions(this, this.withCredentials, args);
                    return void nativeMethods.xhrOpen.apply(this, args);
                }
                if (xhrSandbox.gettingSettingInProgress())
                    return void xhrSandbox.delayUntilGetSettings(function () { return _this.open.apply(_this, args); });
                url = typeof url === 'string' ? url : String(url);
                args[1] = getAjaxProxyUrl(url, this.withCredentials ? Credentials.include : Credentials.sameOrigin, xhrSandbox.proxyless);
                nativeMethods.xhrOpen.apply(this, args);
                args[1] = url;
                XhrSandbox.setRequestOptions(this, this.withCredentials, args);
            });
            overrideFunction(xmlHttpRequestProto, 'send', function () {
                var _this = this;
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                if (xhrSandbox.gettingSettingInProgress())
                    return void xhrSandbox.delayUntilGetSettings(function () { return _this.send.apply(_this, args); });
                var reqOpts = XhrSandbox.REQUESTS_OPTIONS.get(this);
                if (reqOpts && reqOpts.withCredentials !== this.withCredentials)
                    XhrSandbox._reopenXhr(this, reqOpts, xhrSandbox.proxyless);
                xhrSandbox.emit(xhrSandbox.BEFORE_XHR_SEND_EVENT, { xhr: this });
                nativeMethods.xhrSend.apply(this, args);
                // NOTE: For xhr with the sync mode
                if (this.readyState === this.DONE)
                    emitXhrCompletedEvent.call(this);
                syncCookieWithClientIfNecessary.call(this);
            });
            overrideFunction(xmlHttpRequestProto, 'setRequestHeader', function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                if (isAuthorizationHeader(args[0]))
                    args[1] = addAuthorizationPrefix(args[1]);
                nativeMethods.xhrSetRequestHeader.apply(this, args);
                var reqOpts = XhrSandbox.REQUESTS_OPTIONS.get(this);
                if (reqOpts)
                    reqOpts.headers.push([String(args[0]), String(args[1])]);
            });
            if (nativeMethods.xhrResponseURLGetter) {
                overrideDescriptor(window.XMLHttpRequest.prototype, 'responseURL', {
                    getter: function () {
                        var nativeResponseURL = nativeMethods.xhrResponseURLGetter.call(this);
                        return xhrSandbox.proxyless ? nativeResponseURL : getDestinationUrl(nativeResponseURL);
                    },
                });
            }
            overrideFunction(xmlHttpRequestProto, 'getResponseHeader', function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                var value = nativeMethods.xhrGetResponseHeader.apply(this, args);
                if (value && isAuthenticateHeader(args[0]))
                    value = removeAuthenticatePrefix(value);
                return value;
            });
            overrideFunction(xmlHttpRequestProto, 'getAllResponseHeaders', function () {
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                var allHeaders = nativeMethods.xhrGetAllResponseHeaders.apply(this, args);
                while (hasAuthenticatePrefix(allHeaders))
                    allHeaders = removeAuthenticatePrefix(allHeaders);
                return allHeaders;
            });
        };
        XhrSandbox.REQUESTS_OPTIONS = new WeakMap();
        return XhrSandbox;
    }(SandboxBaseWithDelayedSettings));

    function getCredentialsMode(credentialsOpt) {
        credentialsOpt = String(credentialsOpt).toLowerCase();
        switch (credentialsOpt) {
            case 'omit': return Credentials.omit;
            case 'same-origin': return Credentials.sameOrigin;
            case 'include': return Credentials.include;
            default: return Credentials.unknown;
        }
    }
    var DEFAULT_REQUEST_CREDENTIALS = getCredentialsMode(nativeMethods.Request && new nativeMethods.Request(location.toString()).credentials);
    var FetchSandbox = /** @class */ (function (_super) {
        __extends(FetchSandbox, _super);
        function FetchSandbox(cookieSandbox, waitHammerheadSettings) {
            var _this = _super.call(this, waitHammerheadSettings) || this;
            _this.cookieSandbox = cookieSandbox;
            _this.FETCH_REQUEST_SENT_EVENT = 'hammerhead|event|fetch-request-sent-event';
            return _this;
        }
        FetchSandbox._removeAuthHeadersPrefix = function (name, value) {
            if (isAuthorizationHeader(name))
                return removeAuthorizationPrefix(value);
            else if (isAuthenticateHeader(name))
                return removeAuthenticatePrefix(value);
            return value;
        };
        FetchSandbox._processInit = function (init) {
            var headers = init.headers;
            if (!headers)
                return init;
            if (!isFetchHeaders(headers)) {
                headers = headers ? new nativeMethods.Headers(headers) : new nativeMethods.Headers();
                init.headers = headers;
            }
            var authorizationValue = nativeMethods.headersGet.call(headers, BUILTIN_HEADERS.authorization);
            var proxyAuthorizationValue = nativeMethods.headersGet.call(headers, BUILTIN_HEADERS.proxyAuthorization);
            if (authorizationValue !== null && !hasAuthorizationPrefix(authorizationValue))
                nativeMethods.headersSet.call(headers, BUILTIN_HEADERS.authorization, addAuthorizationPrefix(authorizationValue));
            if (proxyAuthorizationValue !== null && !hasAuthorizationPrefix(proxyAuthorizationValue))
                nativeMethods.headersSet.call(headers, BUILTIN_HEADERS.proxyAuthorization, addAuthorizationPrefix(proxyAuthorizationValue));
            return init;
        };
        FetchSandbox._processArguments = function (args, proxyless) {
            var input = args[0], init = args[1];
            var inputIsString = typeof input === 'string';
            var optsCredentials = getCredentialsMode(init && init.credentials);
            if (!isFetchRequest(input)) {
                var url = inputIsString ? input : String(input);
                var credentials = optsCredentials === Credentials.unknown ? DEFAULT_REQUEST_CREDENTIALS : optsCredentials;
                args[0] = getAjaxProxyUrl(url, credentials, proxyless);
                args[1] = FetchSandbox._processInit(init || {});
            }
            else {
                if (optsCredentials !== Credentials.unknown)
                    args[0] = getAjaxProxyUrl(input.url, optsCredentials);
                if (init && init.headers && input.destination !== 'worker')
                    args[1] = FetchSandbox._processInit(init);
            }
        };
        FetchSandbox._processHeaderEntry = function (entry, isOnlyValue) {
            if (isOnlyValue === void 0) { isOnlyValue = false; }
            if (entry.done)
                return entry;
            /* eslint-disable no-restricted-properties */
            var processedValue = FetchSandbox._removeAuthHeadersPrefix(entry.value[0], entry.value[1]);
            if (isOnlyValue)
                entry.value = processedValue;
            else
                entry.value[1] = processedValue;
            /* eslint-enable no-restricted-properties */
            return entry;
        };
        FetchSandbox._entriesWrapper = function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var iterator = nativeMethods.headersEntries.apply(this, args);
            var nativeNext = iterator.next;
            iterator.next = function () { return FetchSandbox._processHeaderEntry(nativeNext.call(iterator)); };
            return iterator;
        };
        FetchSandbox._valuesWrapper = function () {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var iterator = nativeMethods.headersEntries.apply(this, args);
            var nativeNext = iterator.next;
            iterator.next = function () { return FetchSandbox._processHeaderEntry(nativeNext.call(iterator), true); };
            return iterator;
        };
        FetchSandbox.prototype.attach = function (window) {
            _super.prototype.attach.call(this, window, window.document);
            if (!nativeMethods.fetch)
                return;
            var sandbox = this;
            if (!this.proxyless) {
                overrideConstructor(window, 'Request', function () {
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    FetchSandbox._processArguments(args, sandbox.proxyless);
                    window.Headers.prototype.entries = window.Headers.prototype[Symbol.iterator] = nativeMethods.headersEntries;
                    var request = args.length === 1
                        ? new nativeMethods.Request(args[0])
                        : new nativeMethods.Request(args[0], args[1]);
                    window.Headers.prototype.entries = window.Headers.prototype[Symbol.iterator] = FetchSandbox._entriesWrapper;
                    return request;
                });
                overrideDescriptor(window.Request.prototype, 'url', {
                    getter: function () {
                        var nativeRequestUrl = nativeMethods.requestUrlGetter.call(this);
                        return sandbox.proxyless ? nativeRequestUrl : getDestinationUrl(nativeRequestUrl);
                    },
                });
                overrideDescriptor(window.Request.prototype, 'referrer', {
                    getter: function () {
                        var nativeReferrer = nativeMethods.requestReferrerGetter.call(this);
                        return sandbox.proxyless ? nativeReferrer : getDestinationUrl(nativeReferrer);
                    },
                });
                overrideDescriptor(window.Response.prototype, 'url', {
                    getter: function () {
                        var nativeResponseUrl = nativeMethods.responseUrlGetter.call(this);
                        return sandbox.proxyless ? nativeResponseUrl : getDestinationUrl(nativeResponseUrl);
                    },
                });
                overrideFunction(window.Headers.prototype, 'entries', FetchSandbox._entriesWrapper);
                overrideFunction(window.Headers.prototype, Symbol.iterator, FetchSandbox._entriesWrapper);
                overrideFunction(window.Headers.prototype, 'values', FetchSandbox._valuesWrapper);
                overrideFunction(window.Headers.prototype, 'forEach', function () {
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    var callback = args[0];
                    if (isFunction(callback)) {
                        args[0] = function (value, name, headers) {
                            value = FetchSandbox._removeAuthHeadersPrefix(name, value);
                            callback.call(this, value, name, headers);
                        };
                    }
                    return nativeMethods.headersForEach.apply(this, args);
                });
                overrideFunction(window.Headers.prototype, 'get', function () {
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    var value = nativeMethods.headersGet.apply(this, args);
                    return value && FetchSandbox._removeAuthHeadersPrefix(args[0], value);
                });
                overrideFunction(window.Headers.prototype, 'set', function () {
                    var args = [];
                    for (var _i = 0; _i < arguments.length; _i++) {
                        args[_i] = arguments[_i];
                    }
                    if (isAuthorizationHeader(args[0]))
                        args[1] = addAuthorizationPrefix(args[1]);
                    return nativeMethods.headersSet.apply(this, args);
                });
            }
            overrideFunction(window, 'fetch', function () {
                var _this = this;
                var args = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    args[_i] = arguments[_i];
                }
                if (!sandbox.proxyless && sandbox.gettingSettingInProgress())
                    return sandbox.delayUntilGetSettings(function () { return _this.fetch.apply(_this, args); });
                // NOTE: Safari processed the empty `fetch()` request without `Promise` rejection (GH-1613)
                if (!args.length && !isSafari)
                    return nativeMethods.fetch.apply(this, args);
                if (sandbox.proxyless) {
                    var fetchPromise_1 = nativeMethods.fetch.apply(this, args);
                    sandbox.emit(sandbox.FETCH_REQUEST_SENT_EVENT, fetchPromise_1);
                    return fetchPromise_1;
                }
                try {
                    FetchSandbox._processArguments(args, sandbox.proxyless);
                }
                catch (e) {
                    return nativeMethods.promiseReject.call(sandbox.window.Promise, e);
                }
                window.Headers.prototype.entries = window.Headers.prototype[Symbol.iterator] = nativeMethods.headersEntries;
                var fetchPromise = nativeMethods.fetch.apply(this, args);
                window.Headers.prototype.entries = window.Headers.prototype[Symbol.iterator] = FetchSandbox._entriesWrapper;
                sandbox.emit(sandbox.FETCH_REQUEST_SENT_EVENT, fetchPromise);
                return nativeMethods.promiseThen.call(fetchPromise, function (response) {
                    sandbox.cookieSandbox.syncCookie();
                    return response;
                });
            });
        };
        return FetchSandbox;
    }(SandboxBaseWithDelayedSettings));

    function stopPropagation(ev) {
        if (ev.stopImmediatePropagation)
            ev.stopImmediatePropagation();
        else if (ev.stopPropagation)
            ev.stopPropagation();
        ev.cancelBubble = true;
    }
    !!(nativeMethods.WindowPointerEvent || nativeMethods.WindowMSPointerEvent);

    var SET_SERVICE_WORKER_SETTINGS = 'hammerhead|set-service-worker-settings';

    // -------------------------------------------------------------
    // WARNING: this file is used by both the client and the server.
    // Do not use any browser or node-specific API!
    // -------------------------------------------------------------
    var INSTRUCTION = {
        getLocation: '__get$Loc',
        setLocation: '__set$Loc',
        getProperty: '__get$',
        setProperty: '__set$',
        callMethod: '__call$',
        processScript: '__proc$Script',
        processHtml: '__proc$Html',
        getEval: '__get$Eval',
        getPostMessage: '__get$PostMessage',
        getProxyUrl: '__get$ProxyUrl',
        restArray: '__rest$Array',
        arrayFrom: '__arrayFrom$',
        restObject: '__rest$Object',
        swScopeHeaderValue: '__swScopeHeaderValue',
        getWorkerSettings: '__getWorkerSettings$',
    };

    /*eslint-disable*/
    var swFetchCheckSettings = {
        protocol: '',
        host: '',
        scope: ''
    };
    function isCorrectScope(parsedUrl) {
        return parsedUrl.protocol === swFetchCheckSettings.protocol &&
            parsedUrl.host === swFetchCheckSettings.host &&
            parsedUrl.partAfterHost.startsWith(swFetchCheckSettings.scope);
    }
    function overrideFetchEvent() {
        var waitSettingsPromise = new Promise(function (resolve, reject) {
            nativeMethods.windowAddEventListener.call(self, 'message', function onMessage(e /*ExtendableMessageEvent*/) {
                var data = e.data;
                if (data.cmd !== SET_SERVICE_WORKER_SETTINGS)
                    return;
                var swScopeHeaderExists = self[INSTRUCTION.swScopeHeaderValue] !== void 0;
                var currentScope = swScopeHeaderExists ? self[INSTRUCTION.swScopeHeaderValue] : data.currentScope;
                var scope = data.optsScope;
                if (!scope)
                    scope = currentScope;
                else if (!scope.startsWith(currentScope)) {
                    // @ts-ignore
                    self.registration.unregister();
                    var errorMessage = "The path of the provided scope ('".concat(data.optsScope, "') is not under the max ") +
                        "scope allowed (".concat(swScopeHeaderExists ? 'set by Service-Worker-Allowed: ' : '', "'") +
                        "".concat(currentScope, "'). Adjust the scope, move the Service Worker script, ") +
                        'or use the Service-Worker-Allowed HTTP header to allow the scope.';
                    e.ports[0].postMessage({ error: errorMessage });
                    reject(new Error(errorMessage));
                    return;
                }
                e.ports[0].postMessage({});
                swFetchCheckSettings.protocol = data.protocol;
                swFetchCheckSettings.host = data.host;
                swFetchCheckSettings.scope = scope;
                nativeMethods.windowRemoveEventListener.call(self, 'message', onMessage);
                stopPropagation(e);
                waitSettingsPromise = null;
                resolve();
            });
        });
        self.addEventListener('install', function (e /*InstallEvent*/) { return e.waitUntil(waitSettingsPromise); });
        nativeMethods.windowAddEventListener.call(self, 'fetch', function (e /*FetchEvent*/) {
            var request = e.request;
            var proxyUrl = nativeMethods.requestUrlGetter.call(request);
            var parsedProxyUrl = parseProxyUrl(proxyUrl);
            var isInternalRequest = !parsedProxyUrl;
            if (!isInternalRequest) {
                // @ts-ignore Chrome has a non-standard the "iframe" destination
                var isPage = request.destination === 'document' || request.destination === 'iframe';
                if (isPage) {
                    if (isCorrectScope(parsedProxyUrl.destResourceInfo))
                        return;
                }
                else {
                    var proxyReferrer = nativeMethods.requestReferrerGetter.call(request);
                    var parsedProxyReferrer = parseProxyUrl(proxyReferrer);
                    if (parsedProxyReferrer && isCorrectScope(parsedProxyReferrer.destResourceInfo))
                        return;
                }
            }
            // NOTE: This request should not have gotten into this service worker
            e.respondWith(nativeMethods.fetch.call(self, request));
            stopPropagation(e);
        });
    }

    function noop () {
        // NOTE: empty function
    }

    var WorkerHammerhead = /** @class */ (function () {
        function WorkerHammerhead() {
            var parsedLocation = parseProxyUrl$1(location.toString());
            var cookieSandboxMock = { syncCookie: noop };
            // NOTE: the blob location case
            if (!parsedLocation)
                this._getBlobSettings();
            else
                WorkerHammerhead._setProxySettings(parsedLocation.sessionId, parsedLocation.windowId);
            this.fetch = new FetchSandbox(cookieSandboxMock);
            this.fetch.attach(self);
            WorkerHammerhead._overrideImportScripts();
            if (!globalContextInfo.isServiceWorker) {
                this.xhr = new XhrSandbox(cookieSandboxMock);
                this.xhr.attach(self);
            }
            else
                overrideFetchEvent();
        }
        WorkerHammerhead._setProxySettings = function (sessionId, windowId) {
            var currentSettings = settings.get();
            currentSettings.sessionId = sessionId;
            currentSettings.windowId = windowId;
            settings.set(currentSettings);
        };
        WorkerHammerhead._overrideImportScripts = function () {
            // @ts-ignore
            overrideFunction(self, 'importScripts', function () {
                var urls = [];
                for (var _i = 0; _i < arguments.length; _i++) {
                    urls[_i] = arguments[_i];
                }
                for (var i = 0; i < urls.length; i++)
                    urls[i] = getProxyUrl(urls[i], { resourceType: stringifyResourceType({ isScript: true }) });
                return nativeMethods.importScripts.apply(self, urls);
            });
        };
        WorkerHammerhead.prototype._getBlobSettings = function () {
            var data = self[INSTRUCTION.getWorkerSettings]();
            WorkerHammerhead._setProxySettings(data.sessionId, data.windowId);
            forceLocation(data.origin); // eslint-disable-line no-restricted-properties
        };
        return WorkerHammerhead;
    }());
    var index = new WorkerHammerhead();

    return index;

})();