@solana/web3.js 1.70.0 → 1.70.1-pr-29195

package/lib/index.iife.js

@@ -3,6 +3,10 @@ var solanaWeb3 = (function (exports) {
 
 	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
 	function getAugmentedNamespace(n) {
 	  var f = n.default;
 		if (typeof f == "function") {
@@ -8301,6 +8305,7 @@ var solanaWeb3 = (function (exports) {
 	}
 	const SOLANA_SCHEMA = new Map();
 
+	let _Symbol$toStringTag;
 	/**
 	 * Maximum length of derived pubkey seed
 	 */
@@ -8325,6 +8330,7 @@ var solanaWeb3 = (function (exports) {
 	 * A public key
 	 */
 
+	_Symbol$toStringTag = Symbol.toStringTag;
 	class PublicKey extends Struct$1 {
 	  /** @internal */
 
@@ -8415,6 +8421,10 @@ var solanaWeb3 = (function (exports) {
 	    b.copy(zeroPad, 32 - b.length);
 	    return zeroPad;
 	  }
+
+	  get [_Symbol$toStringTag]() {
+	    return `PublicKey(${this.toString()})`;
+	  }
 	  /**
 	   * Return the base-58 representation of the public key
 	   */
@@ -14528,2639 +14538,2619 @@ var solanaWeb3 = (function (exports) {
 	  });
 	}
 
-	var index_browser = {};
-
-	var interopRequireDefault = {exports: {}};
+	// Unique ID creation requires a high quality random # generator. In the browser we therefore
+	// require the crypto API and do not support built-in fallback to lower quality random number
+	// generators (like Math.random()).
+	var getRandomValues;
+	var rnds8 = new Uint8Array(16);
+	function rng() {
+	  // lazy load so that environments that need to polyfill have a chance to do so
+	  if (!getRandomValues) {
+	    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+	    // find the complete implementation of crypto (msCrypto) on IE11.
+	    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
 
-	(function (module) {
-		function _interopRequireDefault(obj) {
-		  return obj && obj.__esModule ? obj : {
-		    "default": obj
-		  };
-		}
+	    if (!getRandomValues) {
+	      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+	    }
+	  }
 
-		module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (interopRequireDefault));
+	  return getRandomValues(rnds8);
+	}
 
-	var createClass = {exports: {}};
+	var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
 
-	var hasRequiredCreateClass;
+	function validate(uuid) {
+	  return typeof uuid === 'string' && REGEX.test(uuid);
+	}
 
-	function requireCreateClass () {
-		if (hasRequiredCreateClass) return createClass.exports;
-		hasRequiredCreateClass = 1;
-		(function (module) {
-			function _defineProperties(target, props) {
-			  for (var i = 0; i < props.length; i++) {
-			    var descriptor = props[i];
-			    descriptor.enumerable = descriptor.enumerable || false;
-			    descriptor.configurable = true;
-			    if ("value" in descriptor) descriptor.writable = true;
-			    Object.defineProperty(target, descriptor.key, descriptor);
-			  }
-			}
+	/**
+	 * Convert array of 16 byte values to UUID string format of the form:
+	 * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+	 */
 
-			function _createClass(Constructor, protoProps, staticProps) {
-			  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-			  if (staticProps) _defineProperties(Constructor, staticProps);
-			  Object.defineProperty(Constructor, "prototype", {
-			    writable: false
-			  });
-			  return Constructor;
-			}
+	var byteToHex = [];
 
-			module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (createClass));
-		return createClass.exports;
+	for (var i = 0; i < 256; ++i) {
+	  byteToHex.push((i + 0x100).toString(16).substr(1));
 	}
 
-	var classCallCheck = {exports: {}};
-
-	var hasRequiredClassCallCheck;
+	function stringify(arr) {
+	  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+	  // Note: Be careful editing this code!  It's been tuned for performance
+	  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+	  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
+	  // of the following:
+	  // - One or more input array values don't map to a hex octet (leading to
+	  // "undefined" in the uuid)
+	  // - Invalid input values for the RFC `version` or `variant` fields
 
-	function requireClassCallCheck () {
-		if (hasRequiredClassCallCheck) return classCallCheck.exports;
-		hasRequiredClassCallCheck = 1;
-		(function (module) {
-			function _classCallCheck(instance, Constructor) {
-			  if (!(instance instanceof Constructor)) {
-			    throw new TypeError("Cannot call a class as a function");
-			  }
-			}
+	  if (!validate(uuid)) {
+	    throw TypeError('Stringified UUID is invalid');
+	  }
 
-			module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (classCallCheck));
-		return classCallCheck.exports;
+	  return uuid;
 	}
 
-	var inherits = {exports: {}};
+	//
+	// Inspired by https://github.com/LiosK/UUID.js
+	// and http://docs.python.org/library/uuid.html
 
-	var setPrototypeOf = {exports: {}};
+	var _nodeId;
 
-	var hasRequiredSetPrototypeOf;
+	var _clockseq; // Previous uuid creation time
 
-	function requireSetPrototypeOf () {
-		if (hasRequiredSetPrototypeOf) return setPrototypeOf.exports;
-		hasRequiredSetPrototypeOf = 1;
-		(function (module) {
-			function _setPrototypeOf(o, p) {
-			  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-			    o.__proto__ = p;
-			    return o;
-			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-			  return _setPrototypeOf(o, p);
-			}
 
-			module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (setPrototypeOf));
-		return setPrototypeOf.exports;
-	}
+	var _lastMSecs = 0;
+	var _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
 
-	var hasRequiredInherits;
+	function v1(options, buf, offset) {
+	  var i = buf && offset || 0;
+	  var b = buf || new Array(16);
+	  options = options || {};
+	  var node = options.node || _nodeId;
+	  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
+	  // specified.  We do this lazily to minimize issues related to insufficient
+	  // system entropy.  See #189
 
-	function requireInherits () {
-		if (hasRequiredInherits) return inherits.exports;
-		hasRequiredInherits = 1;
-		(function (module) {
-			var setPrototypeOf = requireSetPrototypeOf();
+	  if (node == null || clockseq == null) {
+	    var seedBytes = options.random || (options.rng || rng)();
 
-			function _inherits(subClass, superClass) {
-			  if (typeof superClass !== "function" && superClass !== null) {
-			    throw new TypeError("Super expression must either be null or a function");
-			  }
+	    if (node == null) {
+	      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+	      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
+	    }
 
-			  subClass.prototype = Object.create(superClass && superClass.prototype, {
-			    constructor: {
-			      value: subClass,
-			      writable: true,
-			      configurable: true
-			    }
-			  });
-			  Object.defineProperty(subClass, "prototype", {
-			    writable: false
-			  });
-			  if (superClass) setPrototypeOf(subClass, superClass);
-			}
+	    if (clockseq == null) {
+	      // Per 4.2.2, randomize (14 bit) clockseq
+	      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
+	    }
+	  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+	  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
+	  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+	  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
 
-			module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (inherits));
-		return inherits.exports;
-	}
 
-	var possibleConstructorReturn = {exports: {}};
+	  var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock
+	  // cycle to simulate higher resolution clock
 
-	var _typeof = {exports: {}};
+	  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
 
-	var hasRequired_typeof;
+	  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression
 
-	function require_typeof () {
-		if (hasRequired_typeof) return _typeof.exports;
-		hasRequired_typeof = 1;
-		(function (module) {
-			function _typeof(obj) {
-			  "@babel/helpers - typeof";
+	  if (dt < 0 && options.clockseq === undefined) {
+	    clockseq = clockseq + 1 & 0x3fff;
+	  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+	  // time interval
 
-			  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
-			    return typeof obj;
-			  } : function (obj) {
-			    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-			  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
-			}
 
-			module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (_typeof));
-		return _typeof.exports;
-	}
+	  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
+	    nsecs = 0;
+	  } // Per 4.2.1.2 Throw error if too many uuids are requested
 
-	var assertThisInitialized = {exports: {}};
 
-	var hasRequiredAssertThisInitialized;
+	  if (nsecs >= 10000) {
+	    throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
+	  }
 
-	function requireAssertThisInitialized () {
-		if (hasRequiredAssertThisInitialized) return assertThisInitialized.exports;
-		hasRequiredAssertThisInitialized = 1;
-		(function (module) {
-			function _assertThisInitialized(self) {
-			  if (self === void 0) {
-			    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-			  }
+	  _lastMSecs = msecs;
+	  _lastNSecs = nsecs;
+	  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
 
-			  return self;
-			}
+	  msecs += 12219292800000; // `time_low`
 
-			module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (assertThisInitialized));
-		return assertThisInitialized.exports;
-	}
+	  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+	  b[i++] = tl >>> 24 & 0xff;
+	  b[i++] = tl >>> 16 & 0xff;
+	  b[i++] = tl >>> 8 & 0xff;
+	  b[i++] = tl & 0xff; // `time_mid`
 
-	var hasRequiredPossibleConstructorReturn;
+	  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
+	  b[i++] = tmh >>> 8 & 0xff;
+	  b[i++] = tmh & 0xff; // `time_high_and_version`
 
-	function requirePossibleConstructorReturn () {
-		if (hasRequiredPossibleConstructorReturn) return possibleConstructorReturn.exports;
-		hasRequiredPossibleConstructorReturn = 1;
-		(function (module) {
-			var _typeof = require_typeof()["default"];
+	  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
 
-			var assertThisInitialized = requireAssertThisInitialized();
+	  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
 
-			function _possibleConstructorReturn(self, call) {
-			  if (call && (_typeof(call) === "object" || typeof call === "function")) {
-			    return call;
-			  } else if (call !== void 0) {
-			    throw new TypeError("Derived constructors may only return object or undefined");
-			  }
+	  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`
 
-			  return assertThisInitialized(self);
-			}
+	  b[i++] = clockseq & 0xff; // `node`
 
-			module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (possibleConstructorReturn));
-		return possibleConstructorReturn.exports;
-	}
+	  for (var n = 0; n < 6; ++n) {
+	    b[i + n] = node[n];
+	  }
 
-	var getPrototypeOf = {exports: {}};
-
-	var hasRequiredGetPrototypeOf;
-
-	function requireGetPrototypeOf () {
-		if (hasRequiredGetPrototypeOf) return getPrototypeOf.exports;
-		hasRequiredGetPrototypeOf = 1;
-		(function (module) {
-			function _getPrototypeOf(o) {
-			  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-			    return o.__proto__ || Object.getPrototypeOf(o);
-			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-			  return _getPrototypeOf(o);
-			}
-
-			module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (getPrototypeOf));
-		return getPrototypeOf.exports;
+	  return buf || stringify(b);
 	}
 
-	var websocket_browser = {};
+	function parse(uuid) {
+	  if (!validate(uuid)) {
+	    throw TypeError('Invalid UUID');
+	  }
 
-	var eventemitter3 = {exports: {}};
+	  var v;
+	  var arr = new Uint8Array(16); // Parse ########-....-....-....-............
 
-	var hasRequiredEventemitter3;
+	  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+	  arr[1] = v >>> 16 & 0xff;
+	  arr[2] = v >>> 8 & 0xff;
+	  arr[3] = v & 0xff; // Parse ........-####-....-....-............
 
-	function requireEventemitter3 () {
-		if (hasRequiredEventemitter3) return eventemitter3.exports;
-		hasRequiredEventemitter3 = 1;
-		(function (module) {
+	  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+	  arr[5] = v & 0xff; // Parse ........-....-####-....-............
 
-			var has = Object.prototype.hasOwnProperty
-			  , prefix = '~';
+	  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+	  arr[7] = v & 0xff; // Parse ........-....-....-####-............
 
-			/**
-			 * Constructor to create a storage for our `EE` objects.
-			 * An `Events` instance is a plain object whose properties are event names.
-			 *
-			 * @constructor
-			 * @private
-			 */
-			function Events() {}
+	  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+	  arr[9] = v & 0xff; // Parse ........-....-....-....-############
+	  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
 
-			//
-			// We try to not inherit from `Object.prototype`. In some engines creating an
-			// instance in this way is faster than calling `Object.create(null)` directly.
-			// If `Object.create(null)` is not supported we prefix the event names with a
-			// character to make sure that the built-in object properties are not
-			// overridden or used as an attack vector.
-			//
-			if (Object.create) {
-			  Events.prototype = Object.create(null);
+	  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+	  arr[11] = v / 0x100000000 & 0xff;
+	  arr[12] = v >>> 24 & 0xff;
+	  arr[13] = v >>> 16 & 0xff;
+	  arr[14] = v >>> 8 & 0xff;
+	  arr[15] = v & 0xff;
+	  return arr;
+	}
 
-			  //
-			  // This hack is needed because the `__proto__` property is still inherited in
-			  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
-			  //
-			  if (!new Events().__proto__) prefix = false;
-			}
+	function stringToBytes(str) {
+	  str = unescape(encodeURIComponent(str)); // UTF8 escape
 
-			/**
-			 * Representation of a single event listener.
-			 *
-			 * @param {Function} fn The listener function.
-			 * @param {*} context The context to invoke the listener with.
-			 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
-			 * @constructor
-			 * @private
-			 */
-			function EE(fn, context, once) {
-			  this.fn = fn;
-			  this.context = context;
-			  this.once = once || false;
-			}
+	  var bytes = [];
 
-			/**
-			 * Add a listener for a given event.
-			 *
-			 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-			 * @param {(String|Symbol)} event The event name.
-			 * @param {Function} fn The listener function.
-			 * @param {*} context The context to invoke the listener with.
-			 * @param {Boolean} once Specify if the listener is a one-time listener.
-			 * @returns {EventEmitter}
-			 * @private
-			 */
-			function addListener(emitter, event, fn, context, once) {
-			  if (typeof fn !== 'function') {
-			    throw new TypeError('The listener must be a function');
-			  }
+	  for (var i = 0; i < str.length; ++i) {
+	    bytes.push(str.charCodeAt(i));
+	  }
 
-			  var listener = new EE(fn, context || emitter, once)
-			    , evt = prefix ? prefix + event : event;
+	  return bytes;
+	}
 
-			  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
-			  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
-			  else emitter._events[evt] = [emitter._events[evt], listener];
+	var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+	var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+	function v35 (name, version, hashfunc) {
+	  function generateUUID(value, namespace, buf, offset) {
+	    if (typeof value === 'string') {
+	      value = stringToBytes(value);
+	    }
 
-			  return emitter;
-			}
+	    if (typeof namespace === 'string') {
+	      namespace = parse(namespace);
+	    }
 
-			/**
-			 * Clear event by name.
-			 *
-			 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
-			 * @param {(String|Symbol)} evt The Event name.
-			 * @private
-			 */
-			function clearEvent(emitter, evt) {
-			  if (--emitter._eventsCount === 0) emitter._events = new Events();
-			  else delete emitter._events[evt];
-			}
+	    if (namespace.length !== 16) {
+	      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+	    } // Compute hash of namespace and value, Per 4.3
+	    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+	    // hashfunc([...namespace, ... value])`
 
-			/**
-			 * Minimal `EventEmitter` interface that is molded against the Node.js
-			 * `EventEmitter` interface.
-			 *
-			 * @constructor
-			 * @public
-			 */
-			function EventEmitter() {
-			  this._events = new Events();
-			  this._eventsCount = 0;
-			}
 
-			/**
-			 * Return an array listing the events for which the emitter has registered
-			 * listeners.
-			 *
-			 * @returns {Array}
-			 * @public
-			 */
-			EventEmitter.prototype.eventNames = function eventNames() {
-			  var names = []
-			    , events
-			    , name;
+	    var bytes = new Uint8Array(16 + value.length);
+	    bytes.set(namespace);
+	    bytes.set(value, namespace.length);
+	    bytes = hashfunc(bytes);
+	    bytes[6] = bytes[6] & 0x0f | version;
+	    bytes[8] = bytes[8] & 0x3f | 0x80;
 
-			  if (this._eventsCount === 0) return names;
+	    if (buf) {
+	      offset = offset || 0;
 
-			  for (name in (events = this._events)) {
-			    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
-			  }
+	      for (var i = 0; i < 16; ++i) {
+	        buf[offset + i] = bytes[i];
+	      }
 
-			  if (Object.getOwnPropertySymbols) {
-			    return names.concat(Object.getOwnPropertySymbols(events));
-			  }
+	      return buf;
+	    }
 
-			  return names;
-			};
+	    return stringify(bytes);
+	  } // Function#name is not settable on some platforms (#270)
 
-			/**
-			 * Return the listeners registered for a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @returns {Array} The registered listeners.
-			 * @public
-			 */
-			EventEmitter.prototype.listeners = function listeners(event) {
-			  var evt = prefix ? prefix + event : event
-			    , handlers = this._events[evt];
 
-			  if (!handlers) return [];
-			  if (handlers.fn) return [handlers.fn];
+	  try {
+	    generateUUID.name = name; // eslint-disable-next-line no-empty
+	  } catch (err) {} // For CommonJS default export support
 
-			  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
-			    ee[i] = handlers[i].fn;
-			  }
 
-			  return ee;
-			};
+	  generateUUID.DNS = DNS;
+	  generateUUID.URL = URL;
+	  return generateUUID;
+	}
 
-			/**
-			 * Return the number of listeners listening to a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @returns {Number} The number of listeners.
-			 * @public
-			 */
-			EventEmitter.prototype.listenerCount = function listenerCount(event) {
-			  var evt = prefix ? prefix + event : event
-			    , listeners = this._events[evt];
+	/*
+	 * Browser-compatible JavaScript MD5
+	 *
+	 * Modification of JavaScript MD5
+	 * https://github.com/blueimp/JavaScript-MD5
+	 *
+	 * Copyright 2011, Sebastian Tschan
+	 * https://blueimp.net
+	 *
+	 * Licensed under the MIT license:
+	 * https://opensource.org/licenses/MIT
+	 *
+	 * Based on
+	 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
+	 * Digest Algorithm, as defined in RFC 1321.
+	 * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
+	 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+	 * Distributed under the BSD License
+	 * See http://pajhome.org.uk/crypt/md5 for more info.
+	 */
+	function md5(bytes) {
+	  if (typeof bytes === 'string') {
+	    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
 
-			  if (!listeners) return 0;
-			  if (listeners.fn) return 1;
-			  return listeners.length;
-			};
+	    bytes = new Uint8Array(msg.length);
 
-			/**
-			 * Calls each of the listeners registered for a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @returns {Boolean} `true` if the event had listeners, else `false`.
-			 * @public
-			 */
-			EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-			  var evt = prefix ? prefix + event : event;
+	    for (var i = 0; i < msg.length; ++i) {
+	      bytes[i] = msg.charCodeAt(i);
+	    }
+	  }
 
-			  if (!this._events[evt]) return false;
+	  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
+	}
+	/*
+	 * Convert an array of little-endian words to an array of bytes
+	 */
 
-			  var listeners = this._events[evt]
-			    , len = arguments.length
-			    , args
-			    , i;
 
-			  if (listeners.fn) {
-			    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+	function md5ToHexEncodedArray(input) {
+	  var output = [];
+	  var length32 = input.length * 32;
+	  var hexTab = '0123456789abcdef';
 
-			    switch (len) {
-			      case 1: return listeners.fn.call(listeners.context), true;
-			      case 2: return listeners.fn.call(listeners.context, a1), true;
-			      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
-			      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
-			      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-			      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-			    }
+	  for (var i = 0; i < length32; i += 8) {
+	    var x = input[i >> 5] >>> i % 32 & 0xff;
+	    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
+	    output.push(hex);
+	  }
 
-			    for (i = 1, args = new Array(len -1); i < len; i++) {
-			      args[i - 1] = arguments[i];
-			    }
+	  return output;
+	}
+	/**
+	 * Calculate output length with padding and bit length
+	 */
 
-			    listeners.fn.apply(listeners.context, args);
-			  } else {
-			    var length = listeners.length
-			      , j;
 
-			    for (i = 0; i < length; i++) {
-			      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+	function getOutputLength(inputLength8) {
+	  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
+	}
+	/*
+	 * Calculate the MD5 of an array of little-endian words, and a bit length.
+	 */
 
-			      switch (len) {
-			        case 1: listeners[i].fn.call(listeners[i].context); break;
-			        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
-			        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
-			        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
-			        default:
-			          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
-			            args[j - 1] = arguments[j];
-			          }
 
-			          listeners[i].fn.apply(listeners[i].context, args);
-			      }
-			    }
-			  }
+	function wordsToMd5(x, len) {
+	  /* append padding */
+	  x[len >> 5] |= 0x80 << len % 32;
+	  x[getOutputLength(len) - 1] = len;
+	  var a = 1732584193;
+	  var b = -271733879;
+	  var c = -1732584194;
+	  var d = 271733878;
 
-			  return true;
-			};
+	  for (var i = 0; i < x.length; i += 16) {
+	    var olda = a;
+	    var oldb = b;
+	    var oldc = c;
+	    var oldd = d;
+	    a = md5ff(a, b, c, d, x[i], 7, -680876936);
+	    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
+	    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
+	    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
+	    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
+	    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
+	    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
+	    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
+	    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
+	    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
+	    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
+	    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
+	    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
+	    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
+	    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
+	    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
+	    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
+	    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
+	    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
+	    b = md5gg(b, c, d, a, x[i], 20, -373897302);
+	    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
+	    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
+	    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
+	    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
+	    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
+	    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
+	    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
+	    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
+	    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
+	    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
+	    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
+	    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
+	    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
+	    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
+	    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
+	    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
+	    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
+	    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
+	    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
+	    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
+	    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
+	    d = md5hh(d, a, b, c, x[i], 11, -358537222);
+	    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
+	    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
+	    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
+	    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
+	    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
+	    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
+	    a = md5ii(a, b, c, d, x[i], 6, -198630844);
+	    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
+	    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
+	    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
+	    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
+	    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
+	    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
+	    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
+	    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
+	    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
+	    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
+	    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
+	    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
+	    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
+	    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
+	    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
+	    a = safeAdd(a, olda);
+	    b = safeAdd(b, oldb);
+	    c = safeAdd(c, oldc);
+	    d = safeAdd(d, oldd);
+	  }
 
-			/**
-			 * Add a listener for a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @param {Function} fn The listener function.
-			 * @param {*} [context=this] The context to invoke the listener with.
-			 * @returns {EventEmitter} `this`.
-			 * @public
-			 */
-			EventEmitter.prototype.on = function on(event, fn, context) {
-			  return addListener(this, event, fn, context, false);
-			};
+	  return [a, b, c, d];
+	}
+	/*
+	 * Convert an array bytes to an array of little-endian words
+	 * Characters >255 have their high-byte silently ignored.
+	 */
 
-			/**
-			 * Add a one-time listener for a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @param {Function} fn The listener function.
-			 * @param {*} [context=this] The context to invoke the listener with.
-			 * @returns {EventEmitter} `this`.
-			 * @public
-			 */
-			EventEmitter.prototype.once = function once(event, fn, context) {
-			  return addListener(this, event, fn, context, true);
-			};
 
-			/**
-			 * Remove the listeners of a given event.
-			 *
-			 * @param {(String|Symbol)} event The event name.
-			 * @param {Function} fn Only remove the listeners that match this function.
-			 * @param {*} context Only remove the listeners that have this context.
-			 * @param {Boolean} once Only remove one-time listeners.
-			 * @returns {EventEmitter} `this`.
-			 * @public
-			 */
-			EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
-			  var evt = prefix ? prefix + event : event;
+	function bytesToWords(input) {
+	  if (input.length === 0) {
+	    return [];
+	  }
 
-			  if (!this._events[evt]) return this;
-			  if (!fn) {
-			    clearEvent(this, evt);
-			    return this;
-			  }
+	  var length8 = input.length * 8;
+	  var output = new Uint32Array(getOutputLength(length8));
 
-			  var listeners = this._events[evt];
+	  for (var i = 0; i < length8; i += 8) {
+	    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
+	  }
 
-			  if (listeners.fn) {
-			    if (
-			      listeners.fn === fn &&
-			      (!once || listeners.once) &&
-			      (!context || listeners.context === context)
-			    ) {
-			      clearEvent(this, evt);
-			    }
-			  } else {
-			    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
-			      if (
-			        listeners[i].fn !== fn ||
-			        (once && !listeners[i].once) ||
-			        (context && listeners[i].context !== context)
-			      ) {
-			        events.push(listeners[i]);
-			      }
-			    }
+	  return output;
+	}
+	/*
+	 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+	 * to work around bugs in some JS interpreters.
+	 */
 
-			    //
-			    // Reset the array, or remove it completely if we have no more listeners.
-			    //
-			    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
-			    else clearEvent(this, evt);
-			  }
 
-			  return this;
-			};
+	function safeAdd(x, y) {
+	  var lsw = (x & 0xffff) + (y & 0xffff);
+	  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+	  return msw << 16 | lsw & 0xffff;
+	}
+	/*
+	 * Bitwise rotate a 32-bit number to the left.
+	 */
 
-			/**
-			 * Remove all listeners, or those of the specified event.
-			 *
-			 * @param {(String|Symbol)} [event] The event name.
-			 * @returns {EventEmitter} `this`.
-			 * @public
-			 */
-			EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
-			  var evt;
 
-			  if (event) {
-			    evt = prefix ? prefix + event : event;
-			    if (this._events[evt]) clearEvent(this, evt);
-			  } else {
-			    this._events = new Events();
-			    this._eventsCount = 0;
-			  }
+	function bitRotateLeft(num, cnt) {
+	  return num << cnt | num >>> 32 - cnt;
+	}
+	/*
+	 * These functions implement the four basic operations the algorithm uses.
+	 */
 
-			  return this;
-			};
 
-			//
-			// Alias methods names because people roll like that.
-			//
-			EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-			EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+	function md5cmn(q, a, b, x, s, t) {
+	  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
+	}
 
-			//
-			// Expose the prefix.
-			//
-			EventEmitter.prefixed = prefix;
+	function md5ff(a, b, c, d, x, s, t) {
+	  return md5cmn(b & c | ~b & d, a, b, x, s, t);
+	}
 
-			//
-			// Allow `EventEmitter` to be imported as module namespace.
-			//
-			EventEmitter.EventEmitter = EventEmitter;
+	function md5gg(a, b, c, d, x, s, t) {
+	  return md5cmn(b & d | c & ~d, a, b, x, s, t);
+	}
 
-			//
-			// Expose the module.
-			//
-			{
-			  module.exports = EventEmitter;
-			}
-	} (eventemitter3));
-		return eventemitter3.exports;
+	function md5hh(a, b, c, d, x, s, t) {
+	  return md5cmn(b ^ c ^ d, a, b, x, s, t);
 	}
 
-	/**
-	 * WebSocket implements a browser-side WebSocket specification.
-	 * @module Client
-	 */
+	function md5ii(a, b, c, d, x, s, t) {
+	  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
+	}
 
-	var hasRequiredWebsocket_browser;
+	var v3 = v35('v3', 0x30, md5);
+	var v3$1 = v3;
 
-	function requireWebsocket_browser () {
-		if (hasRequiredWebsocket_browser) return websocket_browser;
-		hasRequiredWebsocket_browser = 1;
-		(function (exports) {
+	function v4(options, buf, offset) {
+	  options = options || {};
+	  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
 
-			var _interopRequireDefault = interopRequireDefault.exports;
+	  rnds[6] = rnds[6] & 0x0f | 0x40;
+	  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
 
-			Object.defineProperty(exports, "__esModule", {
-			  value: true
-			});
-			exports["default"] = _default;
+	  if (buf) {
+	    offset = offset || 0;
 
-			var _classCallCheck2 = _interopRequireDefault(requireClassCallCheck());
+	    for (var i = 0; i < 16; ++i) {
+	      buf[offset + i] = rnds[i];
+	    }
 
-			var _createClass2 = _interopRequireDefault(requireCreateClass());
+	    return buf;
+	  }
 
-			var _inherits2 = _interopRequireDefault(requireInherits());
+	  return stringify(rnds);
+	}
 
-			var _possibleConstructorReturn2 = _interopRequireDefault(requirePossibleConstructorReturn());
+	// Adapted from Chris Veness' SHA1 code at
+	// http://www.movable-type.co.uk/scripts/sha1.html
+	function f(s, x, y, z) {
+	  switch (s) {
+	    case 0:
+	      return x & y ^ ~x & z;
 
-			var _getPrototypeOf2 = _interopRequireDefault(requireGetPrototypeOf());
+	    case 1:
+	      return x ^ y ^ z;
 
-			var _eventemitter = requireEventemitter3();
+	    case 2:
+	      return x & y ^ x & z ^ y & z;
 
-			function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+	    case 3:
+	      return x ^ y ^ z;
+	  }
+	}
 
-			function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+	function ROTL(x, n) {
+	  return x << n | x >>> 32 - n;
+	}
 
-			var WebSocketBrowserImpl = /*#__PURE__*/function (_EventEmitter) {
-			  (0, _inherits2["default"])(WebSocketBrowserImpl, _EventEmitter);
+	function sha1(bytes) {
+	  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+	  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
 
-			  var _super = _createSuper(WebSocketBrowserImpl);
+	  if (typeof bytes === 'string') {
+	    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
 
-			  /** Instantiate a WebSocket class
-			   * @constructor
-			   * @param {String} address - url to a websocket server
-			   * @param {(Object)} options - websocket options
-			   * @param {(String|Array)} protocols - a list of protocols
-			   * @return {WebSocketBrowserImpl} - returns a WebSocket instance
-			   */
-			  function WebSocketBrowserImpl(address, options, protocols) {
-			    var _this;
+	    bytes = [];
 
-			    (0, _classCallCheck2["default"])(this, WebSocketBrowserImpl);
-			    _this = _super.call(this);
-			    _this.socket = new window.WebSocket(address, protocols);
+	    for (var i = 0; i < msg.length; ++i) {
+	      bytes.push(msg.charCodeAt(i));
+	    }
+	  } else if (!Array.isArray(bytes)) {
+	    // Convert Array-like to Array
+	    bytes = Array.prototype.slice.call(bytes);
+	  }
 
-			    _this.socket.onopen = function () {
-			      return _this.emit("open");
-			    };
+	  bytes.push(0x80);
+	  var l = bytes.length / 4 + 2;
+	  var N = Math.ceil(l / 16);
+	  var M = new Array(N);
 
-			    _this.socket.onmessage = function (event) {
-			      return _this.emit("message", event.data);
-			    };
+	  for (var _i = 0; _i < N; ++_i) {
+	    var arr = new Uint32Array(16);
 
-			    _this.socket.onerror = function (error) {
-			      return _this.emit("error", error);
-			    };
+	    for (var j = 0; j < 16; ++j) {
+	      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];
+	    }
 
-			    _this.socket.onclose = function (event) {
-			      _this.emit("close", event.code, event.reason);
-			    };
+	    M[_i] = arr;
+	  }
 
-			    return _this;
-			  }
-			  /**
-			   * Sends data through a websocket connection
-			   * @method
-			   * @param {(String|Object)} data - data to be sent via websocket
-			   * @param {Object} optionsOrCallback - ws options
-			   * @param {Function} callback - a callback called once the data is sent
-			   * @return {Undefined}
-			   */
-
-
-			  (0, _createClass2["default"])(WebSocketBrowserImpl, [{
-			    key: "send",
-			    value: function send(data, optionsOrCallback, callback) {
-			      var cb = callback || optionsOrCallback;
-
-			      try {
-			        this.socket.send(data);
-			        cb();
-			      } catch (error) {
-			        cb(error);
-			      }
-			    }
-			    /**
-			     * Closes an underlying socket
-			     * @method
-			     * @param {Number} code - status code explaining why the connection is being closed
-			     * @param {String} reason - a description why the connection is closing
-			     * @return {Undefined}
-			     * @throws {Error}
-			     */
-
-			  }, {
-			    key: "close",
-			    value: function close(code, reason) {
-			      this.socket.close(code, reason);
-			    }
-			  }, {
-			    key: "addEventListener",
-			    value: function addEventListener(type, listener, options) {
-			      this.socket.addEventListener(type, listener, options);
-			    }
-			  }]);
-			  return WebSocketBrowserImpl;
-			}(_eventemitter.EventEmitter);
-			/**
-			 * factory method for common WebSocket instance
-			 * @method
-			 * @param {String} address - url to a websocket server
-			 * @param {(Object)} options - websocket options
-			 * @return {Undefined}
-			 */
+	  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
+	  M[N - 1][14] = Math.floor(M[N - 1][14]);
+	  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
 
+	  for (var _i2 = 0; _i2 < N; ++_i2) {
+	    var W = new Uint32Array(80);
 
-			function _default(address, options) {
-			  return new WebSocketBrowserImpl(address, options);
-			}
-	} (websocket_browser));
-		return websocket_browser;
-	}
+	    for (var t = 0; t < 16; ++t) {
+	      W[t] = M[_i2][t];
+	    }
 
-	var client = {};
+	    for (var _t = 16; _t < 80; ++_t) {
+	      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);
+	    }
 
-	var regeneratorRuntime = {exports: {}};
+	    var a = H[0];
+	    var b = H[1];
+	    var c = H[2];
+	    var d = H[3];
+	    var e = H[4];
 
-	var hasRequiredRegeneratorRuntime;
+	    for (var _t2 = 0; _t2 < 80; ++_t2) {
+	      var s = Math.floor(_t2 / 20);
+	      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;
+	      e = d;
+	      d = c;
+	      c = ROTL(b, 30) >>> 0;
+	      b = a;
+	      a = T;
+	    }
 
-	function requireRegeneratorRuntime () {
-		if (hasRequiredRegeneratorRuntime) return regeneratorRuntime.exports;
-		hasRequiredRegeneratorRuntime = 1;
-		(function (module) {
-			var _typeof = require_typeof()["default"];
+	    H[0] = H[0] + a >>> 0;
+	    H[1] = H[1] + b >>> 0;
+	    H[2] = H[2] + c >>> 0;
+	    H[3] = H[3] + d >>> 0;
+	    H[4] = H[4] + e >>> 0;
+	  }
 
-			function _regeneratorRuntime() {
-			  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+	  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
+	}
 
-			  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
-			    return exports;
-			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
-			  var exports = {},
-			      Op = Object.prototype,
-			      hasOwn = Op.hasOwnProperty,
-			      $Symbol = "function" == typeof Symbol ? Symbol : {},
-			      iteratorSymbol = $Symbol.iterator || "@@iterator",
-			      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
-			      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+	var v5 = v35('v5', 0x50, sha1);
+	var v5$1 = v5;
 
-			  function define(obj, key, value) {
-			    return Object.defineProperty(obj, key, {
-			      value: value,
-			      enumerable: !0,
-			      configurable: !0,
-			      writable: !0
-			    }), obj[key];
-			  }
+	var nil = '00000000-0000-0000-0000-000000000000';
 
-			  try {
-			    define({}, "");
-			  } catch (err) {
-			    define = function define(obj, key, value) {
-			      return obj[key] = value;
-			    };
-			  }
+	function version(uuid) {
+	  if (!validate(uuid)) {
+	    throw TypeError('Invalid UUID');
+	  }
 
-			  function wrap(innerFn, outerFn, self, tryLocsList) {
-			    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
-			        generator = Object.create(protoGenerator.prototype),
-			        context = new Context(tryLocsList || []);
-			    return generator._invoke = function (innerFn, self, context) {
-			      var state = "suspendedStart";
-			      return function (method, arg) {
-			        if ("executing" === state) throw new Error("Generator is already running");
+	  return parseInt(uuid.substr(14, 1), 16);
+	}
 
-			        if ("completed" === state) {
-			          if ("throw" === method) throw arg;
-			          return doneResult();
-			        }
+	var esmBrowser = /*#__PURE__*/Object.freeze({
+		__proto__: null,
+		v1: v1,
+		v3: v3$1,
+		v4: v4,
+		v5: v5$1,
+		NIL: nil,
+		version: version,
+		validate: validate,
+		stringify: stringify,
+		parse: parse
+	});
 
-			        for (context.method = method, context.arg = arg;;) {
-			          var delegate = context.delegate;
+	var require$$0 = /*@__PURE__*/getAugmentedNamespace(esmBrowser);
+
+	const uuid$1 = require$$0.v4;
+
+	/**
+	 *  Generates a JSON-RPC 1.0 or 2.0 request
+	 *  @param {String} method Name of method to call
+	 *  @param {Array|Object} params Array of parameters passed to the method as specified, or an object of parameter names and corresponding value
+	 *  @param {String|Number|null} [id] Request ID can be a string, number, null for explicit notification or left out for automatic generation
+	 *  @param {Object} [options]
+	 *  @param {Number} [options.version=2] JSON-RPC version to use (1 or 2)
+	 *  @param {Boolean} [options.notificationIdNull=false] When true, version 2 requests will set id to null instead of omitting it
+	 *  @param {Function} [options.generator] Passed the request, and the options object and is expected to return a request ID
+	 *  @throws {TypeError} If any of the parameters are invalid
+	 *  @return {Object} A JSON-RPC 1.0 or 2.0 request
+	 *  @memberOf Utils
+	 */
+	const generateRequest$1 = function(method, params, id, options) {
+	  if(typeof method !== 'string') {
+	    throw new TypeError(method + ' must be a string');
+	  }
 
-			          if (delegate) {
-			            var delegateResult = maybeInvokeDelegate(delegate, context);
+	  options = options || {};
 
-			            if (delegateResult) {
-			              if (delegateResult === ContinueSentinel) continue;
-			              return delegateResult;
-			            }
-			          }
+	  // check valid version provided
+	  const version = typeof options.version === 'number' ? options.version : 2;
+	  if (version !== 1 && version !== 2) {
+	    throw new TypeError(version + ' must be 1 or 2');
+	  }
 
-			          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
-			            if ("suspendedStart" === state) throw state = "completed", context.arg;
-			            context.dispatchException(context.arg);
-			          } else "return" === context.method && context.abrupt("return", context.arg);
-			          state = "executing";
-			          var record = tryCatch(innerFn, self, context);
+	  const request = {
+	    method: method
+	  };
 
-			          if ("normal" === record.type) {
-			            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
-			            return {
-			              value: record.arg,
-			              done: context.done
-			            };
-			          }
+	  if(version === 2) {
+	    request.jsonrpc = '2.0';
+	  }
 
-			          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
-			        }
-			      };
-			    }(innerFn, self, context), generator;
-			  }
+	  if(params) {
+	    // params given, but invalid?
+	    if(typeof params !== 'object' && !Array.isArray(params)) {
+	      throw new TypeError(params + ' must be an object, array or omitted');
+	    }
+	    request.params = params;
+	  }
 
-			  function tryCatch(fn, obj, arg) {
-			    try {
-			      return {
-			        type: "normal",
-			        arg: fn.call(obj, arg)
-			      };
-			    } catch (err) {
-			      return {
-			        type: "throw",
-			        arg: err
-			      };
-			    }
-			  }
+	  // if id was left out, generate one (null means explicit notification)
+	  if(typeof(id) === 'undefined') {
+	    const generator = typeof options.generator === 'function' ? options.generator : function() { return uuid$1(); };
+	    request.id = generator(request, options);
+	  } else if (version === 2 && id === null) {
+	    // we have a version 2 notification
+	    if (options.notificationIdNull) {
+	      request.id = null; // id will not be set at all unless option provided
+	    }
+	  } else {
+	    request.id = id;
+	  }
 
-			  exports.wrap = wrap;
-			  var ContinueSentinel = {};
+	  return request;
+	};
 
-			  function Generator() {}
+	var generateRequest_1 = generateRequest$1;
 
-			  function GeneratorFunction() {}
+	const uuid = require$$0.v4;
+	const generateRequest = generateRequest_1;
 
-			  function GeneratorFunctionPrototype() {}
+	/**
+	 * Constructor for a Jayson Browser Client that does not depend any node.js core libraries
+	 * @class ClientBrowser
+	 * @param {Function} callServer Method that calls the server, receives the stringified request and a regular node-style callback
+	 * @param {Object} [options]
+	 * @param {Function} [options.reviver] Reviver function for JSON
+	 * @param {Function} [options.replacer] Replacer function for JSON
+	 * @param {Number} [options.version=2] JSON-RPC version to use (1|2)
+	 * @param {Function} [options.generator] Function to use for generating request IDs
+	 *  @param {Boolean} [options.notificationIdNull=false] When true, version 2 requests will set id to null instead of omitting it
+	 * @return {ClientBrowser}
+	 */
+	const ClientBrowser = function(callServer, options) {
+	  if(!(this instanceof ClientBrowser)) {
+	    return new ClientBrowser(callServer, options);
+	  }
 
-			  var IteratorPrototype = {};
-			  define(IteratorPrototype, iteratorSymbol, function () {
-			    return this;
-			  });
-			  var getProto = Object.getPrototypeOf,
-			      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-			  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
-			  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+	  if (!options) {
+	    options = {};
+	  }
 
-			  function defineIteratorMethods(prototype) {
-			    ["next", "throw", "return"].forEach(function (method) {
-			      define(prototype, method, function (arg) {
-			        return this._invoke(method, arg);
-			      });
-			    });
-			  }
+	  this.options = {
+	    reviver: typeof options.reviver !== 'undefined' ? options.reviver : null,
+	    replacer: typeof options.replacer !== 'undefined' ? options.replacer : null,
+	    generator: typeof options.generator !== 'undefined' ? options.generator : function() { return uuid(); },
+	    version: typeof options.version !== 'undefined' ? options.version : 2,
+	    notificationIdNull: typeof options.notificationIdNull === 'boolean' ? options.notificationIdNull : false,
+	  };
 
-			  function AsyncIterator(generator, PromiseImpl) {
-			    function invoke(method, arg, resolve, reject) {
-			      var record = tryCatch(generator[method], generator, arg);
+	  this.callServer = callServer;
+	};
 
-			      if ("throw" !== record.type) {
-			        var result = record.arg,
-			            value = result.value;
-			        return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
-			          invoke("next", value, resolve, reject);
-			        }, function (err) {
-			          invoke("throw", err, resolve, reject);
-			        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
-			          result.value = unwrapped, resolve(result);
-			        }, function (error) {
-			          return invoke("throw", error, resolve, reject);
-			        });
-			      }
+	var browser = ClientBrowser;
 
-			      reject(record.arg);
-			    }
+	/**
+	 *  Creates a request and dispatches it if given a callback.
+	 *  @param {String|Array} method A batch request if passed an Array, or a method name if passed a String
+	 *  @param {Array|Object} [params] Parameters for the method
+	 *  @param {String|Number} [id] Optional id. If undefined an id will be generated. If null it creates a notification request
+	 *  @param {Function} [callback] Request callback. If specified, executes the request rather than only returning it.
+	 *  @throws {TypeError} Invalid parameters
+	 *  @return {Object} JSON-RPC 1.0 or 2.0 compatible request
+	 */
+	ClientBrowser.prototype.request = function(method, params, id, callback) {
+	  const self = this;
+	  let request = null;
 
-			    var previousPromise;
+	  // is this a batch request?
+	  const isBatch = Array.isArray(method) && typeof params === 'function';
 
-			    this._invoke = function (method, arg) {
-			      function callInvokeWithMethodAndArg() {
-			        return new PromiseImpl(function (resolve, reject) {
-			          invoke(method, arg, resolve, reject);
-			        });
-			      }
+	  if (this.options.version === 1 && isBatch) {
+	    throw new TypeError('JSON-RPC 1.0 does not support batching');
+	  }
 
-			      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-			    };
-			  }
+	  // is this a raw request?
+	  const isRaw = !isBatch && method && typeof method === 'object' && typeof params === 'function';
 
-			  function maybeInvokeDelegate(delegate, context) {
-			    var method = delegate.iterator[context.method];
+	  if(isBatch || isRaw) {
+	    callback = params;
+	    request = method;
+	  } else {
+	    if(typeof id === 'function') {
+	      callback = id;
+	      // specifically undefined because "null" is a notification request
+	      id = undefined;
+	    }
 
-			    if (undefined === method) {
-			      if (context.delegate = null, "throw" === context.method) {
-			        if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
-			        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
-			      }
+	    const hasCallback = typeof callback === 'function';
 
-			      return ContinueSentinel;
-			    }
+	    try {
+	      request = generateRequest(method, params, id, {
+	        generator: this.options.generator,
+	        version: this.options.version,
+	        notificationIdNull: this.options.notificationIdNull,
+	      });
+	    } catch(err) {
+	      if(hasCallback) {
+	        return callback(err);
+	      }
+	      throw err;
+	    }
 
-			    var record = tryCatch(method, delegate.iterator, context.arg);
-			    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
-			    var info = record.arg;
-			    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
-			  }
+	    // no callback means we should just return a raw request
+	    if(!hasCallback) {
+	      return request;
+	    }
 
-			  function pushTryEntry(locs) {
-			    var entry = {
-			      tryLoc: locs[0]
-			    };
-			    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
-			  }
+	  }
 
-			  function resetTryEntry(entry) {
-			    var record = entry.completion || {};
-			    record.type = "normal", delete record.arg, entry.completion = record;
-			  }
+	  let message;
+	  try {
+	    message = JSON.stringify(request, this.options.replacer);
+	  } catch(err) {
+	    return callback(err);
+	  }
 
-			  function Context(tryLocsList) {
-			    this.tryEntries = [{
-			      tryLoc: "root"
-			    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
-			  }
+	  this.callServer(message, function(err, response) {
+	    self._parseResponse(err, response, callback);
+	  });
 
-			  function values(iterable) {
-			    if (iterable) {
-			      var iteratorMethod = iterable[iteratorSymbol];
-			      if (iteratorMethod) return iteratorMethod.call(iterable);
-			      if ("function" == typeof iterable.next) return iterable;
+	  // always return the raw request
+	  return request;
+	};
 
-			      if (!isNaN(iterable.length)) {
-			        var i = -1,
-			            next = function next() {
-			          for (; ++i < iterable.length;) {
-			            if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
-			          }
+	/**
+	 * Parses a response from a server
+	 * @param {Object} err Error to pass on that is unrelated to the actual response
+	 * @param {String} responseText JSON-RPC 1.0 or 2.0 response
+	 * @param {Function} callback Callback that will receive different arguments depending on the amount of parameters
+	 * @private
+	 */
+	ClientBrowser.prototype._parseResponse = function(err, responseText, callback) {
+	  if(err) {
+	    callback(err);
+	    return;
+	  }
 
-			          return next.value = undefined, next.done = !0, next;
-			        };
+	  if(!responseText) {
+	    // empty response text, assume that is correct because it could be a
+	    // notification which jayson does not give any body for
+	    return callback();
+	  }
 
-			        return next.next = next;
-			      }
-			    }
+	  let response;
+	  try {
+	    response = JSON.parse(responseText, this.options.reviver);
+	  } catch(err) {
+	    return callback(err);
+	  }
 
-			    return {
-			      next: doneResult
-			    };
-			  }
+	  if(callback.length === 3) {
+	    // if callback length is 3, we split callback arguments on error and response
 
-			  function doneResult() {
-			    return {
-			      value: undefined,
-			      done: !0
-			    };
-			  }
+	    // is batch response?
+	    if(Array.isArray(response)) {
 
-			  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
-			    var ctor = "function" == typeof genFun && genFun.constructor;
-			    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
-			  }, exports.mark = function (genFun) {
-			    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
-			  }, exports.awrap = function (arg) {
-			    return {
-			      __await: arg
-			    };
-			  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
-			    return this;
-			  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-			    void 0 === PromiseImpl && (PromiseImpl = Promise);
-			    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-			    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
-			      return result.done ? result.value : iter.next();
-			    });
-			  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
-			    return this;
-			  }), define(Gp, "toString", function () {
-			    return "[object Generator]";
-			  }), exports.keys = function (object) {
-			    var keys = [];
+	      // neccesary to split strictly on validity according to spec here
+	      const isError = function(res) {
+	        return typeof res.error !== 'undefined';
+	      };
 
-			    for (var key in object) {
-			      keys.push(key);
-			    }
+	      const isNotError = function (res) {
+	        return !isError(res);
+	      };
 
-			    return keys.reverse(), function next() {
-			      for (; keys.length;) {
-			        var key = keys.pop();
-			        if (key in object) return next.value = key, next.done = !1, next;
-			      }
+	      return callback(null, response.filter(isError), response.filter(isNotError));
+	    
+	    } else {
 
-			      return next.done = !0, next;
-			    };
-			  }, exports.values = values, Context.prototype = {
-			    constructor: Context,
-			    reset: function reset(skipTempReset) {
-			      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {
-			        "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
-			      }
-			    },
-			    stop: function stop() {
-			      this.done = !0;
-			      var rootRecord = this.tryEntries[0].completion;
-			      if ("throw" === rootRecord.type) throw rootRecord.arg;
-			      return this.rval;
-			    },
-			    dispatchException: function dispatchException(exception) {
-			      if (this.done) throw exception;
-			      var context = this;
+	      // split regardless of validity
+	      return callback(null, response.error, response.result);
+	    
+	    }
+	  
+	  }
 
-			      function handle(loc, caught) {
-			        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
-			      }
+	  callback(null, response);
+	};
 
-			      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-			        var entry = this.tryEntries[i],
-			            record = entry.completion;
-			        if ("root" === entry.tryLoc) return handle("end");
+	var RpcClient = browser;
 
-			        if (entry.tryLoc <= this.prev) {
-			          var hasCatch = hasOwn.call(entry, "catchLoc"),
-			              hasFinally = hasOwn.call(entry, "finallyLoc");
+	const MINIMUM_SLOT_PER_EPOCH = 32; // Returns the number of trailing zeros in the binary representation of self.
 
-			          if (hasCatch && hasFinally) {
-			            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-			            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-			          } else if (hasCatch) {
-			            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-			          } else {
-			            if (!hasFinally) throw new Error("try statement without catch or finally");
-			            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-			          }
-			        }
-			      }
-			    },
-			    abrupt: function abrupt(type, arg) {
-			      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-			        var entry = this.tryEntries[i];
+	function trailingZeros(n) {
+	  let trailingZeros = 0;
 
-			        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-			          var finallyEntry = entry;
-			          break;
-			        }
-			      }
+	  while (n > 1) {
+	    n /= 2;
+	    trailingZeros++;
+	  }
 
-			      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
-			      var record = finallyEntry ? finallyEntry.completion : {};
-			      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
-			    },
-			    complete: function complete(record, afterLoc) {
-			      if ("throw" === record.type) throw record.arg;
-			      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
-			    },
-			    finish: function finish(finallyLoc) {
-			      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-			        var entry = this.tryEntries[i];
-			        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
-			      }
-			    },
-			    "catch": function _catch(tryLoc) {
-			      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-			        var entry = this.tryEntries[i];
+	  return trailingZeros;
+	} // Returns the smallest power of two greater than or equal to n
 
-			        if (entry.tryLoc === tryLoc) {
-			          var record = entry.completion;
 
-			          if ("throw" === record.type) {
-			            var thrown = record.arg;
-			            resetTryEntry(entry);
-			          }
+	function nextPowerOfTwo(n) {
+	  if (n === 0) return 1;
+	  n--;
+	  n |= n >> 1;
+	  n |= n >> 2;
+	  n |= n >> 4;
+	  n |= n >> 8;
+	  n |= n >> 16;
+	  n |= n >> 32;
+	  return n + 1;
+	}
+	/**
+	 * Epoch schedule
+	 * (see https://docs.solana.com/terminology#epoch)
+	 * Can be retrieved with the {@link Connection.getEpochSchedule} method
+	 */
 
-			          return thrown;
-			        }
-			      }
 
-			      throw new Error("illegal catch attempt");
-			    },
-			    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
-			      return this.delegate = {
-			        iterator: values(iterable),
-			        resultName: resultName,
-			        nextLoc: nextLoc
-			      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
-			    }
-			  }, exports;
-			}
+	class EpochSchedule {
+	  /** The maximum number of slots in each epoch */
 
-			module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (regeneratorRuntime));
-		return regeneratorRuntime.exports;
-	}
+	  /** The number of slots before beginning of an epoch to calculate a leader schedule for that epoch */
 
-	var regenerator;
-	var hasRequiredRegenerator;
+	  /** Indicates whether epochs start short and grow */
 
-	function requireRegenerator () {
-		if (hasRequiredRegenerator) return regenerator;
-		hasRequiredRegenerator = 1;
-		regenerator = requireRegeneratorRuntime()();
-		return regenerator;
-	}
+	  /** The first epoch with `slotsPerEpoch` slots */
 
-	var asyncToGenerator = {exports: {}};
+	  /** The first slot of `firstNormalEpoch` */
+	  constructor(slotsPerEpoch, leaderScheduleSlotOffset, warmup, firstNormalEpoch, firstNormalSlot) {
+	    this.slotsPerEpoch = void 0;
+	    this.leaderScheduleSlotOffset = void 0;
+	    this.warmup = void 0;
+	    this.firstNormalEpoch = void 0;
+	    this.firstNormalSlot = void 0;
+	    this.slotsPerEpoch = slotsPerEpoch;
+	    this.leaderScheduleSlotOffset = leaderScheduleSlotOffset;
+	    this.warmup = warmup;
+	    this.firstNormalEpoch = firstNormalEpoch;
+	    this.firstNormalSlot = firstNormalSlot;
+	  }
 
-	var hasRequiredAsyncToGenerator;
+	  getEpoch(slot) {
+	    return this.getEpochAndSlotIndex(slot)[0];
+	  }
 
-	function requireAsyncToGenerator () {
-		if (hasRequiredAsyncToGenerator) return asyncToGenerator.exports;
-		hasRequiredAsyncToGenerator = 1;
-		(function (module) {
-			function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-			  try {
-			    var info = gen[key](arg);
-			    var value = info.value;
-			  } catch (error) {
-			    reject(error);
-			    return;
-			  }
+	  getEpochAndSlotIndex(slot) {
+	    if (slot < this.firstNormalSlot) {
+	      const epoch = trailingZeros(nextPowerOfTwo(slot + MINIMUM_SLOT_PER_EPOCH + 1)) - trailingZeros(MINIMUM_SLOT_PER_EPOCH) - 1;
+	      const epochLen = this.getSlotsInEpoch(epoch);
+	      const slotIndex = slot - (epochLen - MINIMUM_SLOT_PER_EPOCH);
+	      return [epoch, slotIndex];
+	    } else {
+	      const normalSlotIndex = slot - this.firstNormalSlot;
+	      const normalEpochIndex = Math.floor(normalSlotIndex / this.slotsPerEpoch);
+	      const epoch = this.firstNormalEpoch + normalEpochIndex;
+	      const slotIndex = normalSlotIndex % this.slotsPerEpoch;
+	      return [epoch, slotIndex];
+	    }
+	  }
 
-			  if (info.done) {
-			    resolve(value);
-			  } else {
-			    Promise.resolve(value).then(_next, _throw);
-			  }
-			}
+	  getFirstSlotInEpoch(epoch) {
+	    if (epoch <= this.firstNormalEpoch) {
+	      return (Math.pow(2, epoch) - 1) * MINIMUM_SLOT_PER_EPOCH;
+	    } else {
+	      return (epoch - this.firstNormalEpoch) * this.slotsPerEpoch + this.firstNormalSlot;
+	    }
+	  }
 
-			function _asyncToGenerator(fn) {
-			  return function () {
-			    var self = this,
-			        args = arguments;
-			    return new Promise(function (resolve, reject) {
-			      var gen = fn.apply(self, args);
+	  getLastSlotInEpoch(epoch) {
+	    return this.getFirstSlotInEpoch(epoch) + this.getSlotsInEpoch(epoch) - 1;
+	  }
 
-			      function _next(value) {
-			        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-			      }
+	  getSlotsInEpoch(epoch) {
+	    if (epoch < this.firstNormalEpoch) {
+	      return Math.pow(2, epoch + trailingZeros(MINIMUM_SLOT_PER_EPOCH));
+	    } else {
+	      return this.slotsPerEpoch;
+	    }
+	  }
 
-			      function _throw(err) {
-			        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-			      }
+	}
 
-			      _next(undefined);
-			    });
-			  };
-			}
+	class SendTransactionError extends Error {
+	  constructor(message, logs) {
+	    super(message);
+	    this.logs = void 0;
+	    this.logs = logs;
+	  }
 
-			module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
-	} (asyncToGenerator));
-		return asyncToGenerator.exports;
-	}
+	} // Keep in sync with client/src/rpc_custom_errors.rs
+	// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
 
-	/**
-	 * "Client" wraps "ws" or a browser-implemented "WebSocket" library
-	 * according to the environment providing JSON RPC 2.0 support on top.
-	 * @module Client
-	 */
+	const SolanaJSONRPCErrorCode = {
+	  JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001,
+	  JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002,
+	  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003,
+	  JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004,
+	  JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005,
+	  JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: -32006,
+	  JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007,
+	  JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008,
+	  JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009,
+	  JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010,
+	  JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011,
+	  JSON_RPC_SCAN_ERROR: -32012,
+	  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013,
+	  JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014,
+	  JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015,
+	  JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016
+	};
+	class SolanaJSONRPCError extends Error {
+	  constructor({
+	    code,
+	    message,
+	    data
+	  }, customMessage) {
+	    super(customMessage != null ? `${customMessage}: ${message}` : message);
+	    this.code = void 0;
+	    this.data = void 0;
+	    this.code = code;
+	    this.data = data;
+	    this.name = 'SolanaJSONRPCError';
+	  }
 
-	var hasRequiredClient;
+	}
 
-	function requireClient () {
-		if (hasRequiredClient) return client;
-		hasRequiredClient = 1;
-		(function (exports) {
+	var fetchImpl = globalThis.fetch;
 
-			var _interopRequireDefault = interopRequireDefault.exports;
+	var client = {};
 
-			Object.defineProperty(exports, "__esModule", {
-			  value: true
-			});
-			exports["default"] = void 0;
+	var interopRequireDefault = {exports: {}};
 
-			var _regenerator = _interopRequireDefault(requireRegenerator());
+	(function (module) {
+		function _interopRequireDefault(obj) {
+		  return obj && obj.__esModule ? obj : {
+		    "default": obj
+		  };
+		}
 
-			var _asyncToGenerator2 = _interopRequireDefault(requireAsyncToGenerator());
+		module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (interopRequireDefault));
 
-			var _typeof2 = _interopRequireDefault(require_typeof());
+	var regeneratorRuntime = {exports: {}};
 
-			var _classCallCheck2 = _interopRequireDefault(requireClassCallCheck());
+	var _typeof = {exports: {}};
 
-			var _createClass2 = _interopRequireDefault(requireCreateClass());
+	var hasRequired_typeof;
 
-			var _inherits2 = _interopRequireDefault(requireInherits());
+	function require_typeof () {
+		if (hasRequired_typeof) return _typeof.exports;
+		hasRequired_typeof = 1;
+		(function (module) {
+			function _typeof(obj) {
+			  "@babel/helpers - typeof";
 
-			var _possibleConstructorReturn2 = _interopRequireDefault(requirePossibleConstructorReturn());
+			  return (module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+			    return typeof obj;
+			  } : function (obj) {
+			    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+			  }, module.exports.__esModule = true, module.exports["default"] = module.exports), _typeof(obj);
+			}
 
-			var _getPrototypeOf2 = _interopRequireDefault(requireGetPrototypeOf());
+			module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (_typeof));
+		return _typeof.exports;
+	}
 
-			var _eventemitter = requireEventemitter3();
+	var hasRequiredRegeneratorRuntime;
 
-			function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+	function requireRegeneratorRuntime () {
+		if (hasRequiredRegeneratorRuntime) return regeneratorRuntime.exports;
+		hasRequiredRegeneratorRuntime = 1;
+		(function (module) {
+			var _typeof = require_typeof()["default"];
 
-			function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+			function _regeneratorRuntime() {
+			  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
 
-			var __rest = function (s, e) {
-			  var t = {};
+			  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
+			    return exports;
+			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+			  var exports = {},
+			      Op = Object.prototype,
+			      hasOwn = Op.hasOwnProperty,
+			      $Symbol = "function" == typeof Symbol ? Symbol : {},
+			      iteratorSymbol = $Symbol.iterator || "@@iterator",
+			      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
+			      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
 
-			  for (var p in s) {
-			    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+			  function define(obj, key, value) {
+			    return Object.defineProperty(obj, key, {
+			      value: value,
+			      enumerable: !0,
+			      configurable: !0,
+			      writable: !0
+			    }), obj[key];
 			  }
 
-			  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-			    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-			  }
-			  return t;
-			}; // @ts-ignore
-
-
-			var CommonClient = /*#__PURE__*/function (_EventEmitter) {
-			  (0, _inherits2["default"])(CommonClient, _EventEmitter);
-
-			  var _super = _createSuper(CommonClient);
-
-			  /**
-			   * Instantiate a Client class.
-			   * @constructor
-			   * @param {webSocketFactory} webSocketFactory - factory method for WebSocket
-			   * @param {String} address - url to a websocket server
-			   * @param {Object} options - ws options object with reconnect parameters
-			   * @param {Function} generate_request_id - custom generation request Id
-			   * @return {CommonClient}
-			   */
-			  function CommonClient(webSocketFactory) {
-			    var _this;
-
-			    var address = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "ws://localhost:8080";
-
-			    var _a = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-			    var generate_request_id = arguments.length > 3 ? arguments[3] : undefined;
-			    (0, _classCallCheck2["default"])(this, CommonClient);
-
-			    var _a$autoconnect = _a.autoconnect,
-			        autoconnect = _a$autoconnect === void 0 ? true : _a$autoconnect,
-			        _a$reconnect = _a.reconnect,
-			        reconnect = _a$reconnect === void 0 ? true : _a$reconnect,
-			        _a$reconnect_interval = _a.reconnect_interval,
-			        reconnect_interval = _a$reconnect_interval === void 0 ? 1000 : _a$reconnect_interval,
-			        _a$max_reconnects = _a.max_reconnects,
-			        max_reconnects = _a$max_reconnects === void 0 ? 5 : _a$max_reconnects,
-			        rest_options = __rest(_a, ["autoconnect", "reconnect", "reconnect_interval", "max_reconnects"]);
-
-			    _this = _super.call(this);
-			    _this.webSocketFactory = webSocketFactory;
-			    _this.queue = {};
-			    _this.rpc_id = 0;
-			    _this.address = address;
-			    _this.autoconnect = autoconnect;
-			    _this.ready = false;
-			    _this.reconnect = reconnect;
-			    _this.reconnect_interval = reconnect_interval;
-			    _this.max_reconnects = max_reconnects;
-			    _this.rest_options = rest_options;
-			    _this.current_reconnects = 0;
-
-			    _this.generate_request_id = generate_request_id || function () {
-			      return ++_this.rpc_id;
+			  try {
+			    define({}, "");
+			  } catch (err) {
+			    define = function define(obj, key, value) {
+			      return obj[key] = value;
 			    };
-
-			    if (_this.autoconnect) _this._connect(_this.address, Object.assign({
-			      autoconnect: _this.autoconnect,
-			      reconnect: _this.reconnect,
-			      reconnect_interval: _this.reconnect_interval,
-			      max_reconnects: _this.max_reconnects
-			    }, _this.rest_options));
-			    return _this;
 			  }
-			  /**
-			   * Connects to a defined server if not connected already.
-			   * @method
-			   * @return {Undefined}
-			   */
-
-
-			  (0, _createClass2["default"])(CommonClient, [{
-			    key: "connect",
-			    value: function connect() {
-			      if (this.socket) return;
-
-			      this._connect(this.address, Object.assign({
-			        autoconnect: this.autoconnect,
-			        reconnect: this.reconnect,
-			        reconnect_interval: this.reconnect_interval,
-			        max_reconnects: this.max_reconnects
-			      }, this.rest_options));
-			    }
-			    /**
-			     * Calls a registered RPC method on server.
-			     * @method
-			     * @param {String} method - RPC method name
-			     * @param {Object|Array} params - optional method parameters
-			     * @param {Number} timeout - RPC reply timeout value
-			     * @param {Object} ws_opts - options passed to ws
-			     * @return {Promise}
-			     */
-
-			  }, {
-			    key: "call",
-			    value: function call(method, params, timeout, ws_opts) {
-			      var _this2 = this;
-
-			      if (!ws_opts && "object" === (0, _typeof2["default"])(timeout)) {
-			        ws_opts = timeout;
-			        timeout = null;
-			      }
-
-			      return new Promise(function (resolve, reject) {
-			        if (!_this2.ready) return reject(new Error("socket not ready"));
-
-			        var rpc_id = _this2.generate_request_id(method, params);
 
-			        var message = {
-			          jsonrpc: "2.0",
-			          method: method,
-			          params: params || null,
-			          id: rpc_id
-			        };
-
-			        _this2.socket.send(JSON.stringify(message), ws_opts, function (error) {
-			          if (error) return reject(error);
-			          _this2.queue[rpc_id] = {
-			            promise: [resolve, reject]
-			          };
-
-			          if (timeout) {
-			            _this2.queue[rpc_id].timeout = setTimeout(function () {
-			              delete _this2.queue[rpc_id];
-			              reject(new Error("reply timeout"));
-			            }, timeout);
-			          }
-			        });
-			      });
-			    }
-			    /**
-			     * Logins with the other side of the connection.
-			     * @method
-			     * @param {Object} params - Login credentials object
-			     * @return {Promise}
-			     */
-
-			  }, {
-			    key: "login",
-			    value: function () {
-			      var _login = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(params) {
-			        var resp;
-			        return _regenerator["default"].wrap(function _callee$(_context) {
-			          while (1) {
-			            switch (_context.prev = _context.next) {
-			              case 0:
-			                _context.next = 2;
-			                return this.call("rpc.login", params);
-
-			              case 2:
-			                resp = _context.sent;
-
-			                if (resp) {
-			                  _context.next = 5;
-			                  break;
-			                }
-
-			                throw new Error("authentication failed");
-
-			              case 5:
-			                return _context.abrupt("return", resp);
-
-			              case 6:
-			              case "end":
-			                return _context.stop();
-			            }
-			          }
-			        }, _callee, this);
-			      }));
-
-			      function login(_x) {
-			        return _login.apply(this, arguments);
-			      }
+			  function wrap(innerFn, outerFn, self, tryLocsList) {
+			    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
+			        generator = Object.create(protoGenerator.prototype),
+			        context = new Context(tryLocsList || []);
+			    return generator._invoke = function (innerFn, self, context) {
+			      var state = "suspendedStart";
+			      return function (method, arg) {
+			        if ("executing" === state) throw new Error("Generator is already running");
 
-			      return login;
-			    }()
-			    /**
-			     * Fetches a list of client's methods registered on server.
-			     * @method
-			     * @return {Array}
-			     */
-
-			  }, {
-			    key: "listMethods",
-			    value: function () {
-			      var _listMethods = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
-			        return _regenerator["default"].wrap(function _callee2$(_context2) {
-			          while (1) {
-			            switch (_context2.prev = _context2.next) {
-			              case 0:
-			                _context2.next = 2;
-			                return this.call("__listMethods");
-
-			              case 2:
-			                return _context2.abrupt("return", _context2.sent);
-
-			              case 3:
-			              case "end":
-			                return _context2.stop();
-			            }
-			          }
-			        }, _callee2, this);
-			      }));
+			        if ("completed" === state) {
+			          if ("throw" === method) throw arg;
+			          return doneResult();
+			        }
 
-			      function listMethods() {
-			        return _listMethods.apply(this, arguments);
-			      }
+			        for (context.method = method, context.arg = arg;;) {
+			          var delegate = context.delegate;
 
-			      return listMethods;
-			    }()
-			    /**
-			     * Sends a JSON-RPC 2.0 notification to server.
-			     * @method
-			     * @param {String} method - RPC method name
-			     * @param {Object} params - optional method parameters
-			     * @return {Promise}
-			     */
-
-			  }, {
-			    key: "notify",
-			    value: function notify(method, params) {
-			      var _this3 = this;
-
-			      return new Promise(function (resolve, reject) {
-			        if (!_this3.ready) return reject(new Error("socket not ready"));
-			        var message = {
-			          jsonrpc: "2.0",
-			          method: method,
-			          params: params || null
-			        };
+			          if (delegate) {
+			            var delegateResult = maybeInvokeDelegate(delegate, context);
 
-			        _this3.socket.send(JSON.stringify(message), function (error) {
-			          if (error) return reject(error);
-			          resolve();
-			        });
-			      });
-			    }
-			    /**
-			     * Subscribes for a defined event.
-			     * @method
-			     * @param {String|Array} event - event name
-			     * @return {Undefined}
-			     * @throws {Error}
-			     */
-
-			  }, {
-			    key: "subscribe",
-			    value: function () {
-			      var _subscribe = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(event) {
-			        var result;
-			        return _regenerator["default"].wrap(function _callee3$(_context3) {
-			          while (1) {
-			            switch (_context3.prev = _context3.next) {
-			              case 0:
-			                if (typeof event === "string") event = [event];
-			                _context3.next = 3;
-			                return this.call("rpc.on", event);
-
-			              case 3:
-			                result = _context3.sent;
-
-			                if (!(typeof event === "string" && result[event] !== "ok")) {
-			                  _context3.next = 6;
-			                  break;
-			                }
-
-			                throw new Error("Failed subscribing to an event '" + event + "' with: " + result[event]);
-
-			              case 6:
-			                return _context3.abrupt("return", result);
-
-			              case 7:
-			              case "end":
-			                return _context3.stop();
+			            if (delegateResult) {
+			              if (delegateResult === ContinueSentinel) continue;
+			              return delegateResult;
 			            }
 			          }
-			        }, _callee3, this);
-			      }));
 
-			      function subscribe(_x2) {
-			        return _subscribe.apply(this, arguments);
-			      }
+			          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
+			            if ("suspendedStart" === state) throw state = "completed", context.arg;
+			            context.dispatchException(context.arg);
+			          } else "return" === context.method && context.abrupt("return", context.arg);
+			          state = "executing";
+			          var record = tryCatch(innerFn, self, context);
 
-			      return subscribe;
-			    }()
-			    /**
-			     * Unsubscribes from a defined event.
-			     * @method
-			     * @param {String|Array} event - event name
-			     * @return {Undefined}
-			     * @throws {Error}
-			     */
-
-			  }, {
-			    key: "unsubscribe",
-			    value: function () {
-			      var _unsubscribe = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(event) {
-			        var result;
-			        return _regenerator["default"].wrap(function _callee4$(_context4) {
-			          while (1) {
-			            switch (_context4.prev = _context4.next) {
-			              case 0:
-			                if (typeof event === "string") event = [event];
-			                _context4.next = 3;
-			                return this.call("rpc.off", event);
-
-			              case 3:
-			                result = _context4.sent;
-
-			                if (!(typeof event === "string" && result[event] !== "ok")) {
-			                  _context4.next = 6;
-			                  break;
-			                }
-
-			                throw new Error("Failed unsubscribing from an event with: " + result);
-
-			              case 6:
-			                return _context4.abrupt("return", result);
-
-			              case 7:
-			              case "end":
-			                return _context4.stop();
-			            }
+			          if ("normal" === record.type) {
+			            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
+			            return {
+			              value: record.arg,
+			              done: context.done
+			            };
 			          }
-			        }, _callee4, this);
-			      }));
-
-			      function unsubscribe(_x3) {
-			        return _unsubscribe.apply(this, arguments);
-			      }
 
-			      return unsubscribe;
-			    }()
-			    /**
-			     * Closes a WebSocket connection gracefully.
-			     * @method
-			     * @param {Number} code - socket close code
-			     * @param {String} data - optional data to be sent before closing
-			     * @return {Undefined}
-			     */
-
-			  }, {
-			    key: "close",
-			    value: function close(code, data) {
-			      this.socket.close(code || 1000, data);
-			    }
-			    /**
-			     * Connection/Message handler.
-			     * @method
-			     * @private
-			     * @param {String} address - WebSocket API address
-			     * @param {Object} options - ws options object
-			     * @return {Undefined}
-			     */
-
-			  }, {
-			    key: "_connect",
-			    value: function _connect(address, options) {
-			      var _this4 = this;
-
-			      this.socket = this.webSocketFactory(address, options);
-			      this.socket.addEventListener("open", function () {
-			        _this4.ready = true;
-
-			        _this4.emit("open");
-
-			        _this4.current_reconnects = 0;
-			      });
-			      this.socket.addEventListener("message", function (_ref) {
-			        var message = _ref.data;
-			        if (message instanceof ArrayBuffer) message = Buffer.from(message).toString();
-
-			        try {
-			          message = JSON.parse(message);
-			        } catch (error) {
-			          return;
-			        } // check if any listeners are attached and forward event
-
-
-			        if (message.notification && _this4.listeners(message.notification).length) {
-			          if (!Object.keys(message.params).length) return _this4.emit(message.notification);
-			          var args = [message.notification];
-			          if (message.params.constructor === Object) args.push(message.params);else // using for-loop instead of unshift/spread because performance is better
-			            for (var i = 0; i < message.params.length; i++) {
-			              args.push(message.params[i]);
-			            } // run as microtask so that pending queue messages are resolved first
-			          // eslint-disable-next-line prefer-spread
-
-			          return Promise.resolve().then(function () {
-			            _this4.emit.apply(_this4, args);
-			          });
+			          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
 			        }
+			      };
+			    }(innerFn, self, context), generator;
+			  }
 
-			        if (!_this4.queue[message.id]) {
-			          // general JSON RPC 2.0 events
-			          if (message.method && message.params) {
-			            // run as microtask so that pending queue messages are resolved first
-			            return Promise.resolve().then(function () {
-			              _this4.emit(message.method, message.params);
-			            });
-			          }
-
-			          return;
-			        } // reject early since server's response is invalid
-
-
-			        if ("error" in message === "result" in message) _this4.queue[message.id].promise[1](new Error("Server response malformed. Response must include either \"result\"" + " or \"error\", but not both."));
-			        if (_this4.queue[message.id].timeout) clearTimeout(_this4.queue[message.id].timeout);
-			        if (message.error) _this4.queue[message.id].promise[1](message.error);else _this4.queue[message.id].promise[0](message.result);
-			        delete _this4.queue[message.id];
-			      });
-			      this.socket.addEventListener("error", function (error) {
-			        return _this4.emit("error", error);
-			      });
-			      this.socket.addEventListener("close", function (_ref2) {
-			        var code = _ref2.code,
-			            reason = _ref2.reason;
-			        if (_this4.ready) // Delay close event until internal state is updated
-			          setTimeout(function () {
-			            return _this4.emit("close", code, reason);
-			          }, 0);
-			        _this4.ready = false;
-			        _this4.socket = undefined;
-			        if (code === 1000) return;
-			        _this4.current_reconnects++;
-			        if (_this4.reconnect && (_this4.max_reconnects > _this4.current_reconnects || _this4.max_reconnects === 0)) setTimeout(function () {
-			          return _this4._connect(address, options);
-			        }, _this4.reconnect_interval);
-			      });
+			  function tryCatch(fn, obj, arg) {
+			    try {
+			      return {
+			        type: "normal",
+			        arg: fn.call(obj, arg)
+			      };
+			    } catch (err) {
+			      return {
+			        type: "throw",
+			        arg: err
+			      };
 			    }
-			  }]);
-			  return CommonClient;
-			}(_eventemitter.EventEmitter);
-
-			exports["default"] = CommonClient;
-	} (client));
-		return client;
-	}
-
-	var _interopRequireDefault = interopRequireDefault.exports;
-
-	Object.defineProperty(index_browser, "__esModule", {
-	  value: true
-	});
-	var Client_1 = index_browser.Client = void 0;
-
-	var _createClass2 = _interopRequireDefault(requireCreateClass());
-
-	var _classCallCheck2 = _interopRequireDefault(requireClassCallCheck());
+			  }
 
-	var _inherits2 = _interopRequireDefault(requireInherits());
+			  exports.wrap = wrap;
+			  var ContinueSentinel = {};
 
-	var _possibleConstructorReturn2 = _interopRequireDefault(requirePossibleConstructorReturn());
+			  function Generator() {}
 
-	var _getPrototypeOf2 = _interopRequireDefault(requireGetPrototypeOf());
+			  function GeneratorFunction() {}
 
-	var _websocket = _interopRequireDefault(requireWebsocket_browser());
+			  function GeneratorFunctionPrototype() {}
 
-	var _client = _interopRequireDefault(requireClient());
+			  var IteratorPrototype = {};
+			  define(IteratorPrototype, iteratorSymbol, function () {
+			    return this;
+			  });
+			  var getProto = Object.getPrototypeOf,
+			      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+			  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
+			  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
 
-	function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+			  function defineIteratorMethods(prototype) {
+			    ["next", "throw", "return"].forEach(function (method) {
+			      define(prototype, method, function (arg) {
+			        return this._invoke(method, arg);
+			      });
+			    });
+			  }
 
-	function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+			  function AsyncIterator(generator, PromiseImpl) {
+			    function invoke(method, arg, resolve, reject) {
+			      var record = tryCatch(generator[method], generator, arg);
 
-	var Client = /*#__PURE__*/function (_CommonClient) {
-	  (0, _inherits2["default"])(Client, _CommonClient);
+			      if ("throw" !== record.type) {
+			        var result = record.arg,
+			            value = result.value;
+			        return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
+			          invoke("next", value, resolve, reject);
+			        }, function (err) {
+			          invoke("throw", err, resolve, reject);
+			        }) : PromiseImpl.resolve(value).then(function (unwrapped) {
+			          result.value = unwrapped, resolve(result);
+			        }, function (error) {
+			          return invoke("throw", error, resolve, reject);
+			        });
+			      }
 
-	  var _super = _createSuper(Client);
+			      reject(record.arg);
+			    }
 
-	  function Client() {
-	    var address = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "ws://localhost:8080";
+			    var previousPromise;
 
-	    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-	        _ref$autoconnect = _ref.autoconnect,
-	        autoconnect = _ref$autoconnect === void 0 ? true : _ref$autoconnect,
-	        _ref$reconnect = _ref.reconnect,
-	        reconnect = _ref$reconnect === void 0 ? true : _ref$reconnect,
-	        _ref$reconnect_interv = _ref.reconnect_interval,
-	        reconnect_interval = _ref$reconnect_interv === void 0 ? 1000 : _ref$reconnect_interv,
-	        _ref$max_reconnects = _ref.max_reconnects,
-	        max_reconnects = _ref$max_reconnects === void 0 ? 5 : _ref$max_reconnects;
+			    this._invoke = function (method, arg) {
+			      function callInvokeWithMethodAndArg() {
+			        return new PromiseImpl(function (resolve, reject) {
+			          invoke(method, arg, resolve, reject);
+			        });
+			      }
 
-	    var generate_request_id = arguments.length > 2 ? arguments[2] : undefined;
-	    (0, _classCallCheck2["default"])(this, Client);
-	    return _super.call(this, _websocket["default"], address, {
-	      autoconnect: autoconnect,
-	      reconnect: reconnect,
-	      reconnect_interval: reconnect_interval,
-	      max_reconnects: max_reconnects
-	    }, generate_request_id);
-	  }
+			      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+			    };
+			  }
 
-	  return (0, _createClass2["default"])(Client);
-	}(_client["default"]);
+			  function maybeInvokeDelegate(delegate, context) {
+			    var method = delegate.iterator[context.method];
 
-	Client_1 = index_browser.Client = Client;
+			    if (undefined === method) {
+			      if (context.delegate = null, "throw" === context.method) {
+			        if (delegate.iterator["return"] && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
+			        context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
+			      }
 
-	// Unique ID creation requires a high quality random # generator. In the browser we therefore
-	// require the crypto API and do not support built-in fallback to lower quality random number
-	// generators (like Math.random()).
-	var getRandomValues;
-	var rnds8 = new Uint8Array(16);
-	function rng() {
-	  // lazy load so that environments that need to polyfill have a chance to do so
-	  if (!getRandomValues) {
-	    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
-	    // find the complete implementation of crypto (msCrypto) on IE11.
-	    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+			      return ContinueSentinel;
+			    }
 
-	    if (!getRandomValues) {
-	      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
-	    }
-	  }
+			    var record = tryCatch(method, delegate.iterator, context.arg);
+			    if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
+			    var info = record.arg;
+			    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
+			  }
 
-	  return getRandomValues(rnds8);
-	}
+			  function pushTryEntry(locs) {
+			    var entry = {
+			      tryLoc: locs[0]
+			    };
+			    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
+			  }
 
-	var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+			  function resetTryEntry(entry) {
+			    var record = entry.completion || {};
+			    record.type = "normal", delete record.arg, entry.completion = record;
+			  }
 
-	function validate(uuid) {
-	  return typeof uuid === 'string' && REGEX.test(uuid);
-	}
+			  function Context(tryLocsList) {
+			    this.tryEntries = [{
+			      tryLoc: "root"
+			    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
+			  }
 
-	/**
-	 * Convert array of 16 byte values to UUID string format of the form:
-	 * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
-	 */
+			  function values(iterable) {
+			    if (iterable) {
+			      var iteratorMethod = iterable[iteratorSymbol];
+			      if (iteratorMethod) return iteratorMethod.call(iterable);
+			      if ("function" == typeof iterable.next) return iterable;
 
-	var byteToHex = [];
+			      if (!isNaN(iterable.length)) {
+			        var i = -1,
+			            next = function next() {
+			          for (; ++i < iterable.length;) {
+			            if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
+			          }
 
-	for (var i = 0; i < 256; ++i) {
-	  byteToHex.push((i + 0x100).toString(16).substr(1));
-	}
+			          return next.value = undefined, next.done = !0, next;
+			        };
 
-	function stringify(arr) {
-	  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-	  // Note: Be careful editing this code!  It's been tuned for performance
-	  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
-	  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
-	  // of the following:
-	  // - One or more input array values don't map to a hex octet (leading to
-	  // "undefined" in the uuid)
-	  // - Invalid input values for the RFC `version` or `variant` fields
+			        return next.next = next;
+			      }
+			    }
 
-	  if (!validate(uuid)) {
-	    throw TypeError('Stringified UUID is invalid');
-	  }
+			    return {
+			      next: doneResult
+			    };
+			  }
 
-	  return uuid;
-	}
+			  function doneResult() {
+			    return {
+			      value: undefined,
+			      done: !0
+			    };
+			  }
 
-	//
-	// Inspired by https://github.com/LiosK/UUID.js
-	// and http://docs.python.org/library/uuid.html
+			  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
+			    var ctor = "function" == typeof genFun && genFun.constructor;
+			    return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
+			  }, exports.mark = function (genFun) {
+			    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
+			  }, exports.awrap = function (arg) {
+			    return {
+			      __await: arg
+			    };
+			  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+			    return this;
+			  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+			    void 0 === PromiseImpl && (PromiseImpl = Promise);
+			    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+			    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+			      return result.done ? result.value : iter.next();
+			    });
+			  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+			    return this;
+			  }), define(Gp, "toString", function () {
+			    return "[object Generator]";
+			  }), exports.keys = function (object) {
+			    var keys = [];
 
-	var _nodeId;
+			    for (var key in object) {
+			      keys.push(key);
+			    }
 
-	var _clockseq; // Previous uuid creation time
+			    return keys.reverse(), function next() {
+			      for (; keys.length;) {
+			        var key = keys.pop();
+			        if (key in object) return next.value = key, next.done = !1, next;
+			      }
 
+			      return next.done = !0, next;
+			    };
+			  }, exports.values = values, Context.prototype = {
+			    constructor: Context,
+			    reset: function reset(skipTempReset) {
+			      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {
+			        "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
+			      }
+			    },
+			    stop: function stop() {
+			      this.done = !0;
+			      var rootRecord = this.tryEntries[0].completion;
+			      if ("throw" === rootRecord.type) throw rootRecord.arg;
+			      return this.rval;
+			    },
+			    dispatchException: function dispatchException(exception) {
+			      if (this.done) throw exception;
+			      var context = this;
 
-	var _lastMSecs = 0;
-	var _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
+			      function handle(loc, caught) {
+			        return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
+			      }
 
-	function v1(options, buf, offset) {
-	  var i = buf && offset || 0;
-	  var b = buf || new Array(16);
-	  options = options || {};
-	  var node = options.node || _nodeId;
-	  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
-	  // specified.  We do this lazily to minimize issues related to insufficient
-	  // system entropy.  See #189
+			      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+			        var entry = this.tryEntries[i],
+			            record = entry.completion;
+			        if ("root" === entry.tryLoc) return handle("end");
 
-	  if (node == null || clockseq == null) {
-	    var seedBytes = options.random || (options.rng || rng)();
+			        if (entry.tryLoc <= this.prev) {
+			          var hasCatch = hasOwn.call(entry, "catchLoc"),
+			              hasFinally = hasOwn.call(entry, "finallyLoc");
 
-	    if (node == null) {
-	      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
-	      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
-	    }
+			          if (hasCatch && hasFinally) {
+			            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+			            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+			          } else if (hasCatch) {
+			            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
+			          } else {
+			            if (!hasFinally) throw new Error("try statement without catch or finally");
+			            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
+			          }
+			        }
+			      }
+			    },
+			    abrupt: function abrupt(type, arg) {
+			      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+			        var entry = this.tryEntries[i];
 
-	    if (clockseq == null) {
-	      // Per 4.2.2, randomize (14 bit) clockseq
-	      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
-	    }
-	  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,
-	  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
-	  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
-	  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+			        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+			          var finallyEntry = entry;
+			          break;
+			        }
+			      }
 
+			      finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
+			      var record = finallyEntry ? finallyEntry.completion : {};
+			      return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
+			    },
+			    complete: function complete(record, afterLoc) {
+			      if ("throw" === record.type) throw record.arg;
+			      return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
+			    },
+			    finish: function finish(finallyLoc) {
+			      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+			        var entry = this.tryEntries[i];
+			        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
+			      }
+			    },
+			    "catch": function _catch(tryLoc) {
+			      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+			        var entry = this.tryEntries[i];
 
-	  var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock
-	  // cycle to simulate higher resolution clock
+			        if (entry.tryLoc === tryLoc) {
+			          var record = entry.completion;
 
-	  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
+			          if ("throw" === record.type) {
+			            var thrown = record.arg;
+			            resetTryEntry(entry);
+			          }
 
-	  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression
+			          return thrown;
+			        }
+			      }
 
