var XsollaLogin = (function (exports) {
    'use strict';

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    /* 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };

    function __extends(d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    }

    var __assign = function() {
        __assign = Object.assign || function __assign(t) {
            for (var s, i = 1, n = arguments.length; i < n; i++) {
                s = arguments[i];
                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
            }
            return t;
        };
        return __assign.apply(this, arguments);
    };

    var bind = function bind(fn, thisArg) {
      return function wrap() {
        var args = new Array(arguments.length);
        for (var i = 0; i < args.length; i++) {
          args[i] = arguments[i];
        }
        return fn.apply(thisArg, args);
      };
    };

    /*!
     * Determine if an object is a Buffer
     *
     * @author   Feross Aboukhadijeh <https://feross.org>
     * @license  MIT
     */

    // The _isBuffer check is for Safari 5-7 support, because it's missing
    // Object.prototype.constructor. Remove this eventually
    var isBuffer_1 = function (obj) {
      return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
    };

    function isBuffer (obj) {
      return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
    }

    // For Node v0.10 support. Remove this eventually.
    function isSlowBuffer (obj) {
      return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
    }

    /*global toString:true*/

    // utils is a library of generic helper functions non-specific to axios

    var toString = Object.prototype.toString;

    /**
     * Determine if a value is an Array
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is an Array, otherwise false
     */
    function isArray(val) {
      return toString.call(val) === '[object Array]';
    }

    /**
     * Determine if a value is an ArrayBuffer
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is an ArrayBuffer, otherwise false
     */
    function isArrayBuffer(val) {
      return toString.call(val) === '[object ArrayBuffer]';
    }

    /**
     * Determine if a value is a FormData
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is an FormData, otherwise false
     */
    function isFormData(val) {
      return (typeof FormData !== 'undefined') && (val instanceof FormData);
    }

    /**
     * Determine if a value is a view on an ArrayBuffer
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
     */
    function isArrayBufferView(val) {
      var result;
      if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
        result = ArrayBuffer.isView(val);
      } else {
        result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
      }
      return result;
    }

    /**
     * Determine if a value is a String
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a String, otherwise false
     */
    function isString(val) {
      return typeof val === 'string';
    }

    /**
     * Determine if a value is a Number
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a Number, otherwise false
     */
    function isNumber(val) {
      return typeof val === 'number';
    }

    /**
     * Determine if a value is undefined
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if the value is undefined, otherwise false
     */
    function isUndefined(val) {
      return typeof val === 'undefined';
    }

    /**
     * Determine if a value is an Object
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is an Object, otherwise false
     */
    function isObject(val) {
      return val !== null && typeof val === 'object';
    }

    /**
     * Determine if a value is a Date
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a Date, otherwise false
     */
    function isDate(val) {
      return toString.call(val) === '[object Date]';
    }

    /**
     * Determine if a value is a File
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a File, otherwise false
     */
    function isFile(val) {
      return toString.call(val) === '[object File]';
    }

    /**
     * Determine if a value is a Blob
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a Blob, otherwise false
     */
    function isBlob(val) {
      return toString.call(val) === '[object Blob]';
    }

    /**
     * Determine if a value is a Function
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a Function, otherwise false
     */
    function isFunction(val) {
      return toString.call(val) === '[object Function]';
    }

    /**
     * Determine if a value is a Stream
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a Stream, otherwise false
     */
    function isStream(val) {
      return isObject(val) && isFunction(val.pipe);
    }

    /**
     * Determine if a value is a URLSearchParams object
     *
     * @param {Object} val The value to test
     * @returns {boolean} True if value is a URLSearchParams object, otherwise false
     */
    function isURLSearchParams(val) {
      return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
    }

    /**
     * Trim excess whitespace off the beginning and end of a string
     *
     * @param {String} str The String to trim
     * @returns {String} The String freed of excess whitespace
     */
    function trim(str) {
      return str.replace(/^\s*/, '').replace(/\s*$/, '');
    }

    /**
     * Determine if we're running in a standard browser environment
     *
     * This allows axios to run in a web worker, and react-native.
     * Both environments support XMLHttpRequest, but not fully standard globals.
     *
     * web workers:
     *  typeof window -> undefined
     *  typeof document -> undefined
     *
     * react-native:
     *  navigator.product -> 'ReactNative'
     */
    function isStandardBrowserEnv() {
      if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
        return false;
      }
      return (
        typeof window !== 'undefined' &&
        typeof document !== 'undefined'
      );
    }

    /**
     * Iterate over an Array or an Object invoking a function for each item.
     *
     * If `obj` is an Array callback will be called passing
     * the value, index, and complete array for each item.
     *
     * If 'obj' is an Object callback will be called passing
     * the value, key, and complete object for each property.
     *
     * @param {Object|Array} obj The object to iterate
     * @param {Function} fn The callback to invoke for each item
     */
    function forEach(obj, fn) {
      // Don't bother if no value provided
      if (obj === null || typeof obj === 'undefined') {
        return;
      }

      // Force an array if not already something iterable
      if (typeof obj !== 'object') {
        /*eslint no-param-reassign:0*/
        obj = [obj];
      }

      if (isArray(obj)) {
        // Iterate over array values
        for (var i = 0, l = obj.length; i < l; i++) {
          fn.call(null, obj[i], i, obj);
        }
      } else {
        // Iterate over object keys
        for (var key in obj) {
          if (Object.prototype.hasOwnProperty.call(obj, key)) {
            fn.call(null, obj[key], key, obj);
          }
        }
      }
    }

    /**
     * Accepts varargs expecting each argument to be an object, then
     * immutably merges the properties of each object and returns result.
     *
     * When multiple objects contain the same key the later object in
     * the arguments list will take precedence.
     *
     * Example:
     *
     * ```js
     * var result = merge({foo: 123}, {foo: 456});
     * console.log(result.foo); // outputs 456
     * ```
     *
     * @param {Object} obj1 Object to merge
     * @returns {Object} Result of all merge properties
     */
    function merge(/* obj1, obj2, obj3, ... */) {
      var result = {};
      function assignValue(val, key) {
        if (typeof result[key] === 'object' && typeof val === 'object') {
          result[key] = merge(result[key], val);
        } else {
          result[key] = val;
        }
      }

      for (var i = 0, l = arguments.length; i < l; i++) {
        forEach(arguments[i], assignValue);
      }
      return result;
    }

    /**
     * Extends object a by mutably adding to it the properties of object b.
     *
     * @param {Object} a The object to be extended
     * @param {Object} b The object to copy properties from
     * @param {Object} thisArg The object to bind function to
     * @return {Object} The resulting value of object a
     */
    function extend(a, b, thisArg) {
      forEach(b, function assignValue(val, key) {
        if (thisArg && typeof val === 'function') {
          a[key] = bind(val, thisArg);
        } else {
          a[key] = val;
        }
      });
      return a;
    }

    var utils = {
      isArray: isArray,
      isArrayBuffer: isArrayBuffer,
      isBuffer: isBuffer_1,
      isFormData: isFormData,
      isArrayBufferView: isArrayBufferView,
      isString: isString,
      isNumber: isNumber,
      isObject: isObject,
      isUndefined: isUndefined,
      isDate: isDate,
      isFile: isFile,
      isBlob: isBlob,
      isFunction: isFunction,
      isStream: isStream,
      isURLSearchParams: isURLSearchParams,
      isStandardBrowserEnv: isStandardBrowserEnv,
      forEach: forEach,
      merge: merge,
      extend: extend,
      trim: trim
    };

    var global$1 = (typeof global !== "undefined" ? global :
                typeof self !== "undefined" ? self :
                typeof window !== "undefined" ? window : {});

    // shim for using process in browser
    // based off https://github.com/defunctzombie/node-process/blob/master/browser.js

    function defaultSetTimout() {
        throw new Error('setTimeout has not been defined');
    }
    function defaultClearTimeout () {
        throw new Error('clearTimeout has not been defined');
    }
    var cachedSetTimeout = defaultSetTimout;
    var cachedClearTimeout = defaultClearTimeout;
    if (typeof global$1.setTimeout === 'function') {
        cachedSetTimeout = setTimeout;
    }
    if (typeof global$1.clearTimeout === 'function') {
        cachedClearTimeout = clearTimeout;
    }

    function runTimeout(fun) {
        if (cachedSetTimeout === setTimeout) {
            //normal enviroments in sane situations
            return setTimeout(fun, 0);
        }
        // if setTimeout wasn't available but was latter defined
        if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
            cachedSetTimeout = setTimeout;
            return setTimeout(fun, 0);
        }
        try {
            // when when somebody has screwed with setTimeout but no I.E. maddness
            return cachedSetTimeout(fun, 0);
        } catch(e){
            try {
                // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
                return cachedSetTimeout.call(null, fun, 0);
            } catch(e){
                // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
                return cachedSetTimeout.call(this, fun, 0);
            }
        }


    }
    function runClearTimeout(marker) {
        if (cachedClearTimeout === clearTimeout) {
            //normal enviroments in sane situations
            return clearTimeout(marker);
        }
        // if clearTimeout wasn't available but was latter defined
        if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
            cachedClearTimeout = clearTimeout;
            return clearTimeout(marker);
        }
        try {
            // when when somebody has screwed with setTimeout but no I.E. maddness
            return cachedClearTimeout(marker);
        } catch (e){
            try {
                // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
                return cachedClearTimeout.call(null, marker);
            } catch (e){
                // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
                // Some versions of I.E. have different rules for clearTimeout vs setTimeout
                return cachedClearTimeout.call(this, marker);
            }
        }



    }
    var queue = [];
    var draining = false;
    var currentQueue;
    var queueIndex = -1;

    function cleanUpNextTick() {
        if (!draining || !currentQueue) {
            return;
        }
        draining = false;
        if (currentQueue.length) {
            queue = currentQueue.concat(queue);
        } else {
            queueIndex = -1;
        }
        if (queue.length) {
            drainQueue();
        }
    }

    function drainQueue() {
        if (draining) {
            return;
        }
        var timeout = runTimeout(cleanUpNextTick);
        draining = true;

        var len = queue.length;
        while(len) {
            currentQueue = queue;
            queue = [];
            while (++queueIndex < len) {
                if (currentQueue) {
                    currentQueue[queueIndex].run();
                }
            }
            queueIndex = -1;
            len = queue.length;
        }
        currentQueue = null;
        draining = false;
        runClearTimeout(timeout);
    }
    function nextTick(fun) {
        var args = new Array(arguments.length - 1);
        if (arguments.length > 1) {
            for (var i = 1; i < arguments.length; i++) {
                args[i - 1] = arguments[i];
            }
        }
        queue.push(new Item(fun, args));
        if (queue.length === 1 && !draining) {
            runTimeout(drainQueue);
        }
    }
    // v8 likes predictible objects
    function Item(fun, array) {
        this.fun = fun;
        this.array = array;
    }
    Item.prototype.run = function () {
        this.fun.apply(null, this.array);
    };
    var title = 'browser';
    var platform = 'browser';
    var browser = true;
    var env = {};
    var argv = [];
    var version = ''; // empty string to avoid regexp issues
    var versions = {};
    var release = {};
    var config = {};

    function noop() {}

    var on = noop;
    var addListener = noop;
    var once = noop;
    var off = noop;
    var removeListener = noop;
    var removeAllListeners = noop;
    var emit = noop;

    function binding(name) {
        throw new Error('process.binding is not supported');
    }

    function cwd () { return '/' }
    function chdir (dir) {
        throw new Error('process.chdir is not supported');
    }function umask() { return 0; }

    // from https://github.com/kumavis/browser-process-hrtime/blob/master/index.js
    var performance = global$1.performance || {};
    var performanceNow =
      performance.now        ||
      performance.mozNow     ||
      performance.msNow      ||
      performance.oNow       ||
      performance.webkitNow  ||
      function(){ return (new Date()).getTime() };

    // generate timestamp or delta
    // see http://nodejs.org/api/process.html#process_process_hrtime
    function hrtime(previousTimestamp){
      var clocktime = performanceNow.call(performance)*1e-3;
      var seconds = Math.floor(clocktime);
      var nanoseconds = Math.floor((clocktime%1)*1e9);
      if (previousTimestamp) {
        seconds = seconds - previousTimestamp[0];
        nanoseconds = nanoseconds - previousTimestamp[1];
        if (nanoseconds<0) {
          seconds--;
          nanoseconds += 1e9;
        }
      }
      return [seconds,nanoseconds]
    }

    var startTime = new Date();
    function uptime() {
      var currentTime = new Date();
      var dif = currentTime - startTime;
      return dif / 1000;
    }

    var process = {
      nextTick: nextTick,
      title: title,
      browser: browser,
      env: env,
      argv: argv,
      version: version,
      versions: versions,
      on: on,
      addListener: addListener,
      once: once,
      off: off,
      removeListener: removeListener,
      removeAllListeners: removeAllListeners,
      emit: emit,
      binding: binding,
      cwd: cwd,
      chdir: chdir,
      umask: umask,
      hrtime: hrtime,
      platform: platform,
      release: release,
      config: config,
      uptime: uptime
    };

    var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName) {
      utils.forEach(headers, function processHeader(value, name) {
        if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
          headers[normalizedName] = value;
          delete headers[name];
        }
      });
    };

    /**
     * Update an Error with the specified config, error code, and response.
     *
     * @param {Error} error The error to update.
     * @param {Object} config The config.
     * @param {string} [code] The error code (for example, 'ECONNABORTED').
     * @param {Object} [request] The request.
     * @param {Object} [response] The response.
     * @returns {Error} The error.
     */
    var enhanceError = function enhanceError(error, config, code, request, response) {
      error.config = config;
      if (code) {
        error.code = code;
      }
      error.request = request;
      error.response = response;
      return error;
    };

    /**
     * Create an Error with the specified message, config, error code, request and response.
     *
     * @param {string} message The error message.
     * @param {Object} config The config.
     * @param {string} [code] The error code (for example, 'ECONNABORTED').
     * @param {Object} [request] The request.
     * @param {Object} [response] The response.
     * @returns {Error} The created error.
     */
    var createError = function createError(message, config, code, request, response) {
      var error = new Error(message);
      return enhanceError(error, config, code, request, response);
    };

    /**
     * Resolve or reject a Promise based on response status.
     *
     * @param {Function} resolve A function that resolves the promise.
     * @param {Function} reject A function that rejects the promise.
     * @param {object} response The response.
     */
    var settle = function settle(resolve, reject, response) {
      var validateStatus = response.config.validateStatus;
      // Note: status is not exposed by XDomainRequest
      if (!response.status || !validateStatus || validateStatus(response.status)) {
        resolve(response);
      } else {
        reject(createError(
          'Request failed with status code ' + response.status,
          response.config,
          null,
          response.request,
          response
        ));
      }
    };

    function encode(val) {
      return encodeURIComponent(val).
        replace(/%40/gi, '@').
        replace(/%3A/gi, ':').
        replace(/%24/g, '$').
        replace(/%2C/gi, ',').
        replace(/%20/g, '+').
        replace(/%5B/gi, '[').
        replace(/%5D/gi, ']');
    }

    /**
     * Build a URL by appending params to the end
     *
     * @param {string} url The base of the url (e.g., http://www.google.com)
     * @param {object} [params] The params to be appended
     * @returns {string} The formatted url
     */
    var buildURL = function buildURL(url, params, paramsSerializer) {
      /*eslint no-param-reassign:0*/
      if (!params) {
        return url;
      }

      var serializedParams;
      if (paramsSerializer) {
        serializedParams = paramsSerializer(params);
      } else if (utils.isURLSearchParams(params)) {
        serializedParams = params.toString();
      } else {
        var parts = [];

        utils.forEach(params, function serialize(val, key) {
          if (val === null || typeof val === 'undefined') {
            return;
          }

          if (utils.isArray(val)) {
            key = key + '[]';
          } else {
            val = [val];
          }

          utils.forEach(val, function parseValue(v) {
            if (utils.isDate(v)) {
              v = v.toISOString();
            } else if (utils.isObject(v)) {
              v = JSON.stringify(v);
            }
            parts.push(encode(key) + '=' + encode(v));
          });
        });

        serializedParams = parts.join('&');
      }

      if (serializedParams) {
        url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
      }

      return url;
    };

    // Headers whose duplicates are ignored by node
    // c.f. https://nodejs.org/api/http.html#http_message_headers
    var ignoreDuplicateOf = [
      'age', 'authorization', 'content-length', 'content-type', 'etag',
      'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
      'last-modified', 'location', 'max-forwards', 'proxy-authorization',
      'referer', 'retry-after', 'user-agent'
    ];

    /**
     * Parse headers into an object
     *
     * ```
     * Date: Wed, 27 Aug 2014 08:58:49 GMT
     * Content-Type: application/json
     * Connection: keep-alive
     * Transfer-Encoding: chunked
     * ```
     *
     * @param {String} headers Headers needing to be parsed
     * @returns {Object} Headers parsed into an object
     */
    var parseHeaders = function parseHeaders(headers) {
      var parsed = {};
      var key;
      var val;
      var i;

      if (!headers) { return parsed; }

      utils.forEach(headers.split('\n'), function parser(line) {
        i = line.indexOf(':');
        key = utils.trim(line.substr(0, i)).toLowerCase();
        val = utils.trim(line.substr(i + 1));

        if (key) {
          if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
            return;
          }
          if (key === 'set-cookie') {
            parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
          } else {
            parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
          }
        }
      });

      return parsed;
    };

    var isURLSameOrigin = (
      utils.isStandardBrowserEnv() ?

      // Standard browser envs have full support of the APIs needed to test
      // whether the request URL is of the same origin as current location.
      (function standardBrowserEnv() {
        var msie = /(msie|trident)/i.test(navigator.userAgent);
        var urlParsingNode = document.createElement('a');
        var originURL;

        /**
        * Parse a URL to discover it's components
        *
        * @param {String} url The URL to be parsed
        * @returns {Object}
        */
        function resolveURL(url) {
          var href = url;

          if (msie) {
            // IE needs attribute set twice to normalize properties
            urlParsingNode.setAttribute('href', href);
            href = urlParsingNode.href;
          }

          urlParsingNode.setAttribute('href', href);

          // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
          return {
            href: urlParsingNode.href,
            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
            host: urlParsingNode.host,
            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
            hostname: urlParsingNode.hostname,
            port: urlParsingNode.port,
            pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
                      urlParsingNode.pathname :
                      '/' + urlParsingNode.pathname
          };
        }

        originURL = resolveURL(window.location.href);

        /**
        * Determine if a URL shares the same origin as the current location
        *
        * @param {String} requestURL The URL to test
        * @returns {boolean} True if URL shares the same origin, otherwise false
        */
        return function isURLSameOrigin(requestURL) {
          var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
          return (parsed.protocol === originURL.protocol &&
                parsed.host === originURL.host);
        };
      })() :

      // Non standard browser envs (web workers, react-native) lack needed support.
      (function nonStandardBrowserEnv() {
        return function isURLSameOrigin() {
          return true;
        };
      })()
    );

    // btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js

    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

    function E() {
      this.message = 'String contains an invalid character';
    }
    E.prototype = new Error;
    E.prototype.code = 5;
    E.prototype.name = 'InvalidCharacterError';

    function btoa(input) {
      var str = String(input);
      var output = '';
      for (
        // initialize result and counter
        var block, charCode, idx = 0, map = chars;
        // if the next str index does not exist:
        //   change the mapping table to "="
        //   check if d has no fractional digits
        str.charAt(idx | 0) || (map = '=', idx % 1);
        // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8
        output += map.charAt(63 & block >> 8 - idx % 1 * 8)
      ) {
        charCode = str.charCodeAt(idx += 3 / 4);
        if (charCode > 0xFF) {
          throw new E();
        }
        block = block << 8 | charCode;
      }
      return output;
    }

    var btoa_1 = btoa;

    var cookies = (
      utils.isStandardBrowserEnv() ?

      // Standard browser envs support document.cookie
      (function standardBrowserEnv() {
        return {
          write: function write(name, value, expires, path, domain, secure) {
            var cookie = [];
            cookie.push(name + '=' + encodeURIComponent(value));

            if (utils.isNumber(expires)) {
              cookie.push('expires=' + new Date(expires).toGMTString());
            }

            if (utils.isString(path)) {
              cookie.push('path=' + path);
            }

            if (utils.isString(domain)) {
              cookie.push('domain=' + domain);
            }

            if (secure === true) {
              cookie.push('secure');
            }

            document.cookie = cookie.join('; ');
          },

          read: function read(name) {
            var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
            return (match ? decodeURIComponent(match[3]) : null);
          },

          remove: function remove(name) {
            this.write(name, '', Date.now() - 86400000);
          }
        };
      })() :

      // Non standard browser env (web workers, react-native) lack needed support.
      (function nonStandardBrowserEnv() {
        return {
          write: function write() {},
          read: function read() { return null; },
          remove: function remove() {}
        };
      })()
    );

    var btoa$1 = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || btoa_1;

    var xhr = function xhrAdapter(config$$1) {
      return new Promise(function dispatchXhrRequest(resolve, reject) {
        var requestData = config$$1.data;
        var requestHeaders = config$$1.headers;

        if (utils.isFormData(requestData)) {
          delete requestHeaders['Content-Type']; // Let the browser set it
        }

        var request = new XMLHttpRequest();
        var loadEvent = 'onreadystatechange';
        var xDomain = false;

        // For IE 8/9 CORS support
        // Only supports POST and GET calls and doesn't returns the response headers.
        // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.
        if (process.env.NODE_ENV !== 'test' &&
            typeof window !== 'undefined' &&
            window.XDomainRequest && !('withCredentials' in request) &&
            !isURLSameOrigin(config$$1.url)) {
          request = new window.XDomainRequest();
          loadEvent = 'onload';
          xDomain = true;
          request.onprogress = function handleProgress() {};
          request.ontimeout = function handleTimeout() {};
        }

        // HTTP basic authentication
        if (config$$1.auth) {
          var username = config$$1.auth.username || '';
          var password = config$$1.auth.password || '';
          requestHeaders.Authorization = 'Basic ' + btoa$1(username + ':' + password);
        }

        request.open(config$$1.method.toUpperCase(), buildURL(config$$1.url, config$$1.params, config$$1.paramsSerializer), true);

        // Set the request timeout in MS
        request.timeout = config$$1.timeout;

        // Listen for ready state
        request[loadEvent] = function handleLoad() {
          if (!request || (request.readyState !== 4 && !xDomain)) {
            return;
          }

          // The request errored out and we didn't get a response, this will be
          // handled by onerror instead
          // With one exception: request that using file: protocol, most browsers
          // will return status as 0 even though it's a successful request
          if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
            return;
          }

          // Prepare the response
          var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
          var responseData = !config$$1.responseType || config$$1.responseType === 'text' ? request.responseText : request.response;
          var response = {
            data: responseData,
            // IE sends 1223 instead of 204 (https://github.com/axios/axios/issues/201)
            status: request.status === 1223 ? 204 : request.status,
            statusText: request.status === 1223 ? 'No Content' : request.statusText,
            headers: responseHeaders,
            config: config$$1,
            request: request
          };

          settle(resolve, reject, response);

          // Clean up request
          request = null;
        };

        // Handle low level network errors
        request.onerror = function handleError() {
          // Real errors are hidden from us by the browser
          // onerror should only fire if it's a network error
          reject(createError('Network Error', config$$1, null, request));

          // Clean up request
          request = null;
        };

        // Handle timeout
        request.ontimeout = function handleTimeout() {
          reject(createError('timeout of ' + config$$1.timeout + 'ms exceeded', config$$1, 'ECONNABORTED',
            request));

          // Clean up request
          request = null;
        };

        // Add xsrf header
        // This is only done if running in a standard browser environment.
        // Specifically not if we're in a web worker, or react-native.
        if (utils.isStandardBrowserEnv()) {
          var cookies$$1 = cookies;

          // Add xsrf header
          var xsrfValue = (config$$1.withCredentials || isURLSameOrigin(config$$1.url)) && config$$1.xsrfCookieName ?
              cookies$$1.read(config$$1.xsrfCookieName) :
              undefined;

          if (xsrfValue) {
            requestHeaders[config$$1.xsrfHeaderName] = xsrfValue;
          }
        }

        // Add headers to the request
        if ('setRequestHeader' in request) {
          utils.forEach(requestHeaders, function setRequestHeader(val, key) {
            if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
              // Remove Content-Type if data is undefined
              delete requestHeaders[key];
            } else {
              // Otherwise add header to the request
              request.setRequestHeader(key, val);
            }
          });
        }

        // Add withCredentials to request if needed
        if (config$$1.withCredentials) {
          request.withCredentials = true;
        }

        // Add responseType to request if needed
        if (config$$1.responseType) {
          try {
            request.responseType = config$$1.responseType;
          } catch (e) {
            // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.
            // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.
            if (config$$1.responseType !== 'json') {
              throw e;
            }
          }
        }

        // Handle progress if needed
        if (typeof config$$1.onDownloadProgress === 'function') {
          request.addEventListener('progress', config$$1.onDownloadProgress);
        }

        // Not all browsers support upload events
        if (typeof config$$1.onUploadProgress === 'function' && request.upload) {
          request.upload.addEventListener('progress', config$$1.onUploadProgress);
        }

        if (config$$1.cancelToken) {
          // Handle cancellation
          config$$1.cancelToken.promise.then(function onCanceled(cancel) {
            if (!request) {
              return;
            }

            request.abort();
            reject(cancel);
            // Clean up request
            request = null;
          });
        }

        if (requestData === undefined) {
          requestData = null;
        }

        // Send the request
        request.send(requestData);
      });
    };

    var DEFAULT_CONTENT_TYPE = {
      'Content-Type': 'application/x-www-form-urlencoded'
    };

    function setContentTypeIfUnset(headers, value) {
      if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
        headers['Content-Type'] = value;
      }
    }

    function getDefaultAdapter() {
      var adapter;
      if (typeof XMLHttpRequest !== 'undefined') {
        // For browsers use XHR adapter
        adapter = xhr;
      } else if (typeof process !== 'undefined') {
        // For node use HTTP adapter
        adapter = xhr;
      }
      return adapter;
    }

    var defaults = {
      adapter: getDefaultAdapter(),

      transformRequest: [function transformRequest(data, headers) {
        normalizeHeaderName(headers, 'Content-Type');
        if (utils.isFormData(data) ||
          utils.isArrayBuffer(data) ||
          utils.isBuffer(data) ||
          utils.isStream(data) ||
          utils.isFile(data) ||
          utils.isBlob(data)
        ) {
          return data;
        }
        if (utils.isArrayBufferView(data)) {
          return data.buffer;
        }
        if (utils.isURLSearchParams(data)) {
          setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
          return data.toString();
        }
        if (utils.isObject(data)) {
          setContentTypeIfUnset(headers, 'application/json;charset=utf-8');
          return JSON.stringify(data);
        }
        return data;
      }],

      transformResponse: [function transformResponse(data) {
        /*eslint no-param-reassign:0*/
        if (typeof data === 'string') {
          try {
            data = JSON.parse(data);
          } catch (e) { /* Ignore */ }
        }
        return data;
      }],

      /**
       * A timeout in milliseconds to abort a request. If set to 0 (default) a
       * timeout is not created.
       */
      timeout: 0,

      xsrfCookieName: 'XSRF-TOKEN',
      xsrfHeaderName: 'X-XSRF-TOKEN',

      maxContentLength: -1,

      validateStatus: function validateStatus(status) {
        return status >= 200 && status < 300;
      }
    };

    defaults.headers = {
      common: {
        'Accept': 'application/json, text/plain, */*'
      }
    };

    utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
      defaults.headers[method] = {};
    });

    utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
      defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
    });

    var defaults_1 = defaults;

    function InterceptorManager() {
      this.handlers = [];
    }

    /**
     * Add a new interceptor to the stack
     *
     * @param {Function} fulfilled The function to handle `then` for a `Promise`
     * @param {Function} rejected The function to handle `reject` for a `Promise`
     *
     * @return {Number} An ID used to remove interceptor later
     */
    InterceptorManager.prototype.use = function use(fulfilled, rejected) {
      this.handlers.push({
        fulfilled: fulfilled,
        rejected: rejected
      });
      return this.handlers.length - 1;
    };

    /**
     * Remove an interceptor from the stack
     *
     * @param {Number} id The ID that was returned by `use`
     */
    InterceptorManager.prototype.eject = function eject(id) {
      if (this.handlers[id]) {
        this.handlers[id] = null;
      }
    };

    /**
     * Iterate over all the registered interceptors
     *
     * This method is particularly useful for skipping over any
     * interceptors that may have become `null` calling `eject`.
     *
     * @param {Function} fn The function to call for each interceptor
     */
    InterceptorManager.prototype.forEach = function forEach(fn) {
      utils.forEach(this.handlers, function forEachHandler(h) {
        if (h !== null) {
          fn(h);
        }
      });
    };

    var InterceptorManager_1 = InterceptorManager;

    /**
     * Transform the data for a request or a response
     *
     * @param {Object|String} data The data to be transformed
     * @param {Array} headers The headers for the request or response
     * @param {Array|Function} fns A single function or Array of functions
     * @returns {*} The resulting transformed data
     */
    var transformData = function transformData(data, headers, fns) {
      /*eslint no-param-reassign:0*/
      utils.forEach(fns, function transform(fn) {
        data = fn(data, headers);
      });

      return data;
    };

    var isCancel = function isCancel(value) {
      return !!(value && value.__CANCEL__);
    };

    /**
     * Determines whether the specified URL is absolute
     *
     * @param {string} url The URL to test
     * @returns {boolean} True if the specified URL is absolute, otherwise false
     */
    var isAbsoluteURL = function isAbsoluteURL(url) {
      // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
      // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
      // by any combination of letters, digits, plus, period, or hyphen.
      return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
    };

    /**
     * Creates a new URL by combining the specified URLs
     *
     * @param {string} baseURL The base URL
     * @param {string} relativeURL The relative URL
     * @returns {string} The combined URL
     */
    var combineURLs = function combineURLs(baseURL, relativeURL) {
      return relativeURL
        ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
        : baseURL;
    };

    /**
     * Throws a `Cancel` if cancellation has been requested.
     */
    function throwIfCancellationRequested(config) {
      if (config.cancelToken) {
        config.cancelToken.throwIfRequested();
      }
    }

    /**
     * Dispatch a request to the server using the configured adapter.
     *
     * @param {object} config The config that is to be used for the request
     * @returns {Promise} The Promise to be fulfilled
     */
    var dispatchRequest = function dispatchRequest(config) {
      throwIfCancellationRequested(config);

      // Support baseURL config
      if (config.baseURL && !isAbsoluteURL(config.url)) {
        config.url = combineURLs(config.baseURL, config.url);
      }

      // Ensure headers exist
      config.headers = config.headers || {};

      // Transform request data
      config.data = transformData(
        config.data,
        config.headers,
        config.transformRequest
      );

      // Flatten headers
      config.headers = utils.merge(
        config.headers.common || {},
        config.headers[config.method] || {},
        config.headers || {}
      );

      utils.forEach(
        ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
        function cleanHeaderConfig(method) {
          delete config.headers[method];
        }
      );

      var adapter = config.adapter || defaults_1.adapter;

      return adapter(config).then(function onAdapterResolution(response) {
        throwIfCancellationRequested(config);

        // Transform response data
        response.data = transformData(
          response.data,
          response.headers,
          config.transformResponse
        );

        return response;
      }, function onAdapterRejection(reason) {
        if (!isCancel(reason)) {
          throwIfCancellationRequested(config);

          // Transform response data
          if (reason && reason.response) {
            reason.response.data = transformData(
              reason.response.data,
              reason.response.headers,
              config.transformResponse
            );
          }
        }

        return Promise.reject(reason);
      });
    };

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

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

    var clone_1 = createCommonjsModule(function (module) {
    var clone = (function() {

    /**
     * Clones (copies) an Object using deep copying.
     *
     * This function supports circular references by default, but if you are certain
     * there are no circular references in your object, you can save some CPU time
     * by calling clone(obj, false).
     *
     * Caution: if `circular` is false and `parent` contains circular references,
     * your program may enter an infinite loop and crash.
     *
     * @param `parent` - the object to be cloned
     * @param `circular` - set to true if the object to be cloned may contain
     *    circular references. (optional - true by default)
     * @param `depth` - set to a number if the object is only to be cloned to
     *    a particular depth. (optional - defaults to Infinity)
     * @param `prototype` - sets the prototype to be used when cloning an object.
     *    (optional - defaults to parent prototype).
    */
    function clone(parent, circular, depth, prototype) {
      var filter;
      if (typeof circular === 'object') {
        depth = circular.depth;
        prototype = circular.prototype;
        filter = circular.filter;
        circular = circular.circular;
      }
      // maintain two arrays for circular references, where corresponding parents
      // and children have the same index
      var allParents = [];
      var allChildren = [];

      var useBuffer = typeof Buffer != 'undefined';

      if (typeof circular == 'undefined')
        circular = true;

      if (typeof depth == 'undefined')
        depth = Infinity;

      // recurse this function so we don't reset allParents and allChildren
      function _clone(parent, depth) {
        // cloning null always returns null
        if (parent === null)
          return null;

        if (depth == 0)
          return parent;

        var child;
        var proto;
        if (typeof parent != 'object') {
          return parent;
        }

        if (clone.__isArray(parent)) {
          child = [];
        } else if (clone.__isRegExp(parent)) {
          child = new RegExp(parent.source, __getRegExpFlags(parent));
          if (parent.lastIndex) child.lastIndex = parent.lastIndex;
        } else if (clone.__isDate(parent)) {
          child = new Date(parent.getTime());
        } else if (useBuffer && Buffer.isBuffer(parent)) {
          if (Buffer.allocUnsafe) {
            // Node.js >= 4.5.0
            child = Buffer.allocUnsafe(parent.length);
          } else {
            // Older Node.js versions
            child = new Buffer(parent.length);
          }
          parent.copy(child);
          return child;
        } else {
          if (typeof prototype == 'undefined') {
            proto = Object.getPrototypeOf(parent);
            child = Object.create(proto);
          }
          else {
            child = Object.create(prototype);
            proto = prototype;
          }
        }

        if (circular) {
          var index = allParents.indexOf(parent);

          if (index != -1) {
            return allChildren[index];
          }
          allParents.push(parent);
          allChildren.push(child);
        }

        for (var i in parent) {
          var attrs;
          if (proto) {
            attrs = Object.getOwnPropertyDescriptor(proto, i);
          }

          if (attrs && attrs.set == null) {
            continue;
          }
          child[i] = _clone(parent[i], depth - 1);
        }

        return child;
      }

      return _clone(parent, depth);
    }

    /**
     * Simple flat clone using prototype, accepts only objects, usefull for property
     * override on FLAT configuration object (no nested props).
     *
     * USE WITH CAUTION! This may not behave as you wish if you do not know how this
     * works.
     */
    clone.clonePrototype = function clonePrototype(parent) {
      if (parent === null)
        return null;

      var c = function () {};
      c.prototype = parent;
      return new c();
    };

    // private utility functions

    function __objToStr(o) {
      return Object.prototype.toString.call(o);
    }clone.__objToStr = __objToStr;

    function __isDate(o) {
      return typeof o === 'object' && __objToStr(o) === '[object Date]';
    }clone.__isDate = __isDate;

    function __isArray(o) {
      return typeof o === 'object' && __objToStr(o) === '[object Array]';
    }clone.__isArray = __isArray;

    function __isRegExp(o) {
      return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
    }clone.__isRegExp = __isRegExp;

    function __getRegExpFlags(re) {
      var flags = '';
      if (re.global) flags += 'g';
      if (re.ignoreCase) flags += 'i';
      if (re.multiline) flags += 'm';
      return flags;
    }clone.__getRegExpFlags = __getRegExpFlags;

    return clone;
    })();

    if (module.exports) {
      module.exports = clone;
    }
    });

    var defaults$1 = function(options, defaults) {
      options = options || {};

      Object.keys(defaults).forEach(function(key) {
        if (typeof options[key] === 'undefined') {
          options[key] = clone_1(defaults[key]);
        }
      });

      return options;
    };

    /**
     * Create a new instance of Axios
     *
     * @param {Object} instanceConfig The default config for the instance
     */
    function Axios(instanceConfig) {
      this.defaults = instanceConfig;
      this.interceptors = {
        request: new InterceptorManager_1(),
        response: new InterceptorManager_1()
      };
    }

    /**
     * Dispatch a request
     *
     * @param {Object} config The config specific for this request (merged with this.defaults)
     */
    Axios.prototype.request = function request(config) {
      /*eslint no-param-reassign:0*/
      // Allow for axios('example/url'[, config]) a la fetch API
      if (typeof config === 'string') {
        config = utils.merge({
          url: arguments[0]
        }, arguments[1]);
      }

      config = utils.merge(defaults$1, {method: 'get'}, this.defaults, config);
      config.method = config.method.toLowerCase();

      // Hook up interceptors middleware
      var chain = [dispatchRequest, undefined];
      var promise = Promise.resolve(config);

      this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
        chain.unshift(interceptor.fulfilled, interceptor.rejected);
      });

      this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
        chain.push(interceptor.fulfilled, interceptor.rejected);
      });

      while (chain.length) {
        promise = promise.then(chain.shift(), chain.shift());
      }

      return promise;
    };

    // Provide aliases for supported request methods
    utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
      /*eslint func-names:0*/
      Axios.prototype[method] = function(url, config) {
        return this.request(utils.merge(config || {}, {
          method: method,
          url: url
        }));
      };
    });

    utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
      /*eslint func-names:0*/
      Axios.prototype[method] = function(url, data, config) {
        return this.request(utils.merge(config || {}, {
          method: method,
          url: url,
          data: data
        }));
      };
    });

    var Axios_1 = Axios;

    /**
     * A `Cancel` is an object that is thrown when an operation is canceled.
     *
     * @class
     * @param {string=} message The message.
     */
    function Cancel(message) {
      this.message = message;
    }

    Cancel.prototype.toString = function toString() {
      return 'Cancel' + (this.message ? ': ' + this.message : '');
    };

    Cancel.prototype.__CANCEL__ = true;

    var Cancel_1 = Cancel;

    /**
     * A `CancelToken` is an object that can be used to request cancellation of an operation.
     *
     * @class
     * @param {Function} executor The executor function.
     */
    function CancelToken(executor) {
      if (typeof executor !== 'function') {
        throw new TypeError('executor must be a function.');
      }

      var resolvePromise;
      this.promise = new Promise(function promiseExecutor(resolve) {
        resolvePromise = resolve;
      });

      var token = this;
      executor(function cancel(message) {
        if (token.reason) {
          // Cancellation has already been requested
          return;
        }

        token.reason = new Cancel_1(message);
        resolvePromise(token.reason);
      });
    }

    /**
     * Throws a `Cancel` if cancellation has been requested.
     */
    CancelToken.prototype.throwIfRequested = function throwIfRequested() {
      if (this.reason) {
        throw this.reason;
      }
    };

    /**
     * Returns an object that contains a new `CancelToken` and a function that, when called,
     * cancels the `CancelToken`.
     */
    CancelToken.source = function source() {
      var cancel;
      var token = new CancelToken(function executor(c) {
        cancel = c;
      });
      return {
        token: token,
        cancel: cancel
      };
    };

    var CancelToken_1 = CancelToken;

    /**
     * Syntactic sugar for invoking a function and expanding an array for arguments.
     *
     * Common use case would be to use `Function.prototype.apply`.
     *
     *  ```js
     *  function f(x, y, z) {}
     *  var args = [1, 2, 3];
     *  f.apply(null, args);
     *  ```
     *
     * With `spread` this example can be re-written.
     *
     *  ```js
     *  spread(function(x, y, z) {})([1, 2, 3]);
     *  ```
     *
     * @param {Function} callback
     * @returns {Function}
     */
    var spread = function spread(callback) {
      return function wrap(arr) {
        return callback.apply(null, arr);
      };
    };

    /**
     * Create an instance of Axios
     *
     * @param {Object} defaultConfig The default config for the instance
     * @return {Axios} A new instance of Axios
     */
    function createInstance(defaultConfig) {
      var context = new Axios_1(defaultConfig);
      var instance = bind(Axios_1.prototype.request, context);

      // Copy axios.prototype to instance
      utils.extend(instance, Axios_1.prototype, context);

      // Copy context to instance
      utils.extend(instance, context);

      return instance;
    }

    // Create the default instance to be exported
    var axios = createInstance(defaults_1);

    // Expose Axios class to allow class inheritance
    axios.Axios = Axios_1;

    // Factory for creating new instances
    axios.create = function create(instanceConfig) {
      return createInstance(utils.merge(defaults_1, instanceConfig));
    };

    // Expose Cancel & CancelToken
    axios.Cancel = Cancel_1;
    axios.CancelToken = CancelToken_1;
    axios.isCancel = isCancel;

    // Expose all/spread
    axios.all = function all(promises) {
      return Promise.all(promises);
    };
    axios.spread = spread;

    var axios_1 = axios;

    // Allow use of default import syntax in TypeScript
    var default_1 = axios;
    axios_1.default = default_1;

    var axios$1 = axios_1;

    /* eslint no-invalid-this: 1 */

    var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
    var slice = Array.prototype.slice;
    var toStr = Object.prototype.toString;
    var funcType = '[object Function]';

    var implementation = function bind(that) {
        var target = this;
        if (typeof target !== 'function' || toStr.call(target) !== funcType) {
            throw new TypeError(ERROR_MESSAGE + target);
        }
        var args = slice.call(arguments, 1);

        var bound;
        var binder = function () {
            if (this instanceof bound) {
                var result = target.apply(
                    this,
                    args.concat(slice.call(arguments))
                );
                if (Object(result) === result) {
                    return result;
                }
                return this;
            } else {
                return target.apply(
                    that,
                    args.concat(slice.call(arguments))
                );
            }
        };

        var boundLength = Math.max(0, target.length - args.length);
        var boundArgs = [];
        for (var i = 0; i < boundLength; i++) {
            boundArgs.push('$' + i);
        }

        bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);

        if (target.prototype) {
            var Empty = function Empty() {};
            Empty.prototype = target.prototype;
            bound.prototype = new Empty();
            Empty.prototype = null;
        }

        return bound;
    };

    var functionBind = Function.prototype.bind || implementation;

    /* eslint complexity: [2, 18], max-statements: [2, 33] */
    var shams = function hasSymbols() {
    	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
    	if (typeof Symbol.iterator === 'symbol') { return true; }

    	var obj = {};
    	var sym = Symbol('test');
    	var symObj = Object(sym);
    	if (typeof sym === 'string') { return false; }

    	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
    	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }

    	// temp disabled per https://github.com/ljharb/object.assign/issues/17
    	// if (sym instanceof Symbol) { return false; }
    	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
    	// if (!(symObj instanceof Symbol)) { return false; }

    	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
    	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }

    	var symVal = 42;
    	obj[sym] = symVal;
    	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop
    	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }

    	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }

    	var syms = Object.getOwnPropertySymbols(obj);
    	if (syms.length !== 1 || syms[0] !== sym) { return false; }

    	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }

    	if (typeof Object.getOwnPropertyDescriptor === 'function') {
    		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
    		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
    	}

    	return true;
    };

    var origSymbol = typeof Symbol !== 'undefined' && Symbol;


    var hasSymbols = function hasNativeSymbols() {
    	if (typeof origSymbol !== 'function') { return false; }
    	if (typeof Symbol !== 'function') { return false; }
    	if (typeof origSymbol('foo') !== 'symbol') { return false; }
    	if (typeof Symbol('bar') !== 'symbol') { return false; }

    	return shams();
    };

    var src = functionBind.call(Function.call, Object.prototype.hasOwnProperty);

    var undefined$1;

    var $SyntaxError = SyntaxError;
    var $Function = Function;
    var $TypeError = TypeError;

    // eslint-disable-next-line consistent-return
    var getEvalledConstructor = function (expressionSyntax) {
    	try {
    		return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
    	} catch (e) {}
    };

    var $gOPD = Object.getOwnPropertyDescriptor;
    if ($gOPD) {
    	try {
    		$gOPD({}, '');
    	} catch (e) {
    		$gOPD = null; // this is IE 8, which has a broken gOPD
    	}
    }

    var throwTypeError = function () {
    	throw new $TypeError();
    };
    var ThrowTypeError = $gOPD
    	? (function () {
    		try {
    			return throwTypeError;
    		} catch (calleeThrows) {
    			try {
    				// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
    				return $gOPD(arguments, 'callee').get;
    			} catch (gOPDthrows) {
    				return throwTypeError;
    			}
    		}
    	}())
    	: throwTypeError;

    var hasSymbols$1 = hasSymbols();

    var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto

    var needsEval = {};

    var TypedArray = typeof Uint8Array === 'undefined' ? undefined$1 : getProto(Uint8Array);

    var INTRINSICS = {
    	'%AggregateError%': typeof AggregateError === 'undefined' ? undefined$1 : AggregateError,
    	'%Array%': Array,
    	'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined$1 : ArrayBuffer,
    	'%ArrayIteratorPrototype%': hasSymbols$1 ? getProto([][Symbol.iterator]()) : undefined$1,
    	'%AsyncFromSyncIteratorPrototype%': undefined$1,
    	'%AsyncFunction%': needsEval,
    	'%AsyncGenerator%': needsEval,
    	'%AsyncGeneratorFunction%': needsEval,
    	'%AsyncIteratorPrototype%': needsEval,
    	'%Atomics%': typeof Atomics === 'undefined' ? undefined$1 : Atomics,
    	'%BigInt%': typeof BigInt === 'undefined' ? undefined$1 : BigInt,
    	'%Boolean%': Boolean,
    	'%DataView%': typeof DataView === 'undefined' ? undefined$1 : DataView,
    	'%Date%': Date,
    	'%decodeURI%': decodeURI,
    	'%decodeURIComponent%': decodeURIComponent,
    	'%encodeURI%': encodeURI,
    	'%encodeURIComponent%': encodeURIComponent,
    	'%Error%': Error,
    	'%eval%': eval, // eslint-disable-line no-eval
    	'%EvalError%': EvalError,
    	'%Float32Array%': typeof Float32Array === 'undefined' ? undefined$1 : Float32Array,
    	'%Float64Array%': typeof Float64Array === 'undefined' ? undefined$1 : Float64Array,
    	'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined$1 : FinalizationRegistry,
    	'%Function%': $Function,
    	'%GeneratorFunction%': needsEval,
    	'%Int8Array%': typeof Int8Array === 'undefined' ? undefined$1 : Int8Array,
    	'%Int16Array%': typeof Int16Array === 'undefined' ? undefined$1 : Int16Array,
    	'%Int32Array%': typeof Int32Array === 'undefined' ? undefined$1 : Int32Array,
    	'%isFinite%': isFinite,
    	'%isNaN%': isNaN,
    	'%IteratorPrototype%': hasSymbols$1 ? getProto(getProto([][Symbol.iterator]())) : undefined$1,
    	'%JSON%': typeof JSON === 'object' ? JSON : undefined$1,
    	'%Map%': typeof Map === 'undefined' ? undefined$1 : Map,
    	'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols$1 ? undefined$1 : getProto(new Map()[Symbol.iterator]()),
    	'%Math%': Math,
    	'%Number%': Number,
    	'%Object%': Object,
    	'%parseFloat%': parseFloat,
    	'%parseInt%': parseInt,
    	'%Promise%': typeof Promise === 'undefined' ? undefined$1 : Promise,
    	'%Proxy%': typeof Proxy === 'undefined' ? undefined$1 : Proxy,
    	'%RangeError%': RangeError,
    	'%ReferenceError%': ReferenceError,
    	'%Reflect%': typeof Reflect === 'undefined' ? undefined$1 : Reflect,
    	'%RegExp%': RegExp,
    	'%Set%': typeof Set === 'undefined' ? undefined$1 : Set,
    	'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols$1 ? undefined$1 : getProto(new Set()[Symbol.iterator]()),
    	'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined$1 : SharedArrayBuffer,
    	'%String%': String,
    	'%StringIteratorPrototype%': hasSymbols$1 ? getProto(''[Symbol.iterator]()) : undefined$1,
    	'%Symbol%': hasSymbols$1 ? Symbol : undefined$1,
    	'%SyntaxError%': $SyntaxError,
    	'%ThrowTypeError%': ThrowTypeError,
    	'%TypedArray%': TypedArray,
    	'%TypeError%': $TypeError,
    	'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined$1 : Uint8Array,
    	'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined$1 : Uint8ClampedArray,
    	'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined$1 : Uint16Array,
    	'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined$1 : Uint32Array,
    	'%URIError%': URIError,
    	'%WeakMap%': typeof WeakMap === 'undefined' ? undefined$1 : WeakMap,
    	'%WeakRef%': typeof WeakRef === 'undefined' ? undefined$1 : WeakRef,
    	'%WeakSet%': typeof WeakSet === 'undefined' ? undefined$1 : WeakSet
    };

    var doEval = function doEval(name) {
    	var value;
    	if (name === '%AsyncFunction%') {
    		value = getEvalledConstructor('async function () {}');
    	} else if (name === '%GeneratorFunction%') {
    		value = getEvalledConstructor('function* () {}');
    	} else if (name === '%AsyncGeneratorFunction%') {
    		value = getEvalledConstructor('async function* () {}');
    	} else if (name === '%AsyncGenerator%') {
    		var fn = doEval('%AsyncGeneratorFunction%');
    		if (fn) {
    			value = fn.prototype;
    		}
    	} else if (name === '%AsyncIteratorPrototype%') {
    		var gen = doEval('%AsyncGenerator%');
    		if (gen) {
    			value = getProto(gen.prototype);
    		}
    	}

    	INTRINSICS[name] = value;

    	return value;
    };

    var LEGACY_ALIASES = {
    	'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],
    	'%ArrayPrototype%': ['Array', 'prototype'],
    	'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],
    	'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],
    	'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],
    	'%ArrayProto_values%': ['Array', 'prototype', 'values'],
    	'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],
    	'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],
    	'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],
    	'%BooleanPrototype%': ['Boolean', 'prototype'],
    	'%DataViewPrototype%': ['DataView', 'prototype'],
    	'%DatePrototype%': ['Date', 'prototype'],
    	'%ErrorPrototype%': ['Error', 'prototype'],
    	'%EvalErrorPrototype%': ['EvalError', 'prototype'],
    	'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],
    	'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],
    	'%FunctionPrototype%': ['Function', 'prototype'],
    	'%Generator%': ['GeneratorFunction', 'prototype'],
    	'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],
    	'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],
    	'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],
    	'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],
    	'%JSONParse%': ['JSON', 'parse'],
    	'%JSONStringify%': ['JSON', 'stringify'],
    	'%MapPrototype%': ['Map', 'prototype'],
    	'%NumberPrototype%': ['Number', 'prototype'],
    	'%ObjectPrototype%': ['Object', 'prototype'],
    	'%ObjProto_toString%': ['Object', 'prototype', 'toString'],
    	'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],
    	'%PromisePrototype%': ['Promise', 'prototype'],
    	'%PromiseProto_then%': ['Promise', 'prototype', 'then'],
    	'%Promise_all%': ['Promise', 'all'],
    	'%Promise_reject%': ['Promise', 'reject'],
    	'%Promise_resolve%': ['Promise', 'resolve'],
    	'%RangeErrorPrototype%': ['RangeError', 'prototype'],
    	'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],
    	'%RegExpPrototype%': ['RegExp', 'prototype'],
    	'%SetPrototype%': ['Set', 'prototype'],
    	'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],
    	'%StringPrototype%': ['String', 'prototype'],
    	'%SymbolPrototype%': ['Symbol', 'prototype'],
    	'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],
    	'%TypedArrayPrototype%': ['TypedArray', 'prototype'],
    	'%TypeErrorPrototype%': ['TypeError', 'prototype'],
    	'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],
    	'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],
    	'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],
    	'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],
    	'%URIErrorPrototype%': ['URIError', 'prototype'],
    	'%WeakMapPrototype%': ['WeakMap', 'prototype'],
    	'%WeakSetPrototype%': ['WeakSet', 'prototype']
    };



    var $concat = functionBind.call(Function.call, Array.prototype.concat);
    var $spliceApply = functionBind.call(Function.apply, Array.prototype.splice);
    var $replace = functionBind.call(Function.call, String.prototype.replace);
    var $strSlice = functionBind.call(Function.call, String.prototype.slice);

    /* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
    var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
    var stringToPath = function stringToPath(string) {
    	var first = $strSlice(string, 0, 1);
    	var last = $strSlice(string, -1);
    	if (first === '%' && last !== '%') {
    		throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`');
    	} else if (last === '%' && first !== '%') {
    		throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`');
    	}
    	var result = [];
    	$replace(string, rePropName, function (match, number, quote, subString) {
    		result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;
    	});
    	return result;
    };
    /* end adaptation */

    var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
    	var intrinsicName = name;
    	var alias;
    	if (src(LEGACY_ALIASES, intrinsicName)) {
    		alias = LEGACY_ALIASES[intrinsicName];
    		intrinsicName = '%' + alias[0] + '%';
    	}

    	if (src(INTRINSICS, intrinsicName)) {
    		var value = INTRINSICS[intrinsicName];
    		if (value === needsEval) {
    			value = doEval(intrinsicName);
    		}
    		if (typeof value === 'undefined' && !allowMissing) {
    			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
    		}

    		return {
    			alias: alias,
    			name: intrinsicName,
    			value: value
    		};
    	}

    	throw new $SyntaxError('intrinsic ' + name + ' does not exist!');
    };

    var getIntrinsic = function GetIntrinsic(name, allowMissing) {
    	if (typeof name !== 'string' || name.length === 0) {
    		throw new $TypeError('intrinsic name must be a non-empty string');
    	}
    	if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
    		throw new $TypeError('"allowMissing" argument must be a boolean');
    	}

    	var parts = stringToPath(name);
    	var intrinsicBaseName = parts.length > 0 ? parts[0] : '';

    	var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);
    	var intrinsicRealName = intrinsic.name;
    	var value = intrinsic.value;
    	var skipFurtherCaching = false;

    	var alias = intrinsic.alias;
    	if (alias) {
    		intrinsicBaseName = alias[0];
    		$spliceApply(parts, $concat([0, 1], alias));
    	}

    	for (var i = 1, isOwn = true; i < parts.length; i += 1) {
    		var part = parts[i];
    		var first = $strSlice(part, 0, 1);
    		var last = $strSlice(part, -1);
    		if (
    			(
    				(first === '"' || first === "'" || first === '`')
    				|| (last === '"' || last === "'" || last === '`')
    			)
    			&& first !== last
    		) {
    			throw new $SyntaxError('property names with quotes must have matching quotes');
    		}
    		if (part === 'constructor' || !isOwn) {
    			skipFurtherCaching = true;
    		}

    		intrinsicBaseName += '.' + part;
    		intrinsicRealName = '%' + intrinsicBaseName + '%';

    		if (src(INTRINSICS, intrinsicRealName)) {
    			value = INTRINSICS[intrinsicRealName];
    		} else if (value != null) {
    			if (!(part in value)) {
    				if (!allowMissing) {
    					throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');
    				}
    				return void undefined$1;
    			}
    			if ($gOPD && (i + 1) >= parts.length) {
    				var desc = $gOPD(value, part);
    				isOwn = !!desc;

    				// By convention, when a data property is converted to an accessor
    				// property to emulate a data property that does not suffer from
    				// the override mistake, that accessor's getter is marked with
    				// an `originalValue` property. Here, when we detect this, we
    				// uphold the illusion by pretending to see that original data
    				// property, i.e., returning the value rather than the getter
    				// itself.
    				if (isOwn && 'get' in desc && !('originalValue' in desc.get)) {
    					value = desc.get;
    				} else {
    					value = value[part];
    				}
    			} else {
    				isOwn = src(value, part);
    				value = value[part];
    			}

    			if (isOwn && !skipFurtherCaching) {
    				INTRINSICS[intrinsicRealName] = value;
    			}
    		}
    	}
    	return value;
    };

    var callBind = createCommonjsModule(function (module) {




    var $apply = getIntrinsic('%Function.prototype.apply%');
    var $call = getIntrinsic('%Function.prototype.call%');
    var $reflectApply = getIntrinsic('%Reflect.apply%', true) || functionBind.call($call, $apply);

    var $gOPD = getIntrinsic('%Object.getOwnPropertyDescriptor%', true);
    var $defineProperty = getIntrinsic('%Object.defineProperty%', true);
    var $max = getIntrinsic('%Math.max%');

    if ($defineProperty) {
    	try {
    		$defineProperty({}, 'a', { value: 1 });
    	} catch (e) {
    		// IE 8 has a broken defineProperty
    		$defineProperty = null;
    	}
    }

    module.exports = function callBind(originalFunction) {
    	var func = $reflectApply(functionBind, $call, arguments);
    	if ($gOPD && $defineProperty) {
    		var desc = $gOPD(func, 'length');
    		if (desc.configurable) {
    			// original length, plus the receiver, minus any additional arguments (after the receiver)
    			$defineProperty(
    				func,
    				'length',
    				{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }
    			);
    		}
    	}
    	return func;
    };

    var applyBind = function applyBind() {
    	return $reflectApply(functionBind, $apply, arguments);
    };

    if ($defineProperty) {
    	$defineProperty(module.exports, 'apply', { value: applyBind });
    } else {
    	module.exports.apply = applyBind;
    }
    });
    var callBind_1 = callBind.apply;

    var toStr$1 = Object.prototype.toString;

    var isArguments = function isArguments(value) {
    	var str = toStr$1.call(value);
    	var isArgs = str === '[object Arguments]';
    	if (!isArgs) {
    		isArgs = str !== '[object Array]' &&
    			value !== null &&
    			typeof value === 'object' &&
    			typeof value.length === 'number' &&
    			value.length >= 0 &&
    			toStr$1.call(value.callee) === '[object Function]';
    	}
    	return isArgs;
    };

    // modified from https://github.com/es-shims/es5-shim
    var has = Object.prototype.hasOwnProperty;
    var toStr$2 = Object.prototype.toString;
    var slice$1 = Array.prototype.slice;

    var isEnumerable = Object.prototype.propertyIsEnumerable;
    var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
    var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
    var dontEnums = [
    	'toString',
    	'toLocaleString',
    	'valueOf',
    	'hasOwnProperty',
    	'isPrototypeOf',
    	'propertyIsEnumerable',
    	'constructor'
    ];
    var equalsConstructorPrototype = function (o) {
    	var ctor = o.constructor;
    	return ctor && ctor.prototype === o;
    };
    var excludedKeys = {
    	$applicationCache: true,
    	$console: true,
    	$external: true,
    	$frame: true,
    	$frameElement: true,
    	$frames: true,
    	$innerHeight: true,
    	$innerWidth: true,
    	$outerHeight: true,
    	$outerWidth: true,
    	$pageXOffset: true,
    	$pageYOffset: true,
    	$parent: true,
    	$scrollLeft: true,
    	$scrollTop: true,
    	$scrollX: true,
    	$scrollY: true,
    	$self: true,
    	$webkitIndexedDB: true,
    	$webkitStorageInfo: true,
    	$window: true
    };
    var hasAutomationEqualityBug = (function () {
    	/* global window */
    	if (typeof window === 'undefined') { return false; }
    	for (var k in window) {
    		try {
    			if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
    				try {
    					equalsConstructorPrototype(window[k]);
    				} catch (e) {
    					return true;
    				}
    			}
    		} catch (e) {
    			return true;
    		}
    	}
    	return false;
    }());
    var equalsConstructorPrototypeIfNotBuggy = function (o) {
    	/* global window */
    	if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
    		return equalsConstructorPrototype(o);
    	}
    	try {
    		return equalsConstructorPrototype(o);
    	} catch (e) {
    		return false;
    	}
    };

    var keysShim = function keys(object) {
    	var isObject = object !== null && typeof object === 'object';
    	var isFunction = toStr$2.call(object) === '[object Function]';
    	var isArguments$$1 = isArguments(object);
    	var isString = isObject && toStr$2.call(object) === '[object String]';
    	var theKeys = [];

    	if (!isObject && !isFunction && !isArguments$$1) {
    		throw new TypeError('Object.keys called on a non-object');
    	}

    	var skipProto = hasProtoEnumBug && isFunction;
    	if (isString && object.length > 0 && !has.call(object, 0)) {
    		for (var i = 0; i < object.length; ++i) {
    			theKeys.push(String(i));
    		}
    	}

    	if (isArguments$$1 && object.length > 0) {
    		for (var j = 0; j < object.length; ++j) {
    			theKeys.push(String(j));
    		}
    	} else {
    		for (var name in object) {
    			if (!(skipProto && name === 'prototype') && has.call(object, name)) {
    				theKeys.push(String(name));
    			}
    		}
    	}

    	if (hasDontEnumBug) {
    		var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);

    		for (var k = 0; k < dontEnums.length; ++k) {
    			if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
    				theKeys.push(dontEnums[k]);
    			}
    		}
    	}
    	return theKeys;
    };

    keysShim.shim = function shimObjectKeys() {
    	if (Object.keys) {
    		var keysWorksWithArguments = (function () {
    			// Safari 5.0 bug
    			return (Object.keys(arguments) || '').length === 2;
    		}(1, 2));
    		if (!keysWorksWithArguments) {
    			var originalKeys = Object.keys;
    			Object.keys = function keys(object) { // eslint-disable-line func-name-matching
    				if (isArguments(object)) {
    					return originalKeys(slice$1.call(object));
    				} else {
    					return originalKeys(object);
    				}
    			};
    		}
    	} else {
    		Object.keys = keysShim;
    	}
    	return Object.keys || keysShim;
    };

    var objectKeys = keysShim;

    var hasSymbols$2 = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';

    var toStr$3 = Object.prototype.toString;
    var concat = Array.prototype.concat;
    var origDefineProperty = Object.defineProperty;

    var isFunction$1 = function (fn) {
    	return typeof fn === 'function' && toStr$3.call(fn) === '[object Function]';
    };

    var arePropertyDescriptorsSupported = function () {
    	var obj = {};
    	try {
    		origDefineProperty(obj, 'x', { enumerable: false, value: obj });
    		// eslint-disable-next-line no-unused-vars, no-restricted-syntax
    		for (var _ in obj) { // jscs:ignore disallowUnusedVariables
    			return false;
    		}
    		return obj.x === obj;
    	} catch (e) { /* this is IE 8. */
    		return false;
    	}
    };
    var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();

    var defineProperty = function (object, name, value, predicate) {
    	if (name in object && (!isFunction$1(predicate) || !predicate())) {
    		return;
    	}
    	if (supportsDescriptors) {
    		origDefineProperty(object, name, {
    			configurable: true,
    			enumerable: false,
    			value: value,
    			writable: true
    		});
    	} else {
    		object[name] = value;
    	}
    };

    var defineProperties = function (object, map) {
    	var predicates = arguments.length > 2 ? arguments[2] : {};
    	var props = objectKeys(map);
    	if (hasSymbols$2) {
    		props = concat.call(props, Object.getOwnPropertySymbols(map));
    	}
    	for (var i = 0; i < props.length; i += 1) {
    		defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
    	}
    };

    defineProperties.supportsDescriptors = !!supportsDescriptors;

    var defineProperties_1 = defineProperties;

    var requirePromise = function requirePromise() {
    	if (typeof Promise !== 'function') {
    		throw new TypeError('`Promise.any` requires a global `Promise` be available.');
    	}
    };

    var $indexOf = callBind(getIntrinsic('String.prototype.indexOf'));

    var callBound = function callBoundIntrinsic(name, allowMissing) {
    	var intrinsic = getIntrinsic(name, !!allowMissing);
    	if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {
    		return callBind(intrinsic);
    	}
    	return intrinsic;
    };

    var isLeadingSurrogate = function isLeadingSurrogate(charCode) {
    	return typeof charCode === 'number' && charCode >= 0xD800 && charCode <= 0xDBFF;
    };

    var isTrailingSurrogate = function isTrailingSurrogate(charCode) {
    	return typeof charCode === 'number' && charCode >= 0xDC00 && charCode <= 0xDFFF;
    };

    // https://262.ecma-international.org/5.1/#sec-8

    var Type = function Type(x) {
    	if (x === null) {
    		return 'Null';
    	}
    	if (typeof x === 'undefined') {
    		return 'Undefined';
    	}
    	if (typeof x === 'function' || typeof x === 'object') {
    		return 'Object';
    	}
    	if (typeof x === 'number') {
    		return 'Number';
    	}
    	if (typeof x === 'boolean') {
    		return 'Boolean';
    	}
    	if (typeof x === 'string') {
    		return 'String';
    	}
    };

    // https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values

    var Type$1 = function Type$$1(x) {
    	if (typeof x === 'symbol') {
    		return 'Symbol';
    	}
    	if (typeof x === 'bigint') {
    		return 'BigInt';
    	}
    	return Type(x);
    };

    var $TypeError$1 = getIntrinsic('%TypeError%');
    var $fromCharCode = getIntrinsic('%String.fromCharCode%');




    // https://262.ecma-international.org/11.0/#sec-utf16decodesurrogatepair

    var UTF16DecodeSurrogatePair = function UTF16DecodeSurrogatePair(lead, trail) {
    	if (!isLeadingSurrogate(lead) || !isTrailingSurrogate(trail)) {
    		throw new $TypeError$1('Assertion failed: `lead` must be a leading surrogate char code, and `trail` must be a trailing surrogate char code');
    	}
    	// var cp = (lead - 0xD800) * 0x400 + (trail - 0xDC00) + 0x10000;
    	return $fromCharCode(lead) + $fromCharCode(trail);
    };

    var $TypeError$2 = getIntrinsic('%TypeError%');







    var $charAt = callBound('String.prototype.charAt');
    var $charCodeAt = callBound('String.prototype.charCodeAt');

    // https://262.ecma-international.org/11.0/#sec-codepointat

    var CodePointAt = function CodePointAt(string, position) {
    	if (Type$1(string) !== 'String') {
    		throw new $TypeError$2('Assertion failed: `string` must be a String');
    	}
    	var size = string.length;
    	if (position < 0 || position >= size) {
    		throw new $TypeError$2('Assertion failed: `position` must be >= 0, and < the length of `string`');
    	}
    	var first = $charCodeAt(string, position);
    	var cp = $charAt(string, position);
    	var firstIsLeading = isLeadingSurrogate(first);
    	var firstIsTrailing = isTrailingSurrogate(first);
    	if (!firstIsLeading && !firstIsTrailing) {
    		return {
    			'[[CodePoint]]': cp,
    			'[[CodeUnitCount]]': 1,
    			'[[IsUnpairedSurrogate]]': false
    		};
    	}
    	if (firstIsTrailing || (position + 1 === size)) {
    		return {
    			'[[CodePoint]]': cp,
    			'[[CodeUnitCount]]': 1,
    			'[[IsUnpairedSurrogate]]': true
    		};
    	}
    	var second = $charCodeAt(string, position + 1);
    	if (!isTrailingSurrogate(second)) {
    		return {
    			'[[CodePoint]]': cp,
    			'[[CodeUnitCount]]': 1,
    			'[[IsUnpairedSurrogate]]': true
    		};
    	}

    	return {
    		'[[CodePoint]]': UTF16DecodeSurrogatePair(first, second),
    		'[[CodeUnitCount]]': 2,
    		'[[IsUnpairedSurrogate]]': false
    	};
    };

    var $abs = getIntrinsic('%Math.abs%');

    // http://262.ecma-international.org/5.1/#sec-5.2

    var abs = function abs(x) {
    	return $abs(x);
    };

    // var modulo = require('./modulo');
    var $floor = Math.floor;

    // http://262.ecma-international.org/5.1/#sec-5.2

    var floor = function floor(x) {
    	// return x - modulo(x, 1);
    	return $floor(x);
    };

    var _isNaN = Number.isNaN || function isNaN(a) {
    	return a !== a;
    };

    var $isNaN = Number.isNaN || function (a) { return a !== a; };

    var _isFinite = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; };

    // https://ecma-international.org/ecma-262/6.0/#sec-isinteger

    var IsInteger = function IsInteger(argument) {
    	if (typeof argument !== 'number' || _isNaN(argument) || !_isFinite(argument)) {
    		return false;
    	}
    	var absValue = abs(argument);
    	return floor(absValue) === absValue;
    };

    var $Math = getIntrinsic('%Math%');
    var $Number = getIntrinsic('%Number%');

    var maxSafeInteger = $Number.MAX_SAFE_INTEGER || $Math.pow(2, 53) - 1;

    var $TypeError$3 = getIntrinsic('%TypeError%');

    // https://262.ecma-international.org/6.0/#sec-advancestringindex

    var AdvanceStringIndex = function AdvanceStringIndex(S, index, unicode) {
    	if (Type$1(S) !== 'String') {
    		throw new $TypeError$3('Assertion failed: `S` must be a String');
    	}
    	if (!IsInteger(index) || index < 0 || index > maxSafeInteger) {
    		throw new $TypeError$3('Assertion failed: `length` must be an integer >= 0 and <= 2**53');
    	}
    	if (Type$1(unicode) !== 'Boolean') {
    		throw new $TypeError$3('Assertion failed: `unicode` must be a Boolean');
    	}
    	if (!unicode) {
    		return index + 1;
    	}
    	var length = S.length;
    	if ((index + 1) >= length) {
    		return index + 1;
    	}
    	var cp = CodePointAt(S, index);
    	return index + cp['[[CodeUnitCount]]'];
    };

    var $defineProperty = getIntrinsic('%Object.defineProperty%', true);

    if ($defineProperty) {
    	try {
    		$defineProperty({}, 'a', { value: 1 });
    	} catch (e) {
    		// IE 8 has a broken defineProperty
    		$defineProperty = null;
    	}
    }



    var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');

    // eslint-disable-next-line max-params
    var DefineOwnProperty = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {
    	if (!$defineProperty) {
    		if (!IsDataDescriptor(desc)) {
    			// ES3 does not support getters/setters
    			return false;
    		}
    		if (!desc['[[Configurable]]'] || !desc['[[Writable]]']) {
    			return false;
    		}

    		// fallback for ES3
    		if (P in O && $isEnumerable(O, P) !== !!desc['[[Enumerable]]']) {
    			// a non-enumerable existing property
    			return false;
    		}

    		// property does not exist at all, or exists but is enumerable
    		var V = desc['[[Value]]'];
    		// eslint-disable-next-line no-param-reassign
    		O[P] = V; // will use [[Define]]
    		return SameValue(O[P], V);
    	}
    	$defineProperty(O, P, FromPropertyDescriptor(desc));
    	return true;
    };

    var $TypeError$4 = getIntrinsic('%TypeError%');
    var $SyntaxError$1 = getIntrinsic('%SyntaxError%');



    var predicates = {
    	// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type
    	'Property Descriptor': function isPropertyDescriptor(Type, Desc) {
    		if (Type(Desc) !== 'Object') {
    			return false;
    		}
    		var allowed = {
    			'[[Configurable]]': true,
    			'[[Enumerable]]': true,
    			'[[Get]]': true,
    			'[[Set]]': true,
    			'[[Value]]': true,
    			'[[Writable]]': true
    		};

    		for (var key in Desc) { // eslint-disable-line
    			if (src(Desc, key) && !allowed[key]) {
    				return false;
    			}
    		}

    		var isData = src(Desc, '[[Value]]');
    		var IsAccessor = src(Desc, '[[Get]]') || src(Desc, '[[Set]]');
    		if (isData && IsAccessor) {
    			throw new $TypeError$4('Property Descriptors may not be both accessor and data descriptors');
    		}
    		return true;
    	}
    };

    var assertRecord = function assertRecord(Type, recordType, argumentName, value) {
    	var predicate = predicates[recordType];
    	if (typeof predicate !== 'function') {
    		throw new $SyntaxError$1('unknown record type: ' + recordType);
    	}
    	if (!predicate(Type, value)) {
    		throw new $TypeError$4(argumentName + ' must be a ' + recordType);
    	}
    };

    // https://ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor

    var FromPropertyDescriptor = function FromPropertyDescriptor(Desc) {
    	if (typeof Desc === 'undefined') {
    		return Desc;
    	}

    	assertRecord(Type$1, 'Property Descriptor', 'Desc', Desc);

    	var obj = {};
    	if ('[[Value]]' in Desc) {
    		obj.value = Desc['[[Value]]'];
    	}
    	if ('[[Writable]]' in Desc) {
    		obj.writable = Desc['[[Writable]]'];
    	}
    	if ('[[Get]]' in Desc) {
    		obj.get = Desc['[[Get]]'];
    	}
    	if ('[[Set]]' in Desc) {
    		obj.set = Desc['[[Set]]'];
    	}
    	if ('[[Enumerable]]' in Desc) {
    		obj.enumerable = Desc['[[Enumerable]]'];
    	}
    	if ('[[Configurable]]' in Desc) {
    		obj.configurable = Desc['[[Configurable]]'];
    	}
    	return obj;
    };

    var $gOPD$1 = getIntrinsic('%Object.getOwnPropertyDescriptor%');
    if ($gOPD$1) {
    	try {
    		$gOPD$1([], 'length');
    	} catch (e) {
    		// IE 8 has a broken gOPD
    		$gOPD$1 = null;
    	}
    }

    var getOwnPropertyDescriptor = $gOPD$1;

    var $Array = getIntrinsic('%Array%');

    // eslint-disable-next-line global-require
    var toStr$4 = !$Array.isArray && callBound('Object.prototype.toString');

    // https://ecma-international.org/ecma-262/6.0/#sec-isarray

    var IsArray = $Array.isArray || function IsArray(argument) {
    	return toStr$4(argument) === '[object Array]';
    };

    // https://ecma-international.org/ecma-262/6.0/#sec-ispropertykey

    var IsPropertyKey = function IsPropertyKey(argument) {
    	return typeof argument === 'string' || typeof argument === 'symbol';
    };

    var shams$1 = function hasToStringTagShams() {
    	return shams() && !!Symbol.toStringTag;
    };

    var hasToStringTag = shams$1();
    var has$1;
    var $exec;
    var isRegexMarker;
    var badStringifier;

    if (hasToStringTag) {
    	has$1 = callBound('Object.prototype.hasOwnProperty');
    	$exec = callBound('RegExp.prototype.exec');
    	isRegexMarker = {};

    	var throwRegexMarker = function () {
    		throw isRegexMarker;
    	};
    	badStringifier = {
    		toString: throwRegexMarker,
    		valueOf: throwRegexMarker
    	};

    	if (typeof Symbol.toPrimitive === 'symbol') {
    		badStringifier[Symbol.toPrimitive] = throwRegexMarker;
    	}
    }

    var $toString = callBound('Object.prototype.toString');
    var gOPD = Object.getOwnPropertyDescriptor;
    var regexClass = '[object RegExp]';

    var isRegex = hasToStringTag
    	// eslint-disable-next-line consistent-return
    	? function isRegex(value) {
    		if (!value || typeof value !== 'object') {
    			return false;
    		}

    		var descriptor = gOPD(value, 'lastIndex');
    		var hasLastIndexDataProperty = descriptor && has$1(descriptor, 'value');
    		if (!hasLastIndexDataProperty) {
    			return false;
    		}

    		try {
    			$exec(value, badStringifier);
    		} catch (e) {
    			return e === isRegexMarker;
    		}
    	}
    	: function isRegex(value) {
    		// In older browsers, typeof regex incorrectly returns 'function'
    		if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
    			return false;
    		}

    		return $toString(value) === regexClass;
    	};

    // http://262.ecma-international.org/5.1/#sec-9.2

    var ToBoolean = function ToBoolean(value) { return !!value; };

    var $match = getIntrinsic('%Symbol.match%', true);





    // https://ecma-international.org/ecma-262/6.0/#sec-isregexp

    var IsRegExp = function IsRegExp(argument) {
    	if (!argument || typeof argument !== 'object') {
    		return false;
    	}
    	if ($match) {
    		var isRegExp = argument[$match];
    		if (typeof isRegExp !== 'undefined') {
    			return ToBoolean(isRegExp);
    		}
    	}
    	return isRegex(argument);
    };

    var fnToStr = Function.prototype.toString;
    var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
    var badArrayLike;
    var isCallableMarker;
    if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
    	try {
    		badArrayLike = Object.defineProperty({}, 'length', {
    			get: function () {
    				throw isCallableMarker;
    			}
    		});
    		isCallableMarker = {};
    		// eslint-disable-next-line no-throw-literal
    		reflectApply(function () { throw 42; }, null, badArrayLike);
    	} catch (_) {
    		if (_ !== isCallableMarker) {
    			reflectApply = null;
    		}
    	}
    } else {
    	reflectApply = null;
    }

    var constructorRegex = /^\s*class\b/;
    var isES6ClassFn = function isES6ClassFunction(value) {
    	try {
    		var fnStr = fnToStr.call(value);
    		return constructorRegex.test(fnStr);
    	} catch (e) {
    		return false; // not a function
    	}
    };

    var tryFunctionObject = function tryFunctionToStr(value) {
    	try {
    		if (isES6ClassFn(value)) { return false; }
    		fnToStr.call(value);
    		return true;
    	} catch (e) {
    		return false;
    	}
    };
    var toStr$5 = Object.prototype.toString;
    var fnClass = '[object Function]';
    var genClass = '[object GeneratorFunction]';
    var hasToStringTag$1 = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
    /* globals document: false */
    var documentDotAll = typeof document === 'object' && typeof document.all === 'undefined' && document.all !== undefined ? document.all : {};

    var isCallable = reflectApply
    	? function isCallable(value) {
    		if (value === documentDotAll) { return true; }
    		if (!value) { return false; }
    		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
    		if (typeof value === 'function' && !value.prototype) { return true; }
    		try {
    			reflectApply(value, null, badArrayLike);
    		} catch (e) {
    			if (e !== isCallableMarker) { return false; }
    		}
    		return !isES6ClassFn(value);
    	}
    	: function isCallable(value) {
    		if (value === documentDotAll) { return true; }
    		if (!value) { return false; }
    		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
    		if (typeof value === 'function' && !value.prototype) { return true; }
    		if (hasToStringTag$1) { return tryFunctionObject(value); }
    		if (isES6ClassFn(value)) { return false; }
    		var strClass = toStr$5.call(value);
    		return strClass === fnClass || strClass === genClass;
    	};

    // http://262.ecma-international.org/5.1/#sec-9.11

    var IsCallable = isCallable;

    var $TypeError$5 = getIntrinsic('%TypeError%');





    // https://262.ecma-international.org/5.1/#sec-8.10.5

    var ToPropertyDescriptor = function ToPropertyDescriptor(Obj) {
    	if (Type$1(Obj) !== 'Object') {
    		throw new $TypeError$5('ToPropertyDescriptor requires an object');
    	}

    	var desc = {};
    	if (src(Obj, 'enumerable')) {
    		desc['[[Enumerable]]'] = ToBoolean(Obj.enumerable);
    	}
    	if (src(Obj, 'configurable')) {
    		desc['[[Configurable]]'] = ToBoolean(Obj.configurable);
    	}
    	if (src(Obj, 'value')) {
    		desc['[[Value]]'] = Obj.value;
    	}
    	if (src(Obj, 'writable')) {
    		desc['[[Writable]]'] = ToBoolean(Obj.writable);
    	}
    	if (src(Obj, 'get')) {
    		var getter = Obj.get;
    		if (typeof getter !== 'undefined' && !IsCallable(getter)) {
    			throw new $TypeError$5('getter must be a function');
    		}
    		desc['[[Get]]'] = getter;
    	}
    	if (src(Obj, 'set')) {
    		var setter = Obj.set;
    		if (typeof setter !== 'undefined' && !IsCallable(setter)) {
    			throw new $TypeError$5('setter must be a function');
    		}
    		desc['[[Set]]'] = setter;
    	}

    	if ((src(desc, '[[Get]]') || src(desc, '[[Set]]')) && (src(desc, '[[Value]]') || src(desc, '[[Writable]]'))) {
    		throw new $TypeError$5('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
    	}
    	return desc;
    };

    var $TypeError$6 = getIntrinsic('%TypeError%');



    var $isEnumerable$1 = callBound('Object.prototype.propertyIsEnumerable');









    // https://ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty

    var OrdinaryGetOwnProperty = function OrdinaryGetOwnProperty(O, P) {
    	if (Type$1(O) !== 'Object') {
    		throw new $TypeError$6('Assertion failed: O must be an Object');
    	}
    	if (!IsPropertyKey(P)) {
    		throw new $TypeError$6('Assertion failed: P must be a Property Key');
    	}
    	if (!src(O, P)) {
    		return void 0;
    	}
    	if (!getOwnPropertyDescriptor) {
    		// ES3 / IE 8 fallback
    		var arrayLength = IsArray(O) && P === 'length';
    		var regexLastIndex = IsRegExp(O) && P === 'lastIndex';
    		return {
    			'[[Configurable]]': !(arrayLength || regexLastIndex),
    			'[[Enumerable]]': $isEnumerable$1(O, P),
    			'[[Value]]': O[P],
    			'[[Writable]]': true
    		};
    	}
    	return ToPropertyDescriptor(getOwnPropertyDescriptor(O, P));
    };

    // https://ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor

    var IsDataDescriptor = function IsDataDescriptor(Desc) {
    	if (typeof Desc === 'undefined') {
    		return false;
    	}

    	assertRecord(Type$1, 'Property Descriptor', 'Desc', Desc);

    	if (!src(Desc, '[[Value]]') && !src(Desc, '[[Writable]]')) {
    		return false;
    	}

    	return true;
    };

    var isPrimitive = function isPrimitive(value) {
    	return value === null || (typeof value !== 'function' && typeof value !== 'object');
    };

    var $Object = getIntrinsic('%Object%');



    var $preventExtensions = $Object.preventExtensions;
    var $isExtensible = $Object.isExtensible;

    // https://ecma-international.org/ecma-262/6.0/#sec-isextensible-o

    var IsExtensible = $preventExtensions
    	? function IsExtensible(obj) {
    		return !isPrimitive(obj) && $isExtensible(obj);
    	}
    	: function IsExtensible(obj) {
    		return !isPrimitive(obj);
    	};

    // http://262.ecma-international.org/5.1/#sec-9.12

    var SameValue = function SameValue(x, y) {
    	if (x === y) { // 0 === -0, but they are not identical.
    		if (x === 0) { return 1 / x === 1 / y; }
    		return true;
    	}
    	return _isNaN(x) && _isNaN(y);
    };

    var $TypeError$7 = getIntrinsic('%TypeError%');











    // https://ecma-international.org/ecma-262/6.0/#sec-createdataproperty

    var CreateDataProperty = function CreateDataProperty(O, P, V) {
    	if (Type$1(O) !== 'Object') {
    		throw new $TypeError$7('Assertion failed: Type(O) is not Object');
    	}
    	if (!IsPropertyKey(P)) {
    		throw new $TypeError$7('Assertion failed: IsPropertyKey(P) is not true');
    	}
    	var oldDesc = OrdinaryGetOwnProperty(O, P);
    	var extensible = !oldDesc || IsExtensible(O);
    	var immutable = oldDesc && (!oldDesc['[[Writable]]'] || !oldDesc['[[Configurable]]']);
    	if (immutable || !extensible) {
    		return false;
    	}
    	return DefineOwnProperty(
    		IsDataDescriptor,
    		SameValue,
    		FromPropertyDescriptor,
    		O,
    		P,
    		{
    			'[[Configurable]]': true,
    			'[[Enumerable]]': true,
    			'[[Value]]': V,
    			'[[Writable]]': true
    		}
    	);
    };

    var $TypeError$8 = getIntrinsic('%TypeError%');





    // // https://ecma-international.org/ecma-262/6.0/#sec-createdatapropertyorthrow

    var CreateDataPropertyOrThrow = function CreateDataPropertyOrThrow(O, P, V) {
    	if (Type$1(O) !== 'Object') {
    		throw new $TypeError$8('Assertion failed: Type(O) is not Object');
    	}
    	if (!IsPropertyKey(P)) {
    		throw new $TypeError$8('Assertion failed: IsPropertyKey(P) is not true');
    	}
    	var success = CreateDataProperty(O, P, V);
    	if (!success) {
    		throw new $TypeError$8('unable to create data property');
    	}
    	return success;
    };

    var $TypeError$9 = getIntrinsic('%TypeError%');

    // http://262.ecma-international.org/5.1/#sec-9.10

    var CheckObjectCoercible = function CheckObjectCoercible(value, optMessage) {
    	if (value == null) {
    		throw new $TypeError$9(optMessage || ('Cannot call method on ' + value));
    	}
    	return value;
    };

    var RequireObjectCoercible = CheckObjectCoercible;

    var $Object$1 = getIntrinsic('%Object%');



    // https://ecma-international.org/ecma-262/6.0/#sec-toobject

    var ToObject = function ToObject(value) {
    	RequireObjectCoercible(value);
    	return $Object$1(value);
    };

    var $TypeError$a = getIntrinsic('%TypeError%');




    /**
     * 7.3.2 GetV (V, P)
     * 1. Assert: IsPropertyKey(P) is true.
     * 2. Let O be ToObject(V).
     * 3. ReturnIfAbrupt(O).
     * 4. Return O.[[Get]](P, V).
     */

    var GetV = function GetV(V, P) {
    	// 7.3.2.1
    	if (!IsPropertyKey(P)) {
    		throw new $TypeError$a('Assertion failed: IsPropertyKey(P) is not true');
    	}

    	// 7.3.2.2-3
    	var O = ToObject(V);

    	// 7.3.2.4
    	return O[P];
    };

    var $TypeError$b = getIntrinsic('%TypeError%');





    /**
     * 7.3.9 - https://ecma-international.org/ecma-262/6.0/#sec-getmethod
     * 1. Assert: IsPropertyKey(P) is true.
     * 2. Let func be GetV(O, P).
     * 3. ReturnIfAbrupt(func).
     * 4. If func is either undefined or null, return undefined.
     * 5. If IsCallable(func) is false, throw a TypeError exception.
     * 6. Return func.
     */

    var GetMethod = function GetMethod(O, P) {
    	// 7.3.9.1
    	if (!IsPropertyKey(P)) {
    		throw new $TypeError$b('Assertion failed: IsPropertyKey(P) is not true');
    	}

    	// 7.3.9.2
    	var func = GetV(O, P);

    	// 7.3.9.4
    	if (func == null) {
    		return void 0;
    	}

    	// 7.3.9.5
    	if (!IsCallable(func)) {
    		throw new $TypeError$b(P + 'is not a function');
    	}

    	// 7.3.9.6
    	return func;
    };

    var isBufferBrowser = function isBuffer(arg) {
      return arg && typeof arg === 'object'
        && typeof arg.copy === 'function'
        && typeof arg.fill === 'function'
        && typeof arg.readUInt8 === 'function';
    };

    var inherits_browser = createCommonjsModule(function (module) {
    if (typeof Object.create === 'function') {
      // implementation from standard node.js 'util' module
      module.exports = function inherits(ctor, superCtor) {
        ctor.super_ = superCtor;
        ctor.prototype = Object.create(superCtor.prototype, {
          constructor: {
            value: ctor,
            enumerable: false,
            writable: true,
            configurable: true
          }
        });
      };
    } else {
      // old school shim for old browsers
      module.exports = function inherits(ctor, superCtor) {
        ctor.super_ = superCtor;
        var TempCtor = function () {};
        TempCtor.prototype = superCtor.prototype;
        ctor.prototype = new TempCtor();
        ctor.prototype.constructor = ctor;
      };
    }
    });

    var util = createCommonjsModule(function (module, exports) {
    // Copyright Joyent, Inc. and other Node contributors.
    //
    // Permission is hereby granted, free of charge, to any person obtaining a
    // copy of this software and associated documentation files (the
    // "Software"), to deal in the Software without restriction, including
    // without limitation the rights to use, copy, modify, merge, publish,
    // distribute, sublicense, and/or sell copies of the Software, and to permit
    // persons to whom the Software is furnished to do so, subject to the
    // following conditions:
    //
    // The above copyright notice and this permission notice shall be included
    // in all copies or substantial portions of the Software.
    //
    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
    // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
    // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
    // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
    // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
    // USE OR OTHER DEALINGS IN THE SOFTWARE.

    var formatRegExp = /%[sdj%]/g;
    exports.format = function(f) {
      if (!isString(f)) {
        var objects = [];
        for (var i = 0; i < arguments.length; i++) {
          objects.push(inspect(arguments[i]));
        }
        return objects.join(' ');
      }

      var i = 1;
      var args = arguments;
      var len = args.length;
      var str = String(f).replace(formatRegExp, function(x) {
        if (x === '%%') return '%';
        if (i >= len) return x;
        switch (x) {
          case '%s': return String(args[i++]);
          case '%d': return Number(args[i++]);
          case '%j':
            try {
              return JSON.stringify(args[i++]);
            } catch (_) {
              return '[Circular]';
            }
          default:
            return x;
        }
      });
      for (var x = args[i]; i < len; x = args[++i]) {
        if (isNull(x) || !isObject(x)) {
          str += ' ' + x;
        } else {
          str += ' ' + inspect(x);
        }
      }
      return str;
    };


    // Mark that a method should not be used.
    // Returns a modified function which warns once by default.
    // If --no-deprecation is set, then it is a no-op.
    exports.deprecate = function(fn, msg) {
      // Allow for deprecating things in the process of starting up.
      if (isUndefined(commonjsGlobal.process)) {
        return function() {
          return exports.deprecate(fn, msg).apply(this, arguments);
        };
      }

      var warned = false;
      function deprecated() {
        if (!warned) {
          {
            console.error(msg);
          }
          warned = true;
        }
        return fn.apply(this, arguments);
      }

      return deprecated;
    };


    var debugs = {};
    var debugEnviron;
    exports.debuglog = function(set) {
      if (isUndefined(debugEnviron))
        debugEnviron = '';
      set = set.toUpperCase();
      if (!debugs[set]) {
        if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
          var pid = process.pid;
          debugs[set] = function() {
            var msg = exports.format.apply(exports, arguments);
            console.error('%s %d: %s', set, pid, msg);
          };
        } else {
          debugs[set] = function() {};
        }
      }
      return debugs[set];
    };


    /**
     * Echos the value of a value. Trys to print the value out
     * in the best way possible given the different types.
     *
     * @param {Object} obj The object to print out.
     * @param {Object} opts Optional options object that alters the output.
     */
    /* legacy: obj, showHidden, depth, colors*/
    function inspect(obj, opts) {
      // default options
      var ctx = {
        seen: [],
        stylize: stylizeNoColor
      };
      // legacy...
      if (arguments.length >= 3) ctx.depth = arguments[2];
      if (arguments.length >= 4) ctx.colors = arguments[3];
      if (isBoolean(opts)) {
        // legacy...
        ctx.showHidden = opts;
      } else if (opts) {
        // got an "options" object
        exports._extend(ctx, opts);
      }
      // set default options
      if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
      if (isUndefined(ctx.depth)) ctx.depth = 2;
      if (isUndefined(ctx.colors)) ctx.colors = false;
      if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
      if (ctx.colors) ctx.stylize = stylizeWithColor;
      return formatValue(ctx, obj, ctx.depth);
    }
    exports.inspect = inspect;


    // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
    inspect.colors = {
      'bold' : [1, 22],
      'italic' : [3, 23],
      'underline' : [4, 24],
      'inverse' : [7, 27],
      'white' : [37, 39],
      'grey' : [90, 39],
      'black' : [30, 39],
      'blue' : [34, 39],
      'cyan' : [36, 39],
      'green' : [32, 39],
      'magenta' : [35, 39],
      'red' : [31, 39],
      'yellow' : [33, 39]
    };

    // Don't use 'blue' not visible on cmd.exe
    inspect.styles = {
      'special': 'cyan',
      'number': 'yellow',
      'boolean': 'yellow',
      'undefined': 'grey',
      'null': 'bold',
      'string': 'green',
      'date': 'magenta',
      // "name": intentionally not styling
      'regexp': 'red'
    };


    function stylizeWithColor(str, styleType) {
      var style = inspect.styles[styleType];

      if (style) {
        return '\u001b[' + inspect.colors[style][0] + 'm' + str +
               '\u001b[' + inspect.colors[style][1] + 'm';
      } else {
        return str;
      }
    }


    function stylizeNoColor(str, styleType) {
      return str;
    }


    function arrayToHash(array) {
      var hash = {};

      array.forEach(function(val, idx) {
        hash[val] = true;
      });

      return hash;
    }


    function formatValue(ctx, value, recurseTimes) {
      // Provide a hook for user-specified inspect functions.
      // Check that value is an object with an inspect function on it
      if (ctx.customInspect &&
          value &&
          isFunction(value.inspect) &&
          // Filter out the util module, it's inspect function is special
          value.inspect !== exports.inspect &&
          // Also filter out any prototype objects using the circular check.
          !(value.constructor && value.constructor.prototype === value)) {
        var ret = value.inspect(recurseTimes, ctx);
        if (!isString(ret)) {
          ret = formatValue(ctx, ret, recurseTimes);
        }
        return ret;
      }

      // Primitive types cannot have properties
      var primitive = formatPrimitive(ctx, value);
      if (primitive) {
        return primitive;
      }

      // Look up the keys of the object.
      var keys = Object.keys(value);
      var visibleKeys = arrayToHash(keys);

      if (ctx.showHidden) {
        keys = Object.getOwnPropertyNames(value);
      }

      // IE doesn't make error fields non-enumerable
      // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
      if (isError(value)
          && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
        return formatError(value);
      }

      // Some type of object without properties can be shortcutted.
      if (keys.length === 0) {
        if (isFunction(value)) {
          var name = value.name ? ': ' + value.name : '';
          return ctx.stylize('[Function' + name + ']', 'special');
        }
        if (isRegExp(value)) {
          return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
        }
        if (isDate(value)) {
          return ctx.stylize(Date.prototype.toString.call(value), 'date');
        }
        if (isError(value)) {
          return formatError(value);
        }
      }

      var base = '', array = false, braces = ['{', '}'];

      // Make Array say that they are Array
      if (isArray(value)) {
        array = true;
        braces = ['[', ']'];
      }

      // Make functions say that they are functions
      if (isFunction(value)) {
        var n = value.name ? ': ' + value.name : '';
        base = ' [Function' + n + ']';
      }

      // Make RegExps say that they are RegExps
      if (isRegExp(value)) {
        base = ' ' + RegExp.prototype.toString.call(value);
      }

      // Make dates with properties first say the date
      if (isDate(value)) {
        base = ' ' + Date.prototype.toUTCString.call(value);
      }

      // Make error with message first say the error
      if (isError(value)) {
        base = ' ' + formatError(value);
      }

      if (keys.length === 0 && (!array || value.length == 0)) {
        return braces[0] + base + braces[1];
      }

      if (recurseTimes < 0) {
        if (isRegExp(value)) {
          return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
        } else {
          return ctx.stylize('[Object]', 'special');
        }
      }

      ctx.seen.push(value);

      var output;
      if (array) {
        output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
      } else {
        output = keys.map(function(key) {
          return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
        });
      }

      ctx.seen.pop();

      return reduceToSingleString(output, base, braces);
    }


    function formatPrimitive(ctx, value) {
      if (isUndefined(value))
        return ctx.stylize('undefined', 'undefined');
      if (isString(value)) {
        var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                                                 .replace(/'/g, "\\'")
                                                 .replace(/\\"/g, '"') + '\'';
        return ctx.stylize(simple, 'string');
      }
      if (isNumber(value))
        return ctx.stylize('' + value, 'number');
      if (isBoolean(value))
        return ctx.stylize('' + value, 'boolean');
      // For some reason typeof null is "object", so special case here.
      if (isNull(value))
        return ctx.stylize('null', 'null');
    }


    function formatError(value) {
      return '[' + Error.prototype.toString.call(value) + ']';
    }


    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
      var output = [];
      for (var i = 0, l = value.length; i < l; ++i) {
        if (hasOwnProperty(value, String(i))) {
          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
              String(i), true));
        } else {
          output.push('');
        }
      }
      keys.forEach(function(key) {
        if (!key.match(/^\d+$/)) {
          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
              key, true));
        }
      });
      return output;
    }


    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
      var name, str, desc;
      desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
      if (desc.get) {
        if (desc.set) {
          str = ctx.stylize('[Getter/Setter]', 'special');
        } else {
          str = ctx.stylize('[Getter]', 'special');
        }
      } else {
        if (desc.set) {
          str = ctx.stylize('[Setter]', 'special');
        }
      }
      if (!hasOwnProperty(visibleKeys, key)) {
        name = '[' + key + ']';
      }
      if (!str) {
        if (ctx.seen.indexOf(desc.value) < 0) {
          if (isNull(recurseTimes)) {
            str = formatValue(ctx, desc.value, null);
          } else {
            str = formatValue(ctx, desc.value, recurseTimes - 1);
          }
          if (str.indexOf('\n') > -1) {
            if (array) {
              str = str.split('\n').map(function(line) {
                return '  ' + line;
              }).join('\n').substr(2);
            } else {
              str = '\n' + str.split('\n').map(function(line) {
                return '   ' + line;
              }).join('\n');
            }
          }
        } else {
          str = ctx.stylize('[Circular]', 'special');
        }
      }
      if (isUndefined(name)) {
        if (array && key.match(/^\d+$/)) {
          return str;
        }
        name = JSON.stringify('' + key);
        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
          name = name.substr(1, name.length - 2);
          name = ctx.stylize(name, 'name');
        } else {
          name = name.replace(/'/g, "\\'")
                     .replace(/\\"/g, '"')
                     .replace(/(^"|"$)/g, "'");
          name = ctx.stylize(name, 'string');
        }
      }

      return name + ': ' + str;
    }


    function reduceToSingleString(output, base, braces) {
      var length = output.reduce(function(prev, cur) {
        if (cur.indexOf('\n') >= 0) ;
        return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
      }, 0);

      if (length > 60) {
        return braces[0] +
               (base === '' ? '' : base + '\n ') +
               ' ' +
               output.join(',\n  ') +
               ' ' +
               braces[1];
      }

      return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
    }


    // NOTE: These type checking functions intentionally don't use `instanceof`
    // because it is fragile and can be easily faked with `Object.create()`.
    function isArray(ar) {
      return Array.isArray(ar);
    }
    exports.isArray = isArray;

    function isBoolean(arg) {
      return typeof arg === 'boolean';
    }
    exports.isBoolean = isBoolean;

    function isNull(arg) {
      return arg === null;
    }
    exports.isNull = isNull;

    function isNullOrUndefined(arg) {
      return arg == null;
    }
    exports.isNullOrUndefined = isNullOrUndefined;

    function isNumber(arg) {
      return typeof arg === 'number';
    }
    exports.isNumber = isNumber;

    function isString(arg) {
      return typeof arg === 'string';
    }
    exports.isString = isString;

    function isSymbol(arg) {
      return typeof arg === 'symbol';
    }
    exports.isSymbol = isSymbol;

    function isUndefined(arg) {
      return arg === void 0;
    }
    exports.isUndefined = isUndefined;

    function isRegExp(re) {
      return isObject(re) && objectToString(re) === '[object RegExp]';
    }
    exports.isRegExp = isRegExp;

    function isObject(arg) {
      return typeof arg === 'object' && arg !== null;
    }
    exports.isObject = isObject;

    function isDate(d) {
      return isObject(d) && objectToString(d) === '[object Date]';
    }
    exports.isDate = isDate;

    function isError(e) {
      return isObject(e) &&
          (objectToString(e) === '[object Error]' || e instanceof Error);
    }
    exports.isError = isError;

    function isFunction(arg) {
      return typeof arg === 'function';
    }
    exports.isFunction = isFunction;

    function isPrimitive(arg) {
      return arg === null ||
             typeof arg === 'boolean' ||
             typeof arg === 'number' ||
             typeof arg === 'string' ||
             typeof arg === 'symbol' ||  // ES6 symbol
             typeof arg === 'undefined';
    }
    exports.isPrimitive = isPrimitive;

    exports.isBuffer = isBufferBrowser;

    function objectToString(o) {
      return Object.prototype.toString.call(o);
    }


    function pad(n) {
      return n < 10 ? '0' + n.toString(10) : n.toString(10);
    }


    var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
                  'Oct', 'Nov', 'Dec'];

    // 26 Feb 16:19:34
    function timestamp() {
      var d = new Date();
      var time = [pad(d.getHours()),
                  pad(d.getMinutes()),
                  pad(d.getSeconds())].join(':');
      return [d.getDate(), months[d.getMonth()], time].join(' ');
    }


    // log is just a thin wrapper to console.log that prepends a timestamp
    exports.log = function() {
      console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
    };


    /**
     * Inherit the prototype methods from one constructor into another.
     *
     * The Function.prototype.inherits from lang.js rewritten as a standalone
     * function (not on Function.prototype). NOTE: If this file is to be loaded
     * during bootstrapping this function needs to be rewritten using some native
     * functions as prototype setup using normal JavaScript does not work as
     * expected during bootstrapping (see mirror.js in r114903).
     *
     * @param {function} ctor Constructor function which needs to inherit the
     *     prototype.
     * @param {function} superCtor Constructor function to inherit prototype from.
     */
    exports.inherits = inherits_browser;

    exports._extend = function(origin, add) {
      // Don't do anything if add isn't an object
      if (!add || !isObject(add)) return origin;

      var keys = Object.keys(add);
      var i = keys.length;
      while (i--) {
        origin[keys[i]] = add[keys[i]];
      }
      return origin;
    };

    function hasOwnProperty(obj, prop) {
      return Object.prototype.hasOwnProperty.call(obj, prop);
    }
    });
    var util_1 = util.format;
    var util_2 = util.deprecate;
    var util_3 = util.debuglog;
    var util_4 = util.inspect;
    var util_5 = util.isArray;
    var util_6 = util.isBoolean;
    var util_7 = util.isNull;
    var util_8 = util.isNullOrUndefined;
    var util_9 = util.isNumber;
    var util_10 = util.isString;
    var util_11 = util.isSymbol;
    var util_12 = util.isUndefined;
    var util_13 = util.isRegExp;
    var util_14 = util.isObject;
    var util_15 = util.isDate;
    var util_16 = util.isError;
    var util_17 = util.isFunction;
    var util_18 = util.isPrimitive;
    var util_19 = util.isBuffer;
    var util_20 = util.log;
    var util_21 = util.inherits;
    var util_22 = util._extend;

    var util_inspect = util.inspect;

    var hasMap = typeof Map === 'function' && Map.prototype;
    var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
    var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
    var mapForEach = hasMap && Map.prototype.forEach;
    var hasSet = typeof Set === 'function' && Set.prototype;
    var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
    var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
    var setForEach = hasSet && Set.prototype.forEach;
    var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
    var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
    var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
    var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
    var hasWeakRef = typeof WeakRef === 'function' && WeakRef.prototype;
    var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
    var booleanValueOf = Boolean.prototype.valueOf;
    var objectToString = Object.prototype.toString;
    var functionToString = Function.prototype.toString;
    var match = String.prototype.match;
    var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
    var gOPS = Object.getOwnPropertySymbols;
    var symToString = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol.prototype.toString : null;
    var hasShammedSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'object';
    var isEnumerable$1 = Object.prototype.propertyIsEnumerable;

    var gPO = (typeof Reflect === 'function' ? Reflect.getPrototypeOf : Object.getPrototypeOf) || (
        [].__proto__ === Array.prototype // eslint-disable-line no-proto
            ? function (O) {
                return O.__proto__; // eslint-disable-line no-proto
            }
            : null
    );

    var inspectCustom = util_inspect.custom;
    var inspectSymbol = inspectCustom && isSymbol(inspectCustom) ? inspectCustom : null;
    var toStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag !== 'undefined' ? Symbol.toStringTag : null;

    var objectInspect = function inspect_(obj, options, depth, seen) {
        var opts = options || {};

        if (has$2(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {
            throw new TypeError('option "quoteStyle" must be "single" or "double"');
        }
        if (
            has$2(opts, 'maxStringLength') && (typeof opts.maxStringLength === 'number'
                ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity
                : opts.maxStringLength !== null
            )
        ) {
            throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
        }
        var customInspect = has$2(opts, 'customInspect') ? opts.customInspect : true;
        if (typeof customInspect !== 'boolean' && customInspect !== 'symbol') {
            throw new TypeError('option "customInspect", if provided, must be `true`, `false`, or `\'symbol\'`');
        }

        if (
            has$2(opts, 'indent')
            && opts.indent !== null
            && opts.indent !== '\t'
            && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)
        ) {
            throw new TypeError('options "indent" must be "\\t", an integer > 0, or `null`');
        }

        if (typeof obj === 'undefined') {
            return 'undefined';
        }
        if (obj === null) {
            return 'null';
        }
        if (typeof obj === 'boolean') {
            return obj ? 'true' : 'false';
        }

        if (typeof obj === 'string') {
            return inspectString(obj, opts);
        }
        if (typeof obj === 'number') {
            if (obj === 0) {
                return Infinity / obj > 0 ? '0' : '-0';
            }
            return String(obj);
        }
        if (typeof obj === 'bigint') {
            return String(obj) + 'n';
        }

        var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
        if (typeof depth === 'undefined') { depth = 0; }
        if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
            return isArray$1(obj) ? '[Array]' : '[Object]';
        }

        var indent = getIndent(opts, depth);

        if (typeof seen === 'undefined') {
            seen = [];
        } else if (indexOf(seen, obj) >= 0) {
            return '[Circular]';
        }

        function inspect(value, from, noIndent) {
            if (from) {
                seen = seen.slice();
                seen.push(from);
            }
            if (noIndent) {
                var newOpts = {
                    depth: opts.depth
                };
                if (has$2(opts, 'quoteStyle')) {
                    newOpts.quoteStyle = opts.quoteStyle;
                }
                return inspect_(value, newOpts, depth + 1, seen);
            }
            return inspect_(value, opts, depth + 1, seen);
        }

        if (typeof obj === 'function') {
            var name = nameOf(obj);
            var keys = arrObjKeys(obj, inspect);
            return '[Function' + (name ? ': ' + name : ' (anonymous)') + ']' + (keys.length > 0 ? ' { ' + keys.join(', ') + ' }' : '');
        }
        if (isSymbol(obj)) {
            var symString = hasShammedSymbols ? String(obj).replace(/^(Symbol\(.*\))_[^)]*$/, '$1') : symToString.call(obj);
            return typeof obj === 'object' && !hasShammedSymbols ? markBoxed(symString) : symString;
        }
        if (isElement(obj)) {
            var s = '<' + String(obj.nodeName).toLowerCase();
            var attrs = obj.attributes || [];
            for (var i = 0; i < attrs.length; i++) {
                s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);
            }
            s += '>';
            if (obj.childNodes && obj.childNodes.length) { s += '...'; }
            s += '</' + String(obj.nodeName).toLowerCase() + '>';
            return s;
        }
        if (isArray$1(obj)) {
            if (obj.length === 0) { return '[]'; }
            var xs = arrObjKeys(obj, inspect);
            if (indent && !singleLineValues(xs)) {
                return '[' + indentedJoin(xs, indent) + ']';
            }
            return '[ ' + xs.join(', ') + ' ]';
        }
        if (isError(obj)) {
            var parts = arrObjKeys(obj, inspect);
            if (parts.length === 0) { return '[' + String(obj) + ']'; }
            return '{ [' + String(obj) + '] ' + parts.join(', ') + ' }';
        }
        if (typeof obj === 'object' && customInspect) {
            if (inspectSymbol && typeof obj[inspectSymbol] === 'function') {
                return obj[inspectSymbol]();
            } else if (customInspect !== 'symbol' && typeof obj.inspect === 'function') {
                return obj.inspect();
            }
        }
        if (isMap(obj)) {
            var mapParts = [];
            mapForEach.call(obj, function (value, key) {
                mapParts.push(inspect(key, obj, true) + ' => ' + inspect(value, obj));
            });
            return collectionOf('Map', mapSize.call(obj), mapParts, indent);
        }
        if (isSet(obj)) {
            var setParts = [];
            setForEach.call(obj, function (value) {
                setParts.push(inspect(value, obj));
            });
            return collectionOf('Set', setSize.call(obj), setParts, indent);
        }
        if (isWeakMap(obj)) {
            return weakCollectionOf('WeakMap');
        }
        if (isWeakSet(obj)) {
            return weakCollectionOf('WeakSet');
        }
        if (isWeakRef(obj)) {
            return weakCollectionOf('WeakRef');
        }
        if (isNumber$1(obj)) {
            return markBoxed(inspect(Number(obj)));
        }
        if (isBigInt(obj)) {
            return markBoxed(inspect(bigIntValueOf.call(obj)));
        }
        if (isBoolean(obj)) {
            return markBoxed(booleanValueOf.call(obj));
        }
        if (isString$1(obj)) {
            return markBoxed(inspect(String(obj)));
        }
        if (!isDate$1(obj) && !isRegExp(obj)) {
            var ys = arrObjKeys(obj, inspect);
            var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
            var protoTag = obj instanceof Object ? '' : 'null prototype';
            var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? toStr$6(obj).slice(8, -1) : protoTag ? 'Object' : '';
            var constructorTag = isPlainObject || typeof obj.constructor !== 'function' ? '' : obj.constructor.name ? obj.constructor.name + ' ' : '';
            var tag = constructorTag + (stringTag || protoTag ? '[' + [].concat(stringTag || [], protoTag || []).join(': ') + '] ' : '');
            if (ys.length === 0) { return tag + '{}'; }
            if (indent) {
                return tag + '{' + indentedJoin(ys, indent) + '}';
            }
            return tag + '{ ' + ys.join(', ') + ' }';
        }
        return String(obj);
    };

    function wrapQuotes(s, defaultStyle, opts) {
        var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'";
        return quoteChar + s + quoteChar;
    }

    function quote(s) {
        return String(s).replace(/"/g, '&quot;');
    }

    function isArray$1(obj) { return toStr$6(obj) === '[object Array]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
    function isDate$1(obj) { return toStr$6(obj) === '[object Date]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
    function isRegExp(obj) { return toStr$6(obj) === '[object RegExp]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
    function isError(obj) { return toStr$6(obj) === '[object Error]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
    function isString$1(obj) { return toStr$6(obj) === '[object String]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
    function isNumber$1(obj) { return toStr$6(obj) === '[object Number]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }
    function isBoolean(obj) { return toStr$6(obj) === '[object Boolean]' && (!toStringTag || !(typeof obj === 'object' && toStringTag in obj)); }

    // Symbol and BigInt do have Symbol.toStringTag by spec, so that can't be used to eliminate false positives
    function isSymbol(obj) {
        if (hasShammedSymbols) {
            return obj && typeof obj === 'object' && obj instanceof Symbol;
        }
        if (typeof obj === 'symbol') {
            return true;
        }
        if (!obj || typeof obj !== 'object' || !symToString) {
            return false;
        }
        try {
            symToString.call(obj);
            return true;
        } catch (e) {}
        return false;
    }

    function isBigInt(obj) {
        if (!obj || typeof obj !== 'object' || !bigIntValueOf) {
            return false;
        }
        try {
            bigIntValueOf.call(obj);
            return true;
        } catch (e) {}
        return false;
    }

    var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };
    function has$2(obj, key) {
        return hasOwn.call(obj, key);
    }

    function toStr$6(obj) {
        return objectToString.call(obj);
    }

    function nameOf(f) {
        if (f.name) { return f.name; }
        var m = match.call(functionToString.call(f), /^function\s*([\w$]+)/);
        if (m) { return m[1]; }
        return null;
    }

    function indexOf(xs, x) {
        if (xs.indexOf) { return xs.indexOf(x); }
        for (var i = 0, l = xs.length; i < l; i++) {
            if (xs[i] === x) { return i; }
        }
        return -1;
    }

    function isMap(x) {
        if (!mapSize || !x || typeof x !== 'object') {
            return false;
        }
        try {
            mapSize.call(x);
            try {
                setSize.call(x);
            } catch (s) {
                return true;
            }
            return x instanceof Map; // core-js workaround, pre-v2.5.0
        } catch (e) {}
        return false;
    }

    function isWeakMap(x) {
        if (!weakMapHas || !x || typeof x !== 'object') {
            return false;
        }
        try {
            weakMapHas.call(x, weakMapHas);
            try {
                weakSetHas.call(x, weakSetHas);
            } catch (s) {
                return true;
            }
            return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
        } catch (e) {}
        return false;
    }

    function isWeakRef(x) {
        if (!weakRefDeref || !x || typeof x !== 'object') {
            return false;
        }
        try {
            weakRefDeref.call(x);
            return true;
        } catch (e) {}
        return false;
    }

    function isSet(x) {
        if (!setSize || !x || typeof x !== 'object') {
            return false;
        }
        try {
            setSize.call(x);
            try {
                mapSize.call(x);
            } catch (m) {
                return true;
            }
            return x instanceof Set; // core-js workaround, pre-v2.5.0
        } catch (e) {}
        return false;
    }

    function isWeakSet(x) {
        if (!weakSetHas || !x || typeof x !== 'object') {
            return false;
        }
        try {
            weakSetHas.call(x, weakSetHas);
            try {
                weakMapHas.call(x, weakMapHas);
            } catch (s) {
                return true;
            }
            return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
        } catch (e) {}
        return false;
    }

    function isElement(x) {
        if (!x || typeof x !== 'object') { return false; }
        if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
            return true;
        }
        return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
    }

    function inspectString(str, opts) {
        if (str.length > opts.maxStringLength) {
            var remaining = str.length - opts.maxStringLength;
            var trailer = '... ' + remaining + ' more character' + (remaining > 1 ? 's' : '');
            return inspectString(str.slice(0, opts.maxStringLength), opts) + trailer;
        }
        // eslint-disable-next-line no-control-regex
        var s = str.replace(/(['\\])/g, '\\$1').replace(/[\x00-\x1f]/g, lowbyte);
        return wrapQuotes(s, 'single', opts);
    }

    function lowbyte(c) {
        var n = c.charCodeAt(0);
        var x = {
            8: 'b',
            9: 't',
            10: 'n',
            12: 'f',
            13: 'r'
        }[n];
        if (x) { return '\\' + x; }
        return '\\x' + (n < 0x10 ? '0' : '') + n.toString(16).toUpperCase();
    }

    function markBoxed(str) {
        return 'Object(' + str + ')';
    }

    function weakCollectionOf(type) {
        return type + ' { ? }';
    }

    function collectionOf(type, size, entries, indent) {
        var joinedEntries = indent ? indentedJoin(entries, indent) : entries.join(', ');
        return type + ' (' + size + ') {' + joinedEntries + '}';
    }

    function singleLineValues(xs) {
        for (var i = 0; i < xs.length; i++) {
            if (indexOf(xs[i], '\n') >= 0) {
                return false;
            }
        }
        return true;
    }

    function getIndent(opts, depth) {
        var baseIndent;
        if (opts.indent === '\t') {
            baseIndent = '\t';
        } else if (typeof opts.indent === 'number' && opts.indent > 0) {
            baseIndent = Array(opts.indent + 1).join(' ');
        } else {
            return null;
        }
        return {
            base: baseIndent,
            prev: Array(depth + 1).join(baseIndent)
        };
    }

    function indentedJoin(xs, indent) {
        if (xs.length === 0) { return ''; }
        var lineJoiner = '\n' + indent.prev + indent.base;
        return lineJoiner + xs.join(',' + lineJoiner) + '\n' + indent.prev;
    }

    function arrObjKeys(obj, inspect) {
        var isArr = isArray$1(obj);
        var xs = [];
        if (isArr) {
            xs.length = obj.length;
            for (var i = 0; i < obj.length; i++) {
                xs[i] = has$2(obj, i) ? inspect(obj[i], obj) : '';
            }
        }
        var syms = typeof gOPS === 'function' ? gOPS(obj) : [];
        var symMap;
        if (hasShammedSymbols) {
            symMap = {};
            for (var k = 0; k < syms.length; k++) {
                symMap['$' + syms[k]] = syms[k];
            }
        }

        for (var key in obj) { // eslint-disable-line no-restricted-syntax
            if (!has$2(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
            if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
            if (hasShammedSymbols && symMap['$' + key] instanceof Symbol) {
                // this is to prevent shammed Symbols, which are stored as strings, from being included in the string key section
                continue; // eslint-disable-line no-restricted-syntax, no-continue
            } else if ((/[^\w$]/).test(key)) {
                xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
            } else {
                xs.push(key + ': ' + inspect(obj[key], obj));
            }
        }
        if (typeof gOPS === 'function') {
            for (var j = 0; j < syms.length; j++) {
                if (isEnumerable$1.call(obj, syms[j])) {
                    xs.push('[' + inspect(syms[j]) + ']: ' + inspect(obj[syms[j]], obj));
                }
            }
        }
        return xs;
    }

    var hasSymbols$3 = hasSymbols();



    var $iterator = getIntrinsic('%Symbol.iterator%', true);
    var $stringSlice = callBound('String.prototype.slice');

    var getIteratorMethod = function getIteratorMethod(ES, iterable) {
    	var usingIterator;
    	if (hasSymbols$3) {
    		usingIterator = ES.GetMethod(iterable, $iterator);
    	} else if (ES.IsArray(iterable)) {
    		usingIterator = function () {
    			var i = -1;
    			var arr = this; // eslint-disable-line no-invalid-this
    			return {
    				next: function () {
    					i += 1;
    					return {
    						done: i >= arr.length,
    						value: arr[i]
    					};
    				}
    			};
    		};
    	} else if (ES.Type(iterable) === 'String') {
    		usingIterator = function () {
    			var i = 0;
    			return {
    				next: function () {
    					var nextIndex = ES.AdvanceStringIndex(iterable, i, true);
    					var value = $stringSlice(iterable, i, nextIndex);
    					i = nextIndex;
    					return {
    						done: nextIndex > iterable.length,
    						value: value
    					};
    				}
    			};
    		};
    	}
    	return usingIterator;
    };

    var $TypeError$c = getIntrinsic('%TypeError%');



    var $apply = getIntrinsic('%Reflect.apply%', true) || callBound('%Function.prototype.apply%');

    // https://ecma-international.org/ecma-262/6.0/#sec-call

    var Call = function Call(F, V) {
    	var argumentsList = arguments.length > 2 ? arguments[2] : [];
    	if (!IsArray(argumentsList)) {
    		throw new $TypeError$c('Assertion failed: optional `argumentsList`, if provided, must be a List');
    	}
    	return $apply(F, V, argumentsList);
    };

    var $TypeError$d = getIntrinsic('%TypeError%');
    var $asyncIterator = getIntrinsic('%Symbol.asyncIterator%', true);


    var hasSymbols$4 = hasSymbols();








    // https://262.ecma-international.org/9.0/#sec-getiterator
    var GetIterator = function GetIterator(obj, hint, method) {
    	var actualHint = hint;
    	if (arguments.length < 2) {
    		actualHint = 'sync';
    	}
    	if (actualHint !== 'sync' && actualHint !== 'async') {
    		throw new $TypeError$d("Assertion failed: `hint` must be one of 'sync' or 'async', got " + objectInspect(hint));
    	}

    	var actualMethod = method;
    	if (arguments.length < 3) {
    		if (actualHint === 'async') {
    			if (hasSymbols$4 && $asyncIterator) {
    				actualMethod = GetMethod(obj, $asyncIterator);
    			}
    			if (actualMethod === undefined) {
    				throw new $TypeError$d("async from sync iterators aren't currently supported");
    			}
    		} else {
    			actualMethod = getIteratorMethod(
    				{
    					AdvanceStringIndex: AdvanceStringIndex,
    					GetMethod: GetMethod,
    					IsArray: IsArray,
    					Type: Type$1
    				},
    				obj
    			);
    		}
    	}
    	var iterator = Call(actualMethod, obj);
    	if (Type$1(iterator) !== 'Object') {
    		throw new $TypeError$d('iterator must return an object');
    	}

    	return iterator;

    	// TODO: This should return an IteratorRecord
    	/*
    	var nextMethod = GetV(iterator, 'next');
    	return {
    		'[[Iterator]]': iterator,
    		'[[NextMethod]]': nextMethod,
    		'[[Done]]': false
    	};
    	*/
    };

    var $TypeError$e = getIntrinsic('%TypeError%');






    /**
     * 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p
     * 1. Assert: Type(O) is Object.
     * 2. Assert: IsPropertyKey(P) is true.
     * 3. Return O.[[Get]](P, O).
     */

    var Get = function Get(O, P) {
    	// 7.3.1.1
    	if (Type$1(O) !== 'Object') {
    		throw new $TypeError$e('Assertion failed: Type(O) is not Object');
    	}
    	// 7.3.1.2
    	if (!IsPropertyKey(P)) {
    		throw new $TypeError$e('Assertion failed: IsPropertyKey(P) is not true, got ' + objectInspect(P));
    	}
    	// 7.3.1.3
    	return O[P];
    };

    var $TypeError$f = getIntrinsic('%TypeError%');





    // https://ecma-international.org/ecma-262/6.0/#sec-iteratorcomplete

    var IteratorComplete = function IteratorComplete(iterResult) {
    	if (Type$1(iterResult) !== 'Object') {
    		throw new $TypeError$f('Assertion failed: Type(iterResult) is not Object');
    	}
    	return ToBoolean(Get(iterResult, 'done'));
    };

    var $TypeError$g = getIntrinsic('%TypeError%');






    // https://ecma-international.org/ecma-262/6.0/#sec-invoke

    var Invoke = function Invoke(O, P) {
    	if (!IsPropertyKey(P)) {
    		throw new $TypeError$g('Assertion failed: P must be a Property Key');
    	}
    	var argumentsList = arguments.length > 2 ? arguments[2] : [];
    	if (!IsArray(argumentsList)) {
    		throw new $TypeError$g('Assertion failed: optional `argumentsList`, if provided, must be a List');
    	}
    	var func = GetV(O, P);
    	return Call(func, O, argumentsList);
    };

    var $TypeError$h = getIntrinsic('%TypeError%');




    // https://ecma-international.org/ecma-262/6.0/#sec-iteratornext

    var IteratorNext = function IteratorNext(iterator, value) {
    	var result = Invoke(iterator, 'next', arguments.length < 2 ? [] : [value]);
    	if (Type$1(result) !== 'Object') {
    		throw new $TypeError$h('iterator next must return an object');
    	}
    	return result;
    };

    // https://ecma-international.org/ecma-262/6.0/#sec-iteratorstep

    var IteratorStep = function IteratorStep(iterator) {
    	var result = IteratorNext(iterator);
    	var done = IteratorComplete(result);
    	return done === true ? false : result;
    };

    var $TypeError$i = getIntrinsic('%TypeError%');




    // https://ecma-international.org/ecma-262/6.0/#sec-iteratorvalue

    var IteratorValue = function IteratorValue(iterResult) {
    	if (Type$1(iterResult) !== 'Object') {
    		throw new $TypeError$i('Assertion failed: Type(iterResult) is not Object');
    	}
    	return Get(iterResult, 'value');
    };

    var $arrayPush = callBound('Array.prototype.push');





    // https://262.ecma-international.org/9.0/#sec-iterabletolist

    var IterableToList = function IterableToList(items, method) {
    	var iterator = GetIterator(items, 'sync', method);
    	var values = [];
    	var next = true;
    	while (next) {
    		next = IteratorStep(iterator);
    		if (next) {
    			var nextValue = IteratorValue(next);
    			$arrayPush(values, nextValue);
    		}
    	}
    	return values;
    };

    var originalSetProto = getIntrinsic('%Object.setPrototypeOf%', true);
    var $ArrayProto = getIntrinsic('%Array.prototype%');

    var setProto = originalSetProto || (
    	// eslint-disable-next-line no-proto, no-negated-condition
    	[].__proto__ !== $ArrayProto
    		? null
    		: function (O, proto) {
    			O.__proto__ = proto; // eslint-disable-line no-proto, no-param-reassign
    			return O;
    		}
    );

    var originalGetProto = getIntrinsic('%Object.getPrototypeOf%', true);
    var $ArrayProto$1 = getIntrinsic('%Array.prototype%');

    var getProto$1 = originalGetProto || (
    	// eslint-disable-next-line no-proto
    	[].__proto__ === $ArrayProto$1
    		? function (O) {
    			return O.__proto__; // eslint-disable-line no-proto
    		}
    		: null
    );

    var $TypeError$j = getIntrinsic('%TypeError%');





    // https://262.ecma-international.org/7.0/#sec-ordinarygetprototypeof

    var OrdinaryGetPrototypeOf = function OrdinaryGetPrototypeOf(O) {
    	if (Type$1(O) !== 'Object') {
    		throw new $TypeError$j('Assertion failed: O must be an Object');
    	}
    	if (!getProto$1) {
    		throw new $TypeError$j('This environment does not support fetching prototypes.');
    	}
    	return getProto$1(O);
    };

    var $TypeError$k = getIntrinsic('%TypeError%');






    // https://262.ecma-international.org/7.0/#sec-ordinarysetprototypeof

    var OrdinarySetPrototypeOf = function OrdinarySetPrototypeOf(O, V) {
    	if (Type$1(V) !== 'Object' && Type$1(V) !== 'Null') {
    		throw new $TypeError$k('Assertion failed: V must be Object or Null');
    	}
    	/*
        var extensible = IsExtensible(O);
        var current = OrdinaryGetPrototypeOf(O);
        if (SameValue(V, current)) {
            return true;
        }
        if (!extensible) {
            return false;
        }
        */
    	try {
    		setProto(O, V);
    	} catch (e) {
    		return false;
    	}
    	return OrdinaryGetPrototypeOf(O) === V;
    	/*
        var p = V;
        var done = false;
        while (!done) {
            if (p === null) {
                done = true;
            } else if (SameValue(p, O)) {
                return false;
            } else {
                if (wat) {
                    done = true;
                } else {
                    p = p.[[Prototype]];
                }
            }
         }
         O.[[Prototype]] = V;
         return true;
         */
    };

    var $Error = getIntrinsic('%Error%');

    // eslint-disable-next-line func-style
    function AggregateError$1(errors, message) {
    	var error = new $Error(message);
    	OrdinarySetPrototypeOf(error, proto); // eslint-disable-line no-use-before-define
    	delete error.constructor;

    	var errorsList = IterableToList(errors, getIteratorMethod({
    		AdvanceStringIndex: AdvanceStringIndex,
    		GetMethod: GetMethod,
    		IsArray: IsArray,
    		Type: Type$1
    	}, errors));
    	CreateDataPropertyOrThrow(error, 'errors', errorsList);

    	return error;
    }
    var proto = AggregateError$1.prototype;

    defineProperties_1(AggregateError$1.prototype, {
    	constructor: AggregateError$1,
    	message: '',
    	name: 'AggregateError'
    });

    OrdinarySetPrototypeOf(AggregateError$1.prototype, Error.prototype);

    var implementation$1 = AggregateError$1;

    var polyfill = function getPolyfill() {
    	return typeof AggregateError === 'function' ? AggregateError : implementation$1;
    };

    var $resolve = getIntrinsic('%Promise.resolve%', true);
    var $PromiseResolve = $resolve && callBind($resolve);

    // https://262.ecma-international.org/9.0/#sec-promise-resolve

    var PromiseResolve = function PromiseResolve(C, x) {
    	if (!$PromiseResolve) {
    		throw new SyntaxError('This environment does not support Promises.');
    	}
    	return $PromiseResolve(C, x);
    };

    // https://262.ecma-international.org/5.1/#sec-8

    var Type$2 = function Type(x) {
    	if (x === null) {
    		return 'Null';
    	}
    	if (typeof x === 'undefined') {
    		return 'Undefined';
    	}
    	if (typeof x === 'function' || typeof x === 'object') {
    		return 'Object';
    	}
    	if (typeof x === 'number') {
    		return 'Number';
    	}
    	if (typeof x === 'boolean') {
    		return 'Boolean';
    	}
    	if (typeof x === 'string') {
    		return 'String';
    	}
    };

    // https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values

    var Type$3 = function Type(x) {
    	if (typeof x === 'symbol') {
    		return 'Symbol';
    	}
    	if (typeof x === 'bigint') {
    		return 'BigInt';
    	}
    	return Type$2(x);
    };

    var hasToStringTag$2 = shams$1();


    var $toString$1 = callBound('Object.prototype.toString');

    var isStandardArguments = function isArguments(value) {
    	if (hasToStringTag$2 && value && typeof value === 'object' && Symbol.toStringTag in value) {
    		return false;
    	}
    	return $toString$1(value) === '[object Arguments]';
    };

    var isLegacyArguments = function isArguments(value) {
    	if (isStandardArguments(value)) {
    		return true;
    	}
    	return value !== null &&
    		typeof value === 'object' &&
    		typeof value.length === 'number' &&
    		value.length >= 0 &&
    		$toString$1(value) !== '[object Array]' &&
    		$toString$1(value.callee) === '[object Function]';
    };

    var supportsStandardArguments = (function () {
    	return isStandardArguments(arguments);
    }());

    isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests

    var isArguments$1 = supportsStandardArguments ? isStandardArguments : isLegacyArguments;

    var toString$1 = {}.toString;

    var isarray = Array.isArray || function (arr) {
      return toString$1.call(arr) == '[object Array]';
    };

    var strValue = String.prototype.valueOf;
    var tryStringObject = function tryStringObject(value) {
    	try {
    		strValue.call(value);
    		return true;
    	} catch (e) {
    		return false;
    	}
    };
    var toStr$7 = Object.prototype.toString;
    var strClass = '[object String]';
    var hasToStringTag$3 = shams$1();

    var isString$2 = function isString(value) {
    	if (typeof value === 'string') {
    		return true;
    	}
    	if (typeof value !== 'object') {
    		return false;
    	}
    	return hasToStringTag$3 ? tryStringObject(value) : toStr$7.call(value) === strClass;
    };

    var $Map = typeof Map === 'function' && Map.prototype ? Map : null;
    var $Set = typeof Set === 'function' && Set.prototype ? Set : null;

    var exported;

    if (!$Map) {
    	// eslint-disable-next-line no-unused-vars
    	exported = function isMap(x) {
    		// `Map` is not present in this environment.
    		return false;
    	};
    }

    var $mapHas = $Map ? Map.prototype.has : null;
    var $setHas = $Set ? Set.prototype.has : null;
    if (!exported && !$mapHas) {
    	// eslint-disable-next-line no-unused-vars
    	exported = function isMap(x) {
    		// `Map` does not have a `has` method
    		return false;
    	};
    }

    var isMap$1 = exported || function isMap(x) {
    	if (!x || typeof x !== 'object') {
    		return false;
    	}
    	try {
    		$mapHas.call(x);
    		if ($setHas) {
    			try {
    				$setHas.call(x);
    			} catch (e) {
    				return true;
    			}
    		}
    		return x instanceof $Map; // core-js workaround, pre-v2.5.0
    	} catch (e) {}
    	return false;
    };

    var $Map$1 = typeof Map === 'function' && Map.prototype ? Map : null;
    var $Set$1 = typeof Set === 'function' && Set.prototype ? Set : null;

    var exported$1;

    if (!$Set$1) {
    	// eslint-disable-next-line no-unused-vars
    	exported$1 = function isSet(x) {
    		// `Set` is not present in this environment.
    		return false;
    	};
    }

    var $mapHas$1 = $Map$1 ? Map.prototype.has : null;
    var $setHas$1 = $Set$1 ? Set.prototype.has : null;
    if (!exported$1 && !$setHas$1) {
    	// eslint-disable-next-line no-unused-vars
    	exported$1 = function isSet(x) {
    		// `Set` does not have a `has` method
    		return false;
    	};
    }

    var isSet$1 = exported$1 || function isSet(x) {
    	if (!x || typeof x !== 'object') {
    		return false;
    	}
    	try {
    		$setHas$1.call(x);
    		if ($mapHas$1) {
    			try {
    				$mapHas$1.call(x);
    			} catch (e) {
    				return true;
    			}
    		}
    		return x instanceof $Set$1; // core-js workaround, pre-v2.5.0
    	} catch (e) {}
    	return false;
    };

    var esGetIterator = createCommonjsModule(function (module) {

    /* eslint global-require: 0 */
    // the code is structured this way so that bundlers can
    // alias out `has-symbols` to `() => true` or `() => false` if your target
    // environments' Symbol capabilities are known, and then use
    // dead code elimination on the rest of this module.
    //
    // Similarly, `isarray` can be aliased to `Array.isArray` if
    // available in all target environments.



    if (hasSymbols() || shams()) {
    	var $iterator = Symbol.iterator;
    	// Symbol is available natively or shammed
    	// natively:
    	//  - Chrome >= 38
    	//  - Edge 12-14?, Edge >= 15 for sure
    	//  - FF >= 36
    	//  - Safari >= 9
    	//  - node >= 0.12
    	module.exports = function getIterator(iterable) {
    		// alternatively, `iterable[$iterator]?.()`
    		if (iterable != null && typeof iterable[$iterator] !== 'undefined') {
    			return iterable[$iterator]();
    		}
    		if (isArguments$1(iterable)) {
    			// arguments objects lack Symbol.iterator
    			// - node 0.12
    			return Array.prototype[$iterator].call(iterable);
    		}
    	};
    } else {
    	// Symbol is not available, native or shammed
    	var isArray = isarray;
    	var isString = isString$2;
    	var GetIntrinsic = getIntrinsic;
    	var $Map = GetIntrinsic('%Map%', true);
    	var $Set = GetIntrinsic('%Set%', true);
    	var callBound$$1 = callBound;
    	var $arrayPush = callBound$$1('Array.prototype.push');
    	var $charCodeAt = callBound$$1('String.prototype.charCodeAt');
    	var $stringSlice = callBound$$1('String.prototype.slice');

    	var advanceStringIndex = function advanceStringIndex(S, index) {
    		var length = S.length;
    		if ((index + 1) >= length) {
    			return index + 1;
    		}

    		var first = $charCodeAt(S, index);
    		if (first < 0xD800 || first > 0xDBFF) {
    			return index + 1;
    		}

    		var second = $charCodeAt(S, index + 1);
    		if (second < 0xDC00 || second > 0xDFFF) {
    			return index + 1;
    		}

    		return index + 2;
    	};

    	var getArrayIterator = function getArrayIterator(arraylike) {
    		var i = 0;
    		return {
    			next: function next() {
    				var done = i >= arraylike.length;
    				var value;
    				if (!done) {
    					value = arraylike[i];
    					i += 1;
    				}
    				return {
    					done: done,
    					value: value
    				};
    			}
    		};
    	};

    	var getNonCollectionIterator = function getNonCollectionIterator(iterable, noPrimordialCollections) {
    		if (isArray(iterable) || isArguments$1(iterable)) {
    			return getArrayIterator(iterable);
    		}
    		if (isString(iterable)) {
    			var i = 0;
    			return {
    				next: function next() {
    					var nextIndex = advanceStringIndex(iterable, i);
    					var value = $stringSlice(iterable, i, nextIndex);
    					i = nextIndex;
    					return {
    						done: nextIndex > iterable.length,
    						value: value
    					};
    				}
    			};
    		}

    		// es6-shim and es-shims' es-map use a string "_es6-shim iterator_" property on different iterables, such as MapIterator.
    		if (noPrimordialCollections && typeof iterable['_es6-shim iterator_'] !== 'undefined') {
    			return iterable['_es6-shim iterator_']();
    		}
    	};

    	if (!$Map && !$Set) {
    		// the only language iterables are Array, String, arguments
    		// - Safari <= 6.0
    		// - Chrome < 38
    		// - node < 0.12
    		// - FF < 13
    		// - IE < 11
    		// - Edge < 11

    		module.exports = function getIterator(iterable) {
    			if (iterable != null) {
    				return getNonCollectionIterator(iterable, true);
    			}
    		};
    	} else {
    		// either Map or Set are available, but Symbol is not
    		// - es6-shim on an ES5 browser
    		// - Safari 6.2 (maybe 6.1?)
    		// - FF v[13, 36)
    		// - IE 11
    		// - Edge 11
    		// - Safari v[6, 9)

    		var isMap = isMap$1;
    		var isSet = isSet$1;

    		// Firefox >= 27, IE 11, Safari 6.2 - 9, Edge 11, es6-shim in older envs, all have forEach
    		var $mapForEach = callBound$$1('Map.prototype.forEach', true);
    		var $setForEach = callBound$$1('Set.prototype.forEach', true);
    		if (typeof process === 'undefined' || !process.versions || !process.versions.node) { // "if is not node"

    			// Firefox 17 - 26 has `.iterator()`, whose iterator `.next()` either
    			// returns a value, or throws a StopIteration object. These browsers
    			// do not have any other mechanism for iteration.
    			var $mapIterator = callBound$$1('Map.prototype.iterator', true);
    			var $setIterator = callBound$$1('Set.prototype.iterator', true);
    			var getStopIterationIterator = function (iterator) {
    				var done = false;
    				return {
    					next: function next() {
    						try {
    							return {
    								done: done,
    								value: done ? undefined : iterator.next()
    							};
    						} catch (e) {
    							done = true;
    							return {
    								done: true,
    								value: undefined
    							};
    						}
    					}
    				};
    			};
    		}
    		// Firefox 27-35, and some older es6-shim versions, use a string "@@iterator" property
    		// this returns a proper iterator object, so we should use it instead of forEach.
    		// newer es6-shim versions use a string "_es6-shim iterator_" property.
    		var $mapAtAtIterator = callBound$$1('Map.prototype.@@iterator', true) || callBound$$1('Map.prototype._es6-shim iterator_', true);
    		var $setAtAtIterator = callBound$$1('Set.prototype.@@iterator', true) || callBound$$1('Set.prototype._es6-shim iterator_', true);

    		var getCollectionIterator = function getCollectionIterator(iterable) {
    			if (isMap(iterable)) {
    				if ($mapIterator) {
    					return getStopIterationIterator($mapIterator(iterable));
    				}
    				if ($mapAtAtIterator) {
    					return $mapAtAtIterator(iterable);
    				}
    				if ($mapForEach) {
    					var entries = [];
    					$mapForEach(iterable, function (v, k) {
    						$arrayPush(entries, [k, v]);
    					});
    					return getArrayIterator(entries);
    				}
    			}
    			if (isSet(iterable)) {
    				if ($setIterator) {
    					return getStopIterationIterator($setIterator(iterable));
    				}
    				if ($setAtAtIterator) {
    					return $setAtAtIterator(iterable);
    				}
    				if ($setForEach) {
    					var values = [];
    					$setForEach(iterable, function (v) {
    						$arrayPush(values, v);
    					});
    					return getArrayIterator(values);
    				}
    			}
    		};

    		module.exports = function getIterator(iterable) {
    			return getCollectionIterator(iterable) || getNonCollectionIterator(iterable);
    		};
    	}
    }
    });

    var $TypeError$l = TypeError;

    // eslint-disable-next-line consistent-return
    var iterateIterator = function iterateIterator(iterator) {
    	if (!iterator || typeof iterator.next !== 'function') {
    		throw new $TypeError$l('iterator must be an object with a `next` method');
    	}
    	if (arguments.length > 1) {
    		var callback = arguments[1];
    		if (typeof callback !== 'function') {
    			throw new $TypeError$l('`callback`, if provided, must be a function');
    		}
    	}
    	var values = callback || [];
    	var result;
    	while ((result = iterator.next()) && !result.done) {
    		if (callback) {
    			callback(result.value); // eslint-disable-line callback-return
    		} else {
    			values.push(result.value);
    		}
    	}
    	if (!callback) {
    		return values;
    	}
    };

    var $TypeError$m = TypeError;


    var iterateValue = function iterateValue(iterable) {
    	var iterator = esGetIterator(iterable);
    	if (!iterator) {
    		throw new $TypeError$m('non-iterable value provided');
    	}
    	if (arguments.length > 1) {
    		return iterateIterator(iterator, arguments[1]);
    	}
    	return iterateIterator(iterator);
    };

    var $TypeError$n = getIntrinsic('%TypeError%');

    // http://262.ecma-international.org/5.1/#sec-9.10

    var CheckObjectCoercible$1 = function CheckObjectCoercible(value, optMessage) {
    	if (value == null) {
    		throw new $TypeError$n(optMessage || ('Cannot call method on ' + value));
    	}
    	return value;
    };

    var RequireObjectCoercible$1 = CheckObjectCoercible$1;

    // https://ecma-international.org/ecma-262/6.0/#sec-ispropertykey

    var IsPropertyKey$1 = function IsPropertyKey(argument) {
    	return typeof argument === 'string' || typeof argument === 'symbol';
    };

    // https://262.ecma-international.org/5.1/#sec-8

    var Type$4 = function Type(x) {
    	if (x === null) {
    		return 'Null';
    	}
    	if (typeof x === 'undefined') {
    		return 'Undefined';
    	}
    	if (typeof x === 'function' || typeof x === 'object') {
    		return 'Object';
    	}
    	if (typeof x === 'number') {
    		return 'Number';
    	}
    	if (typeof x === 'boolean') {
    		return 'Boolean';
    	}
    	if (typeof x === 'string') {
    		return 'String';
    	}
    };

    // https://262.ecma-international.org/11.0/#sec-ecmascript-data-types-and-values

    var Type$5 = function Type(x) {
    	if (typeof x === 'symbol') {
    		return 'Symbol';
    	}
    	if (typeof x === 'bigint') {
    		return 'BigInt';
    	}
    	return Type$4(x);
    };

    var $TypeError$o = getIntrinsic('%TypeError%');






    /**
     * 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p
     * 1. Assert: Type(O) is Object.
     * 2. Assert: IsPropertyKey(P) is true.
     * 3. Return O.[[Get]](P, O).
     */

    var Get$1 = function Get(O, P) {
    	// 7.3.1.1
    	if (Type$5(O) !== 'Object') {
    		throw new $TypeError$o('Assertion failed: Type(O) is not Object');
    	}
    	// 7.3.1.2
    	if (!IsPropertyKey$1(P)) {
    		throw new $TypeError$o('Assertion failed: IsPropertyKey(P) is not true, got ' + objectInspect(P));
    	}
    	// 7.3.1.3
    	return O[P];
    };

    var $Array$1 = getIntrinsic('%Array%');

    // eslint-disable-next-line global-require
    var toStr$8 = !$Array$1.isArray && callBound('Object.prototype.toString');

    // https://ecma-international.org/ecma-262/6.0/#sec-isarray

    var IsArray$1 = $Array$1.isArray || function IsArray(argument) {
    	return toStr$8(argument) === '[object Array]';
    };

    // TODO: remove, semver-major

    var GetIntrinsic = getIntrinsic;

    var $TypeError$p = getIntrinsic('%TypeError%');

    var isPropertyDescriptor = function IsPropertyDescriptor(ES, Desc) {
    	if (ES.Type(Desc) !== 'Object') {
    		return false;
    	}
    	var allowed = {
    		'[[Configurable]]': true,
    		'[[Enumerable]]': true,
    		'[[Get]]': true,
    		'[[Set]]': true,
    		'[[Value]]': true,
    		'[[Writable]]': true
    	};

    	for (var key in Desc) { // eslint-disable-line no-restricted-syntax
    		if (src(Desc, key) && !allowed[key]) {
    			return false;
    		}
    	}

    	if (ES.IsDataDescriptor(Desc) && ES.IsAccessorDescriptor(Desc)) {
    		throw new $TypeError$p('Property Descriptors may not be both accessor and data descriptors');
    	}
    	return true;
    };

    var $defineProperty$1 = getIntrinsic('%Object.defineProperty%', true);

    if ($defineProperty$1) {
    	try {
    		$defineProperty$1({}, 'a', { value: 1 });
    	} catch (e) {
    		// IE 8 has a broken defineProperty
    		$defineProperty$1 = null;
    	}
    }



    var $isEnumerable$2 = callBound('Object.prototype.propertyIsEnumerable');

    // eslint-disable-next-line max-params
    var DefineOwnProperty$1 = function DefineOwnProperty(IsDataDescriptor, SameValue, FromPropertyDescriptor, O, P, desc) {
    	if (!$defineProperty$1) {
    		if (!IsDataDescriptor(desc)) {
    			// ES3 does not support getters/setters
    			return false;
    		}
    		if (!desc['[[Configurable]]'] || !desc['[[Writable]]']) {
    			return false;
    		}

    		// fallback for ES3
    		if (P in O && $isEnumerable$2(O, P) !== !!desc['[[Enumerable]]']) {
    			// a non-enumerable existing property
    			return false;
    		}

    		// property does not exist at all, or exists but is enumerable
    		var V = desc['[[Value]]'];
    		// eslint-disable-next-line no-param-reassign
    		O[P] = V; // will use [[Define]]
    		return SameValue(O[P], V);
    	}
    	$defineProperty$1(O, P, FromPropertyDescriptor(desc));
    	return true;
    };

    var $TypeError$q = getIntrinsic('%TypeError%');
    var $SyntaxError$2 = getIntrinsic('%SyntaxError%');



    var predicates$1 = {
    	// https://262.ecma-international.org/6.0/#sec-property-descriptor-specification-type
    	'Property Descriptor': function isPropertyDescriptor(Type, Desc) {
    		if (Type(Desc) !== 'Object') {
    			return false;
    		}
    		var allowed = {
    			'[[Configurable]]': true,
    			'[[Enumerable]]': true,
    			'[[Get]]': true,
    			'[[Set]]': true,
    			'[[Value]]': true,
    			'[[Writable]]': true
    		};

    		for (var key in Desc) { // eslint-disable-line
    			if (src(Desc, key) && !allowed[key]) {
    				return false;
    			}
    		}

    		var isData = src(Desc, '[[Value]]');
    		var IsAccessor = src(Desc, '[[Get]]') || src(Desc, '[[Set]]');
    		if (isData && IsAccessor) {
    			throw new $TypeError$q('Property Descriptors may not be both accessor and data descriptors');
    		}
    		return true;
    	}
    };

    var assertRecord$1 = function assertRecord(Type, recordType, argumentName, value) {
    	var predicate = predicates$1[recordType];
    	if (typeof predicate !== 'function') {
    		throw new $SyntaxError$2('unknown record type: ' + recordType);
    	}
    	if (!predicate(Type, value)) {
    		throw new $TypeError$q(argumentName + ' must be a ' + recordType);
    	}
    };

    // https://ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor

    var FromPropertyDescriptor$1 = function FromPropertyDescriptor(Desc) {
    	if (typeof Desc === 'undefined') {
    		return Desc;
    	}

    	assertRecord$1(Type$5, 'Property Descriptor', 'Desc', Desc);

    	var obj = {};
    	if ('[[Value]]' in Desc) {
    		obj.value = Desc['[[Value]]'];
    	}
    	if ('[[Writable]]' in Desc) {
    		obj.writable = Desc['[[Writable]]'];
    	}
    	if ('[[Get]]' in Desc) {
    		obj.get = Desc['[[Get]]'];
    	}
    	if ('[[Set]]' in Desc) {
    		obj.set = Desc['[[Set]]'];
    	}
    	if ('[[Enumerable]]' in Desc) {
    		obj.enumerable = Desc['[[Enumerable]]'];
    	}
    	if ('[[Configurable]]' in Desc) {
    		obj.configurable = Desc['[[Configurable]]'];
    	}
    	return obj;
    };

    // https://ecma-international.org/ecma-262/6.0/#sec-isaccessordescriptor

    var IsAccessorDescriptor = function IsAccessorDescriptor(Desc) {
    	if (typeof Desc === 'undefined') {
    		return false;
    	}

    	assertRecord$1(Type$5, 'Property Descriptor', 'Desc', Desc);

    	if (!src(Desc, '[[Get]]') && !src(Desc, '[[Set]]')) {
    		return false;
    	}

    	return true;
    };

    // https://ecma-international.org/ecma-262/6.0/#sec-isdatadescriptor

    var IsDataDescriptor$1 = function IsDataDescriptor(Desc) {
    	if (typeof Desc === 'undefined') {
    		return false;
    	}

    	assertRecord$1(Type$5, 'Property Descriptor', 'Desc', Desc);

    	if (!src(Desc, '[[Value]]') && !src(Desc, '[[Writable]]')) {
    		return false;
    	}

    	return true;
    };

    var _isNaN$1 = Number.isNaN || function isNaN(a) {
    	return a !== a;
    };

    // http://262.ecma-international.org/5.1/#sec-9.12

    var SameValue$1 = function SameValue(x, y) {
    	if (x === y) { // 0 === -0, but they are not identical.
    		if (x === 0) { return 1 / x === 1 / y; }
    		return true;
    	}
    	return _isNaN$1(x) && _isNaN$1(y);
    };

    // http://262.ecma-international.org/5.1/#sec-9.2

    var ToBoolean$1 = function ToBoolean(value) { return !!value; };

    var fnToStr$1 = Function.prototype.toString;
    var reflectApply$1 = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
    var badArrayLike$1;
    var isCallableMarker$1;
    if (typeof reflectApply$1 === 'function' && typeof Object.defineProperty === 'function') {
    	try {
    		badArrayLike$1 = Object.defineProperty({}, 'length', {
    			get: function () {
    				throw isCallableMarker$1;
    			}
    		});
    		isCallableMarker$1 = {};
    		// eslint-disable-next-line no-throw-literal
    		reflectApply$1(function () { throw 42; }, null, badArrayLike$1);
    	} catch (_) {
    		if (_ !== isCallableMarker$1) {
    			reflectApply$1 = null;
    		}
    	}
    } else {
    	reflectApply$1 = null;
    }

    var constructorRegex$1 = /^\s*class\b/;
    var isES6ClassFn$1 = function isES6ClassFunction(value) {
    	try {
    		var fnStr = fnToStr$1.call(value);
    		return constructorRegex$1.test(fnStr);
    	} catch (e) {
    		return false; // not a function
    	}
    };

    var tryFunctionObject$1 = function tryFunctionToStr(value) {
    	try {
    		if (isES6ClassFn$1(value)) { return false; }
    		fnToStr$1.call(value);
    		return true;
    	} catch (e) {
    		return false;
    	}
    };
    var toStr$9 = Object.prototype.toString;
    var fnClass$1 = '[object Function]';
    var genClass$1 = '[object GeneratorFunction]';
    var hasToStringTag$4 = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
    /* globals document: false */
    var documentDotAll$1 = typeof document === 'object' && typeof document.all === 'undefined' && document.all !== undefined ? document.all : {};

    var isCallable$1 = reflectApply$1
    	? function isCallable(value) {
    		if (value === documentDotAll$1) { return true; }
    		if (!value) { return false; }
    		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
    		if (typeof value === 'function' && !value.prototype) { return true; }
    		try {
    			reflectApply$1(value, null, badArrayLike$1);
    		} catch (e) {
    			if (e !== isCallableMarker$1) { return false; }
    		}
    		return !isES6ClassFn$1(value);
    	}
    	: function isCallable(value) {
    		if (value === documentDotAll$1) { return true; }
    		if (!value) { return false; }
    		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
    		if (typeof value === 'function' && !value.prototype) { return true; }
    		if (hasToStringTag$4) { return tryFunctionObject$1(value); }
    		if (isES6ClassFn$1(value)) { return false; }
    		var strClass = toStr$9.call(value);
    		return strClass === fnClass$1 || strClass === genClass$1;
    	};

    // http://262.ecma-international.org/5.1/#sec-9.11

    var IsCallable$1 = isCallable$1;

    var $TypeError$r = getIntrinsic('%TypeError%');





    // https://262.ecma-international.org/5.1/#sec-8.10.5

    var ToPropertyDescriptor$1 = function ToPropertyDescriptor(Obj) {
    	if (Type$5(Obj) !== 'Object') {
    		throw new $TypeError$r('ToPropertyDescriptor requires an object');
    	}

    	var desc = {};
    	if (src(Obj, 'enumerable')) {
    		desc['[[Enumerable]]'] = ToBoolean$1(Obj.enumerable);
    	}
    	if (src(Obj, 'configurable')) {
    		desc['[[Configurable]]'] = ToBoolean$1(Obj.configurable);
    	}
    	if (src(Obj, 'value')) {
    		desc['[[Value]]'] = Obj.value;
    	}
    	if (src(Obj, 'writable')) {
    		desc['[[Writable]]'] = ToBoolean$1(Obj.writable);
    	}
    	if (src(Obj, 'get')) {
    		var getter = Obj.get;
    		if (typeof getter !== 'undefined' && !IsCallable$1(getter)) {
    			throw new $TypeError$r('getter must be a function');
    		}
    		desc['[[Get]]'] = getter;
    	}
    	if (src(Obj, 'set')) {
    		var setter = Obj.set;
    		if (typeof setter !== 'undefined' && !IsCallable$1(setter)) {
    			throw new $TypeError$r('setter must be a function');
    		}
    		desc['[[Set]]'] = setter;
    	}

    	if ((src(desc, '[[Get]]') || src(desc, '[[Set]]')) && (src(desc, '[[Value]]') || src(desc, '[[Writable]]'))) {
    		throw new $TypeError$r('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
    	}
    	return desc;
    };

    var $TypeError$s = getIntrinsic('%TypeError%');












    // https://ecma-international.org/ecma-262/6.0/#sec-definepropertyorthrow

    var DefinePropertyOrThrow = function DefinePropertyOrThrow(O, P, desc) {
    	if (Type$5(O) !== 'Object') {
    		throw new $TypeError$s('Assertion failed: Type(O) is not Object');
    	}

    	if (!IsPropertyKey$1(P)) {
    		throw new $TypeError$s('Assertion failed: IsPropertyKey(P) is not true');
    	}

    	var Desc = isPropertyDescriptor({
    		Type: Type$5,
    		IsDataDescriptor: IsDataDescriptor$1,
    		IsAccessorDescriptor: IsAccessorDescriptor
    	}, desc) ? desc : ToPropertyDescriptor$1(desc);
    	if (!isPropertyDescriptor({
    		Type: Type$5,
    		IsDataDescriptor: IsDataDescriptor$1,
    		IsAccessorDescriptor: IsAccessorDescriptor
    	}, Desc)) {
    		throw new $TypeError$s('Assertion failed: Desc is not a valid Property Descriptor');
    	}

    	return DefineOwnProperty$1(
    		IsDataDescriptor$1,
    		SameValue$1,
    		FromPropertyDescriptor$1,
    		O,
    		P,
    		Desc
    	);
    };

    var IsConstructor = createCommonjsModule(function (module) {



    var $construct = GetIntrinsic('%Reflect.construct%', true);

    var DefinePropertyOrThrow$$1 = DefinePropertyOrThrow;
    try {
    	DefinePropertyOrThrow$$1({}, '', { '[[Get]]': function () {} });
    } catch (e) {
    	// Accessor properties aren't supported
    	DefinePropertyOrThrow$$1 = null;
    }

    // https://ecma-international.org/ecma-262/6.0/#sec-isconstructor

    if (DefinePropertyOrThrow$$1 && $construct) {
    	var isConstructorMarker = {};
    	var badArrayLike = {};
    	DefinePropertyOrThrow$$1(badArrayLike, 'length', {
    		'[[Get]]': function () {
    			throw isConstructorMarker;
    		},
    		'[[Enumerable]]': true
    	});

    	module.exports = function IsConstructor(argument) {
    		try {
    			// `Reflect.construct` invokes `IsConstructor(target)` before `Get(args, 'length')`:
    			$construct(argument, badArrayLike);
    		} catch (err) {
    			return err === isConstructorMarker;
    		}
    	};
    } else {
    	module.exports = function IsConstructor(argument) {
    		// unfortunately there's no way to truly check this without try/catch `new argument` in old environments
    		return typeof argument === 'function' && !!argument.prototype;
    	};
    }
    });

    var $abs$1 = getIntrinsic('%Math.abs%');

    // http://262.ecma-international.org/5.1/#sec-5.2

    var abs$1 = function abs(x) {
    	return $abs$1(x);
    };

    // var modulo = require('./modulo');
    var $floor$1 = Math.floor;

    // http://262.ecma-international.org/5.1/#sec-5.2

    var floor$1 = function floor(x) {
    	// return x - modulo(x, 1);
    	return $floor$1(x);
    };

    var $isNaN$1 = Number.isNaN || function (a) { return a !== a; };

    var _isFinite$1 = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN$1(x) && x !== Infinity && x !== -Infinity; };

    // https://ecma-international.org/ecma-262/6.0/#sec-isinteger

    var IsInteger$1 = function IsInteger(argument) {
    	if (typeof argument !== 'number' || _isNaN$1(argument) || !_isFinite$1(argument)) {
    		return false;
    	}
    	var absValue = abs$1(argument);
    	return floor$1(absValue) === absValue;
    };

    var $Array$2 = getIntrinsic('%Array%');
    var $species = getIntrinsic('%Symbol.species%', true);
    var $TypeError$t = getIntrinsic('%TypeError%');







    // https://ecma-international.org/ecma-262/6.0/#sec-arrayspeciescreate

    var ArraySpeciesCreate = function ArraySpeciesCreate(originalArray, length) {
    	if (!IsInteger$1(length) || length < 0) {
    		throw new $TypeError$t('Assertion failed: length must be an integer >= 0');
    	}
    	var len = length === 0 ? 0 : length;
    	var C;
    	var isArray = IsArray$1(originalArray);
    	if (isArray) {
    		C = Get$1(originalArray, 'constructor');
    		// TODO: figure out how to make a cross-realm normal Array, a same-realm Array
    		// if (IsConstructor(C)) {
    		// 	if C is another realm's Array, C = undefined
    		// 	Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ?
    		// }
    		if ($species && Type$5(C) === 'Object') {
    			C = Get$1(C, $species);
    			if (C === null) {
    				C = void 0;
    			}
    		}
    	}
    	if (typeof C === 'undefined') {
    		return $Array$2(len);
    	}
    	if (!IsConstructor(C)) {
    		throw new $TypeError$t('C must be a constructor');
    	}
    	return new C(len); // Construct(C, len);
    };

    var $TypeError$u = getIntrinsic('%TypeError%');



    var $apply$1 = getIntrinsic('%Reflect.apply%', true) || callBound('%Function.prototype.apply%');

    // https://ecma-international.org/ecma-262/6.0/#sec-call

    var Call$1 = function Call(F, V) {
    	var argumentsList = arguments.length > 2 ? arguments[2] : [];
    	if (!IsArray$1(argumentsList)) {
    		throw new $TypeError$u('Assertion failed: optional `argumentsList`, if provided, must be a List');
    	}
    	return $apply$1(F, V, argumentsList);
    };

    var $gOPD$2 = getIntrinsic('%Object.getOwnPropertyDescriptor%');
    if ($gOPD$2) {
    	try {
    		$gOPD$2([], 'length');
    	} catch (e) {
    		// IE 8 has a broken gOPD
    		$gOPD$2 = null;
    	}
    }

    var getOwnPropertyDescriptor$1 = $gOPD$2;

    var hasToStringTag$5 = shams$1();
    var has$3;
    var $exec$1;
    var isRegexMarker$1;
    var badStringifier$1;

    if (hasToStringTag$5) {
    	has$3 = callBound('Object.prototype.hasOwnProperty');
    	$exec$1 = callBound('RegExp.prototype.exec');
    	isRegexMarker$1 = {};

    	var throwRegexMarker$1 = function () {
    		throw isRegexMarker$1;
    	};
    	badStringifier$1 = {
    		toString: throwRegexMarker$1,
    		valueOf: throwRegexMarker$1
    	};

    	if (typeof Symbol.toPrimitive === 'symbol') {
    		badStringifier$1[Symbol.toPrimitive] = throwRegexMarker$1;
    	}
    }

    var $toString$2 = callBound('Object.prototype.toString');
    var gOPD$1 = Object.getOwnPropertyDescriptor;
    var regexClass$1 = '[object RegExp]';

    var isRegex$1 = hasToStringTag$5
    	// eslint-disable-next-line consistent-return
    	? function isRegex(value) {
    		if (!value || typeof value !== 'object') {
    			return false;
    		}

    		var descriptor = gOPD$1(value, 'lastIndex');
    		var hasLastIndexDataProperty = descriptor && has$3(descriptor, 'value');
    		if (!hasLastIndexDataProperty) {
    			return false;
    		}

    		try {
    			$exec$1(value, badStringifier$1);
    		} catch (e) {
    			return e === isRegexMarker$1;
    		}
    	}
    	: function isRegex(value) {
    		// In older browsers, typeof regex incorrectly returns 'function'
    		if (!value || (typeof value !== 'object' && typeof value !== 'function')) {
    			return false;
    		}

    		return $toString$2(value) === regexClass$1;
    	};

    var $match$1 = getIntrinsic('%Symbol.match%', true);





    // https://ecma-international.org/ecma-262/6.0/#sec-isregexp

    var IsRegExp$1 = function IsRegExp(argument) {
    	if (!argument || typeof argument !== 'object') {
    		return false;
    	}
    	if ($match$1) {
    		var isRegExp = argument[$match$1];
    		if (typeof isRegExp !== 'undefined') {
    			return ToBoolean$1(isRegExp);
    		}
    	}
    	return isRegex$1(argument);
    };

    var $TypeError$v = getIntrinsic('%TypeError%');



    var $isEnumerable$3 = callBound('Object.prototype.propertyIsEnumerable');









    // https://ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty

    var OrdinaryGetOwnProperty$1 = function OrdinaryGetOwnProperty(O, P) {
    	if (Type$5(O) !== 'Object') {
    		throw new $TypeError$v('Assertion failed: O must be an Object');
    	}
    	if (!IsPropertyKey$1(P)) {
    		throw new $TypeError$v('Assertion failed: P must be a Property Key');
    	}
    	if (!src(O, P)) {
    		return void 0;
    	}
    	if (!getOwnPropertyDescriptor$1) {
    		// ES3 / IE 8 fallback
    		var arrayLength = IsArray$1(O) && P === 'length';
    		var regexLastIndex = IsRegExp$1(O) && P === 'lastIndex';
    		return {
    			'[[Configurable]]': !(arrayLength || regexLastIndex),
    			'[[Enumerable]]': $isEnumerable$3(O, P),
    			'[[Value]]': O[P],
    			'[[Writable]]': true
    		};
    	}
    	return ToPropertyDescriptor$1(getOwnPropertyDescriptor$1(O, P));
    };

    var isPrimitive$1 = function isPrimitive(value) {
    	return value === null || (typeof value !== 'function' && typeof value !== 'object');
    };

    var $Object$2 = getIntrinsic('%Object%');



    var $preventExtensions$1 = $Object$2.preventExtensions;
    var $isExtensible$1 = $Object$2.isExtensible;

    // https://ecma-international.org/ecma-262/6.0/#sec-isextensible-o

    var IsExtensible$1 = $preventExtensions$1
    	? function IsExtensible(obj) {
    		return !isPrimitive$1(obj) && $isExtensible$1(obj);
    	}
    	: function IsExtensible(obj) {
    		return !isPrimitive$1(obj);
    	};

    var $TypeError$w = getIntrinsic('%TypeError%');











    // https://ecma-international.org/ecma-262/6.0/#sec-createdataproperty

    var CreateDataProperty$1 = function CreateDataProperty(O, P, V) {
    	if (Type$5(O) !== 'Object') {
    		throw new $TypeError$w('Assertion failed: Type(O) is not Object');
    	}
    	if (!IsPropertyKey$1(P)) {
    		throw new $TypeError$w('Assertion failed: IsPropertyKey(P) is not true');
    	}
    	var oldDesc = OrdinaryGetOwnProperty$1(O, P);
    	var extensible = !oldDesc || IsExtensible$1(O);
    	var immutable = oldDesc && (!oldDesc['[[Writable]]'] || !oldDesc['[[Configurable]]']);
    	if (immutable || !extensible) {
    		return false;
    	}
    	return DefineOwnProperty$1(
    		IsDataDescriptor$1,
    		SameValue$1,
    		FromPropertyDescriptor$1,
    		O,
    		P,
    		{
    			'[[Configurable]]': true,
    			'[[Enumerable]]': true,
    			'[[Value]]': V,
    			'[[Writable]]': true
    		}
    	);
    };

    var $TypeError$x = getIntrinsic('%TypeError%');





    // // https://ecma-international.org/ecma-262/6.0/#sec-createdatapropertyorthrow

    var CreateDataPropertyOrThrow$1 = function CreateDataPropertyOrThrow(O, P, V) {
    	if (Type$5(O) !== 'Object') {
    		throw new $TypeError$x('Assertion failed: Type(O) is not Object');
    	}
    	if (!IsPropertyKey$1(P)) {
    		throw new $TypeError$x('Assertion failed: IsPropertyKey(P) is not true');
    	}
    	var success = CreateDataProperty$1(O, P, V);
    	if (!success) {
    		throw new $TypeError$x('unable to create data property');
    	}
    	return success;
    };

    var $TypeError$y = getIntrinsic('%TypeError%');




    // https://ecma-international.org/ecma-262/6.0/#sec-hasproperty

    var HasProperty = function HasProperty(O, P) {
    	if (Type$5(O) !== 'Object') {
    		throw new $TypeError$y('Assertion failed: `O` must be an Object');
    	}
    	if (!IsPropertyKey$1(P)) {
    		throw new $TypeError$y('Assertion failed: `P` must be a Property Key');
    	}
    	return P in O;
    };

    var $test = getIntrinsic('RegExp.prototype.test');



    var regexTester = function regexTester(regex) {
    	return callBind($test, regex);
    };

    var isPrimitive$2 = function isPrimitive(value) {
    	return value === null || (typeof value !== 'function' && typeof value !== 'object');
    };

    var fnToStr$2 = Function.prototype.toString;

    var constructorRegex$2 = /^\s*class\b/;
    var isES6ClassFn$2 = function isES6ClassFunction(value) {
    	try {
    		var fnStr = fnToStr$2.call(value);
    		return constructorRegex$2.test(fnStr);
    	} catch (e) {
    		return false; // not a function
    	}
    };

    var tryFunctionObject$2 = function tryFunctionToStr(value) {
    	try {
    		if (isES6ClassFn$2(value)) { return false; }
    		fnToStr$2.call(value);
    		return true;
    	} catch (e) {
    		return false;
    	}
    };
    var toStr$a = Object.prototype.toString;
    var fnClass$2 = '[object Function]';
    var genClass$2 = '[object GeneratorFunction]';
    var hasToStringTag$6 = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';

    var isCallable$2 = function isCallable(value) {
    	if (!value) { return false; }
    	if (typeof value !== 'function' && typeof value !== 'object') { return false; }
    	if (typeof value === 'function' && !value.prototype) { return true; }
    	if (hasToStringTag$6) { return tryFunctionObject$2(value); }
    	if (isES6ClassFn$2(value)) { return false; }
    	var strClass = toStr$a.call(value);
    	return strClass === fnClass$2 || strClass === genClass$2;
    };

    var getDay = Date.prototype.getDay;
    var tryDateObject = function tryDateObject(value) {
    	try {
    		getDay.call(value);
    		return true;
    	} catch (e) {
    		return false;
    	}
    };

    var toStr$b = Object.prototype.toString;
    var dateClass = '[object Date]';
    var hasToStringTag$7 = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';

    var isDateObject = function isDateObject(value) {
    	if (typeof value !== 'object' || value === null) { return false; }
    	return hasToStringTag$7 ? tryDateObject(value) : toStr$b.call(value) === dateClass;
    };

    /* eslint complexity: [2, 17], max-statements: [2, 33] */
    var shams$2 = function hasSymbols() {
    	if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
    	if (typeof Symbol.iterator === 'symbol') { return true; }

    	var obj = {};
    	var sym = Symbol('test');
    	var symObj = Object(sym);
    	if (typeof sym === 'string') { return false; }

    	if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
    	if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }

    	// temp disabled per https://github.com/ljharb/object.assign/issues/17
    	// if (sym instanceof Symbol) { return false; }
    	// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
    	// if (!(symObj instanceof Symbol)) { return false; }

    	// if (typeof Symbol.prototype.toString !== 'function') { return false; }
    	// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }

    	var symVal = 42;
    	obj[sym] = symVal;
    	for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax
    	if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }

    	if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }

    	var syms = Object.getOwnPropertySymbols(obj);
    	if (syms.length !== 1 || syms[0] !== sym) { return false; }

    	if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }

    	if (typeof Object.getOwnPropertyDescriptor === 'function') {
    		var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
    		if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
    	}

    	return true;
    };

    var origSymbol$1 = commonjsGlobal.Symbol;


    var hasSymbols$5 = function hasNativeSymbols() {
    	if (typeof origSymbol$1 !== 'function') { return false; }
    	if (typeof Symbol !== 'function') { return false; }
    	if (typeof origSymbol$1('foo') !== 'symbol') { return false; }
    	if (typeof Symbol('bar') !== 'symbol') { return false; }

    	return shams$2();
    };

    var isSymbol$1 = createCommonjsModule(function (module) {

    var toStr = Object.prototype.toString;
    var hasSymbols = hasSymbols$5();

    if (hasSymbols) {
    	var symToStr = Symbol.prototype.toString;
    	var symStringRegex = /^Symbol\(.*\)$/;
    	var isSymbolObject = function isRealSymbolObject(value) {
    		if (typeof value.valueOf() !== 'symbol') {
    			return false;
    		}
    		return symStringRegex.test(symToStr.call(value));
    	};

    	module.exports = function isSymbol(value) {
    		if (typeof value === 'symbol') {
    			return true;
    		}
    		if (toStr.call(value) !== '[object Symbol]') {
    			return false;
    		}
    		try {
    			return isSymbolObject(value);
    		} catch (e) {
    			return false;
    		}
    	};
    } else {

    	module.exports = function isSymbol(value) {
    		// this environment does not support Symbols.
    		return false;
    	};
    }
    });

    var hasSymbols$6 = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';






    var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {
    	if (typeof O === 'undefined' || O === null) {
    		throw new TypeError('Cannot call method on ' + O);
    	}
    	if (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) {
    		throw new TypeError('hint must be "string" or "number"');
    	}
    	var methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
    	var method, result, i;
    	for (i = 0; i < methodNames.length; ++i) {
    		method = O[methodNames[i]];
    		if (isCallable$2(method)) {
    			result = method.call(O);
    			if (isPrimitive$2(result)) {
    				return result;
    			}
    		}
    	}
    	throw new TypeError('No default value');
    };

    var GetMethod$1 = function GetMethod(O, P) {
    	var func = O[P];
    	if (func !== null && typeof func !== 'undefined') {
    		if (!isCallable$2(func)) {
    			throw new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function');
    		}
    		return func;
    	}
    	return void 0;
    };

    // http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive
    var es2015 = function ToPrimitive(input) {
    	if (isPrimitive$2(input)) {
    		return input;
    	}
    	var hint = 'default';
    	if (arguments.length > 1) {
    		if (arguments[1] === String) {
    			hint = 'string';
    		} else if (arguments[1] === Number) {
    			hint = 'number';
    		}
    	}

    	var exoticToPrim;
    	if (hasSymbols$6) {
    		if (Symbol.toPrimitive) {
    			exoticToPrim = GetMethod$1(input, Symbol.toPrimitive);
    		} else if (isSymbol$1(input)) {
    			exoticToPrim = Symbol.prototype.valueOf;
    		}
    	}
    	if (typeof exoticToPrim !== 'undefined') {
    		var result = exoticToPrim.call(input, hint);
    		if (isPrimitive$2(result)) {
    			return result;
    		}
    		throw new TypeError('unable to convert exotic object to primitive');
    	}
    	if (hint === 'default' && (isDateObject(input) || isSymbol$1(input))) {
    		hint = 'string';
    	}
    	return ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint);
    };

    // https://ecma-international.org/ecma-262/6.0/#sec-toprimitive

    var ToPrimitive = function ToPrimitive(input) {
    	if (arguments.length > 1) {
    		return es2015(input, arguments[1]);
    	}
    	return es2015(input);
    };

    var $TypeError$z = getIntrinsic('%TypeError%');
    var $Number$1 = getIntrinsic('%Number%');
    var $RegExp = getIntrinsic('%RegExp%');
    var $parseInteger = getIntrinsic('%parseInt%');





    var $strSlice$1 = callBound('String.prototype.slice');
    var isBinary = regexTester(/^0b[01]+$/i);
    var isOctal = regexTester(/^0o[0-7]+$/i);
    var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
    var nonWS = ['\u0085', '\u200b', '\ufffe'].join('');
    var nonWSregex = new $RegExp('[' + nonWS + ']', 'g');
    var hasNonWS = regexTester(nonWSregex);

    // whitespace from: https://es5.github.io/#x15.5.4.20
    // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
    var ws = [
    	'\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003',
    	'\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028',
    	'\u2029\uFEFF'
    ].join('');
    var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');
    var $replace$1 = callBound('String.prototype.replace');
    var $trim = function (value) {
    	return $replace$1(value, trimRegex, '');
    };



    // https://ecma-international.org/ecma-262/6.0/#sec-tonumber

    var ToNumber = function ToNumber(argument) {
    	var value = isPrimitive$1(argument) ? argument : ToPrimitive(argument, $Number$1);
    	if (typeof value === 'symbol') {
    		throw new $TypeError$z('Cannot convert a Symbol value to a number');
    	}
    	if (typeof value === 'bigint') {
    		throw new $TypeError$z('Conversion from \'BigInt\' to \'number\' is not allowed.');
    	}
    	if (typeof value === 'string') {
    		if (isBinary(value)) {
    			return ToNumber($parseInteger($strSlice$1(value, 2), 2));
    		} else if (isOctal(value)) {
    			return ToNumber($parseInteger($strSlice$1(value, 2), 8));
    		} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {
    			return NaN;
    		} else {
    			var trimmed = $trim(value);
    			if (trimmed !== value) {
    				return ToNumber(trimmed);
    			}
    		}
    	}
    	return $Number$1(value);
    };

    // http://262.ecma-international.org/5.1/#sec-9.6

    var ToUint32 = function ToUint32(x) {
    	return ToNumber(x) >>> 0;
    };

    var $Object$3 = getIntrinsic('%Object%');



    // https://ecma-international.org/ecma-262/6.0/#sec-toobject

    var ToObject$1 = function ToObject(value) {
    	RequireObjectCoercible$1(value);
    	return $Object$3(value);
    };

    var $String = getIntrinsic('%String%');
    var $TypeError$A = getIntrinsic('%TypeError%');

    // https://ecma-international.org/ecma-262/6.0/#sec-tostring

    var ToString = function ToString(argument) {
    	if (typeof argument === 'symbol') {
    		throw new $TypeError$A('Cannot convert a Symbol value to a string');
    	}
    	return $String(argument);
    };

    // Check failure of by-index access of string characters (IE < 9) and failure of `0 in boxedString` (Rhino)
    var boxedString = Object('a');
    var splitString = boxedString[0] !== 'a' || !(0 in boxedString);

    var strSplit = callBound('String.prototype.split');

    var implementation$2 = function map(callbackfn) {
    	var O = ToObject$1(this);
    	var self = splitString && isString$2(O) ? strSplit(O, '') : O;
    	var len = ToUint32(self.length);

    	// If no callback function or if callback is not a callable function
    	if (!IsCallable$1(callbackfn)) {
    		throw new TypeError('Array.prototype.map callback must be a function');
    	}

    	var T;
    	if (arguments.length > 1) {
    		T = arguments[1];
    	}

    	var A = ArraySpeciesCreate(O, len);
    	var k = 0;
    	while (k < len) {
    		var Pk = ToString(k);
    		var kPresent = HasProperty(O, Pk);
    		if (kPresent) {
    			var kValue = Get$1(O, Pk);
    			var mappedValue = Call$1(callbackfn, T, [kValue, k, O]);
    			CreateDataPropertyOrThrow$1(A, Pk, mappedValue);
    		}
    		k += 1;
    	}

    	return A;
    };

    var esArrayMethodBoxesProperly = function properlyBoxed(method) {
    	// Check node 0.6.21 bug where third parameter is not boxed
    	var properlyBoxesNonStrict = true;
    	var properlyBoxesStrict = true;
    	var threwException = false;
    	if (typeof method === 'function') {
    		try {
    			// eslint-disable-next-line max-params
    			method.call('f', function (_, __, O) {
    				if (typeof O !== 'object') {
    					properlyBoxesNonStrict = false;
    				}
    			});

    			method.call(
    				[null],
    				function () {

    					properlyBoxesStrict = typeof this === 'string'; // eslint-disable-line no-invalid-this
    				},
    				'x'
    			);
    		} catch (e) {
    			threwException = true;
    		}
    		return !threwException && properlyBoxesNonStrict && properlyBoxesStrict;
    	}
    	return false;
    };

    var polyfill$1 = function getPolyfill() {
    	var method = Array.prototype.map;
    	return esArrayMethodBoxesProperly(method) ? method : implementation$2;
    };

    var shim = function shimArrayPrototypeMap() {
    	var polyfill = polyfill$1();
    	defineProperties_1(
    		Array.prototype,
    		{ map: polyfill },
    		{ map: function () { return Array.prototype.map !== polyfill; } }
    	);
    	return polyfill;
    };

    var polyfill$2 = polyfill$1();


    var $slice = callBound('Array.prototype.slice');

    // eslint-disable-next-line no-unused-vars
    var boundMapShim = function map(array, callbackfn) {
    	RequireObjectCoercible$1(array);
    	return polyfill$2.apply(array, $slice(arguments, 1));
    };
    defineProperties_1(boundMapShim, {
    	getPolyfill: polyfill$1,
    	implementation: implementation$2,
    	shim: shim
    });

    var array_prototype_map = boundMapShim;

    requirePromise();

    var AggregateError$2 = polyfill();







    var all = callBind(getIntrinsic('%Promise.all%'));
    var reject = callBind(getIntrinsic('%Promise.reject%'));

    var identity = function (x) {
    	return x;
    };

    var implementation$3 = function any(iterable) {
    	var C = this;
    	if (Type$3(C) !== 'Object') {
    		throw new TypeError('`this` value must be an object');
    	}
    	var thrower = function (value) {
    		return reject(C, value);
    	};
    	return all(C, array_prototype_map(iterateValue(iterable), function (item) {
    		var itemPromise = PromiseResolve(C, item);
    		try {
    			return itemPromise.then(thrower, identity);
    		} catch (e) {
    			return e;
    		}
    	})).then(
    		function (errors) {
    			throw new AggregateError$2(errors, 'Every promise rejected');
    		},
    		identity
    	);
    };

    var polyfill$3 = function getPolyfill() {
    	requirePromise();
    	return typeof Promise.any === 'function' ? Promise.any : implementation$3;
    };

    var shim$1 = function shimAny() {
    	requirePromise();

    	var polyfill = polyfill$3();
    	defineProperties_1(Promise, { any: polyfill }, {
    		any: function testAny() {
    			return Promise.any !== polyfill;
    		}
    	});
    	return polyfill;
    };

    requirePromise();
    var bound = callBind(polyfill$3());

    var rebindable = function any(iterable) {
    	// eslint-disable-next-line no-invalid-this
    	return bound(typeof this === 'undefined' ? Promise : this, iterable);
    };

    defineProperties_1(rebindable, {
    	getPolyfill: polyfill$3,
    	implementation: implementation$3,
    	shim: shim$1
    });

    var promise_any = rebindable;

    var APIError = /** @class */ (function (_super) {
        __extends(APIError, _super);
        function APIError(code) {
            var args = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                args[_i - 1] = arguments[_i];
            }
            var _this = _super.apply(this, args) || this;
            _this.code = code;
            _this.name = _this.constructor.name;
            _this.message = code;
            Object.setPrototypeOf(_this, APIError.prototype);
            if (Error.captureStackTrace) {
                Error.captureStackTrace(_this, APIError);
            }
            return _this;
        }
        return APIError;
    }(Error));

    var SDKError = /** @class */ (function (_super) {
        __extends(SDKError, _super);
        function SDKError(message) {
            var args = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                args[_i - 1] = arguments[_i];
            }
            var _this = _super.apply(this, args) || this;
            _this.message = message;
            _this.name = _this.constructor.name;
            _this.message = message;
            Object.setPrototypeOf(_this, SDKError.prototype);
            if (Error.captureStackTrace) {
                Error.captureStackTrace(_this, SDKError);
            }
            return _this;
        }
        return SDKError;
    }(Error));

    /**
     * Use invariant() to assert state which your program assumes to be true.
     *
     * Provide sprintf-style format (only %s is supported) and arguments
     * to provide information about what broke and what you were
     * expecting.
     *
     * The invariant message will be stripped in production, but the invariant
     * will remain to ensure logic does not differ in production.
     */

    var invariant = function(condition, format, a, b, c, d, e, f) {
      {
        if (format === undefined) {
          throw new Error('invariant requires an error message argument');
        }
      }

      if (!condition) {
        var error;
        if (format === undefined) {
          error = new Error(
            'Minified exception occurred; use the non-minified dev environment ' +
            'for the full error message and additional helpful warnings.'
          );
        } else {
          var args = [a, b, c, d, e, f];
          var argIndex = 0;
          error = new Error(
            format.replace(/%s/g, function() { return args[argIndex++]; })
          );
          error.name = 'Invariant Violation';
        }

        error.framesToPop = 1; // we don't care about invariant's own frame
        throw error;
      }
    };

    var browser$1 = invariant;

    (function (ConfirmationType) {
        ConfirmationType["CODE"] = "code";
        ConfirmationType["LINK"] = "link";
    })(exports.ConfirmationType || (exports.ConfirmationType = {}));
    (function (PostMessageEvents) {
        PostMessageEvents["ThemeUpdate"] = "@xsolla-login/sdk:theme-update";
        PostMessageEvents["Close"] = "@xsolla-login/sdk:close";
        PostMessageEvents["Open"] = "@xsolla-login/sdk:open";
        PostMessageEvents["PageOpen"] = "@xsolla-login/sdk:page:open";
        PostMessageEvents["IframeOpen"] = "@xsolla-login/sdk:iframe:open";
        PostMessageEvents["GetRedirectCode"] = "@xsolla-login/sdk:get-redirect-url";
        PostMessageEvents["WidgetStep"] = "@xsolla-login/sdk:widget:step";
        PostMessageEvents["GoogleOneTapOpen"] = "@xsolla-login/sdk:google-one-tap:open";
        PostMessageEvents["GoogleOneTapSuccess"] = "@xsolla-login/sdk:google-one-tap:success";
    })(exports.PostMessageEvents || (exports.PostMessageEvents = {}));
    (function (WidgetPages) {
        WidgetPages["SignUpPage"] = "signUp";
        WidgetPages["LogInPage"] = "logIn";
        WidgetPages["LogInPresetPage"] = "logInUserPreset";
        WidgetPages["ResetPasswordPage"] = "passwordReset";
        WidgetPages["SetPasswordPage"] = "passwordSet";
        WidgetPages["AskPage"] = "ask";
        WidgetPages["ErrorPage"] = "error";
        WidgetPages["SocialsPage"] = "socials";
        WidgetPages["AgreementPage"] = "agreement";
        WidgetPages["TwoFactorPage"] = "otp";
    })(exports.WidgetPages || (exports.WidgetPages = {}));
    (function (CloseSource) {
        CloseSource[CloseSource["Button"] = 0] = "Button";
    })(exports.CloseSource || (exports.CloseSource = {}));
    var SUPPORTED_LANGUAGES = [
        'ar',
        'bg',
        'cs',
        'de',
        'en',
        'es',
        'fr',
        'he',
        'hu',
        'it',
        'ja',
        'ko',
        'pl',
        'pt',
        'ro',
        'ru',
        'th',
        'tr',
        'vi',
        'zh',
    ];

    var defaultLocale = 'en-XX';
    var browserLanguages = [
        // In Chrome, navigator.language is the language of the browser UI, and is not guaranteed to be equal to navigator.languages[0].
        // See https://developer.mozilla.org/en-US/docs/Web/API/NavigatorLanguage/languages
        navigator.language
    ].concat(navigator.languages);
    var getLocale = function (languages, preferredLocale) {
        var findInLanguages = [preferredLocale].concat(languages);
        var result = findInLanguages.find(function (lang) { return !!lang && SUPPORTED_LANGUAGES.includes(lang.substring(0, 2)); }) || defaultLocale;
        browser$1(!preferredLocale || result === preferredLocale, 'Locale "%s" cannot be applied, language code should be one of %s', preferredLocale, SUPPORTED_LANGUAGES);
        return result;
    };
    var getBrowserLocale = function (preferredLang) {
        return getLocale(browserLanguages, preferredLang);
    };

    var sendMessage = function (_a) {
        var message = _a.message, targetOrigin = _a.targetOrigin, target = _a.target, _b = _a.globalObject, globalObject = _b === void 0 ? window : _b;
        var windowParent = globalObject.parent;
        var isTopFrame = windowParent === globalObject;
        if (windowParent && !isTopFrame) {
            var messageType = message.type.replace('@xsolla/login-sdk', '@xsolla-login/sdk');
            switch (messageType) {
                case exports.PostMessageEvents.Close:
                case exports.PostMessageEvents.Open:
                case exports.PostMessageEvents.WidgetStep:
                case exports.PostMessageEvents.PageOpen:
                case exports.PostMessageEvents.GetRedirectCode:
                case exports.PostMessageEvents.GoogleOneTapOpen:
                    // @xsolla-login/sdk
                    windowParent.postMessage(__assign({}, message), targetOrigin);
                    break;
                case exports.PostMessageEvents.ThemeUpdate:
                case exports.PostMessageEvents.IframeOpen:
                case exports.PostMessageEvents.GoogleOneTapSuccess:
                    if (target !== undefined) {
                        target.postMessage(__assign({}, message), targetOrigin);
                    }
                    break;
            }
        }
        else if (target !== undefined) {
            switch (message.type) {
                case exports.PostMessageEvents.PageOpen:
                case exports.PostMessageEvents.ThemeUpdate:
                case exports.PostMessageEvents.GoogleOneTapSuccess:
                case exports.PostMessageEvents.IframeOpen:
                    target.postMessage(__assign({}, message), targetOrigin);
                    break;
            }
        }
    };

    var eventMethod = window.addEventListener
        ? 'addEventListener'
        : 'attachEvent';
    var eventer = window[eventMethod];
    var prefix = eventMethod !== 'addEventListener' ? 'on' : '';
    var attachEvent = function (event, func) {
        eventer(prefix + event, func, false);
    };

    function purify(obj) {
        if (obj === null || obj === void 0)
            return void 0;
        var result = Array.isArray(obj) ? [] : {};
        Object.keys(obj).forEach(function (key) {
            var prop = obj[key];
            if (typeof prop === 'object') {
                result[key] = purify(prop);
            }
            else if (prop !== '') {
                result[key] = prop;
            }
        });
        return result;
    }

    function merge$1(target, source) {
        if (target === void 0)
            return source;
        for (var prop in source) {
            if (prop in target && typeof source[prop] === 'object') {
                merge$1(target[prop], source[prop]);
            }
            else if (source[prop] !== void 0) {
                target[prop] = source[prop];
            }
        }
        return target;
    }

    var getEmailFieldFromUrl = function () {
        var fieldsMapped = [];
        var urlParams = new URLSearchParams(window.location.search);
        var fields = urlParams.getAll('fields');
        if (fields.length !== 0) {
            var fieldsArray = fields[0].split(',');
            for (var _i = 0, fieldsArray_1 = fieldsArray; _i < fieldsArray_1.length; _i++) {
                var field = fieldsArray_1[_i];
                if (field === 'email') {
                    fieldsMapped.push({
                        name: 'email',
                        required: true,
                        type: 'email',
                        validation: { regexps: [] },
                        step: 0,
                    });
                    break;
                }
            }
        }
        return fieldsMapped;
    };

    var watch = createCommonjsModule(function (module) {
    (function () {
        var XsollaAnalytics = function (params) {
            var Config = {
                counterId: 0,
                clientId: 0,
                siteDomains: null,
                server: "",
                hitUrl: "",
                userParamsUrl: "",
                externalId: null,
                extraValues : "",
                hit : true,
                extLink: true,
                click: true,
                scroll: true,
                sendLoadMetrics: false,
                abParams: "",
                isBrowser: (typeof window !== 'undefined')
            };
            var ScrollTimer = null;
            var ScrollFirst = false;
            var ScrollMiddle = false;
            var ScrollBottom = false;
            var LCP = 0;
            var firstHiddenTime = 0;
            Config.isBrowser && (firstHiddenTime = document.visibilityState === 'hidden' ? 0 : Infinity);
        
            var Util = {
                isArray: function (a) {
                    return "function" === typeof Array.isArray ? Array.isArray(a) : "[object Array]" === Object.prototype.toString.call(a)
                },
                isString: function (a) {
                    return "[object String]" === Object.prototype.toString.call(a)
                },
                random: function (a, b) {
                    2 > arguments.length && (b = a, a = 0);
                    1 > arguments.length && (b = 1073741824);
                    return Math.floor(Math.random() * (b - a)) + a
                },
                mergeObjects: function (obj, src) {
                    for (var key in src) {
                        if (src.hasOwnProperty(key)) obj[key] = src[key];
                    }
                    return obj;
                },
                apiHelper: function(eventType, obj){
                    if (eventType != 2) {
                        ScrollFirst = false;
                        ScrollMiddle = false;
                        ScrollBottom = false;
                    }
                    var externalId = obj && obj.eid ? obj.eid : Config.externalId;
                    var exv = obj && obj.exv ? JSON.stringify(obj.exv) : Config.extraValues;
                    var abParams = obj && typeof obj.abParams === 'object' ? JSON.stringify(obj.abParams) : Config.abParams;
                    var data = {
                        et: eventType,
                        eid: externalId
                    };
                    if (exv) {
                        data.exv = exv;
                    }
                    if (abParams) {
                        data.abParams = abParams;
                    }
                    if (typeof obj != "object") {
                        obj = {};
                    }
                    obj = Util.mergeObjects(obj, data);
                    return obj;
                }
            };
            var Browser = {
                firstContentfulPaintTime: function () {
                    if (firstHiddenTime === 0) {
                        return null
                    }
                    var FCP = 0;
                    if (window.performance && window.performance.getEntriesByType) {
                        var paints = window.performance.getEntriesByType('paint');
                        for (var i = 0; i < paints.length; i++){
                            if ("first-contentful-paint" === paints[i].name) {
                                FCP = Math.round(paints[i].startTime);
                                return FCP < firstHiddenTime ? FCP : null;
                            }
                        }
                        return null;
                    }
                    if ("object" === typeof window.chrome && window.chrome.loadTimes) {
                        var a = window.chrome.loadTimes();
                        if (a.requestTime && a.firstPaintTime && window.performance && window.performance.timing) {
                            FCP = Math.round(1E3 * a.firstPaintTime - window.performance.timing.navigationStart);
                            return FCP < firstHiddenTime ? FCP : null;
                        }
                    } else if (window.performance && window.performance.timing && (a = window.performance.timing,
                    a.navigationStart && a.msFirstPaint)) {
                        FCP = a.msFirstPaint - a.navigationStart;
                        return FCP < firstHiddenTime ? FCP : null;
                    }
                    return null
                },
                largestContentfulPaintTime: function() {
                    try {
                        function updateLCP(entry) {
                            if (entry.startTime < firstHiddenTime) {
                                LCP = Math.round(entry.startTime);
                                // отправить LCP для страниц без скролла
                                if (Config.sendLoadMetrics) {
                                    var scrollHeight = document.documentElement.scrollHeight || 0;
                                    var pageHeight = document.documentElement.clientHeight || 0;
                                    if (pageHeight >= scrollHeight) {
                                        Api.eventForLCP();
                                    }
                                }
                            }
                        }
                        var po = new PerformanceObserver(function(entryList) {
                            var entries = entryList.getEntries();
                            for (var i = 0; i < entries.length; i++) {
                                updateLCP(entries[i]);
                            }
                        });
                        po.observe({type: 'largest-contentful-paint', buffered: true});
        
                        document.addEventListener('visibilitychange', function f(){
                            if (document.visibilityState === 'hidden') {
                                document.removeEventListener('visibilitychange', f, true);
                                var rec = [];
                                if (po.takeRecords) {
                                    rec = po.takeRecords();
                                }
                                for (var i = 0; i < rec.length; i++) {
                                    updateLCP(rec[i], po);
                                }
                                po.disconnect();
                            }
                        }, true);
                    } catch (e) {}
                },
                netType: function () {
                    var a = (navigator.connection || {type: ""}).type;
                    return a === undefined ? "" : a
                },
                getLanguage: function () {
                    var a = (window.navigator ? navigator.language || navigator.userLanguage || navigator.browserLanguage || navigator.systemLanguage : "").toLowerCase();
                    return Util.isString(a) ? a : ""
                },
                getJavaEnabled: function () {
                    try {
                        return navigator.javaEnabled()
                    } catch (a) {
                        return !1
                    }
                },
                getNotificationPermission: function () {
                    try {
                        var a = Notification.permission;
                    } catch (b) {
                    }
                    switch (a) {
                        case "denied":
                            return 0;
                        case "granted":
                            return 1
                    }
                },
                isIframe: function () {
                    try {
                        return window.top !== window.self
                    } catch (a) {
                        return !1
                    }
                },
                getCookiesEnabled: function () {
                    if (navigator.cookieEnabled) return true;
                    // set and read cookie
                    document.cookie = "cookietest=1";
                    var ret = document.cookie.indexOf("cookietest=") !== -1;
                    // delete cookie
                    document.cookie = "cookietest=1; expires=Thu, 01-Jan-1970 00:00:01 GMT";
                    return ret;
                },
            };
        
            var Time = {
                getSeconds: function () {
                    return Math.round(+new Date / 1E3)
                },
                getTimezone: function () {
                    return -(new Date).getTimezoneOffset()
                }
            };
        
            var Cookies = {
                getVid: function () {
                    var generateNew = Document.isFromAd();
                    var vid = generateNew ? 0 : this.readM("vid");
        
                    if (!vid) {
                        vid = Time.getSeconds() + "" + Util.random();
                    }
                    this.create("vid", vid, 30);
        
                    return vid;
                },
                getUid: function () {
                    this.globalDomain();
                    var uid = this.readM("uid");
                    var uidLS = this.readLocalStorage("uid");
        
                    if (!uid && !uidLS) {
                        uid = Time.getSeconds() + "" + Util.random();
                        this.create("uid", uid, 1036800);
                        this.createLocalStorage("uid", uid);
                    } else if (!uid && uidLS) {
                        uid = uidLS;
                        this.create("uid", uidLS, 1036800);
                    } else if (uid && !uidLS) {
                        this.createLocalStorage("uid", uid);
                    }
                    return uid;
                },
                getXsollauid: function (id) {
                    this.globalDomain();
                    var xid = this.readM("xsollauid");
                    var xidLS = this.readLocalStorage("xsollauid");
        
                    if (!id) {
                        if (xid && !xidLS) {
                            this.createLocalStorage("xsollauid", xid);
                        } else if (!xid && xidLS) {
                            this.create("xsollauid", xidLS, 5184000);
                        }
                        return xid || xidLS;
                    }
        
                    this.create("xsollauid", id, 5184000);
                    this.createLocalStorage("xsollauid", id);
        
                    return id;
                },
                createLocalStorage: function (name, value) {
                    try {
                        localStorage.setItem(this._prepareName(name), encodeURIComponent(value));
                    } catch(e){}
                },
        
                create: function (name, value, minutes) {
                    var b, a = [this._prepareName(name) + "\x3d" + encodeURIComponent(value)];
                    minutes && (b = new Date, b.setTime(b.getTime() + 6E4 * minutes), a.push("expires\x3d" + b.toGMTString()));
                    this._domain && a.push("domain\x3d" + this._domain);
                    a.push("path\x3d/");
                    try {
                        document.cookie = a.join(";");
                    } catch (d) {
                    }
                },
                globalDomain: function () {
                    this._domain = Document.extractHostname(window.location.host);
                    return this._domain
                },
                readM: function (name) {
                    name = this._prepareName(name);
                    return this.read(name)
                },
                read: function (name) {
                    try {
                        var b = document.cookie;
                    } catch (c) {
                    }
                    return b && b.match(new RegExp("(?:^|;\\s*)" + name + "\x3d([^;]*)")) ? decodeURIComponent(RegExp.$1) : null
                },
                readLocalStorage: function (name) {
                    name = this._prepareName(name);
                    try{
                        return localStorage.getItem(name);
                    } catch(d) {
                        return null;
                    }
                },
                erase: function (name) {
                    this.create(name, "", -1);
                },
                _prepareName: function (name) {
                    if (name === 'xsollauid') {
                        return name
                    }
                    return "_mm_" + name + (Config.counterId ? "_" + Config.counterId : "")
                }
            };
        
            var Document = {
                getDocumentCharset: function () {
                    return ("" + (document.characterSet || document.charset || "")).toLowerCase()
                },
                getRootElement: function () {
                    var a = document.documentElement;
                    return "CSS1Compat" === document.compatMode ? a : document.body || a
                },
                getViewportSize: function () {
                    var a = this.getRootElement();
                    return [a.clientWidth || window.innerWidth, a.clientHeight || window.innerHeight]
                },
                getDocumentTitle: function () {
                    var a = document.title;
                    "string" !== typeof a && (a = (a = document.getElementsByTagName("title")) && a.length ? a[0].innerHTML : "");
                    return a
                },
                isFromAd: function () {
                    if (!document.referrer) {
                        return false;
                    }
        
                    var adSystemSources = ['adfox', 'admitad', 'adnews', 'adnous', 'adriver', 'advmaker', 'aport', 'aport.ru', 'AvitoPromo', 'AvitoContext', 'begun', 'bing', 'B2BContext', 'criteo', 'directadvert', 'directadvert.ru', 'drivenetwork', 'facebook', 'fb', 'facebook.com', 'fb.com', 'giraffio', 'google', 'adwords', 'adsense', 'instagram', 'kavanga', 'ladycenter', 'link', 'magna', 'marketgid', 'medialand', 'merchant', 'moimir', 'nnn', 'nnn.ru', 'odnoklassniki', 'price', 'price.ru', 'prre', 'mytarget', 'targetmailru', 'taboola', 'torg.mail.ru', 'trorer', 'rorer', 'Ttarget', 'ubn.ua', 'banner.ua', 'videonow', 'vkontakte', 'vk', 'vk.com', 'whisla', 'youtube'];
                    var adSystemMediums = ["cpc", "ppc", "paidsearch", "cpv", "cpa", "cpp", "display", "cpm", "banner"];
        
                    var queryParams = window.location.search.replace("?", "").split('&');
                    var hashParams = window.location.hash.replace("#", "").split('&');
                    var params = hashParams.concat(queryParams);
        
                    var isAd = false;
                    params.forEach(function (item) {
                        var p = item.split("=");
                        if (p[0] === "utm_source" && p[1] && adSystemSources.indexOf(p[1])) {
                            return isAd = true;
                        }
                        if (p[0] === "utm_medium" && p[1] && adSystemMediums.indexOf(p[1])) {
                            return isAd = true;
                        }
                    });
        
                    return isAd;
                },
                extractHostname: function (url) {
                    if (url === undefined || url === '') {
                        return '';
                    }
                    var hostname;
                    //find & remove protocol (http, ftp, etc.) and get hostname
        
                    if (url.indexOf("://") > -1) {
                        hostname = url.split('/')[2];
                    } else {
                        hostname = url.split('/')[0];
                    }
        
                    //find & remove port number
                    hostname = hostname.split(':')[0];
                    //find & remove "?"
                    hostname = hostname.split('?')[0];
                    hostname = hostname.replace(/^www\./, '');
                    hostname = hostname.replace('#', '');
        
                    return hostname;
                },
                isExternal: function (linkUrl) {
                    var hostname = this.extractHostname(linkUrl);
                    if (Array.isArray(Config.siteDomains)) {
                        if (Config.siteDomains.indexOf(hostname) > -1 || hostname === '') {
                            return false;
                        }
                    } else {
                        return !(this.extractHostname(window.location.hostname) === hostname || hostname === '')
                    }
                    return true;
                },
                isInternal: function(linkUrl){
                    var hostname = this.extractHostname(linkUrl);
                    var currHostname = this.extractHostname(window.location.hostname);
                    if (currHostname === hostname) {
                        return false;
                    }
                    if (Array.isArray(Config.siteDomains)) {
                        if (Config.siteDomains.indexOf(hostname) > -1  || hostname === '') {
                            return true;
                        }
                    } else {
                        return true;
                    }
                    return false;
                }
            };
        
            var Request = {
                send: function (url, data) {
                    url === Config.hitUrl && (data.ident = this.prepareBrowserInfo());
                    if (Config.xsollauid && url.indexOf('_xm') === -1) {
                        var param = '_xm=' + Config.xsollauid;
                        url = url.indexOf('?') === -1 ? url + '?' + param : url + '&' + param;
                    }
                    var body = typeof data !== 'string' ? JSON.stringify(data) : data;
                    if (!Config.xsollauid && Config.hitCount === 0) {
                        Config.hitCount = 1;
                        this.sendXHR(url, body);
                    } else if (!Config.xsollauid && Config.hitCount === 1) {
                        setTimeout(function () {
                            Config.hitCount = 2;
                            Request.send(url, data);
                        }, 1000);
                    } else if (!this.sendBeacon(url, body)) {
                        this.sendXHR(url, body);
                    }
                },
                sendUserParams: function (data) {
                    data.clid = Config.clientId;
                    data.cid = Config.counterId;
                    var body = JSON.stringify(data);
                    var url = Config.userParamsUrl;
                    if (!this.sendBeacon(url, body)) {
                        this.sendXHR(url, body);
                    }
                },
        
                sendBeacon: function (url, body) {
                    if ("function" === typeof navigator.sendBeacon && navigator.onLine) {
                        navigator.sendBeacon(url, body);
                        return true;
                    }
                    return false;
                },
                sendXHR: function (url, body) {
                    if (window.XMLHttpRequest) {
                        var xhr = new XMLHttpRequest;
                        try {
                            xhr.open("POST", url, true);
                        } catch (e) {
                            return false
                        }
                        xhr.timeout = 10000;
                        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
                        xhr.withCredentials = true;
                        xhr.ontimeout = function () {
                            Request.sendXHR(url, body);
                        };
                        xhr.onload = function () {
                            var xsollauidFromUrl = Request.getValueFromUrl(xhr.responseURL, '_xm');
                            if (xsollauidFromUrl && xsollauidFromUrl !== Config.xsollauid) {
                                Config.xsollauid = Cookies.getXsollauid(xsollauidFromUrl);
                            } else {
                                var xsollauidFromBody = Request.getValueFromBody(xhr.responseText, 'xsollauid');
                                if (xsollauidFromBody && xsollauidFromBody !== Config.xsollauid) {
                                    Config.xsollauid = Cookies.getXsollauid(xsollauidFromBody);
                                }
                            }
                        };
                        xhr.send(body);
                        return true;
                    }
                    return false;
                },
                getValueFromUrl: function(url, key) {
                    if (url && url.indexOf(key + '=') > -1) {
                        var regexp = new RegExp('https?:\/\/.*' + key + '=([^&]*)');
                        var valueFromURL = url.match(regexp);
                        if (valueFromURL && valueFromURL.length > 1) {
                            return valueFromURL[1];
                        }
                    }
                    return null;
                },
                getValueFromBody: function(body, key) {
                    try {
                        var valueFromBody = body ? JSON.parse(body)[key] : null;
                    } catch (e) {
                        valueFromBody = null;
                    }
                    return valueFromBody;
                },
                setXsollauidFromUrl: function (url) {
                    var params = Request.getValueFromUrl(url, '_xm');
                    if (params) {
                        params = params.split('.');
                        if (params && params.length === 2 && params[0] === '' + Config.counterId && params[1] !== Config.xsollauid) {
                            Config.xsollauid = Cookies.getXsollauid(params[1]);
                        }
                    } else {
                        params = Request.getValueFromUrl(url, '_xsollauid');
                        if (params && params !== Config.xsollauid) {
                            Config.xsollauid = Cookies.getXsollauid(params);
                        }
                    }
                },
                prepareBrowserInfo: function () {
                    var p = {};
                    var screen = window.screen;
        
                    var ntf = Browser.getNotificationPermission();
                    ntf !== "" && (p.ntf = ntf);
                    var net = Browser.netType();
                    net !== "" && (p.net = net);
        
                    p.t = Document.getDocumentTitle();
                    p.pc = Document.getDocumentCharset();
                    p.tz = Time.getTimezone();
        
                    var vs = Document.getViewportSize();
                    p.wcw = vs[0];
                    p.wch = vs[1];
        
                    p.plt = Browser.firstContentfulPaintTime();
                    p.lcp = Config.sendLoadMetrics ? LCP : 0;
        
                    p.la = Browser.getLanguage();
                    p.j = Browser.getJavaEnabled() ? 1 : 0;
        
                    p.clid = Config.clientId;
                    p.cid = Config.counterId;
                    p.vid = Cookies.getVid();
                    p.c = Browser.getCookiesEnabled() ? 1 : 0;
                    p.sw = screen.width;
                    p.sh = screen.height;
                    p.sc = screen.colorDepth || screen.pixelDepth;
                    Browser.isIframe() && (p.ifr = 1);
        
                    var yid = Cookies.read("_ym_uid");
                    if (yid) {
                        p.yid = yid;
                    }
                    try {
                        var ga = Cookies.read("_ga");
                        if (ga.length > 0) {
                            ga = ga.split(".");
                            p.gaid = ga[2] + "." + ga[3];
                        }
                    } catch (e) {
                    }
                    var pv = Cookies.read("paystation_visit");
                    if (pv) {
                        p.pv = pv;
                    }
                    var cv = Cookies.read("corpsite_visit");
                    if (cv) {
                        p.cv = cv;
                    }
                    var pav = Cookies.read("pa_visit");
                    if (pav) {
                        p.pav = pav;
                    }
                    var dv = Cookies.read("dev_visit");
                    if (dv) {
                        p.dv = dv;
                    }
                    var fvp = Cookies.read("first_visit");
                    if (fvp) {
                        p.fvp = fvp;
                    }
                    return p
                }
            };
        
            var Events = {
                setHandlers: function (hit, extLink, click, scroll, sendLoadMetrics, crossDomainTracking) {
                    sendLoadMetrics && this.documentVisibilityChange();
                    sendLoadMetrics && this.documentReadyEvent(Browser.largestContentfulPaintTime);
                    hit && this.documentReadyEvent(this.onDocumentReady);
                    extLink && this.documentReadyEvent(this.clickEvent);
                    click && this.documentReadyEvent(this.selectorEvent);
                    scroll && this.documentReadyEvent(this.scrollEvent);
                    crossDomainTracking && this.documentReadyEvent(this.externalTransitionEvent);
                },
                documentReadyEvent: function (func) {
                    if (document.attachEvent ? document.readyState === "complete" : document.readyState !== "loading") {
                        func();
                    } else {
                        document.addEventListener('DOMContentLoaded', func);
                    }
                },
                documentVisibilityChange: function() {
                    document.addEventListener('visibilitychange', function fn(e){
                        if (document.visibilityState === 'hidden') {
                            firstHiddenTime = Math.min(firstHiddenTime, Math.round(e.timeStamp));
                            document.removeEventListener('visibilitychange', fn);
                        }
                    });
                },
                clickEvent: function () {
                    var Anchors = document.getElementsByTagName("a");
                    for (var i = 0; i < Anchors.length; i++) {
                        Events.setEvents(Anchors[i], "click", Events.onClick);
                    }
                },
                setEvents: function (el, eventType, func) {
                    el.addEventListener ? el.addEventListener(eventType, func) : el.attachEvent && el.attachEvent("on" + eventType, func);
                },
                onDocumentReady: function () {
                    var url = window.location.href;
                    var data = {
                        et: 1,
                        url: url,
                        eid: Config.externalId,
                        exv: Config.extraValues,
                        abParams: Config.abParams
                    };
        
                    // не нужно отправлять редирект с дефолтным merchant_id
                    if (data.eid && data.eid === 2340) {
                        return
                    }
        
                    if (document.referrer) {
                        data.referer = document.referrer;
                        if (!Document.isExternal(data.referer)) {
                            data.ss = 1;
                        }
                        Request.setXsollauidFromUrl(url);
                    }
                    Request.send(Config.hitUrl, data);
                },
                onClick: function () {
                    if (Document.isExternal(this.href)) {
                        Request.send(Config.hitUrl, {
                            et: 2,
                            referer: window.location.href,
                            url: this.href,
                            eid: Config.externalId,
                            exv: Config.extraValues,
                            abParams: Config.abParams
                        });
                    }
                },
                selectorEvent: function () {
                    var Anchors = document.querySelectorAll("[data-analytics]");
                    for (var i = 0; i < Anchors.length; i++) {
                        Events.setEvents(Anchors[i], "click", Events.onSelectorClick);
                    }
                },
                onSelectorClick: function () {
                    Request.send(Config.hitUrl, {
                        et: 3,
                        en: this.dataset.analytics,
                        url: window.location.href,
                        eid: Config.externalId,
                        exv: Config.extraValues,
                        abParams: Config.abParams
                    });
                },
                scrollEvent: function () {
                    Events.setEvents(window, "scroll", Events.onScroll);
                },
                onScroll: function () {
                    if (ScrollTimer !== null) {
                        clearTimeout(ScrollTimer);
                    }
                    ScrollTimer = setTimeout(function () {
                        // отправляем скролл только если страница не помещается в экран
                        var scrollTop = document.documentElement.scrollTop || document.body.scrollTop;
                        var scrollHeight = document.documentElement.scrollHeight || document.body.scrollHeight;
                        if (!ScrollFirst && scrollTop > 0) {
                            ScrollFirst = true;
                            Request.send(Config.hitUrl, {
                                et: 10,
                                url: window.location.href,
                                eid: Config.externalId,
                                exv: Config.extraValues,
                                abParams: Config.abParams
                            });
                        }
                        if (!ScrollMiddle && 2 * scrollTop > (scrollHeight - document.documentElement.clientHeight)) {
                            ScrollMiddle = true;
                            Request.send(Config.hitUrl, {
                                et: 11,
                                url: window.location.href,
                                eid: Config.externalId,
                                exv: Config.extraValues,
                                abParams: Config.abParams
                            });
                        }
                        if (!ScrollBottom && scrollTop >= (scrollHeight - document.documentElement.clientHeight) * 0.9) {
                            ScrollBottom = true;
                            Request.send(Config.hitUrl, {
                                et: 12,
                                url: window.location.href,
                                eid: Config.externalId,
                                exv: Config.extraValues,
                                abParams: Config.abParams
                            });
                        }
        
        
                    }, 150);
                },
                onFormSubmit: function () {
                },
                externalTransitionEvent: function() {
                    Events.setEvents(document, "mousedown", Events.onExternalTransition);
                    Events.setEvents(document, "keyup", Events.onExternalTransition);
                },
                onExternalTransition: function(e) {
                    e = e || window.event;
                    a: {
                        var trg = e.target || e.srcElement;
                        for (e = 100; trg && 0 < e; ) {
                            if (trg.href && trg.nodeName.match(/^a(?:rea)?$/i)) {
                                var l = trg;
                                break a
                            }
                            trg = trg.parentNode;
                            e--;
                        }
                        l = {};
                    }
                    if (("http:" === l.protocol || "https:" === l.protocol) && l.href && Document.isInternal(l.href)) {
                        if (!(l.href.indexOf('_xm=') > -1) && Config.xsollauid && Config.counterId) {
                            var newParam = '_xm=' + Config.counterId + '.' + Config.xsollauid;
                            l.href = l.href.indexOf('?') !== -1 ? l.href + '&' + newParam : l.href + '?' + newParam;
                        }
                    }
                }
            };
        
            var Api = {
                hit: function (url, obj) {
                    if (!Config.isBrowser) { return }
                    var dataObj = Util.apiHelper(1, obj);
                    var ref = (window.location != window.parent.location) ? document.referrer : document.location.href;
                    var refererUrl = dataObj && dataObj.referer ? dataObj.referer : ref;
                    dataObj.referer = refererUrl;
                    if (dataObj.referer != document.location.href) {
                        Request.setXsollauidFromUrl(url);
                    }
                    dataObj.url = url;
                    Request.send(Config.hitUrl, dataObj);
                },
                externalLink: function (url, obj) {
                    if (!Config.isBrowser) { return }
                    var dataObj = Util.apiHelper(2, obj);
                    dataObj.referer = window.location.href;
                    dataObj.url = url;
                    Request.send(Config.hitUrl, dataObj);
                },
                elementClick: function (name, obj) {
                    if (!Config.isBrowser) { return }
                    var dataObj = Util.apiHelper(3, obj);
                    dataObj.url = window.location.href;
                    dataObj.en = name;
                    Request.send(Config.hitUrl, dataObj);
                },
                formData: function (name, formData, obj) {
                    if (!Config.isBrowser) { return }
                    var dataObj = Util.apiHelper(4, obj);
                    dataObj.url = window.location.href;
                    var formDataStr = formData ? JSON.stringify(formData) : "";
                    dataObj.form = formDataStr;
                    dataObj.en = name;
                    Request.send(Config.hitUrl, dataObj);
                },
                customEvent: function (name, obj) {
                    if (!Config.isBrowser) { return }
                    var dataObj = Util.apiHelper(5, obj);
                    dataObj.url = window.location.href;
                    dataObj.en = name;
                    Request.send(Config.hitUrl, dataObj);
                },
                eventForLCP: function () {
                    if (!Config.isBrowser) { return }
                    var dataObj = {
                        et: 6,
                        url: window.location.href
                    };
                    Request.send(Config.hitUrl, dataObj);
                },
                setABParams: function (obj) {
                    if (!Config.isBrowser) { return }
                    Config.abParams = typeof obj === 'object' ? JSON.stringify(obj) : "";
                },
                setUserParams: function (obj) {
                    var dataObj = typeof obj != 'object' ? "" : {uprm: obj};
                    dataObj && Request.sendUserParams(dataObj);
                },
                addXsollauidToUrl: function(url) {
                    if (url.indexOf('_xsollauid\x3d') > -1) { return url }
                    var xuid = Cookies.getXsollauid();
                    var xuidParam = xuid ? '_xsollauid\x3d' + xuid : '';
                    var newUrl = xuidParam ? (url.indexOf('?') !== -1 ? url + '&' + xuidParam : url + '?' + xuidParam) : url;
                    return newUrl
                },
                sendCustomData: function (route, data) {
                    var url = route ? Config.server + '/' + route : "";
                    var xuidParam = Config.xsollauid ? '_xm\x3d' + Config.xsollauid : '';
                    url = xuidParam ? (url.indexOf('?') !== -1 ? url + '&' + xuidParam : url + '?' + xuidParam) : url;
                    url && Request.send(url, data);
                }
            };

            Config.counterId = params.id;
            Config.siteDomains = params.siteDomains;
            var server = params.server.match(/(https?:\/\/[^\/]*)/g);
            Config.server = server && server.length ? server[0] : console.log('Не удалось извлечь адрес сервера! Установлено значение по умолчанию - https://datagather.xsolla.com') || 'https://datagather.xsolla.com';
            Config.hitUrl = Config.server + '/hit';
            Config.userParamsUrl = Config.server + '/users_params';
            Config.externalId = params.externalId || params.merchantId;
            Config.extraValues = params.extraValues ? JSON.stringify(params.extraValues) : "";
            Config.hit = typeof params.hit != "undefined" ? params.hit : true;
            Config.extLink = typeof params.extLink != "undefined" ? params.extLink : true;
            Config.click = typeof params.click != "undefined" ? params.click : true;
            Config.scroll = typeof params.scroll != "undefined" ? params.scroll : true;
            Config.sendLoadMetrics = typeof params.sendLoadMetrics != "undefined" ? params.sendLoadMetrics : false;
            Config.crossDomainTracking = typeof params.crossDomainTracking != "undefined" ? params.crossDomainTracking : true;
            Config.hitCount = 0;
            if (Config.isBrowser) {
                Config.clientId = Cookies.getUid();
                Config.visitId = Cookies.getVid();
                Config.xsollauid = params.xsollauid || Cookies.getXsollauid();
                params.abParams && Api.setABParams(params.abParams);
                Config.server && Config.counterId && Events.setHandlers(Config.hit, Config.extLink, Config.click, Config.scroll, Config.sendLoadMetrics, Config.crossDomainTracking);
                params.userParams && Api.setUserParams(params.userParams);
            }
            return Api;
        };

        if (typeof window !== 'undefined') {
            window.XsollaAnalytics = XsollaAnalytics;
        } else {
            module.exports = XsollaAnalytics;
        }
    })();
    });

    (function (MetrikaEventNames) {
        MetrikaEventNames["initiate"] = "login-widget_sign-in_initiate";
        MetrikaEventNames["secure_account"] = "login-widget_sign-in_secure-account";
        MetrikaEventNames["email_confirm"] = "login-widget_email-verification_confirm";
        MetrikaEventNames["confirm_secure_email"] = "login-widget_email-verification_secure-confirm";
        MetrikaEventNames["phone_confirm"] = "login-widget_phone-verification_confirm";
        MetrikaEventNames["confirm_secure_phone"] = "login-widget_phone-verification_secure-confirm";
        MetrikaEventNames["sign_up"] = "login-widget_sign-up_email";
        MetrikaEventNames["reset_pass_init"] = "login-widget_reset-pass_initiate";
        MetrikaEventNames["widget_open"] = "login-widget_opening_initiate";
    })(exports.MetrikaEventNames || (exports.MetrikaEventNames = {}));
    var initAnalytics = function (projectId, analyticsProductName) {
        try {
            var xsollaDomains = ['login-widget.xsolla.com'];
            var extraValues = {
                projectId: projectId,
            };
            if (analyticsProductName) {
                extraValues.productName = analyticsProductName;
            }
            window.XA = new window.XsollaAnalytics({
                extraValues: extraValues,
                id: 2222,
                server: 'https://datagather.xsolla.com/hit',
                siteDomains: xsollaDomains,
                sendLoadMetrics: true,
            });
            return true;
        }
        catch (e) {
            return e;
        }
    };
    var getMetrikaEventName = function (eventName) {
        if (typeof eventName === 'object') {
            var block = eventName.block, section = eventName.section, action = eventName.action;
            return "lg_" + block + "_" + section + "_" + action;
        }
        return "lg_" + eventName;
    };
    var addEvent = function (eventName, options) {
        var event = getMetrikaEventName(eventName);
        if (window.XA) {
            window.XA.elementClick(event, options);
        }
    };
    var openEvent = function (url, options) {
        if (window.XA) {
            window.XA.hit(url, options);
        }
    };

    // Object for country to region mapping for social ranking
    // 1 - Europe
    // 2 - China
    // 3 - Korea
    // 4 - CIS
    // 5 - America
    // 6 - World (All other countries)
    var regionMap = {
        AD: 6,
        AE: 6,
        AF: 6,
        AG: 6,
        AI: 6,
        AL: 1,
        AM: 4,
        AO: 6,
        AQ: 6,
        AR: 4,
        AS: 5,
        AT: 1,
        AU: 6,
        AW: 5,
        AX: 1,
        AZ: 4,
        BA: 1,
        BB: 5,
        BD: 6,
        BE: 1,
        BF: 6,
        BG: 1,
        BH: 6,
        BI: 6,
        BJ: 6,
        BL: 5,
        BM: 5,
        BN: 6,
        BO: 5,
        BQ: 5,
        BR: 5,
        BS: 5,
        BT: 6,
        BV: 6,
        BW: 6,
        BY: 4,
        BZ: 5,
        CA: 5,
        CC: 5,
        CD: 6,
        CF: 6,
        CG: 6,
        CH: 1,
        CI: 6,
        CK: 6,
        CL: 1,
        CM: 6,
        CN: 2,
        CO: 1,
        CR: 1,
        CU: 1,
        CV: 6,
        CW: 5,
        CX: 6,
        CY: 1,
        CZ: 1,
        DE: 1,
        DJ: 6,
        DK: 1,
        DM: 5,
        DO: 5,
        DZ: 6,
        EC: 5,
        EE: 1,
        EG: 6,
        EH: 6,
        ER: 6,
        ES: 1,
        ET: 6,
        FI: 1,
        FJ: 6,
        FK: 5,
        FM: 5,
        FO: 6,
        FR: 1,
        GA: 6,
        GB: 1,
        GD: 5,
        GE: 4,
        GF: 5,
        GG: 1,
        GH: 6,
        GI: 1,
        GL: 6,
        GM: 6,
        GN: 6,
        GP: 5,
        GQ: 6,
        GR: 1,
        GS: 1,
        GT: 5,
        GU: 6,
        GW: 6,
        GY: 6,
        HK: 2,
        HM: 6,
        HN: 5,
        HR: 1,
        HT: 5,
        HU: 1,
        ID: 6,
        IE: 1,
        IL: 6,
        IM: 1,
        IN: 6,
        IO: 6,
        IQ: 6,
        IR: 6,
        IS: 6,
        IT: 1,
        JE: 1,
        JM: 5,
        JO: 6,
        JP: 6,
        KE: 6,
        KG: 4,
        KH: 6,
        KI: 6,
        KM: 6,
        KN: 5,
        KP: 3,
        KR: 3,
        KW: 6,
        KY: 5,
        KZ: 4,
        LA: 6,
        LB: 6,
        LC: 5,
        LI: 1,
        LK: 6,
        LR: 6,
        LS: 6,
        LT: 1,
        LU: 1,
        LV: 1,
        LY: 6,
        MA: 6,
        MC: 1,
        MD: 4,
        ME: 1,
        MF: 1,
        MG: 6,
        MH: 6,
        MK: 1,
        ML: 6,
        MM: 6,
        MN: 6,
        MO: 2,
        MP: 6,
        MQ: 1,
        MR: 5,
        MS: 5,
        MT: 1,
        MU: 6,
        MV: 6,
        MW: 6,
        MX: 5,
        MY: 6,
        MZ: 6,
        NA: 6,
        NC: 6,
        NE: 6,
        NF: 6,
        NG: 6,
        NI: 5,
        NL: 1,
        NO: 1,
        NP: 6,
        NR: 6,
        NU: 6,
        NZ: 6,
        OM: 6,
        PA: 5,
        PE: 5,
        PF: 6,
        PG: 6,
        PH: 6,
        PK: 6,
        PL: 1,
        PM: 5,
        PN: 6,
        PR: 6,
        PS: 6,
        PT: 1,
        PW: 6,
        PY: 5,
        QA: 6,
        RE: 6,
        RO: 1,
        RS: 1,
        RU: 4,
        RW: 6,
        SA: 6,
        SB: 6,
        SC: 6,
        SD: 6,
        SE: 1,
        SG: 6,
        SH: 6,
        SI: 1,
        SJ: 6,
        SK: 1,
        SL: 6,
        SM: 1,
        SN: 6,
        SO: 6,
        SR: 5,
        SS: 6,
        ST: 6,
        SV: 5,
        SX: 5,
        SY: 6,
        SZ: 6,
        TC: 5,
        TD: 6,
        TF: 6,
        TG: 6,
        TH: 6,
        TJ: 4,
        TK: 6,
        TL: 6,
        TM: 4,
        TN: 6,
        TO: 6,
        TR: 1,
        TT: 5,
        TV: 6,
        TW: 2,
        TZ: 6,
        UA: 4,
        UG: 6,
        UM: 6,
        US: 5,
        UY: 5,
        UZ: 4,
        VA: 1,
        VC: 5,
        VE: 5,
        VG: 6,
        VI: 6,
        VN: 6,
        VU: 6,
        WF: 1,
        WS: 6,
        YE: 6,
        YT: 6,
        ZA: 6,
        ZM: 6,
        ZW: 6,
        ZZ: 6,
    };

    var getParsedSettings = function (settings) {
        var tos_url = settings.tos_url, consent_url = settings.consent_url, cookie_policy = settings.cookie_policy, privacy_policy = settings.privacy_policy;
        var locale = 'en';
        if (navigator.language) {
            locale = navigator.language.trim().split(/-|_/)[0];
        }
        return __assign({}, settings, { tos_url: appendLocale(tos_url, locale), consent_url: appendLocale(consent_url, locale), cookie_policy: appendLocale(cookie_policy, locale), privacy_policy: appendLocale(privacy_policy, locale) });
    };
    var appendLocale = function (url, locale) {
        if (!url) {
            return '';
        }
        if (url.includes('?')) {
            return url + "&xsolla_lang=" + locale;
        }
        return url + "?xsolla_lang=" + locale;
    };
    var getParsedSocials = function (socialResp, country, isOauth2, params) {
        var projectId = params.projectId, _a = params.client_id, client_id = _a === void 0 ? '' : _a, _b = params.scope, scope = _b === void 0 ? '' : _b, _c = params.state, state = _c === void 0 ? '' : _c, _d = params.response_type, response_type = _d === void 0 ? '' : _d, _e = params.redirect_uri, redirect_uri = _e === void 0 ? '' : _e, _f = params.login_url, login_url = _f === void 0 ? '' : _f;
        var paramsString = isOauth2
            ? "?client_id=" + client_id + "&redirect_uri=" + redirect_uri + "&response_type=" + response_type + "&scope=" + scope + "&state=" + state
            : "?projectId=" + projectId + "&login_url=" + login_url;
        var socials = socialResp[regionMap[country]];
        return {
            primary: __assign({}, socials.primary.map(function (item) { return ({
                name: item.name,
                url: isOauth2
                    ? "" + item.oauth2 + paramsString
                    : "" + item.jwt + paramsString,
            }); })),
            secondary: __assign({}, socials.secondary.map(function (item) { return ({
                name: item.name,
                url: isOauth2
                    ? "" + item.oauth2 + paramsString
                    : "" + item.jwt + paramsString,
            }); })),
            other: [],
            showOtherLink: false,
        };
    };

    var initGoogleOneTap = function (appId, callback) {
        var googleLibScript = document.createElement('script');
        googleLibScript.type = 'text/javascript';
        googleLibScript.src = 'https://accounts.google.com/gsi/client';
        googleLibScript.async = true;
        googleLibScript.defer = true;
        document.getElementsByTagName('head')[0].appendChild(googleLibScript);
        // @ts-ignore
        window.onGoogleLibraryLoad = function () {
            // @ts-ignore
            window.google.accounts.id.initialize({
                client_id: appId,
                callback: function (data) { return callback(data); },
                context: 'signin',
                cancel_on_tap_outside: false,
            });
            // @ts-ignore
            window.google.accounts.id.prompt();
        };
    };

    function getUrlVersion(pathname) {
        var urlVersionMatch = pathname.match(/\/([^/]+)\//);
        return urlVersionMatch !== null ? urlVersionMatch[1] : 'latest';
    }
    function getPageName(pathname) {
        var match = pathname.lastIndexOf('/');
        return pathname.substring(match + 1, pathname.length);
    }

    var defaultTheme = {
        background: {
            color: '#FFFFFF',
            image: {
                url: '',
                opacity: '1',
            },
        },
        primary_color: '#0073F7',
        secondary_color: '#DADADA',
        text_color: '#000000',
        error_color: '#eb002f',
        button_image: '',
        rounding: {
            inputs: '6px',
            buttons: '100px',
            widget: '6px',
        },
        scene: {
            color: '#f7faff',
        },
    };
    var defaultConfig = {
        apiUrl: 'https://login.xsolla.com/api/',
        cdnUrl: 'https://cdn.xsolla.net/login-widget/',
        consentUrl: 'https://consent-api.xsolla.com/v2/consen',
        projectId: '',
        theme: defaultTheme,
        is_oauth2: false,
    };

    var parseError = function (responseData) {
        return (responseData &&
            responseData.data &&
            responseData.data.error &&
            responseData.data.error.code) ||
            null;
    };
    var oauthTwoGetParams = [
        'clientId',
        'scope',
        'state',
        'redirectUri',
        'responseType',
    ];
    var jwtAuthGetParams = [
        'projectId',
        'fullLocale',
        'callbackUrl',
        'payload',
        'with_logout',
    ];
    var sendLetterParams = ['emailTemplate'];
    var otpGetParams = ['challenge_id', 'fullLocale'];
    var collectParams = function (config, addGetParams) {
        if (addGetParams === void 0) { addGetParams = []; }
        var params = {
            projectId: config.projectId,
        };
        addGetParams.forEach(function (param) {
            if (config[param]) {
                switch (param) {
                    case 'callbackUrl':
                        params.login_url = config.callbackUrl;
                        break;
                    case 'fullLocale':
                        params.locale = config.fullLocale
                            ? config.fullLocale.replace('-', '_')
                            : config.fullLocale;
                        break;
                    case 'clientId':
                        params.client_id = config.clientId;
                        break;
                    case 'redirectUri':
                        params.redirect_uri = config.redirectUri;
                        break;
                    case 'responseType':
                        params.response_type = config.responseType;
                        break;
                    case 'emailTemplate':
                        params.email_template = config.emailTemplate;
                        break;
                    default:
                        params[param] = config[param];
                        break;
                }
            }
        });
        return params;
    };

    axios$1.defaults.withCredentials = true;
    var Api = /** @class */ (function () {
        function Api(config) {
            this.config = defaultConfig;
            this.updateConfig(config);
        }
        Api.prototype.updateConfig = function (config) {
            var puredConfig = purify(config);
            merge$1(this.config, puredConfig);
            var _a = this.config, clientId = _a.clientId, redirectUri = _a.redirectUri, responseType = _a.responseType, state = _a.state;
            if (clientId && responseType && redirectUri && state) {
                this.config.is_oauth2 = true;
            }
            return this.config;
        };
        Api.prototype.fetchConfig = function () {
            var _this = this;
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams));
            var _a = this.config, settingsJSON = _a.settingsJSON, socialsJSON = _a.socialsJSON, themeJSON = _a.themeJSON;
            var projectId = this.config.projectId;
            // Для использования mock запроса настроек, используйте запрос к this.config.settingsUrl
            var getSettings = [
                axios$1.get(settingsJSON
                    ? settingsJSON
                    : "https://cdn.xsolla.net/xsolla-login-widget/projects/" + projectId + "/settings/auth", { withCredentials: false }),
                axios$1.get(socialsJSON
                    ? socialsJSON
                    : "https://cdn.xsolla.net/xsolla-login-widget/projects/" + projectId + "/settings/socials/by_region", { withCredentials: false }),
                axios$1.get(themeJSON
                    ? themeJSON
                    : "https://cdn.xsolla.net/xsolla-login-widget/projects/" + projectId + "/settings/widget", { withCredentials: false }),
                axios$1.get(this.config.apiUrl + "/client/details"),
            ];
            var newSettings = Promise.all(getSettings);
            var oldSettings = axios$1.get(this.config.apiUrl + "/widget/ng/settings", {
                params: params,
            });
            return promise_any([newSettings, oldSettings])
                .then(function (response) {
                if (!response.data) {
                    var _a = response, settingsResp = _a[0], socialResp = _a[1], themeResp = _a[2], clientResp = _a[3];
                    var clientCountry = clientResp.data.geo_ip_country;
                    var parsedSocials = getParsedSocials(socialResp.data, clientCountry, _this.config.is_oauth2 || false, params);
                    var parsedSettings = getParsedSettings(settingsResp.data);
                    return _this.updateConfig(__assign({ apiUrl: '', projectId: '' }, parsedSettings, { social_links: __assign({}, parsedSocials), theme: themeResp.data, geo_ip_country: clientCountry }));
                }
                return _this.updateConfig(response.data);
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.signup = function (_a) {
            var userInfo = _a.userInfo, recaptcha = _a.recaptcha;
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams, sendLetterParams));
            var headers = {};
            if (recaptcha) {
                headers['X-Captcha-Token'] = recaptcha.token;
            }
            return axios$1
                .post("" + this.config.apiUrl + (this.config.is_oauth2 ? '/oauth2/user' : '/user'), userInfo, {
                params: params,
                headers: headers,
                withCredentials: true,
            })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.login = function (_a) {
            var credentials = _a.credentials, recaptcha = _a.recaptcha;
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams));
            var headers = {};
            if (this.config.callbackUrl) {
                params.login_url = this.config.callbackUrl;
            }
            if (recaptcha) {
                headers['X-Captcha-Token'] = recaptcha.token;
            }
            return axios$1
                .post("" + this.config.apiUrl + (this.config.is_oauth2 ? '/oauth2/login' : '/login'), credentials, {
                params: params,
                headers: headers,
            })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.agreement = function (_a) {
            var token = _a.token, isAccepted = _a.isAccepted, consentId = _a.consentId;
            var params = {
                token: token,
                projectId: this.config.projectId,
                accept_consent: isAccepted,
            };
            if (consentId)
                params.consent_id = consentId;
            return axios$1
                .put(this.config.apiUrl + "/social/consent", params)
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.reset = function (username) {
            var params = collectParams(this.config, jwtAuthGetParams.concat(sendLetterParams));
            if (this.config.callbackUrl)
                params.login_url = this.config.callbackUrl;
            return axios$1
                .post(this.config.apiUrl + "/password/reset/request", username, {
                params: params,
            })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.set = function (setParams) {
            var params = collectParams(this.config, jwtAuthGetParams);
            if (this.config.callbackUrl)
                params.login_url = this.config.callbackUrl;
            var body = {
                new_password: setParams.newPassword,
                reset_code: setParams.code,
                user_id: setParams.user_id,
            };
            return axios$1
                .post(this.config.apiUrl + "/password/reset/confirm", body, {
                params: params,
            })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.getConfirmCode = function (confirmParams) {
            var params = {
                projectId: this.config.projectId,
                login: confirmParams.login,
                operation_id: confirmParams.operation_id,
            };
            return axios$1
                .get(this.config.apiUrl + "/otc/code", {
                params: params,
                cancelToken: confirmParams.cancelToken.token,
            })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.ask = function (askParams) {
            var _a;
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams, sendLetterParams));
            var settingsData = (_a = {},
                _a[askParams.fields.email ? 'email' : 'phone_number'] = {
                    link_url: askParams.link_url,
                    send_link: !this.config.disableConfirmByLink,
                },
                _a);
            var body = {
                updatedFields: askParams.fields,
                token: askParams.token,
                settings: settingsData,
                email: this.config.is_oauth2 ? askParams.fields.email : '',
            };
            return axios$1
                .post("" + this.config.apiUrl + (this.config.is_oauth2 ? '/oauth2/user/ask' : '/token/update'), body, {
                params: params,
            })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.getAskFields = function (token) {
            var params = { projectId: this.config.projectId };
            var headers = {};
            headers.Authorization = "Bearer " + token;
            return axios$1
                .get(this.config.apiUrl + "/users/me/ask", {
                params: params,
                headers: headers,
            })
                .then(function (resp) {
                if (resp.data.length !== 0) {
                    return resp.data;
                }
                return getEmailFieldFromUrl();
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.otpLogin = function (_a) {
            var code = _a.code, _b = _a.remember_me, remember_me = _b === void 0 ? true : _b;
            var params = collectParams(this.config, otpGetParams);
            return axios$1
                .get(this.config.apiUrl + "/otp/validate", {
                params: {
                    code: code,
                    remember_me: remember_me,
                    challenge_id: params.challenge_id,
                },
            })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var apiCode = parseError(error.response);
                if (apiCode) {
                    throw new APIError(apiCode);
                }
                throw error;
            });
        };
        Api.prototype.otpResendCode = function () {
            var params = collectParams(this.config, otpGetParams);
            return axios$1
                .put(this.config.apiUrl + "/otp/resend", { locale: params.locale }, { params: { challenge_id: params.challenge_id } })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var apiCode = parseError(error.response);
                if (apiCode) {
                    throw new APIError(apiCode);
                }
                throw error;
            });
        };
        Api.prototype.phoneGetCode = function (_a) {
            var phone_number = _a.phone_number, link_url = _a.link_url, isOauth2 = _a.isOauth2;
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams));
            var postUrl = "" + this.config.apiUrl + (isOauth2 ? '/oauth2' : '') + "/login/phone/request";
            return axios$1
                .post(postUrl, {
                link_url: link_url,
                phone_number: phone_number || '',
                send_link: !this.config.disableConfirmByLink,
            }, { params: params })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var apiCode = parseError(error.response);
                if (apiCode) {
                    throw new APIError(apiCode);
                }
                throw error;
            });
        };
        Api.prototype.loginWithPhoneCode = function (_a) {
            var phone_number = _a.phone_number, code = _a.code, operation_id = _a.operation_id, isOauth2 = _a.isOauth2;
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams));
            var postUrl = "" + this.config.apiUrl + (isOauth2 ? '/oauth2' : '') + "/login/phone/confirm";
            return axios$1
                .post(postUrl, { phone_number: phone_number, code: code, operation_id: operation_id }, { params: params })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var apiCode = parseError(error.response);
                if (apiCode) {
                    throw new APIError(apiCode);
                }
                throw error;
            });
        };
        Api.prototype.emailGetCode = function (_a) {
            var email = _a.email, isOauth2 = _a.isOauth2, link_url = _a.link_url;
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams));
            var postUrl = "" + this.config.apiUrl + (isOauth2 ? '/oauth2' : '') + "/login/email/request";
            return axios$1
                .post(postUrl, {
                link_url: link_url,
                email: email || '',
                send_link: !this.config.disableConfirmByLink,
            }, { params: params })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var apiCode = parseError(error.response);
                if (apiCode) {
                    throw new APIError(apiCode);
                }
                throw error;
            });
        };
        // }: EmailSetConfirmCode): Promise<Response> {
        Api.prototype.loginWithEmailCode = function (_a) {
            var email = _a.email, code = _a.code, operation_id = _a.operation_id, isOauth2 = _a.isOauth2;
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams));
            var postUrl = "" + this.config.apiUrl + (isOauth2 ? '/oauth2' : '') + "/login/email/confirm";
            return axios$1
                .post(postUrl, { email: email, code: code, operation_id: operation_id }, { params: params })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var apiCode = parseError(error.response);
                if (apiCode) {
                    throw new APIError(apiCode);
                }
                throw error;
            });
        };
        Api.prototype.resendEmail = function (username) {
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams, sendLetterParams));
            return axios$1
                .post("" + this.config.apiUrl + (this.config.is_oauth2 ? '/oauth2' : '') + "/user/resend_confirmation_link", { username: username }, { params: params })
                .then(function (resp) {
                return resp.data;
            })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.oneTapLogin = function (accessToken, providerName) {
            var params = collectParams(this.config, jwtAuthGetParams.concat(oauthTwoGetParams));
            return axios$1
                .post("" + this.config.apiUrl + (this.config.is_oauth2 ? '/oauth2' : '') + "/social/" + providerName + "/one_tap/complete", {
                access_token: accessToken,
            }, { params: params })
                .then(function (resp) { return resp.data; })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.checkUserAuthSSO = function () {
            var params = collectParams(this.config, jwtAuthGetParams);
            return axios$1
                .get(this.config.apiUrl + "/jwt/sso", { params: params })
                .then(function (resp) { return resp.data; })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.userAuthSSOWithRedirect = function (loginUrl) {
            var params = collectParams(this.config, jwtAuthGetParams);
            return axios$1
                .get(this.config.apiUrl + "/jwt/sso/redirect", {
                params: __assign({}, params, { login_url: loginUrl }),
            })
                .then(function (resp) { return resp.data; })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        Api.prototype.logout = function (token, session) {
            var headers = {};
            headers.Authorization = "Bearer " + token;
            return axios$1
                .get(this.config.apiUrl + "/oauth2/logout", {
                headers: headers,
                params: {
                    sessions: session,
                },
            })
                .then(function (resp) { return resp.data; })
                .catch(function (error) {
                var code = parseError(error.response);
                if (code) {
                    throw new APIError(code);
                }
                throw error;
            });
        };
        return Api;
    }());

    // Copyright Joyent, Inc. and other Node contributors.

    var R = typeof Reflect === 'object' ? Reflect : null;
    var ReflectApply = R && typeof R.apply === 'function'
      ? R.apply
      : function ReflectApply(target, receiver, args) {
        return Function.prototype.apply.call(target, receiver, args);
      };

    var ReflectOwnKeys;
    if (R && typeof R.ownKeys === 'function') {
      ReflectOwnKeys = R.ownKeys;
    } else if (Object.getOwnPropertySymbols) {
      ReflectOwnKeys = function ReflectOwnKeys(target) {
        return Object.getOwnPropertyNames(target)
          .concat(Object.getOwnPropertySymbols(target));
      };
    } else {
      ReflectOwnKeys = function ReflectOwnKeys(target) {
        return Object.getOwnPropertyNames(target);
      };
    }

    function ProcessEmitWarning(warning) {
      if (console && console.warn) console.warn(warning);
    }

    var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
      return value !== value;
    };

    function EventEmitter() {
      EventEmitter.init.call(this);
    }
    var events = EventEmitter;

    // Backwards-compat with node 0.10.x
    EventEmitter.EventEmitter = EventEmitter;

    EventEmitter.prototype._events = undefined;
    EventEmitter.prototype._eventsCount = 0;
    EventEmitter.prototype._maxListeners = undefined;

    // By default EventEmitters will print a warning if more than 10 listeners are
    // added to it. This is a useful default which helps finding memory leaks.
    var defaultMaxListeners = 10;

    Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
      enumerable: true,
      get: function() {
        return defaultMaxListeners;
      },
      set: function(arg) {
        if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
        }
        defaultMaxListeners = arg;
      }
    });

    EventEmitter.init = function() {

      if (this._events === undefined ||
          this._events === Object.getPrototypeOf(this)._events) {
        this._events = Object.create(null);
        this._eventsCount = 0;
      }

      this._maxListeners = this._maxListeners || undefined;
    };

    // Obviously not all Emitters should be limited to 10. This function allows
    // that to be increased. Set to zero for unlimited.
    EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
      if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
      }
      this._maxListeners = n;
      return this;
    };

    function $getMaxListeners(that) {
      if (that._maxListeners === undefined)
        return EventEmitter.defaultMaxListeners;
      return that._maxListeners;
    }

    EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
      return $getMaxListeners(this);
    };

    EventEmitter.prototype.emit = function emit(type) {
      var args = [];
      for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
      var doError = (type === 'error');

      var events = this._events;
      if (events !== undefined)
        doError = (doError && events.error === undefined);
      else if (!doError)
        return false;

      // If there is no 'error' event listener then throw.
      if (doError) {
        var er;
        if (args.length > 0)
          er = args[0];
        if (er instanceof Error) {
          // Note: The comments on the `throw` lines are intentional, they show
          // up in Node's output if this results in an unhandled exception.
          throw er; // Unhandled 'error' event
        }
        // At least give some kind of context to the user
        var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
        err.context = er;
        throw err; // Unhandled 'error' event
      }

      var handler = events[type];

      if (handler === undefined)
        return false;

      if (typeof handler === 'function') {
        ReflectApply(handler, this, args);
      } else {
        var len = handler.length;
        var listeners = arrayClone(handler, len);
        for (var i = 0; i < len; ++i)
          ReflectApply(listeners[i], this, args);
      }

      return true;
    };

    function _addListener(target, type, listener, prepend) {
      var m;
      var events;
      var existing;

      if (typeof listener !== 'function') {
        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
      }

      events = target._events;
      if (events === undefined) {
        events = target._events = Object.create(null);
        target._eventsCount = 0;
      } else {
        // To avoid recursion in the case that type === "newListener"! Before
        // adding it to the listeners, first emit "newListener".
        if (events.newListener !== undefined) {
          target.emit('newListener', type,
                      listener.listener ? listener.listener : listener);

          // Re-assign `events` because a newListener handler could have caused the
          // this._events to be assigned to a new object
          events = target._events;
        }
        existing = events[type];
      }

      if (existing === undefined) {
        // Optimize the case of one listener. Don't need the extra array object.
        existing = events[type] = listener;
        ++target._eventsCount;
      } else {
        if (typeof existing === 'function') {
          // Adding the second element, need to change to array.
          existing = events[type] =
            prepend ? [listener, existing] : [existing, listener];
          // If we've already got an array, just append.
        } else if (prepend) {
          existing.unshift(listener);
        } else {
          existing.push(listener);
        }

        // Check for listener leak
        m = $getMaxListeners(target);
        if (m > 0 && existing.length > m && !existing.warned) {
          existing.warned = true;
          // No error code for this since it is a Warning
          // eslint-disable-next-line no-restricted-syntax
          var w = new Error('Possible EventEmitter memory leak detected. ' +
                              existing.length + ' ' + String(type) + ' listeners ' +
                              'added. Use emitter.setMaxListeners() to ' +
                              'increase limit');
          w.name = 'MaxListenersExceededWarning';
          w.emitter = target;
          w.type = type;
          w.count = existing.length;
          ProcessEmitWarning(w);
        }
      }

      return target;
    }

    EventEmitter.prototype.addListener = function addListener(type, listener) {
      return _addListener(this, type, listener, false);
    };

    EventEmitter.prototype.on = EventEmitter.prototype.addListener;

    EventEmitter.prototype.prependListener =
        function prependListener(type, listener) {
          return _addListener(this, type, listener, true);
        };

    function onceWrapper() {
      var args = [];
      for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);
      if (!this.fired) {
        this.target.removeListener(this.type, this.wrapFn);
        this.fired = true;
        ReflectApply(this.listener, this.target, args);
      }
    }

    function _onceWrap(target, type, listener) {
      var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
      var wrapped = onceWrapper.bind(state);
      wrapped.listener = listener;
      state.wrapFn = wrapped;
      return wrapped;
    }

    EventEmitter.prototype.once = function once(type, listener) {
      if (typeof listener !== 'function') {
        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
      }
      this.on(type, _onceWrap(this, type, listener));
      return this;
    };

    EventEmitter.prototype.prependOnceListener =
        function prependOnceListener(type, listener) {
          if (typeof listener !== 'function') {
            throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
          }
          this.prependListener(type, _onceWrap(this, type, listener));
          return this;
        };

    // Emits a 'removeListener' event if and only if the listener was removed.
    EventEmitter.prototype.removeListener =
        function removeListener(type, listener) {
          var list, events, position, i, originalListener;

          if (typeof listener !== 'function') {
            throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
          }

          events = this._events;
          if (events === undefined)
            return this;

          list = events[type];
          if (list === undefined)
            return this;

          if (list === listener || list.listener === listener) {
            if (--this._eventsCount === 0)
              this._events = Object.create(null);
            else {
              delete events[type];
              if (events.removeListener)
                this.emit('removeListener', type, list.listener || listener);
            }
          } else if (typeof list !== 'function') {
            position = -1;

            for (i = list.length - 1; i >= 0; i--) {
              if (list[i] === listener || list[i].listener === listener) {
                originalListener = list[i].listener;
                position = i;
                break;
              }
            }

            if (position < 0)
              return this;

            if (position === 0)
              list.shift();
            else {
              spliceOne(list, position);
            }

            if (list.length === 1)
              events[type] = list[0];

            if (events.removeListener !== undefined)
              this.emit('removeListener', type, originalListener || listener);
          }

          return this;
        };

    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;

    EventEmitter.prototype.removeAllListeners =
        function removeAllListeners(type) {
          var listeners, events, i;

          events = this._events;
          if (events === undefined)
            return this;

          // not listening for removeListener, no need to emit
          if (events.removeListener === undefined) {
            if (arguments.length === 0) {
              this._events = Object.create(null);
              this._eventsCount = 0;
            } else if (events[type] !== undefined) {
              if (--this._eventsCount === 0)
                this._events = Object.create(null);
              else
                delete events[type];
            }
            return this;
          }

          // emit removeListener for all listeners on all events
          if (arguments.length === 0) {
            var keys = Object.keys(events);
            var key;
            for (i = 0; i < keys.length; ++i) {
              key = keys[i];
              if (key === 'removeListener') continue;
              this.removeAllListeners(key);
            }
            this.removeAllListeners('removeListener');
            this._events = Object.create(null);
            this._eventsCount = 0;
            return this;
          }

          listeners = events[type];

          if (typeof listeners === 'function') {
            this.removeListener(type, listeners);
          } else if (listeners !== undefined) {
            // LIFO order
            for (i = listeners.length - 1; i >= 0; i--) {
              this.removeListener(type, listeners[i]);
            }
          }

          return this;
        };

    function _listeners(target, type, unwrap) {
      var events = target._events;

      if (events === undefined)
        return [];

      var evlistener = events[type];
      if (evlistener === undefined)
        return [];

      if (typeof evlistener === 'function')
        return unwrap ? [evlistener.listener || evlistener] : [evlistener];

      return unwrap ?
        unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
    }

    EventEmitter.prototype.listeners = function listeners(type) {
      return _listeners(this, type, true);
    };

    EventEmitter.prototype.rawListeners = function rawListeners(type) {
      return _listeners(this, type, false);
    };

    EventEmitter.listenerCount = function(emitter, type) {
      if (typeof emitter.listenerCount === 'function') {
        return emitter.listenerCount(type);
      } else {
        return listenerCount.call(emitter, type);
      }
    };

    EventEmitter.prototype.listenerCount = listenerCount;
    function listenerCount(type) {
      var events = this._events;

      if (events !== undefined) {
        var evlistener = events[type];

        if (typeof evlistener === 'function') {
          return 1;
        } else if (evlistener !== undefined) {
          return evlistener.length;
        }
      }

      return 0;
    }

    EventEmitter.prototype.eventNames = function eventNames() {
      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
    };

    function arrayClone(arr, n) {
      var copy = new Array(n);
      for (var i = 0; i < n; ++i)
        copy[i] = arr[i];
      return copy;
    }

    function spliceOne(list, index) {
      for (; index + 1 < list.length; index++)
        list[index] = list[index + 1];
      list.pop();
    }

    function unwrapListeners(arr) {
      var ret = new Array(arr.length);
      for (var i = 0; i < ret.length; ++i) {
        ret[i] = arr[i].listener || arr[i];
      }
      return ret;
    }

    var DEFAULT_CONFIG = {
        projectId: '8513c380-0336-4927-b351-02ccec7f3cb6',
        url: 'https://login-widget.xsolla.com/latest',
        popupBackgroundColor: 'rgba(0, 0, 0, 0.6)',
        showPopupBackground: true,
        iframeZIndex: 9000,
        siteHaveGDPRBanner: false,
    };
    var GET_PARAMS = [
        'callbackUrl',
        'disableConfirmByLink',
        'payload',
        'with_logout',
        'clientId',
        'emailTemplate',
        'scope',
        'state',
        'redirectUri',
        'responseType',
        'isDemo',
        'challenge_id',
        'analyticsProductName',
        'theme',
        'authData',
        'page',
        'customStyle',
        'customLabels',
        'parentIsFrame',
        'settingsJSON',
        'socialsJSON',
        'themeJSON',
        'siteHaveGDPRBanner',
    ];
    var pages = {
        signUp: '/sign-up',
        logIn: '/',
        passwordReset: '/password/reset',
        passwordSet: '/password/set',
        ask: '/ask',
        error: '/404',
        socials: '/socials',
        agreement: '/agreement',
        otp: '/otp',
        logInUserPreset: '/',
    };
    var Widget = /** @class */ (function (_super) {
        __extends(Widget, _super);
        function Widget(config) {
            var _this = _super.call(this) || this;
            _this.events = exports.PostMessageEvents;
            _this.eventsArray = Object.values(exports.PostMessageEvents);
            _this.handler = {};
            _this.config = __assign({}, DEFAULT_CONFIG, config);
            _this.api = new Api(__assign({}, defaultConfig, config));
            _this.inFullscreenMode = false;
            _this.page = _this.config.page ? pages[_this.config.page] : '';
            _this.setLocale(_this.config.preferredLocale);
            _this.on('newListener', function (type) {
                if (_this.eventsArray.indexOf(type) > -1) {
                    if (type === exports.PostMessageEvents.Close) {
                        _this.handler[type] = true;
                    }
                }
                else {
                    throw new SDKError('Invalid event');
                }
            });
            return _this;
        }
        Widget.prototype.mount = function (elementId) {
            var isHardMounted = this.config.isHardMounted;
            this.iframe = document.createElement('iframe');
            this.iframe.style.width = '100%';
            this.iframe.style.height = '100%';
            this.iframe.style.border = 'none';
            if (isHardMounted) {
                this.iframe.style.position = 'absolute';
                this.iframe.style.top = '0';
                this.iframe.style.bottom = '0';
                this.iframe.style.left = '0';
                this.iframe.style.right = '0';
            }
            this.updateWidget();
            addEvent(exports.MetrikaEventNames.widget_open);
            var el = isHardMounted
                ? document.body
                : document.getElementById(elementId);
            if (el)
                el.appendChild(this.iframe);
            this.initDispatcher();
        };
        Widget.prototype.setLocale = function (preferredLocale) {
            this.locale = getBrowserLocale(preferredLocale);
            this.updateWidget();
        };
        Widget.prototype.setTheme = function (theme) {
            if (!this.iframe || !this.iframe.contentWindow) {
                throw new SDKError('Widget is not mounted');
            }
            sendMessage({
                message: {
                    theme: theme,
                    type: exports.PostMessageEvents.ThemeUpdate,
                },
                targetOrigin: this.config.url || window.location.origin,
                target: this.iframe.contentWindow,
            });
        };
        Widget.prototype.setPage = function (page) {
            if (page) {
                if (!this.iframe || !this.iframe.contentWindow) {
                    throw new SDKError('Widget is not mounted');
                }
                sendMessage({
                    message: {
                        page: page,
                        type: exports.PostMessageEvents.PageOpen,
                    },
                    targetOrigin: this.config.url || window.location.origin,
                    target: this.iframe.contentWindow,
                });
            }
        };
        Widget.prototype.open = function () {
            if (!this.iframe || !this.iframe.contentWindow) {
                return Error('Widget is not mounted');
            }
            var iframeStyle = this.iframe.style;
            iframeStyle.position = 'fixed';
            iframeStyle.zIndex = String(this.config.iframeZIndex);
            iframeStyle.left = '0';
            iframeStyle.top = '0';
            iframeStyle.width = '100%';
            iframeStyle.height = '100%';
            this.inFullscreenMode = true;
            this.config.showPopupBackground && this.config.popupBackgroundColor
                ? (iframeStyle.backgroundColor = this.config.popupBackgroundColor)
                : (iframeStyle.backgroundColor = 'transparent');
            addEvent(exports.MetrikaEventNames.widget_open);
            sendMessage({
                message: {
                    type: exports.PostMessageEvents.IframeOpen,
                },
                targetOrigin: this.config.url || window.location.origin,
                target: this.iframe.contentWindow,
            });
        };
        Widget.prototype.close = function () {
            if (!this.iframe || !this.iframe.contentWindow) {
                return Error('Widget is not mounted');
            }
            var iframeStyle = this.iframe.style;
            iframeStyle.position = '';
            iframeStyle.zIndex = '';
            iframeStyle.left = '';
            iframeStyle.top = '';
            iframeStyle.width = '0';
            iframeStyle.height = '0';
            iframeStyle.backgroundColor = '';
        };
        Widget.prototype.initDispatcher = function () {
            var _this = this;
            var messageHandler = function (e) {
                if (e.data.type === exports.PostMessageEvents.Close &&
                    !_this.handler[exports.PostMessageEvents.Close]) {
                    _this.onCloseEvent(e.data.source);
                }
                if (e.data.type === exports.PostMessageEvents.GoogleOneTapOpen) {
                    _this.onOpenGoogleOneTapEvent(e.data.params);
                }
                else {
                    _this.emit(e.data.type, e.data);
                }
            };
            attachEvent('message', messageHandler);
        };
        Widget.prototype.unmount = function () {
            if (!this.iframe || !this.iframe.parentNode) {
                throw new SDKError('Widget is not mounted');
            }
            this.iframe.parentNode.removeChild(this.iframe);
        };
        Widget.prototype.onCloseEvent = function (source) {
            if (this.inFullscreenMode || source === exports.CloseSource.Button) {
                this.close();
            }
        };
        Widget.prototype.onOpenGoogleOneTapEvent = function (params) {
            var _this = this;
            if (!this.iframe || !this.iframe.parentNode) {
                throw new SDKError('Widget is not mounted');
            }
            var appId = params.appId;
            var callback = function (resp) {
                sendMessage({
                    message: {
                        type: exports.PostMessageEvents.GoogleOneTapSuccess,
                        credential: resp.credential,
                    },
                    targetOrigin: _this.config.url || window.location.origin,
                    // @ts-ignore
                    target: _this.iframe.contentWindow,
                });
            };
            initGoogleOneTap(appId, callback);
        };
        Widget.prototype.updateWidget = function () {
            var _this = this;
            if (this.iframe) {
                var getParams_1 = '';
                GET_PARAMS.forEach(function (param) {
                    var value = _this.config[param];
                    if (value) {
                        switch (param) {
                            case 'clientId':
                                getParams_1 += "&client_id=" + value;
                                break;
                            case 'redirectUri':
                                getParams_1 += "&redirect_uri=" + value;
                                break;
                            case 'responseType':
                                getParams_1 += "&response_type=" + value;
                                break;
                            case 'theme':
                                getParams_1 += "&theme=" + JSON.stringify(value);
                                break;
                            case 'authData':
                                getParams_1 += "&auth_data=" + JSON.stringify(value);
                                break;
                            case 'siteHaveGDPRBanner':
                                var haveBanner = document.getElementById('gdpr-consent-form');
                                getParams_1 += "&" + param + "=" + value;
                                break;
                            default:
                                getParams_1 += "&" + param + "=" + value;
                                break;
                        }
                    }
                });
                this.iframe.src = "" + this.config.url + this.page + "?projectId=" + this.config.projectId + "&locale=" + this.locale;
                this.iframe.src += getParams_1;
            }
        };
        return Widget;
    }(events));

    var RECAPTCHA_SITEKEY = '6LcpYRMUAAAAAO4DesAut9ElBSBijtqfOLWbHOuO';

    (function (Socials) {
        Socials["amazon"] = "amazon";
        Socials["apple"] = "apple";
        Socials["baidu"] = "baidu";
        Socials["battlenet"] = "battlenet";
        Socials["china_telecom"] = "china_telecom";
        Socials["discord"] = "discord";
        Socials["email"] = "email";
        Socials["epicgames"] = "epicgames";
        Socials["facebook"] = "facebook";
        Socials["github"] = "github";
        Socials["google"] = "google";
        Socials["google-plus"] = "google-plus";
        Socials["instagram"] = "instagram";
        Socials["kakao"] = "kakao";
        Socials["linkedin"] = "linkedin";
        Socials["mailru"] = "mailru";
        Socials["microsoft"] = "microsoft";
        Socials["msn"] = "msn";
        Socials["naver"] = "naver";
        Socials["ok"] = "ok";
        Socials["paradox"] = "paradox";
        Socials["paypal"] = "paypal";
        Socials["pinterest"] = "pinterest";
        Socials["qq"] = "qq";
        Socials["reddit"] = "reddit";
        Socials["steam"] = "steam";
        Socials["slack"] = "slack";
        Socials["twitch"] = "twitch";
        Socials["twitter"] = "twitter";
        Socials["vimeo"] = "vimeo";
        Socials["vk"] = "vk";
        Socials["wechat"] = "wechat";
        Socials["weibo"] = "weibo";
        Socials["xbox"] = "xbox";
        Socials["yahoo"] = "yahoo";
        Socials["yandex"] = "yandex";
        Socials["youtube"] = "youtube";
    })(exports.Socials || (exports.Socials = {}));

    exports.Api = Api;
    exports.defaultConfig = defaultConfig;
    exports.Widget = Widget;
    exports.APIError = APIError;
    exports.RECAPTCHA_SITEKEY = RECAPTCHA_SITEKEY;
    exports.sendMessage = sendMessage;
    exports.initGoogleOneTap = initGoogleOneTap;
    exports.getUrlVersion = getUrlVersion;
    exports.getPageName = getPageName;
    exports.initAnalytics = initAnalytics;
    exports.addEvent = addEvent;
    exports.openEvent = openEvent;

    return exports;

}({}));
//# sourceMappingURL=sdk.js.map