-	  if (dt < 0 && options.clockseq === undefined) {
-	    clockseq = clockseq + 1 & 0x3fff;
-	  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
-	  // time interval
+			      throw new Error("illegal catch attempt");
+			    },
+			    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+			      return this.delegate = {
+			        iterator: values(iterable),
+			        resultName: resultName,
+			        nextLoc: nextLoc
+			      }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
+			    }
+			  }, exports;
+			}
 
+			module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (regeneratorRuntime));
+		return regeneratorRuntime.exports;
+	}
 
-	  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
-	    nsecs = 0;
-	  } // Per 4.2.1.2 Throw error if too many uuids are requested
+	var regenerator;
+	var hasRequiredRegenerator;
 
+	function requireRegenerator () {
+		if (hasRequiredRegenerator) return regenerator;
+		hasRequiredRegenerator = 1;
+		regenerator = requireRegeneratorRuntime()();
+		return regenerator;
+	}
 
-	  if (nsecs >= 10000) {
-	    throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
-	  }
+	var asyncToGenerator = {exports: {}};
 
-	  _lastMSecs = msecs;
-	  _lastNSecs = nsecs;
-	  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+	var hasRequiredAsyncToGenerator;
 
-	  msecs += 12219292800000; // `time_low`
+	function requireAsyncToGenerator () {
+		if (hasRequiredAsyncToGenerator) return asyncToGenerator.exports;
+		hasRequiredAsyncToGenerator = 1;
+		(function (module) {
+			function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+			  try {
+			    var info = gen[key](arg);
+			    var value = info.value;
+			  } catch (error) {
+			    reject(error);
+			    return;
+			  }
 
-	  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
-	  b[i++] = tl >>> 24 & 0xff;
-	  b[i++] = tl >>> 16 & 0xff;
-	  b[i++] = tl >>> 8 & 0xff;
-	  b[i++] = tl & 0xff; // `time_mid`
+			  if (info.done) {
+			    resolve(value);
+			  } else {
+			    Promise.resolve(value).then(_next, _throw);
+			  }
+			}
 
-	  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
-	  b[i++] = tmh >>> 8 & 0xff;
-	  b[i++] = tmh & 0xff; // `time_high_and_version`
+			function _asyncToGenerator(fn) {
+			  return function () {
+			    var self = this,
+			        args = arguments;
+			    return new Promise(function (resolve, reject) {
+			      var gen = fn.apply(self, args);
 
-	  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+			      function _next(value) {
+			        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+			      }
 
-	  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+			      function _throw(err) {
+			        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+			      }
 
-	  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`
+			      _next(undefined);
+			    });
+			  };
+			}
 
-	  b[i++] = clockseq & 0xff; // `node`
+			module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (asyncToGenerator));
+		return asyncToGenerator.exports;
+	}
 
-	  for (var n = 0; n < 6; ++n) {
-	    b[i + n] = node[n];
-	  }
+	var classCallCheck = {exports: {}};
 
-	  return buf || stringify(b);
-	}
+	var hasRequiredClassCallCheck;
 
-	function parse(uuid) {
-	  if (!validate(uuid)) {
-	    throw TypeError('Invalid UUID');
-	  }
+	function requireClassCallCheck () {
+		if (hasRequiredClassCallCheck) return classCallCheck.exports;
+		hasRequiredClassCallCheck = 1;
+		(function (module) {
+			function _classCallCheck(instance, Constructor) {
+			  if (!(instance instanceof Constructor)) {
+			    throw new TypeError("Cannot call a class as a function");
+			  }
+			}
 
-	  var v;
-	  var arr = new Uint8Array(16); // Parse ########-....-....-....-............
+			module.exports = _classCallCheck, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (classCallCheck));
+		return classCallCheck.exports;
+	}
 
-	  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
-	  arr[1] = v >>> 16 & 0xff;
-	  arr[2] = v >>> 8 & 0xff;
-	  arr[3] = v & 0xff; // Parse ........-####-....-....-............
+	var createClass = {exports: {}};
 
-	  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
-	  arr[5] = v & 0xff; // Parse ........-....-####-....-............
+	var hasRequiredCreateClass;
 
-	  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
-	  arr[7] = v & 0xff; // Parse ........-....-....-####-............
+	function requireCreateClass () {
+		if (hasRequiredCreateClass) return createClass.exports;
+		hasRequiredCreateClass = 1;
+		(function (module) {
+			function _defineProperties(target, props) {
+			  for (var i = 0; i < props.length; i++) {
+			    var descriptor = props[i];
+			    descriptor.enumerable = descriptor.enumerable || false;
+			    descriptor.configurable = true;
+			    if ("value" in descriptor) descriptor.writable = true;
+			    Object.defineProperty(target, descriptor.key, descriptor);
+			  }
+			}
 
-	  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
-	  arr[9] = v & 0xff; // Parse ........-....-....-....-############
-	  // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+			function _createClass(Constructor, protoProps, staticProps) {
+			  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+			  if (staticProps) _defineProperties(Constructor, staticProps);
+			  Object.defineProperty(Constructor, "prototype", {
+			    writable: false
+			  });
+			  return Constructor;
+			}
 
-	  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
-	  arr[11] = v / 0x100000000 & 0xff;
-	  arr[12] = v >>> 24 & 0xff;
-	  arr[13] = v >>> 16 & 0xff;
-	  arr[14] = v >>> 8 & 0xff;
-	  arr[15] = v & 0xff;
-	  return arr;
+			module.exports = _createClass, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (createClass));
+		return createClass.exports;
 	}
 
-	function stringToBytes(str) {
-	  str = unescape(encodeURIComponent(str)); // UTF8 escape
-
-	  var bytes = [];
+	var inherits = {exports: {}};
 
-	  for (var i = 0; i < str.length; ++i) {
-	    bytes.push(str.charCodeAt(i));
-	  }
+	var setPrototypeOf = {exports: {}};
 
-	  return bytes;
-	}
+	var hasRequiredSetPrototypeOf;
 
-	var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-	var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
-	function v35 (name, version, hashfunc) {
-	  function generateUUID(value, namespace, buf, offset) {
-	    if (typeof value === 'string') {
-	      value = stringToBytes(value);
-	    }
+	function requireSetPrototypeOf () {
+		if (hasRequiredSetPrototypeOf) return setPrototypeOf.exports;
+		hasRequiredSetPrototypeOf = 1;
+		(function (module) {
+			function _setPrototypeOf(o, p) {
+			  module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+			    o.__proto__ = p;
+			    return o;
+			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+			  return _setPrototypeOf(o, p);
+			}
 
-	    if (typeof namespace === 'string') {
-	      namespace = parse(namespace);
-	    }
+			module.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (setPrototypeOf));
+		return setPrototypeOf.exports;
+	}
 
-	    if (namespace.length !== 16) {
-	      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
-	    } // Compute hash of namespace and value, Per 4.3
-	    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
-	    // hashfunc([...namespace, ... value])`
+	var hasRequiredInherits;
 
+	function requireInherits () {
+		if (hasRequiredInherits) return inherits.exports;
+		hasRequiredInherits = 1;
+		(function (module) {
+			var setPrototypeOf = requireSetPrototypeOf();
 
-	    var bytes = new Uint8Array(16 + value.length);
-	    bytes.set(namespace);
-	    bytes.set(value, namespace.length);
-	    bytes = hashfunc(bytes);
-	    bytes[6] = bytes[6] & 0x0f | version;
-	    bytes[8] = bytes[8] & 0x3f | 0x80;
+			function _inherits(subClass, superClass) {
+			  if (typeof superClass !== "function" && superClass !== null) {
+			    throw new TypeError("Super expression must either be null or a function");
+			  }
 
-	    if (buf) {
-	      offset = offset || 0;
+			  subClass.prototype = Object.create(superClass && superClass.prototype, {
+			    constructor: {
+			      value: subClass,
+			      writable: true,
+			      configurable: true
+			    }
+			  });
+			  Object.defineProperty(subClass, "prototype", {
+			    writable: false
+			  });
+			  if (superClass) setPrototypeOf(subClass, superClass);
+			}
 
-	      for (var i = 0; i < 16; ++i) {
-	        buf[offset + i] = bytes[i];
-	      }
+			module.exports = _inherits, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (inherits));
+		return inherits.exports;
+	}
 
-	      return buf;
-	    }
+	var possibleConstructorReturn = {exports: {}};
 
-	    return stringify(bytes);
-	  } // Function#name is not settable on some platforms (#270)
+	var assertThisInitialized = {exports: {}};
 
+	var hasRequiredAssertThisInitialized;
 
-	  try {
-	    generateUUID.name = name; // eslint-disable-next-line no-empty
-	  } catch (err) {} // For CommonJS default export support
+	function requireAssertThisInitialized () {
+		if (hasRequiredAssertThisInitialized) return assertThisInitialized.exports;
+		hasRequiredAssertThisInitialized = 1;
+		(function (module) {
+			function _assertThisInitialized(self) {
+			  if (self === void 0) {
+			    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+			  }
 
+			  return self;
+			}
 
-	  generateUUID.DNS = DNS;
-	  generateUUID.URL = URL;
-	  return generateUUID;
+			module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (assertThisInitialized));
+		return assertThisInitialized.exports;
 	}
 
-	/*
-	 * Browser-compatible JavaScript MD5
-	 *
-	 * Modification of JavaScript MD5
-	 * https://github.com/blueimp/JavaScript-MD5
-	 *
-	 * Copyright 2011, Sebastian Tschan
-	 * https://blueimp.net
-	 *
-	 * Licensed under the MIT license:
-	 * https://opensource.org/licenses/MIT
-	 *
-	 * Based on
-	 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
-	 * Digest Algorithm, as defined in RFC 1321.
-	 * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
-	 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
-	 * Distributed under the BSD License
-	 * See http://pajhome.org.uk/crypt/md5 for more info.
-	 */
-	function md5(bytes) {
-	  if (typeof bytes === 'string') {
-	    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+	var hasRequiredPossibleConstructorReturn;
 
-	    bytes = new Uint8Array(msg.length);
+	function requirePossibleConstructorReturn () {
+		if (hasRequiredPossibleConstructorReturn) return possibleConstructorReturn.exports;
+		hasRequiredPossibleConstructorReturn = 1;
+		(function (module) {
+			var _typeof = require_typeof()["default"];
 
-	    for (var i = 0; i < msg.length; ++i) {
-	      bytes[i] = msg.charCodeAt(i);
-	    }
-	  }
+			var assertThisInitialized = requireAssertThisInitialized();
 
-	  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
+			function _possibleConstructorReturn(self, call) {
+			  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+			    return call;
+			  } else if (call !== void 0) {
+			    throw new TypeError("Derived constructors may only return object or undefined");
+			  }
+
+			  return assertThisInitialized(self);
+			}
+
+			module.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (possibleConstructorReturn));
+		return possibleConstructorReturn.exports;
 	}
-	/*
-	 * Convert an array of little-endian words to an array of bytes
-	 */
 
+	var getPrototypeOf = {exports: {}};
 
-	function md5ToHexEncodedArray(input) {
-	  var output = [];
-	  var length32 = input.length * 32;
-	  var hexTab = '0123456789abcdef';
+	var hasRequiredGetPrototypeOf;
 
-	  for (var i = 0; i < length32; i += 8) {
-	    var x = input[i >> 5] >>> i % 32 & 0xff;
-	    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
-	    output.push(hex);
-	  }
+	function requireGetPrototypeOf () {
+		if (hasRequiredGetPrototypeOf) return getPrototypeOf.exports;
+		hasRequiredGetPrototypeOf = 1;
+		(function (module) {
+			function _getPrototypeOf(o) {
+			  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+			    return o.__proto__ || Object.getPrototypeOf(o);
+			  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
+			  return _getPrototypeOf(o);
+			}
 
-	  return output;
+			module.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports["default"] = module.exports;
+	} (getPrototypeOf));
+		return getPrototypeOf.exports;
 	}
-	/**
-	 * Calculate output length with padding and bit length
-	 */
 
+	var eventemitter3 = {exports: {}};
 
-	function getOutputLength(inputLength8) {
-	  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
-	}
-	/*
-	 * Calculate the MD5 of an array of little-endian words, and a bit length.
-	 */
+	var hasRequiredEventemitter3;
 
+	function requireEventemitter3 () {
+		if (hasRequiredEventemitter3) return eventemitter3.exports;
+		hasRequiredEventemitter3 = 1;
+		(function (module) {
 
-	function wordsToMd5(x, len) {
-	  /* append padding */
-	  x[len >> 5] |= 0x80 << len % 32;
-	  x[getOutputLength(len) - 1] = len;
-	  var a = 1732584193;
-	  var b = -271733879;
-	  var c = -1732584194;
-	  var d = 271733878;
+			var has = Object.prototype.hasOwnProperty
+			  , prefix = '~';
 
-	  for (var i = 0; i < x.length; i += 16) {
-	    var olda = a;
-	    var oldb = b;
-	    var oldc = c;
-	    var oldd = d;
-	    a = md5ff(a, b, c, d, x[i], 7, -680876936);
-	    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
-	    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
-	    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
-	    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
-	    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
-	    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
-	    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
-	    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
-	    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
-	    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
-	    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
-	    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
-	    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
-	    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
-	    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
-	    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
-	    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
-	    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
-	    b = md5gg(b, c, d, a, x[i], 20, -373897302);
-	    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
-	    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
-	    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
-	    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
-	    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
-	    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
-	    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
-	    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
-	    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
-	    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
-	    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
-	    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
-	    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
-	    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
-	    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
-	    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
-	    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
-	    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
-	    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
-	    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
-	    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
-	    d = md5hh(d, a, b, c, x[i], 11, -358537222);
-	    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
-	    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
-	    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
-	    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
-	    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
-	    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
-	    a = md5ii(a, b, c, d, x[i], 6, -198630844);
-	    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
-	    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
-	    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
-	    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
-	    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
-	    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
-	    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
-	    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
-	    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
-	    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
-	    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
-	    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
-	    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
-	    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
-	    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
-	    a = safeAdd(a, olda);
-	    b = safeAdd(b, oldb);
-	    c = safeAdd(c, oldc);
-	    d = safeAdd(d, oldd);
-	  }
+			/**
+			 * Constructor to create a storage for our `EE` objects.
+			 * An `Events` instance is a plain object whose properties are event names.
+			 *
+			 * @constructor
+			 * @private
+			 */
+			function Events() {}
 
-	  return [a, b, c, d];
-	}
-	/*
-	 * Convert an array bytes to an array of little-endian words
-	 * Characters >255 have their high-byte silently ignored.
-	 */
+			//
+			// We try to not inherit from `Object.prototype`. In some engines creating an
+			// instance in this way is faster than calling `Object.create(null)` directly.
+			// If `Object.create(null)` is not supported we prefix the event names with a
+			// character to make sure that the built-in object properties are not
+			// overridden or used as an attack vector.
+			//
+			if (Object.create) {
+			  Events.prototype = Object.create(null);
+
+			  //
+			  // This hack is needed because the `__proto__` property is still inherited in
+			  // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
+			  //
+			  if (!new Events().__proto__) prefix = false;
+			}
+
+			/**
+			 * Representation of a single event listener.
+			 *
+			 * @param {Function} fn The listener function.
+			 * @param {*} context The context to invoke the listener with.
+			 * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
+			 * @constructor
+			 * @private
+			 */
+			function EE(fn, context, once) {
+			  this.fn = fn;
+			  this.context = context;
+			  this.once = once || false;
+			}
 
+			/**
+			 * Add a listener for a given event.
+			 *
+			 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+			 * @param {(String|Symbol)} event The event name.
+			 * @param {Function} fn The listener function.
+			 * @param {*} context The context to invoke the listener with.
+			 * @param {Boolean} once Specify if the listener is a one-time listener.
+			 * @returns {EventEmitter}
+			 * @private
+			 */
+			function addListener(emitter, event, fn, context, once) {
+			  if (typeof fn !== 'function') {
+			    throw new TypeError('The listener must be a function');
+			  }
 
-	function bytesToWords(input) {
-	  if (input.length === 0) {
-	    return [];
-	  }
+			  var listener = new EE(fn, context || emitter, once)
+			    , evt = prefix ? prefix + event : event;
 
-	  var length8 = input.length * 8;
-	  var output = new Uint32Array(getOutputLength(length8));
+			  if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+			  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+			  else emitter._events[evt] = [emitter._events[evt], listener];
 
-	  for (var i = 0; i < length8; i += 8) {
-	    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
-	  }
+			  return emitter;
+			}
 
-	  return output;
-	}
-	/*
-	 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
-	 * to work around bugs in some JS interpreters.
-	 */
+			/**
+			 * Clear event by name.
+			 *
+			 * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
+			 * @param {(String|Symbol)} evt The Event name.
+			 * @private
+			 */
+			function clearEvent(emitter, evt) {
+			  if (--emitter._eventsCount === 0) emitter._events = new Events();
+			  else delete emitter._events[evt];
+			}
 
+			/**
+			 * Minimal `EventEmitter` interface that is molded against the Node.js
+			 * `EventEmitter` interface.
+			 *
+			 * @constructor
+			 * @public
+			 */
+			function EventEmitter() {
+			  this._events = new Events();
+			  this._eventsCount = 0;
+			}
 
-	function safeAdd(x, y) {
-	  var lsw = (x & 0xffff) + (y & 0xffff);
-	  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
-	  return msw << 16 | lsw & 0xffff;
-	}
-	/*
-	 * Bitwise rotate a 32-bit number to the left.
-	 */
+			/**
+			 * Return an array listing the events for which the emitter has registered
+			 * listeners.
+			 *
+			 * @returns {Array}
+			 * @public
+			 */
+			EventEmitter.prototype.eventNames = function eventNames() {
+			  var names = []
+			    , events
+			    , name;
 
+			  if (this._eventsCount === 0) return names;
 
-	function bitRotateLeft(num, cnt) {
-	  return num << cnt | num >>> 32 - cnt;
-	}
-	/*
-	 * These functions implement the four basic operations the algorithm uses.
-	 */
+			  for (name in (events = this._events)) {
+			    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+			  }
 
+			  if (Object.getOwnPropertySymbols) {
+			    return names.concat(Object.getOwnPropertySymbols(events));
+			  }
 
-	function md5cmn(q, a, b, x, s, t) {
-	  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
-	}
+			  return names;
+			};
 
-	function md5ff(a, b, c, d, x, s, t) {
-	  return md5cmn(b & c | ~b & d, a, b, x, s, t);
-	}
+			/**
+			 * Return the listeners registered for a given event.
+			 *
+			 * @param {(String|Symbol)} event The event name.
+			 * @returns {Array} The registered listeners.
+			 * @public
+			 */
+			EventEmitter.prototype.listeners = function listeners(event) {
+			  var evt = prefix ? prefix + event : event
+			    , handlers = this._events[evt];
 
-	function md5gg(a, b, c, d, x, s, t) {
-	  return md5cmn(b & d | c & ~d, a, b, x, s, t);
-	}
+			  if (!handlers) return [];
+			  if (handlers.fn) return [handlers.fn];
 
-	function md5hh(a, b, c, d, x, s, t) {
-	  return md5cmn(b ^ c ^ d, a, b, x, s, t);
-	}
+			  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+			    ee[i] = handlers[i].fn;
+			  }
 
-	function md5ii(a, b, c, d, x, s, t) {
-	  return md5cmn(c ^ (b | ~d), a, b, x, s, t);
-	}
+			  return ee;
+			};
 
-	var v3 = v35('v3', 0x30, md5);
-	var v3$1 = v3;
+			/**
+			 * Return the number of listeners listening to a given event.
+			 *
+			 * @param {(String|Symbol)} event The event name.
+			 * @returns {Number} The number of listeners.
+			 * @public
+			 */
+			EventEmitter.prototype.listenerCount = function listenerCount(event) {
+			  var evt = prefix ? prefix + event : event
+			    , listeners = this._events[evt];
 
-	function v4(options, buf, offset) {
-	  options = options || {};
-	  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+			  if (!listeners) return 0;
+			  if (listeners.fn) return 1;
+			  return listeners.length;
+			};
 
-	  rnds[6] = rnds[6] & 0x0f | 0x40;
-	  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+			/**
+			 * Calls each of the listeners registered for a given event.
+			 *
+			 * @param {(String|Symbol)} event The event name.
+			 * @returns {Boolean} `true` if the event had listeners, else `false`.
+			 * @public
+			 */
+			EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+			  var evt = prefix ? prefix + event : event;
 
-	  if (buf) {
-	    offset = offset || 0;
+			  if (!this._events[evt]) return false;
 
-	    for (var i = 0; i < 16; ++i) {
-	      buf[offset + i] = rnds[i];
-	    }
+			  var listeners = this._events[evt]
+			    , len = arguments.length
+			    , args
+			    , i;
 
-	    return buf;
-	  }
+			  if (listeners.fn) {
+			    if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
 
-	  return stringify(rnds);
-	}
+			    switch (len) {
+			      case 1: return listeners.fn.call(listeners.context), true;
+			      case 2: return listeners.fn.call(listeners.context, a1), true;
+			      case 3: return listeners.fn.call(listeners.context, a1, a2), true;
+			      case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
+			      case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+			      case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+			    }
 
-	// Adapted from Chris Veness' SHA1 code at
-	// http://www.movable-type.co.uk/scripts/sha1.html
-	function f(s, x, y, z) {
-	  switch (s) {
-	    case 0:
-	      return x & y ^ ~x & z;
+			    for (i = 1, args = new Array(len -1); i < len; i++) {
+			      args[i - 1] = arguments[i];
+			    }
 
-	    case 1:
-	      return x ^ y ^ z;
+			    listeners.fn.apply(listeners.context, args);
+			  } else {
+			    var length = listeners.length
+			      , j;
 
-	    case 2:
-	      return x & y ^ x & z ^ y & z;
+			    for (i = 0; i < length; i++) {
+			      if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
 
-	    case 3:
-	      return x ^ y ^ z;
-	  }
-	}
+			      switch (len) {
+			        case 1: listeners[i].fn.call(listeners[i].context); break;
+			        case 2: listeners[i].fn.call(listeners[i].context, a1); break;
+			        case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
+			        case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
+			        default:
+			          if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
+			            args[j - 1] = arguments[j];
+			          }
 
-	function ROTL(x, n) {
-	  return x << n | x >>> 32 - n;
-	}
+			          listeners[i].fn.apply(listeners[i].context, args);
+			      }
+			    }
+			  }
 
-	function sha1(bytes) {
-	  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
-	  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+			  return true;
+			};
 
-	  if (typeof bytes === 'string') {
-	    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
+			/**
+			 * Add a listener for a given event.
+			 *
+			 * @param {(String|Symbol)} event The event name.
+			 * @param {Function} fn The listener function.
+			 * @param {*} [context=this] The context to invoke the listener with.
+			 * @returns {EventEmitter} `this`.
+			 * @public
+			 */
+			EventEmitter.prototype.on = function on(event, fn, context) {
+			  return addListener(this, event, fn, context, false);
+			};
 
-	    bytes = [];
+			/**
+			 * Add a one-time listener for a given event.
+			 *
+			 * @param {(String|Symbol)} event The event name.
+			 * @param {Function} fn The listener function.
+			 * @param {*} [context=this] The context to invoke the listener with.
+			 * @returns {EventEmitter} `this`.
+			 * @public
+			 */
+			EventEmitter.prototype.once = function once(event, fn, context) {
+			  return addListener(this, event, fn, context, true);
+			};
 
-	    for (var i = 0; i < msg.length; ++i) {
-	      bytes.push(msg.charCodeAt(i));
-	    }
-	  } else if (!Array.isArray(bytes)) {
-	    // Convert Array-like to Array
-	    bytes = Array.prototype.slice.call(bytes);
-	  }
+			/**
+			 * Remove the listeners of a given event.
+			 *
+			 * @param {(String|Symbol)} event The event name.
+			 * @param {Function} fn Only remove the listeners that match this function.
+			 * @param {*} context Only remove the listeners that have this context.
+			 * @param {Boolean} once Only remove one-time listeners.
+			 * @returns {EventEmitter} `this`.
+			 * @public
+			 */
+			EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+			  var evt = prefix ? prefix + event : event;
 
-	  bytes.push(0x80);
-	  var l = bytes.length / 4 + 2;
-	  var N = Math.ceil(l / 16);
-	  var M = new Array(N);
+			  if (!this._events[evt]) return this;
+			  if (!fn) {
+			    clearEvent(this, evt);
+			    return this;
+			  }
 
-	  for (var _i = 0; _i < N; ++_i) {
-	    var arr = new Uint32Array(16);
+			  var listeners = this._events[evt];
 
-	    for (var j = 0; j < 16; ++j) {
-	      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];
-	    }
+			  if (listeners.fn) {
+			    if (
+			      listeners.fn === fn &&
+			      (!once || listeners.once) &&
+			      (!context || listeners.context === context)
+			    ) {
+			      clearEvent(this, evt);
+			    }
+			  } else {
+			    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+			      if (
+			        listeners[i].fn !== fn ||
+			        (once && !listeners[i].once) ||
+			        (context && listeners[i].context !== context)
+			      ) {
+			        events.push(listeners[i]);
+			      }
+			    }
 
-	    M[_i] = arr;
-	  }
+			    //
+			    // Reset the array, or remove it completely if we have no more listeners.
+			    //
+			    if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+			    else clearEvent(this, evt);
+			  }
 
-	  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
-	  M[N - 1][14] = Math.floor(M[N - 1][14]);
-	  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
+			  return this;
+			};
 
-	  for (var _i2 = 0; _i2 < N; ++_i2) {
-	    var W = new Uint32Array(80);
+			/**
+			 * Remove all listeners, or those of the specified event.
+			 *
+			 * @param {(String|Symbol)} [event] The event name.
+			 * @returns {EventEmitter} `this`.
+			 * @public
+			 */
+			EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+			  var evt;
 
-	    for (var t = 0; t < 16; ++t) {
-	      W[t] = M[_i2][t];
-	    }
+			  if (event) {
+			    evt = prefix ? prefix + event : event;
+			    if (this._events[evt]) clearEvent(this, evt);
+			  } else {
+			    this._events = new Events();
+			    this._eventsCount = 0;
+			  }
 
-	    for (var _t = 16; _t < 80; ++_t) {
-	      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);
-	    }
+			  return this;
+			};
 
-	    var a = H[0];
-	    var b = H[1];
-	    var c = H[2];
-	    var d = H[3];
-	    var e = H[4];
+			//
+			// Alias methods names because people roll like that.
+			//
+			EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+			EventEmitter.prototype.addListener = EventEmitter.prototype.on;
 
-	    for (var _t2 = 0; _t2 < 80; ++_t2) {
-	      var s = Math.floor(_t2 / 20);
-	      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;
-	      e = d;
-	      d = c;
-	      c = ROTL(b, 30) >>> 0;
-	      b = a;
-	      a = T;
-	    }
+			//
+			// Expose the prefix.
+			//
+			EventEmitter.prefixed = prefix;
 
-	    H[0] = H[0] + a >>> 0;
-	    H[1] = H[1] + b >>> 0;
-	    H[2] = H[2] + c >>> 0;
-	    H[3] = H[3] + d >>> 0;
-	    H[4] = H[4] + e >>> 0;
-	  }
+			//
+			// Allow `EventEmitter` to be imported as module namespace.
+			//
+			EventEmitter.EventEmitter = EventEmitter;
 
-	  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
+			//
+			// Expose the module.
+			//
+			{
+			  module.exports = EventEmitter;
+			}
+	} (eventemitter3));
+		return eventemitter3.exports;
 	}
 
-	var v5 = v35('v5', 0x50, sha1);
-	var v5$1 = v5;
+	/**
+	 * "Client" wraps "ws" or a browser-implemented "WebSocket" library
+	 * according to the environment providing JSON RPC 2.0 support on top.
+	 * @module Client
+	 */
 
-	var nil = '00000000-0000-0000-0000-000000000000';
+	(function (exports) {
 
-	function version(uuid) {
-	  if (!validate(uuid)) {
-	    throw TypeError('Invalid UUID');
-	  }
+		var _interopRequireDefault = interopRequireDefault.exports;
 
-	  return parseInt(uuid.substr(14, 1), 16);
-	}
+		Object.defineProperty(exports, "__esModule", {
+		  value: true
+		});
+		exports["default"] = void 0;
 
-	var esmBrowser = /*#__PURE__*/Object.freeze({
-		__proto__: null,
-		v1: v1,
-		v3: v3$1,
-		v4: v4,
-		v5: v5$1,
-		NIL: nil,
-		version: version,
-		validate: validate,
-		stringify: stringify,
-		parse: parse
-	});
+		var _regenerator = _interopRequireDefault(requireRegenerator());
 
-	var require$$0 = /*@__PURE__*/getAugmentedNamespace(esmBrowser);
+		var _asyncToGenerator2 = _interopRequireDefault(requireAsyncToGenerator());
 
-	const uuid$1 = require$$0.v4;
+		var _typeof2 = _interopRequireDefault(require_typeof());
 
-	/**
-	 *  Generates a JSON-RPC 1.0 or 2.0 request
-	 *  @param {String} method Name of method to call
-	 *  @param {Array|Object} params Array of parameters passed to the method as specified, or an object of parameter names and corresponding value
-	 *  @param {String|Number|null} [id] Request ID can be a string, number, null for explicit notification or left out for automatic generation
-	 *  @param {Object} [options]
-	 *  @param {Number} [options.version=2] JSON-RPC version to use (1 or 2)
-	 *  @param {Boolean} [options.notificationIdNull=false] When true, version 2 requests will set id to null instead of omitting it
-	 *  @param {Function} [options.generator] Passed the request, and the options object and is expected to return a request ID
-	 *  @throws {TypeError} If any of the parameters are invalid
-	 *  @return {Object} A JSON-RPC 1.0 or 2.0 request
-	 *  @memberOf Utils
-	 */
-	const generateRequest$1 = function(method, params, id, options) {
-	  if(typeof method !== 'string') {
-	    throw new TypeError(method + ' must be a string');
-	  }
+		var _classCallCheck2 = _interopRequireDefault(requireClassCallCheck());
 
-	  options = options || {};
+		var _createClass2 = _interopRequireDefault(requireCreateClass());
 
-	  // check valid version provided
-	  const version = typeof options.version === 'number' ? options.version : 2;
-	  if (version !== 1 && version !== 2) {
-	    throw new TypeError(version + ' must be 1 or 2');
-	  }
+		var _inherits2 = _interopRequireDefault(requireInherits());
 
-	  const request = {
-	    method: method
-	  };
+		var _possibleConstructorReturn2 = _interopRequireDefault(requirePossibleConstructorReturn());
 
-	  if(version === 2) {
-	    request.jsonrpc = '2.0';
-	  }
+		var _getPrototypeOf2 = _interopRequireDefault(requireGetPrototypeOf());
 
-	  if(params) {
-	    // params given, but invalid?
-	    if(typeof params !== 'object' && !Array.isArray(params)) {
-	      throw new TypeError(params + ' must be an object, array or omitted');
-	    }
-	    request.params = params;
-	  }
+		var _eventemitter = requireEventemitter3();
 
-	  // if id was left out, generate one (null means explicit notification)
-	  if(typeof(id) === 'undefined') {
-	    const generator = typeof options.generator === 'function' ? options.generator : function() { return uuid$1(); };
-	    request.id = generator(request, options);
-	  } else if (version === 2 && id === null) {
-	    // we have a version 2 notification
-	    if (options.notificationIdNull) {
-	      request.id = null; // id will not be set at all unless option provided
-	    }
-	  } else {
-	    request.id = id;
-	  }
+		function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
-	  return request;
-	};
+		function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-	var generateRequest_1 = generateRequest$1;
+		var __rest = function (s, e) {
+		  var t = {};
 
-	const uuid = require$$0.v4;
-	const generateRequest = generateRequest_1;
+		  for (var p in s) {
+		    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+		  }
 
-	/**
-	 * Constructor for a Jayson Browser Client that does not depend any node.js core libraries
-	 * @class ClientBrowser
-	 * @param {Function} callServer Method that calls the server, receives the stringified request and a regular node-style callback
-	 * @param {Object} [options]
-	 * @param {Function} [options.reviver] Reviver function for JSON
-	 * @param {Function} [options.replacer] Replacer function for JSON
-	 * @param {Number} [options.version=2] JSON-RPC version to use (1|2)
-	 * @param {Function} [options.generator] Function to use for generating request IDs
-	 *  @param {Boolean} [options.notificationIdNull=false] When true, version 2 requests will set id to null instead of omitting it
-	 * @return {ClientBrowser}
-	 */
-	const ClientBrowser = function(callServer, options) {
-	  if(!(this instanceof ClientBrowser)) {
-	    return new ClientBrowser(callServer, options);
-	  }
+		  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+		    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+		  }
+		  return t;
+		}; // @ts-ignore
+
+
+		var CommonClient = /*#__PURE__*/function (_EventEmitter) {
+		  (0, _inherits2["default"])(CommonClient, _EventEmitter);
+
+		  var _super = _createSuper(CommonClient);
+
+		  /**
+		   * Instantiate a Client class.
+		   * @constructor
+		   * @param {webSocketFactory} webSocketFactory - factory method for WebSocket
+		   * @param {String} address - url to a websocket server
+		   * @param {Object} options - ws options object with reconnect parameters
+		   * @param {Function} generate_request_id - custom generation request Id
+		   * @return {CommonClient}
+		   */
+		  function CommonClient(webSocketFactory) {
+		    var _this;
+
+		    var address = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "ws://localhost:8080";
+
+		    var _a = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+		    var generate_request_id = arguments.length > 3 ? arguments[3] : undefined;
+		    (0, _classCallCheck2["default"])(this, CommonClient);
+
+		    var _a$autoconnect = _a.autoconnect,
+		        autoconnect = _a$autoconnect === void 0 ? true : _a$autoconnect,
+		        _a$reconnect = _a.reconnect,
+		        reconnect = _a$reconnect === void 0 ? true : _a$reconnect,
+		        _a$reconnect_interval = _a.reconnect_interval,
+		        reconnect_interval = _a$reconnect_interval === void 0 ? 1000 : _a$reconnect_interval,
+		        _a$max_reconnects = _a.max_reconnects,
+		        max_reconnects = _a$max_reconnects === void 0 ? 5 : _a$max_reconnects,
+		        rest_options = __rest(_a, ["autoconnect", "reconnect", "reconnect_interval", "max_reconnects"]);
+
+		    _this = _super.call(this);
+		    _this.webSocketFactory = webSocketFactory;
+		    _this.queue = {};
+		    _this.rpc_id = 0;
+		    _this.address = address;
+		    _this.autoconnect = autoconnect;
+		    _this.ready = false;
+		    _this.reconnect = reconnect;
+		    _this.reconnect_interval = reconnect_interval;
+		    _this.max_reconnects = max_reconnects;
+		    _this.rest_options = rest_options;
+		    _this.current_reconnects = 0;
+
+		    _this.generate_request_id = generate_request_id || function () {
+		      return ++_this.rpc_id;
+		    };
 
-	  if (!options) {
-	    options = {};
-	  }
+		    if (_this.autoconnect) _this._connect(_this.address, Object.assign({
+		      autoconnect: _this.autoconnect,
+		      reconnect: _this.reconnect,
+		      reconnect_interval: _this.reconnect_interval,
+		      max_reconnects: _this.max_reconnects
+		    }, _this.rest_options));
+		    return _this;
+		  }
+		  /**
+		   * Connects to a defined server if not connected already.
+		   * @method
+		   * @return {Undefined}
+		   */
+
+
+		  (0, _createClass2["default"])(CommonClient, [{
+		    key: "connect",
+		    value: function connect() {
+		      if (this.socket) return;
+
+		      this._connect(this.address, Object.assign({
+		        autoconnect: this.autoconnect,
+		        reconnect: this.reconnect,
+		        reconnect_interval: this.reconnect_interval,
+		        max_reconnects: this.max_reconnects
+		      }, this.rest_options));
+		    }
+		    /**
+		     * Calls a registered RPC method on server.
+		     * @method
+		     * @param {String} method - RPC method name
+		     * @param {Object|Array} params - optional method parameters
+		     * @param {Number} timeout - RPC reply timeout value
+		     * @param {Object} ws_opts - options passed to ws
+		     * @return {Promise}
+		     */
+
+		  }, {
+		    key: "call",
+		    value: function call(method, params, timeout, ws_opts) {
+		      var _this2 = this;
+
+		      if (!ws_opts && "object" === (0, _typeof2["default"])(timeout)) {
+		        ws_opts = timeout;
+		        timeout = null;
+		      }
 
-	  this.options = {
-	    reviver: typeof options.reviver !== 'undefined' ? options.reviver : null,
-	    replacer: typeof options.replacer !== 'undefined' ? options.replacer : null,
-	    generator: typeof options.generator !== 'undefined' ? options.generator : function() { return uuid(); },
-	    version: typeof options.version !== 'undefined' ? options.version : 2,
-	    notificationIdNull: typeof options.notificationIdNull === 'boolean' ? options.notificationIdNull : false,
-	  };
+		      return new Promise(function (resolve, reject) {
+		        if (!_this2.ready) return reject(new Error("socket not ready"));
 
-	  this.callServer = callServer;
-	};
+		        var rpc_id = _this2.generate_request_id(method, params);
 
-	var browser = ClientBrowser;
+		        var message = {
+		          jsonrpc: "2.0",
+		          method: method,
+		          params: params || null,
+		          id: rpc_id
+		        };
 
-	/**
-	 *  Creates a request and dispatches it if given a callback.
-	 *  @param {String|Array} method A batch request if passed an Array, or a method name if passed a String
-	 *  @param {Array|Object} [params] Parameters for the method
-	 *  @param {String|Number} [id] Optional id. If undefined an id will be generated. If null it creates a notification request
-	 *  @param {Function} [callback] Request callback. If specified, executes the request rather than only returning it.
-	 *  @throws {TypeError} Invalid parameters
-	 *  @return {Object} JSON-RPC 1.0 or 2.0 compatible request
-	 */
-	ClientBrowser.prototype.request = function(method, params, id, callback) {
-	  const self = this;
-	  let request = null;
+		        _this2.socket.send(JSON.stringify(message), ws_opts, function (error) {
+		          if (error) return reject(error);
+		          _this2.queue[rpc_id] = {
+		            promise: [resolve, reject]
+		          };
+
+		          if (timeout) {
+		            _this2.queue[rpc_id].timeout = setTimeout(function () {
+		              delete _this2.queue[rpc_id];
+		              reject(new Error("reply timeout"));
+		            }, timeout);
+		          }
+		        });
+		      });
+		    }
+		    /**
+		     * Logins with the other side of the connection.
+		     * @method
+		     * @param {Object} params - Login credentials object
+		     * @return {Promise}
+		     */
+
+		  }, {
+		    key: "login",
+		    value: function () {
+		      var _login = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(params) {
+		        var resp;
+		        return _regenerator["default"].wrap(function _callee$(_context) {
+		          while (1) {
+		            switch (_context.prev = _context.next) {
+		              case 0:
+		                _context.next = 2;
+		                return this.call("rpc.login", params);
+
+		              case 2:
+		                resp = _context.sent;
+
+		                if (resp) {
+		                  _context.next = 5;
+		                  break;
+		                }
+
+		                throw new Error("authentication failed");
+
+		              case 5:
+		                return _context.abrupt("return", resp);
+
+		              case 6:
+		              case "end":
+		                return _context.stop();
+		            }
+		          }
+		        }, _callee, this);
+		      }));
+
+		      function login(_x) {
+		        return _login.apply(this, arguments);
+		      }
 
-	  // is this a batch request?
-	  const isBatch = Array.isArray(method) && typeof params === 'function';
+		      return login;
+		    }()
+		    /**
+		     * Fetches a list of client's methods registered on server.
+		     * @method
+		     * @return {Array}
+		     */
+
+		  }, {
+		    key: "listMethods",
+		    value: function () {
+		      var _listMethods = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+		        return _regenerator["default"].wrap(function _callee2$(_context2) {
+		          while (1) {
+		            switch (_context2.prev = _context2.next) {
+		              case 0:
+		                _context2.next = 2;
+		                return this.call("__listMethods");
+
+		              case 2:
+		                return _context2.abrupt("return", _context2.sent);
+
+		              case 3:
+		              case "end":
+		                return _context2.stop();
+		            }
+		          }
+		        }, _callee2, this);
+		      }));
 
-	  if (this.options.version === 1 && isBatch) {
-	    throw new TypeError('JSON-RPC 1.0 does not support batching');
-	  }
+		      function listMethods() {
+		        return _listMethods.apply(this, arguments);
+		      }
 
-	  // is this a raw request?
-	  const isRaw = !isBatch && method && typeof method === 'object' && typeof params === 'function';
+		      return listMethods;
+		    }()
+		    /**
+		     * Sends a JSON-RPC 2.0 notification to server.
+		     * @method
+		     * @param {String} method - RPC method name
+		     * @param {Object} params - optional method parameters
+		     * @return {Promise}
+		     */
+
+		  }, {
+		    key: "notify",
+		    value: function notify(method, params) {
+		      var _this3 = this;
+
+		      return new Promise(function (resolve, reject) {
+		        if (!_this3.ready) return reject(new Error("socket not ready"));
+		        var message = {
+		          jsonrpc: "2.0",
+		          method: method,
+		          params: params || null
+		        };
 
-	  if(isBatch || isRaw) {
-	    callback = params;
-	    request = method;
-	  } else {
-	    if(typeof id === 'function') {
-	      callback = id;
-	      // specifically undefined because "null" is a notification request
-	      id = undefined;
-	    }
+		        _this3.socket.send(JSON.stringify(message), function (error) {
+		          if (error) return reject(error);
+		          resolve();
+		        });
+		      });
+		    }
+		    /**
+		     * Subscribes for a defined event.
+		     * @method
+		     * @param {String|Array} event - event name
+		     * @return {Undefined}
+		     * @throws {Error}
+		     */
+
+		  }, {
+		    key: "subscribe",
+		    value: function () {
+		      var _subscribe = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(event) {
+		        var result;
+		        return _regenerator["default"].wrap(function _callee3$(_context3) {
+		          while (1) {
+		            switch (_context3.prev = _context3.next) {
+		              case 0:
+		                if (typeof event === "string") event = [event];
+		                _context3.next = 3;
+		                return this.call("rpc.on", event);
+
+		              case 3:
+		                result = _context3.sent;
+
+		                if (!(typeof event === "string" && result[event] !== "ok")) {
+		                  _context3.next = 6;
+		                  break;
+		                }
+
+		                throw new Error("Failed subscribing to an event '" + event + "' with: " + result[event]);
+
+		              case 6:
+		                return _context3.abrupt("return", result);
+
+		              case 7:
+		              case "end":
+		                return _context3.stop();
+		            }
+		          }
+		        }, _callee3, this);
+		      }));
 
-	    const hasCallback = typeof callback === 'function';
+		      function subscribe(_x2) {
+		        return _subscribe.apply(this, arguments);
+		      }
 
-	    try {
-	      request = generateRequest(method, params, id, {
-	        generator: this.options.generator,
-	        version: this.options.version,
-	        notificationIdNull: this.options.notificationIdNull,
-	      });
-	    } catch(err) {
-	      if(hasCallback) {
-	        return callback(err);
-	      }
-	      throw err;
-	    }
+		      return subscribe;
+		    }()
+		    /**
+		     * Unsubscribes from a defined event.
+		     * @method
+		     * @param {String|Array} event - event name
+		     * @return {Undefined}
+		     * @throws {Error}
+		     */
+
+		  }, {
+		    key: "unsubscribe",
+		    value: function () {
+		      var _unsubscribe = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(event) {
+		        var result;
+		        return _regenerator["default"].wrap(function _callee4$(_context4) {
+		          while (1) {
+		            switch (_context4.prev = _context4.next) {
+		              case 0:
+		                if (typeof event === "string") event = [event];
+		                _context4.next = 3;
+		                return this.call("rpc.off", event);
+
+		              case 3:
+		                result = _context4.sent;
+
+		                if (!(typeof event === "string" && result[event] !== "ok")) {
+		                  _context4.next = 6;
+		                  break;
+		                }
+
+		                throw new Error("Failed unsubscribing from an event with: " + result);
+
+		              case 6:
+		                return _context4.abrupt("return", result);
+
+		              case 7:
+		              case "end":
+		                return _context4.stop();
+		            }
+		          }
+		        }, _callee4, this);
+		      }));
 
-	    // no callback means we should just return a raw request
-	    if(!hasCallback) {
-	      return request;
-	    }
+		      function unsubscribe(_x3) {
+		        return _unsubscribe.apply(this, arguments);
+		      }
 
-	  }
+		      return unsubscribe;
+		    }()
+		    /**
+		     * Closes a WebSocket connection gracefully.
+		     * @method
+		     * @param {Number} code - socket close code
+		     * @param {String} data - optional data to be sent before closing
+		     * @return {Undefined}
+		     */
+
+		  }, {
+		    key: "close",
+		    value: function close(code, data) {
+		      this.socket.close(code || 1000, data);
+		    }
+		    /**
+		     * Connection/Message handler.
+		     * @method
+		     * @private
+		     * @param {String} address - WebSocket API address
+		     * @param {Object} options - ws options object
+		     * @return {Undefined}
+		     */
+
+		  }, {
+		    key: "_connect",
+		    value: function _connect(address, options) {
+		      var _this4 = this;
+
+		      this.socket = this.webSocketFactory(address, options);
+		      this.socket.addEventListener("open", function () {
+		        _this4.ready = true;
+
+		        _this4.emit("open");
+
+		        _this4.current_reconnects = 0;
+		      });
+		      this.socket.addEventListener("message", function (_ref) {
+		        var message = _ref.data;
+		        if (message instanceof ArrayBuffer) message = Buffer.from(message).toString();
+
+		        try {
+		          message = JSON.parse(message);
+		        } catch (error) {
+		          return;
+		        } // check if any listeners are attached and forward event
+
+
+		        if (message.notification && _this4.listeners(message.notification).length) {
+		          if (!Object.keys(message.params).length) return _this4.emit(message.notification);
+		          var args = [message.notification];
+		          if (message.params.constructor === Object) args.push(message.params);else // using for-loop instead of unshift/spread because performance is better
+		            for (var i = 0; i < message.params.length; i++) {
+		              args.push(message.params[i]);
+		            } // run as microtask so that pending queue messages are resolved first
+		          // eslint-disable-next-line prefer-spread
+
+		          return Promise.resolve().then(function () {
+		            _this4.emit.apply(_this4, args);
+		          });
+		        }
 
-	  let message;
-	  try {
-	    message = JSON.stringify(request, this.options.replacer);
-	  } catch(err) {
-	    return callback(err);
-	  }
+		        if (!_this4.queue[message.id]) {
+		          // general JSON RPC 2.0 events
+		          if (message.method && message.params) {
+		            // run as microtask so that pending queue messages are resolved first
+		            return Promise.resolve().then(function () {
+		              _this4.emit(message.method, message.params);
+		            });
+		          }
 
-	  this.callServer(message, function(err, response) {
-	    self._parseResponse(err, response, callback);
-	  });
+		          return;
+		        } // reject early since server's response is invalid
 
-	  // always return the raw request
-	  return request;
-	};
+
+		        if ("error" in message === "result" in message) _this4.queue[message.id].promise[1](new Error("Server response malformed. Response must include either \"result\"" + " or \"error\", but not both."));
+		        if (_this4.queue[message.id].timeout) clearTimeout(_this4.queue[message.id].timeout);
+		        if (message.error) _this4.queue[message.id].promise[1](message.error);else _this4.queue[message.id].promise[0](message.result);
+		        delete _this4.queue[message.id];
+		      });
+		      this.socket.addEventListener("error", function (error) {
+		        return _this4.emit("error", error);
+		      });
+		      this.socket.addEventListener("close", function (_ref2) {
+		        var code = _ref2.code,
+		            reason = _ref2.reason;
+		        if (_this4.ready) // Delay close event until internal state is updated
+		          setTimeout(function () {
+		            return _this4.emit("close", code, reason);
+		          }, 0);
+		        _this4.ready = false;
+		        _this4.socket = undefined;
+		        if (code === 1000) return;
+		        _this4.current_reconnects++;
+		        if (_this4.reconnect && (_this4.max_reconnects > _this4.current_reconnects || _this4.max_reconnects === 0)) setTimeout(function () {
+		          return _this4._connect(address, options);
+		        }, _this4.reconnect_interval);
+		      });
+		    }
+		  }]);
+		  return CommonClient;
+		}(_eventemitter.EventEmitter);
+
+		exports["default"] = CommonClient;
+	} (client));
+
+	var RpcWebSocketCommonClient = /*@__PURE__*/getDefaultExportFromCjs(client);
+
+	var websocket_browser = {};
 
 	/**
-	 * Parses a response from a server
-	 * @param {Object} err Error to pass on that is unrelated to the actual response
-	 * @param {String} responseText JSON-RPC 1.0 or 2.0 response
-	 * @param {Function} callback Callback that will receive different arguments depending on the amount of parameters
-	 * @private
+	 * WebSocket implements a browser-side WebSocket specification.
+	 * @module Client
 	 */
-	ClientBrowser.prototype._parseResponse = function(err, responseText, callback) {
-	  if(err) {
-	    callback(err);
-	    return;
-	  }
 
-	  if(!responseText) {
-	    // empty response text, assume that is correct because it could be a
-	    // notification which jayson does not give any body for
-	    return callback();
-	  }
+	(function (exports) {
 
-	  let response;
-	  try {
-	    response = JSON.parse(responseText, this.options.reviver);
-	  } catch(err) {
-	    return callback(err);
-	  }
+		var _interopRequireDefault = interopRequireDefault.exports;
 
-	  if(callback.length === 3) {
-	    // if callback length is 3, we split callback arguments on error and response
+		Object.defineProperty(exports, "__esModule", {
+		  value: true
+		});
+		exports["default"] = _default;
 
-	    // is batch response?
-	    if(Array.isArray(response)) {
+		var _classCallCheck2 = _interopRequireDefault(requireClassCallCheck());
 
-	      // neccesary to split strictly on validity according to spec here
-	      const isError = function(res) {
-	        return typeof res.error !== 'undefined';
-	      };
+		var _createClass2 = _interopRequireDefault(requireCreateClass());
 
-	      const isNotError = function (res) {
-	        return !isError(res);
-	      };
+		var _inherits2 = _interopRequireDefault(requireInherits());
 
-	      return callback(null, response.filter(isError), response.filter(isNotError));
-	    
-	    } else {
+		var _possibleConstructorReturn2 = _interopRequireDefault(requirePossibleConstructorReturn());
 
-	      // split regardless of validity
-	      return callback(null, response.error, response.result);
-	    
-	    }
-	  
-	  }
+		var _getPrototypeOf2 = _interopRequireDefault(requireGetPrototypeOf());
 
-	  callback(null, response);
-	};
+		var _eventemitter = requireEventemitter3();
 
-	var RpcClient = browser;
+		function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
-	const MINIMUM_SLOT_PER_EPOCH = 32; // Returns the number of trailing zeros in the binary representation of self.
+		function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-	function trailingZeros(n) {
-	  let trailingZeros = 0;
+		var WebSocketBrowserImpl = /*#__PURE__*/function (_EventEmitter) {
+		  (0, _inherits2["default"])(WebSocketBrowserImpl, _EventEmitter);
 
-	  while (n > 1) {
-	    n /= 2;
-	    trailingZeros++;
-	  }
+		  var _super = _createSuper(WebSocketBrowserImpl);
 
-	  return trailingZeros;
-	} // Returns the smallest power of two greater than or equal to n
+		  /** Instantiate a WebSocket class
+		   * @constructor
+		   * @param {String} address - url to a websocket server
+		   * @param {(Object)} options - websocket options
+		   * @param {(String|Array)} protocols - a list of protocols
+		   * @return {WebSocketBrowserImpl} - returns a WebSocket instance
+		   */
+		  function WebSocketBrowserImpl(address, options, protocols) {
+		    var _this;
 
+		    (0, _classCallCheck2["default"])(this, WebSocketBrowserImpl);
+		    _this = _super.call(this);
+		    _this.socket = new window.WebSocket(address, protocols);
 
-	function nextPowerOfTwo(n) {
-	  if (n === 0) return 1;
-	  n--;
-	  n |= n >> 1;
-	  n |= n >> 2;
-	  n |= n >> 4;
-	  n |= n >> 8;
-	  n |= n >> 16;
-	  n |= n >> 32;
-	  return n + 1;
-	}
-	/**
-	 * Epoch schedule
-	 * (see https://docs.solana.com/terminology#epoch)
-	 * Can be retrieved with the {@link Connection.getEpochSchedule} method
-	 */
+		    _this.socket.onopen = function () {
+		      return _this.emit("open");
+		    };
 
+		    _this.socket.onmessage = function (event) {
+		      return _this.emit("message", event.data);
+		    };
 
-	class EpochSchedule {
-	  /** The maximum number of slots in each epoch */
+		    _this.socket.onerror = function (error) {
+		      return _this.emit("error", error);
+		    };
 
-	  /** The number of slots before beginning of an epoch to calculate a leader schedule for that epoch */
+		    _this.socket.onclose = function (event) {
+		      _this.emit("close", event.code, event.reason);
+		    };
 
-	  /** Indicates whether epochs start short and grow */
+		    return _this;
+		  }
+		  /**
+		   * Sends data through a websocket connection
+		   * @method
+		   * @param {(String|Object)} data - data to be sent via websocket
+		   * @param {Object} optionsOrCallback - ws options
+		   * @param {Function} callback - a callback called once the data is sent
+		   * @return {Undefined}
+		   */
+
+
+		  (0, _createClass2["default"])(WebSocketBrowserImpl, [{
+		    key: "send",
+		    value: function send(data, optionsOrCallback, callback) {
+		      var cb = callback || optionsOrCallback;
+
+		      try {
+		        this.socket.send(data);
+		        cb();
+		      } catch (error) {
+		        cb(error);
+		      }
+		    }
+		    /**
+		     * Closes an underlying socket
+		     * @method
+		     * @param {Number} code - status code explaining why the connection is being closed
+		     * @param {String} reason - a description why the connection is closing
+		     * @return {Undefined}
+		     * @throws {Error}
+		     */
+
+		  }, {
+		    key: "close",
+		    value: function close(code, reason) {
+		      this.socket.close(code, reason);
+		    }
+		  }, {
+		    key: "addEventListener",
+		    value: function addEventListener(type, listener, options) {
+		      this.socket.addEventListener(type, listener, options);
+		    }
+		  }]);
+		  return WebSocketBrowserImpl;
+		}(_eventemitter.EventEmitter);
+		/**
+		 * factory method for common WebSocket instance
+		 * @method
+		 * @param {String} address - url to a websocket server
+		 * @param {(Object)} options - websocket options
+		 * @return {Undefined}
+		 */
 
-	  /** The first epoch with `slotsPerEpoch` slots */
 
-	  /** The first slot of `firstNormalEpoch` */
-	  constructor(slotsPerEpoch, leaderScheduleSlotOffset, warmup, firstNormalEpoch, firstNormalSlot) {
-	    this.slotsPerEpoch = void 0;
-	    this.leaderScheduleSlotOffset = void 0;
-	    this.warmup = void 0;
-	    this.firstNormalEpoch = void 0;
-	    this.firstNormalSlot = void 0;
-	    this.slotsPerEpoch = slotsPerEpoch;
-	    this.leaderScheduleSlotOffset = leaderScheduleSlotOffset;
-	    this.warmup = warmup;
-	    this.firstNormalEpoch = firstNormalEpoch;
-	    this.firstNormalSlot = firstNormalSlot;
-	  }
+		function _default(address, options) {
+		  return new WebSocketBrowserImpl(address, options);
+		}
+	} (websocket_browser));
 
-	  getEpoch(slot) {
-	    return this.getEpochAndSlotIndex(slot)[0];
-	  }
+	var WebsocketFactory = /*@__PURE__*/getDefaultExportFromCjs(websocket_browser);
+
+	class RpcWebSocketClient extends RpcWebSocketCommonClient {
+	  constructor(address, options, generate_request_id) {
+	    const webSocketFactory = url => {
+	      const rpc = WebsocketFactory(url, {
+	        autoconnect: true,
+	        max_reconnects: 5,
+	        reconnect: true,
+	        reconnect_interval: 1000,
+	        ...options
+	      });
 
-	  getEpochAndSlotIndex(slot) {
-	    if (slot < this.firstNormalSlot) {
-	      const epoch = trailingZeros(nextPowerOfTwo(slot + MINIMUM_SLOT_PER_EPOCH + 1)) - trailingZeros(MINIMUM_SLOT_PER_EPOCH) - 1;
-	      const epochLen = this.getSlotsInEpoch(epoch);
-	      const slotIndex = slot - (epochLen - MINIMUM_SLOT_PER_EPOCH);
-	      return [epoch, slotIndex];
-	    } else {
-	      const normalSlotIndex = slot - this.firstNormalSlot;
-	      const normalEpochIndex = Math.floor(normalSlotIndex / this.slotsPerEpoch);
-	      const epoch = this.firstNormalEpoch + normalEpochIndex;
-	      const slotIndex = normalSlotIndex % this.slotsPerEpoch;
-	      return [epoch, slotIndex];
-	    }
-	  }
+	      if ('socket' in rpc) {
+	        this.underlyingSocket = rpc.socket;
+	      } else {
+	        this.underlyingSocket = rpc;
+	      }
 
-	  getFirstSlotInEpoch(epoch) {
-	    if (epoch <= this.firstNormalEpoch) {
-	      return (Math.pow(2, epoch) - 1) * MINIMUM_SLOT_PER_EPOCH;
-	    } else {
-	      return (epoch - this.firstNormalEpoch) * this.slotsPerEpoch + this.firstNormalSlot;
-	    }
-	  }
+	      return rpc;
+	    };
 
-	  getLastSlotInEpoch(epoch) {
-	    return this.getFirstSlotInEpoch(epoch) + this.getSlotsInEpoch(epoch) - 1;
+	    super(webSocketFactory, address, options, generate_request_id);
+	    this.underlyingSocket = void 0;
 	  }
 
-	  getSlotsInEpoch(epoch) {
-	    if (epoch < this.firstNormalEpoch) {
-	      return Math.pow(2, epoch + trailingZeros(MINIMUM_SLOT_PER_EPOCH));
-	    } else {
-	      return this.slotsPerEpoch;
+	  call(...args) {
+	    var _this$underlyingSocke;
+
+	    const readyState = (_this$underlyingSocke = this.underlyingSocket) === null || _this$underlyingSocke === void 0 ? void 0 : _this$underlyingSocke.readyState;
+
+	    if (readyState === WebSocket.OPEN) {
+	      return super.call(...args);
 	    }
+
+	    throw new Error('Tried to call a JSON-RPC method `' + args[0] + '` but the socket was not `CONNECTING` or `OPEN` (`readyState` was ' + readyState + ')');
 	  }
 
-	}
+	  notify(...args) {
+	    var _this$underlyingSocke2;
 
-	class SendTransactionError extends Error {
-	  constructor(message, logs) {
-	    super(message);
-	    this.logs = void 0;
-	    this.logs = logs;
-	  }
+	    const readyState = (_this$underlyingSocke2 = this.underlyingSocket) === null || _this$underlyingSocke2 === void 0 ? void 0 : _this$underlyingSocke2.readyState;
 
-	} // Keep in sync with client/src/rpc_custom_errors.rs
-	// Typescript `enums` thwart tree-shaking. See https://bargsten.org/jsts/enums/
+	    if (readyState === WebSocket.OPEN) {
+	      return super.notify(...args);
+	    }
 
-	const SolanaJSONRPCErrorCode = {
-	  JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001,
-	  JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002,
-	  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003,
-	  JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004,
-	  JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005,
-	  JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: -32006,
-	  JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007,
-	  JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008,
-	  JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009,
-	  JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010,
-	  JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011,
-	  JSON_RPC_SCAN_ERROR: -32012,
-	  JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013,
-	  JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014,
-	  JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015,
-	  JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016
-	};
-	class SolanaJSONRPCError extends Error {
-	  constructor({
-	    code,
-	    message,
-	    data
-	  }, customMessage) {
-	    super(customMessage != null ? `${customMessage}: ${message}` : message);
-	    this.code = void 0;
-	    this.data = void 0;
-	    this.code = code;
-	    this.data = data;
-	    this.name = 'SolanaJSONRPCError';
+	    throw new Error('Tried to send a JSON-RPC notification `' + args[0] + '` but the socket was not `CONNECTING` or `OPEN` (`readyState` was ' + readyState + ')');
 	  }
 
 	}
 
-	var fetchImpl = globalThis.fetch;
-
 	// TODO: These constants should be removed in favor of reading them out of a
 	// Syscall account
 
@@ -18319,7 +18309,7 @@ var solanaWeb3 = (function (exports) {
 
 	/** @internal */
 	const COMMON_HTTP_HEADERS = {
-	  'solana-client': `js/${(_process$env$npm_pack = "0.0.0-development") !== null && _process$env$npm_pack !== void 0 ? _process$env$npm_pack : 'UNKNOWN'}`
+	  'solana-client': `js/${(_process$env$npm_pack = "1.70.1-pr-29195") !== null && _process$env$npm_pack !== void 0 ? _process$env$npm_pack : 'UNKNOWN'}`
 	};
 	/**
 	 * A connection to a fullnode JSON RPC endpoint
@@ -18449,7 +18439,7 @@ var solanaWeb3 = (function (exports) {
 	    this._rpcClient = createRpcClient(endpoint, httpHeaders, fetch, fetchMiddleware, disableRetryOnRateLimit, httpAgent);
 	    this._rpcRequest = createRpcRequest(this._rpcClient);
 	    this._rpcBatchRequest = createRpcBatchRequest(this._rpcClient);
-	    this._rpcWebSocket = new Client_1(this._rpcWsEndpoint, {
+	    this._rpcWebSocket = new RpcWebSocketClient(this._rpcWsEndpoint, {
 	      autoconnect: false,
 	      max_reconnects: Infinity
 	    });